Python SoloCommandDescriptor.obtain_descriptor方法代码示例

# 需要导入模块: from _entropy.solo.commands.descriptor import SoloCommandDescriptor [as 别名]
# 或者: from _entropy.solo.commands.descriptor.SoloCommandDescriptor import obtain_descriptor [as 别名]
    def _get_parser(self):
        """
        Overridden from SoloCommand.
        """
        _commands = []

        descriptor = SoloCommandDescriptor.obtain_descriptor(
            SoloCache.NAME)
        parser = argparse.ArgumentParser(
            description=descriptor.get_description(),
            formatter_class=argparse.RawDescriptionHelpFormatter,
            prog="%s %s" % (sys.argv[0], SoloCache.NAME))

        subparsers = parser.add_subparsers(
            title="action", description=_("manage cache"),
            help=_("available commands"))

        clean_parser = subparsers.add_parser(
            "clean", help=_("clean Entropy Library Cache"))
        clean_parser.add_argument(
            "--verbose", "-v", action="store_true", default=False,
            help=_("show more details"))
        clean_parser.add_argument(
            "--quiet", "-q", action="store_true", default=False,
            help=_("print results in a scriptable way"))

        clean_parser.set_defaults(func=self._clean)
        _commands.append("clean")

        self._commands = _commands
        return parser

# 需要导入模块: from _entropy.solo.commands.descriptor import SoloCommandDescriptor [as 别名]
# 或者: from _entropy.solo.commands.descriptor.SoloCommandDescriptor import obtain_descriptor [as 别名]
    def _get_parser(self):
        """
        Overridden from SoloCommand.
        """
        _commands = []
        descriptor = SoloCommandDescriptor.obtain_descriptor(
            SoloUnused.NAME)
        parser = argparse.ArgumentParser(
            description=descriptor.get_description(),
            formatter_class=argparse.RawDescriptionHelpFormatter,
            prog="%s %s" % (sys.argv[0], SoloUnused.NAME))

        parser.add_argument("--quiet", "-q", action="store_true",
                            default=self._quiet,
                            help=_("show less details (useful for scripting)"))
        _commands.append("--quiet")
        _commands.append("-q")

        parser.add_argument("--sortbysize", action="store_true",
                            default=self._sortbysize,
                            help=_("sort packages by size"))
        _commands.append("--sortbysize")

        parser.add_argument("--spm-wanted", action="store_true",
                            default=self._spm_wanted,
                            help=_("consider packages installed with" \
                                   " a Source Package Manager to be wanted"))
        _commands.append("--spm-wanted")

        self._commands = _commands
        return parser

# 需要导入模块: from _entropy.solo.commands.descriptor import SoloCommandDescriptor [as 别名]
# 或者: from _entropy.solo.commands.descriptor.SoloCommandDescriptor import obtain_descriptor [as 别名]
    def _get_parser(self):
        """
        Overridden from SoloCommand.
        """
        _commands = {}

        descriptor = SoloCommandDescriptor.obtain_descriptor(
            SoloPreservedLibs.NAME)
        parser = argparse.ArgumentParser(
            description=descriptor.get_description(),
            formatter_class=argparse.RawDescriptionHelpFormatter,
            prog="%s %s" % (sys.argv[0], SoloPreservedLibs.NAME))

        subparsers = parser.add_subparsers(
            title="action",
            description=_("manage preserved libraries"),
            help=_("available commands"))

        list_parser = subparsers.add_parser(
            "list", help=_("list the currently preserved libraries"))
        list_parser.set_defaults(func=self._list)
        self._setup_verbose_quiet_parser(list_parser)
        _commands["list"] = {}

        gc_parser = subparsers.add_parser(
            "gc", help=_("show libraries that could be garbage collected"))
        gc_parser.set_defaults(func=self._gc)
        _commands["gc"] = {}

        self._commands = _commands
        return parser

# 需要导入模块: from _entropy.solo.commands.descriptor import SoloCommandDescriptor [as 别名]
# 或者: from _entropy.solo.commands.descriptor.SoloCommandDescriptor import obtain_descriptor [as 别名]
    def _get_parser(self):
        """
        Overridden from SoloCommand.
        """
        descriptor = SoloCommandDescriptor.obtain_descriptor(
            SoloSearch.NAME)
        parser = argparse.ArgumentParser(
            description=descriptor.get_description(),
            formatter_class=argparse.RawDescriptionHelpFormatter,
            prog="%s %s" % (sys.argv[0], SoloSearch.NAME))

        parser.add_argument("string", nargs='+',
                            metavar="<string>", help=_("search keyword"))

        parser.add_argument("--quiet", "-q", action="store_true",
                            default=self._quiet,
                            help=_('quiet output, for scripting purposes'))

        parser.add_argument("--verbose", "-v", action="store_true",
                            default=self._verbose,
                            help=_('verbose output'))

        group = parser.add_mutually_exclusive_group()
        group.add_argument("--installed", action="store_true",
                           default=self._installed,
                           help=_('search among installed packages only'))

        group.add_argument("--available", action="store_true",
                           default=self._available,
                           help=_('search among available packages only'))

        return parser

# 需要导入模块: from _entropy.solo.commands.descriptor import SoloCommandDescriptor [as 别名]
# 或者: from _entropy.solo.commands.descriptor.SoloCommandDescriptor import obtain_descriptor [as 别名]
    def _get_parser(self):
        """
        Overridden from SoloCommand.
        """
        _commands = []

        descriptor = SoloCommandDescriptor.obtain_descriptor(
            SoloConf.NAME)
        parser = argparse.ArgumentParser(
            description=descriptor.get_description(),
            formatter_class=argparse.RawDescriptionHelpFormatter,
            prog="%s %s" % (sys.argv[0], SoloConf.NAME))

        subparsers = parser.add_subparsers(
            title="action",
            description=_("manage configuration file updates"),
            help=_("available commands"))

        update_parser = subparsers.add_parser(
            "update", help=_("update configuration files"))
        update_parser.set_defaults(func=self._update)
        _commands.append("update")

        self._commands = _commands
        return parser

# 需要导入模块: from _entropy.solo.commands.descriptor import SoloCommandDescriptor [as 别名]
# 或者: from _entropy.solo.commands.descriptor.SoloCommandDescriptor import obtain_descriptor [as 别名]
    def _get_parser(self):
        """
        Overridden from SoloCommand.
        """
        descriptor = SoloCommandDescriptor.obtain_descriptor(
            SoloCleanup.NAME)
        parser = argparse.ArgumentParser(
            description=descriptor.get_description(),
            formatter_class=argparse.RawDescriptionHelpFormatter,
            prog="%s %s" % (sys.argv[0], SoloCleanup.NAME))

        return parser

# 需要导入模块: from _entropy.solo.commands.descriptor import SoloCommandDescriptor [as 别名]
# 或者: from _entropy.solo.commands.descriptor.SoloCommandDescriptor import obtain_descriptor [as 别名]
    def _get_parser(self):
        """
        Overridden from SoloCommand.
        """
        descriptor = SoloCommandDescriptor.obtain_descriptor(
            SoloHop.NAME)
        parser = argparse.ArgumentParser(
            description=descriptor.get_description(),
            formatter_class=argparse.RawDescriptionHelpFormatter,
            prog="%s %s" % (sys.argv[0], SoloHop.NAME))

        parser.add_argument(
            "branch", metavar="<branch>", help=_("branch"))

        return parser

# 需要导入模块: from _entropy.solo.commands.descriptor import SoloCommandDescriptor [as 别名]
# 或者: from _entropy.solo.commands.descriptor.SoloCommandDescriptor import obtain_descriptor [as 别名]
    def _get_parser(self):
        """
        Overridden from SoloCommand.
        """
        descriptor = SoloCommandDescriptor.obtain_descriptor(
            SoloUpdate.NAME)
        parser = argparse.ArgumentParser(
            description=descriptor.get_description(),
            formatter_class=argparse.RawDescriptionHelpFormatter,
            prog="%s %s" % (sys.argv[0], SoloUpdate.NAME))

        parser.add_argument("repo", nargs='*', default=None,
                            metavar="<repo>", help=_("repository"))
        parser.add_argument("--force", action="store_true",
                            default=self._force,
                            help=_("force update"))

        return parser

# 需要导入模块: from _entropy.solo.commands.descriptor import SoloCommandDescriptor [as 别名]
# 或者: from _entropy.solo.commands.descriptor.SoloCommandDescriptor import obtain_descriptor [as 别名]
    def _get_parser(self):
        """
        Overridden from SoloCommand.
        """
        descriptor = SoloCommandDescriptor.obtain_descriptor(
            SoloLibtest.NAME)
        parser = argparse.ArgumentParser(
            description=descriptor.get_description(),
            formatter_class=argparse.RawDescriptionHelpFormatter,
            prog="%s %s" % (sys.argv[0], SoloLibtest.NAME))

        _commands = []
        parser.add_argument("--ask", "-a", action="store_true",
                            default=False,
                            help=_("ask before making any changes"))
        _commands.append("--ask")
        _commands.append("-a")

        parser.add_argument("--quiet", "-q", action="store_true",
                            default=False,
                            help=_("show less details "
                                   "(useful for scripting)"))
        _commands.append("--quiet")
        _commands.append("-q")

        parser.add_argument("--pretend", "-p", action="store_true",
                            default=False,
                            help=_("just show what would be done"))
        _commands.append("--pretend")
        _commands.append("-p")

        parser.add_argument("--listfiles", action="store_true",
                            default=False,
                            help=_("print broken files to stdout"))
        _commands.append("--listfiles")

        parser.add_argument("--dump", action="store_true",
                            default=False,
                            help=_("dump results to files"))
        _commands.append("--dump")

        self._commands = _commands
        return parser

# 需要导入模块: from _entropy.solo.commands.descriptor import SoloCommandDescriptor [as 别名]
# 或者: from _entropy.solo.commands.descriptor.SoloCommandDescriptor import obtain_descriptor [as 别名]
    def _get_parser(self):
        """
        Overridden from SoloCommand.
        """
        _commands = {}

        descriptor = SoloCommandDescriptor.obtain_descriptor(
            SoloConfig.NAME)
        parser = argparse.ArgumentParser(
            description=descriptor.get_description(),
            formatter_class=argparse.RawDescriptionHelpFormatter,
            prog="%s %s" % (sys.argv[0], SoloConfig.NAME))
        parser.set_defaults(func=self._config)

        parser.add_argument(
            "packages", nargs='+',
            metavar="<package>", help=_("package name"))

        mg_group = parser.add_mutually_exclusive_group()
        mg_group.add_argument(
            "--ask", "-a", action="store_true",
            default=False,
            help=_("ask before making any changes"))
        _commands["--ask"] = {}
        _commands["-a"] = {}
        mg_group.add_argument(
            "--pretend", "-p", action="store_true",
            default=False,
            help=_("show what would be done"))
        _commands["--pretend"] = {}
        _commands["-p"] = {}

        parser.add_argument(
            "--verbose", "-v", action="store_true",
            default=False,
            help=_("verbose output"))
        _commands["--verbose"] = {}
        _commands["-v"] = {}

        self._commands = _commands
        return parser

# 需要导入模块: from _entropy.solo.commands.descriptor import SoloCommandDescriptor [as 别名]
# 或者: from _entropy.solo.commands.descriptor.SoloCommandDescriptor import obtain_descriptor [as 别名]
    def _get_parser(self):
        """
        Overridden from SoloCommand.
        """
        descriptor = SoloCommandDescriptor.obtain_descriptor(
            SoloDeptest.NAME)
        parser = argparse.ArgumentParser(
            description=descriptor.get_description(),
            formatter_class=argparse.RawDescriptionHelpFormatter,
            prog="%s %s" % (sys.argv[0], SoloDeptest.NAME))

        parser.add_argument("--ask", "-a", action="store_true",
                            default=self._ask,
                            help=_("ask before making any changes"))
        parser.add_argument("--quiet", "-q", action="store_true",
                            default=self._quiet,
                            help=_("show less details (useful for scripting)"))
        parser.add_argument("--pretend", "-p", action="store_true",
                            default=self._pretend,
                            help=_("just show what would be done"))

        return parser

# 需要导入模块: from _entropy.solo.commands.descriptor import SoloCommandDescriptor [as 别名]
# 或者: from _entropy.solo.commands.descriptor.SoloCommandDescriptor import obtain_descriptor [as 别名]
    def _get_parser(self):
        """
        Overridden from SoloCommand.
        """
        descriptor = SoloCommandDescriptor.obtain_descriptor(
            self.NAME)
        parser = argparse.ArgumentParser(
            description=descriptor.get_description(),
            formatter_class=argparse.RawDescriptionHelpFormatter,
            prog="%s %s" % (sys.argv[0], self.NAME))

        parser.add_argument("packages", nargs='+',
                            metavar="<package>", help=_("package name"))

        group = parser.add_mutually_exclusive_group()
        group.add_argument("--ask", "-a", action="store_true",
                           default=self._ask,
                           help=_('ask before making any changes'))

        group.add_argument("--pretend", "-p", action="store_true",
                           default=self._pretend,
                           help=_('only show what would be done'))

        return parser

# 需要导入模块: from _entropy.solo.commands.descriptor import SoloCommandDescriptor [as 别名]
# 或者: from _entropy.solo.commands.descriptor.SoloCommandDescriptor import obtain_descriptor [as 别名]
    def _get_parser(self):
        """
        Overridden from SoloCommand.
        """
        _commands = {}

        descriptor = SoloCommandDescriptor.obtain_descriptor(
            SoloRemove.NAME)
        parser = argparse.ArgumentParser(
            description=descriptor.get_description(),
            formatter_class=argparse.RawDescriptionHelpFormatter,
            prog="%s %s" % (sys.argv[0], SoloRemove.NAME))
        parser.set_defaults(func=self._remove)

        parser.add_argument(
            "packages", nargs='+',
            metavar="<package>", help=_("package name"))

        mg_group = parser.add_mutually_exclusive_group()
        mg_group.add_argument(
            "--ask", "-a", action="store_true",
            default=False,
            help=_("ask before making any changes"))
        _commands["--ask"] = {}
        _commands["-a"] = {}

        mg_group.add_argument(
            "--pretend", "-p", action="store_true",
            default=False,
            help=_("show what would be done"))
        _commands["--pretend"] = {}
        _commands["-p"] = {}

        parser.add_argument(
            "--verbose", "-v", action="store_true",
            default=False,
            help=_("verbose output"))
        _commands["--verbose"] = {}
        _commands["-v"] = {}

        parser.add_argument(
            "--nodeps", action="store_true",
            default=False,
            help=_("exclude package dependencies"))
        _commands["--nodeps"] = {}

        parser.add_argument(
            "--norecursive", action="store_true",
            default=False,
            help=_("do not calculate dependencies recursively"))
        _commands["--norecursive"] = {}

        parser.add_argument(
            "--deep", action="store_true",
            default=False,
            help=_("include dependencies no longer needed"))
        _commands["--deep"] = {}

        parser.add_argument(
            "--empty", action="store_true",
            default=False,
            help=_("when used with --deep, include virtual packages"))
        _commands["--empty"] = {}

        parser.add_argument(
            "--configfiles", action="store_true",
            default=False,
            help=_("remove package configuration files no longer needed"))
        _commands["--configfiles"] = {}

        parser.add_argument(
            "--force-system", action="store_true",
            default=False,
            help=_("force system packages removal (dangerous!)"))
        _commands["--force-system"] = {}

        self._commands = _commands
        return parser

# 需要导入模块: from _entropy.solo.commands.descriptor import SoloCommandDescriptor [as 别名]
# 或者: from _entropy.solo.commands.descriptor.SoloCommandDescriptor import obtain_descriptor [as 别名]
    def _get_parser(self):
        """
        Overridden from SoloCommand.
        """
        _commands = {}

        descriptor = SoloCommandDescriptor.obtain_descriptor(
            SoloPkg.NAME)
        parser = argparse.ArgumentParser(
            description=descriptor.get_description(),
            formatter_class=argparse.RawDescriptionHelpFormatter,
            prog="%s %s" % (sys.argv[0], SoloPkg.NAME))

        subparsers = parser.add_subparsers(
            title="action",
            description=_("execute advanced tasks on packages"),
            help=_("available commands"))

        def _argparse_easygoing_valid_entropy_path(string):
            if os.path.isfile(string) and os.path.exists(string):
                return string
            # see bug 3873, requires raw string
            msg = "%s: %s" % (
                _("not a valid Entropy package file"),
                string)
            msg = const_convert_to_rawstring(
                msg, from_enctype="utf-8")
            raise argparse.ArgumentTypeError(msg)

        quickpkg_parser = subparsers.add_parser(
            "quickpkg", help=_("generate packages from "
                               "the installed system"))
        quickpkg_parser.add_argument(
            "packages", nargs='+', metavar="<package>",
            help=_("installed package name"))
        quickpkg_parser.add_argument(
            "--savedir", metavar="<path>",
            type=self._argparse_is_valid_directory,
            default=self._savedir,
            help=_("destination directory "
                   "where to save generated packages"))
        quickpkg_parser.set_defaults(func=self._quickpkg)
        _commands["quickpkg"] = {}

        inflate_parser = subparsers.add_parser(
            "inflate", help=_("transform SPM package files "
                              "into Entropy ones"))
        inflate_parser.add_argument(
            "files", nargs='+', metavar="<file>",
            type=_argparse_easygoing_valid_entropy_path,
            help=_("SPM package file path"))
        inflate_parser.add_argument(
            "--savedir", metavar="<path>",
            type=self._argparse_is_valid_directory,
            default=self._savedir,
            help=_("destination directory "
                   "where to save generated packages"))
        inflate_parser.set_defaults(func=self._inflate)
        _commands["inflate"] = {}

        deflate_parser = subparsers.add_parser(
            "deflate", help=_("transform Entropy package files "
                              "into SPM ones"))
        deflate_parser.add_argument(
            "files", nargs='+', metavar="<file>",
            type=self._argparse_is_valid_entropy_package,
            help=_("Entropy package file path"))
        deflate_parser.add_argument(
            "--savedir", metavar="<path>",
            type=self._argparse_is_valid_directory,
            default=self._savedir,
            help=_("destination directory "
                   "where to save generated packages"))
        deflate_parser.set_defaults(func=self._deflate)
        _commands["deflate"] = {}

        extract_parser = subparsers.add_parser(
            "extract", help=_("extract Entropy metadata "
                              "from Entropy packages"))
        extract_parser.add_argument(
            "files", nargs='+', metavar="<file>",
            type=_argparse_easygoing_valid_entropy_path,
            help=_("Entropy package file path"))
        extract_parser.add_argument(
            "--savedir", metavar="<path>",
            type=self._argparse_is_valid_directory,
            default=self._savedir,
            help=_("destination directory "
                   "where to save generated packages"))
        extract_parser.set_defaults(func=self._extract)
        _commands["extract"] = {}

        self._commands = _commands
        return parser

# 需要导入模块: from _entropy.solo.commands.descriptor import SoloCommandDescriptor [as 别名]
# 或者: from _entropy.solo.commands.descriptor.SoloCommandDescriptor import obtain_descriptor [as 别名]
    def _get_parser(self):
        """
        Overridden from SoloCommand.
        """
        _commands = []

        descriptor = SoloCommandDescriptor.obtain_descriptor(
            SoloRepo.NAME)
        parser = argparse.ArgumentParser(
            description=descriptor.get_description(),
            formatter_class=argparse.RawDescriptionHelpFormatter,
            prog="%s %s" % (sys.argv[0], SoloRepo.NAME))

        subparsers = parser.add_subparsers(
            title="action", description=_("manage repositories"),
            help=_("available commands"))

        enable_parser = subparsers.add_parser("enable",
            help=_("enable repositories"))
        enable_parser.add_argument("repo", nargs='+',
                                   metavar="<repo>",
                                   help=_("repository name"))
        enable_parser.set_defaults(func=self._enable)
        _commands.append("enable")

        disable_parser = subparsers.add_parser("disable",
            help=_("disable repositories"))
        disable_parser.add_argument("repo", nargs='+',
                                    metavar="<repo>",
                                    help=_("repository name"))
        disable_parser.set_defaults(func=self._disable)
        _commands.append("disable")

        add_parser = subparsers.add_parser("add",
            help=_("add a repository"))
        add_parser.add_argument("id", metavar="<repository>",
                                help=_("repository name"))
        add_parser.add_argument("--desc", metavar="<description>",
                                required=True,
                                help=_("repository description"))
        add_parser.add_argument("--repo", nargs='+',
                                metavar="<repo url>",
                                required=True,
                                help=_("repository database URL"))
        add_parser.add_argument("--pkg", nargs='+',
                                metavar="<pkg url>",
                                required=True,
                                help=_("repository packages URL"))
        add_parser.add_argument("--cformat",
                                default=etpConst['etpdatabasefileformat'],
                                metavar="<compression format>",
                                help=_("repository compression format"))
        add_parser.set_defaults(func=self._add)
        _commands.append("add")

        remove_parser = subparsers.add_parser("remove",
            help=_("remove a repository"))
        remove_parser.add_argument("repo", nargs='+',
                                   metavar="<repo>",
                                   help=_("repository name"))
        remove_parser.set_defaults(func=self._remove)
        _commands.append("remove")

        rename_parser = subparsers.add_parser("rename",
            help=_("rename a repository"))
        rename_parser.add_argument("from_repo",
                                   metavar="<from>",
                                   help=_("from repository"))
        rename_parser.add_argument("to_repo",
                                   metavar="<to>",
                                   help=_("to repository"))
        rename_parser.set_defaults(func=self._rename)
        _commands.append("rename")

        list_parser = subparsers.add_parser("list",
            help=_("list active repositories"))
        list_parser.set_defaults(func=self._list)
        list_parser.add_argument(
            "--quiet", "-q", action="store_true",
            default=False,
            help=_('quiet output, for scripting purposes'))
        _commands.append("list")

        mirrorsort_parser = subparsers.add_parser("mirrorsort",
            help=_("reorder mirrors basing on response time"))
        mirrorsort_parser.add_argument("repo", nargs='+',
                                       metavar="<repo>",
                                       help=_("repository name"))
        mirrorsort_parser.add_argument(
            "--simulate", action="store_true",
            default=False, help=_("simulate execution"))
        mirrorsort_parser.set_defaults(func=self._mirrorsort)
        _commands.append("mirrorsort")

        merge_parser = subparsers.add_parser("merge",
            help=_("merge content of source repository to destination"))
        merge_parser.add_argument("source", metavar="<source>",
                                  help=_("source repository"))
        merge_parser.add_argument("dest", metavar="<destination>",
                                  help=_("destination repository"))
#.........这里部分代码省略.........