"""Main command line parser. Implements the pysetup script.""" import os import re import sys import getopt import logging from copy import copy from packaging import logger from packaging.dist import Distribution from packaging.util import _is_archive_file from packaging.command import get_command_class, STANDARD_COMMANDS from packaging.install import install, install_local_project, remove from packaging.database import get_distribution, get_distributions from packaging.depgraph import generate_graph from packaging.fancy_getopt import FancyGetopt from packaging.errors import (PackagingArgError, PackagingError, PackagingModuleError, PackagingClassError, CCompilerError) command_re = re.compile(r'^[a-zA-Z]([a-zA-Z0-9_]*)$') common_usage = """\ Actions: %(actions)s To get more help on an action, use: pysetup action --help """ create_usage = """\ Usage: pysetup create or: pysetup create --help Create a new Python package. """ graph_usage = """\ Usage: pysetup graph dist or: pysetup graph --help Print dependency graph for the distribution. positional arguments: dist installed distribution name """ install_usage = """\ Usage: pysetup install [dist] or: pysetup install [archive] or: pysetup install [src_dir] or: pysetup install --help Install a Python distribution from the indexes, source directory, or sdist. positional arguments: archive path to source distribution (zip, tar.gz) dist distribution name to install from the indexes scr_dir path to source directory """ metadata_usage = """\ Usage: pysetup metadata [dist] [-f field ...] or: pysetup metadata [dist] [--all] or: pysetup metadata --help Print metadata for the distribution. positional arguments: dist installed distribution name optional arguments: -f metadata field to print --all print all metadata fields """ remove_usage = """\ Usage: pysetup remove dist [-y] or: pysetup remove --help Uninstall a Python distribution. positional arguments: dist installed distribution name optional arguments: -y auto confirm package removal """ run_usage = """\ Usage: pysetup run [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...] or: pysetup run --help or: pysetup run --list-commands or: pysetup run cmd --help """ list_usage = """\ Usage: pysetup list dist [dist ...] or: pysetup list --help or: pysetup list --all Print name, version and location for the matching installed distributions. positional arguments: dist installed distribution name optional arguments: --all list all installed distributions """ search_usage = """\ Usage: pysetup search [project] [--simple [url]] [--xmlrpc [url] [--fieldname value ...] --operator or|and] or: pysetup search --help Search the indexes for the matching projects. positional arguments: project the project pattern to search for optional arguments: --xmlrpc [url] wether to use the xmlrpc index or not. If an url is specified, it will be used rather than the default one. --simple [url] wether to use the simple index or not. If an url is specified, it will be used rather than the default one. --fieldname value Make a search on this field. Can only be used if --xmlrpc has been selected or is the default index. --operator or|and Defines what is the operator to use when doing xmlrpc searchs with multiple fieldnames. Can only be used if --xmlrpc has been selected or is the default index. """ global_options = [ # The fourth entry for verbose means that it can be repeated. ('verbose', 'v', "run verbosely (default)", True), ('quiet', 'q', "run quietly (turns verbosity off)"), ('dry-run', 'n', "don't actually do anything"), ('help', 'h', "show detailed help message"), ('no-user-cfg', None, 'ignore pydistutils.cfg in your home directory'), ('version', None, 'Display the version'), ] negative_opt = {'quiet': 'verbose'} display_options = [ ('help-commands', None, "list all available commands"), ] display_option_names = [x[0].replace('-', '_') for x in display_options] def _parse_args(args, options, long_options): """Transform sys.argv input into a dict. :param args: the args to parse (i.e sys.argv) :param options: the list of options to pass to getopt :param long_options: the list of string with the names of the long options to be passed to getopt. The function returns a dict with options/long_options as keys and matching values as values. """ optlist, args = getopt.gnu_getopt(args, options, long_options) optdict = {} optdict['args'] = args for k, v in optlist: k = k.lstrip('-') if k not in optdict: optdict[k] = [] if v: optdict[k].append(v) else: optdict[k].append(v) return optdict class action_help: """Prints a help message when the standard help flags: -h and --help are used on the commandline. """ def __init__(self, help_msg): self.help_msg = help_msg def __call__(self, f): def wrapper(*args, **kwargs): f_args = args[1] if '--help' in f_args or '-h' in f_args: print(self.help_msg) return return f(*args, **kwargs) return wrapper @action_help(create_usage) def _create(distpatcher, args, **kw): from packaging.create import main return main() @action_help(graph_usage) def _graph(dispatcher, args, **kw): name = args[1] dist = get_distribution(name, use_egg_info=True) if dist is None: print('Distribution not found.') else: dists = get_distributions(use_egg_info=True) graph = generate_graph(dists) print(graph.repr_node(dist)) @action_help(install_usage) def _install(dispatcher, args, **kw): # first check if we are in a source directory if len(args) < 2: # are we inside a project dir? listing = os.listdir(os.getcwd()) if 'setup.py' in listing or 'setup.cfg' in listing: args.insert(1, os.getcwd()) else: logger.warning('no project to install') return target = args[1] # installing from a source dir or archive file? if os.path.isdir(target) or _is_archive_file(target): install_local_project(target) else: # download from PyPI install(target) @action_help(metadata_usage) def _metadata(dispatcher, args, **kw): opts = _parse_args(args[1:], 'f:', ['all']) if opts['args']: name = opts['args'][0] dist = get_distribution(name, use_egg_info=True) if dist is None: logger.warning('%s not installed', name) return else: logger.info('searching local dir for metadata') dist = Distribution() dist.parse_config_files() metadata = dist.metadata if 'all' in opts: keys = metadata.keys() else: if 'f' in opts: keys = (k for k in opts['f'] if k in metadata) else: keys = () for key in keys: if key in metadata: print(metadata._convert_name(key) + ':') value = metadata[key] if isinstance(value, list): for v in value: print(' ' + v) else: print(' ' + value.replace('\n', '\n ')) @action_help(remove_usage) def _remove(distpatcher, args, **kw): opts = _parse_args(args[1:], 'y', []) if 'y' in opts: auto_confirm = True else: auto_confirm = False for dist in set(opts['args']): try: remove(dist, auto_confirm=auto_confirm) except PackagingError: logger.warning('%s not installed', dist) @action_help(run_usage) def _run(dispatcher, args, **kw): parser = dispatcher.parser args = args[1:] commands = STANDARD_COMMANDS # + extra commands if args == ['--list-commands']: print('List of available commands:') cmds = sorted(commands) for cmd in cmds: cls = dispatcher.cmdclass.get(cmd) or get_command_class(cmd) desc = getattr(cls, 'description', '(no description available)') print(' %s: %s' % (cmd, desc)) return while args: args = dispatcher._parse_command_opts(parser, args) if args is None: return # create the Distribution class # need to feed setup.cfg here ! dist = Distribution() # Find and parse the config file(s): they will override options from # the setup script, but be overridden by the command line. # XXX still need to be extracted from Distribution dist.parse_config_files() try: for cmd in dispatcher.commands: dist.run_command(cmd, dispatcher.command_options[cmd]) except KeyboardInterrupt: raise SystemExit("interrupted") except (IOError, os.error, PackagingError, CCompilerError) as msg: raise SystemExit("error: " + str(msg)) # XXX this is crappy return dist @action_help(list_usage) def _list(dispatcher, args, **kw): opts = _parse_args(args[1:], '', ['all']) dists = get_distributions(use_egg_info=True) if 'all' in opts or opts['args'] == []: results = dists else: results = [d for d in dists if d.name.lower() in opts['args']] number = 0 for dist in results: print('%s %s at %s' % (dist.name, dist.metadata['version'], dist.path)) number +=1 print('') if number == 0: print('Nothing seems to be installed.') else: print('Found %d projects installed.' % number) @action_help(search_usage) def _search(dispatcher, args, **kw): """The search action. It is able to search for a specific index (specified with --index), using the simple or xmlrpc index types (with --type xmlrpc / --type simple) """ opts = _parse_args(args[1:], '', ['simple', 'xmlrpc']) # 1. what kind of index is requested ? (xmlrpc / simple) actions = [ ('run', 'Run one or several commands', _run), ('metadata', 'Display the metadata of a project', _metadata), ('install', 'Install a project', _install), ('remove', 'Remove a project', _remove), ('search', 'Search for a project in the indexes', _search), ('list', 'Search for local projects', _list), ('graph', 'Display a graph', _graph), ('create', 'Create a Project', _create), ] class Dispatcher: """Reads the command-line options """ def __init__(self, args=None): self.verbose = 1 self.dry_run = False self.help = False self.script_name = 'pysetup' self.cmdclass = {} self.commands = [] self.command_options = {} for attr in display_option_names: setattr(self, attr, False) self.parser = FancyGetopt(global_options + display_options) self.parser.set_negative_aliases(negative_opt) # FIXME this parses everything, including command options (e.g. "run # build -i" errors with "option -i not recognized") args = self.parser.getopt(args=args, object=self) # if first arg is "run", we have some commands if len(args) == 0: self.action = None else: self.action = args[0] allowed = [action[0] for action in actions] + [None] if self.action not in allowed: msg = 'Unrecognized action "%s"' % self.action raise PackagingArgError(msg) self._set_logger() # for display options we return immediately option_order = self.parser.get_option_order() self.args = args if self.help or self.action is None: self._show_help(self.parser, display_options_=False) def _set_logger(self): # setting up the logging level from the command-line options # -q gets warning, error and critical if self.verbose == 0: level = logging.WARNING # default level or -v gets info too # XXX there's a bug somewhere: the help text says that -v is default # (and verbose is set to 1 above), but when the user explicitly gives # -v on the command line, self.verbose is incremented to 2! Here we # compensate for that (I tested manually). On a related note, I think # it's a good thing to use -q/nothing/-v/-vv on the command line # instead of logging constants; it will be easy to add support for # logging configuration in setup.cfg for advanced users. --merwok elif self.verbose in (1, 2): level = logging.INFO else: # -vv and more for debug level = logging.DEBUG # setting up the stream handler handler = logging.StreamHandler(sys.stderr) handler.setLevel(level) logger.addHandler(handler) logger.setLevel(level) def _parse_command_opts(self, parser, args): # Pull the current command from the head of the command line command = args[0] if not command_re.match(command): raise SystemExit("invalid command name %r" % (command,)) self.commands.append(command) # Dig up the command class that implements this command, so we # 1) know that it's a valid command, and 2) know which options # it takes. try: cmd_class = get_command_class(command) except PackagingModuleError as msg: raise PackagingArgError(msg) # XXX We want to push this in packaging.command # # Require that the command class be derived from Command -- want # to be sure that the basic "command" interface is implemented. for meth in ('initialize_options', 'finalize_options', 'run'): if hasattr(cmd_class, meth): continue raise PackagingClassError( 'command %r must implement %r' % (cmd_class, meth)) # Also make sure that the command object provides a list of its # known options. if not (hasattr(cmd_class, 'user_options') and isinstance(cmd_class.user_options, list)): raise PackagingClassError( "command class %s must provide " "'user_options' attribute (a list of tuples)" % cmd_class) # If the command class has a list of negative alias options, # merge it in with the global negative aliases. _negative_opt = negative_opt.copy() if hasattr(cmd_class, 'negative_opt'): _negative_opt.update(cmd_class.negative_opt) # Check for help_options in command class. They have a different # format (tuple of four) so we need to preprocess them here. if (hasattr(cmd_class, 'help_options') and isinstance(cmd_class.help_options, list)): help_options = cmd_class.help_options[:] else: help_options = [] # All commands support the global options too, just by adding # in 'global_options'. parser.set_option_table(global_options + cmd_class.user_options + help_options) parser.set_negative_aliases(_negative_opt) args, opts = parser.getopt(args[1:]) if hasattr(opts, 'help') and opts.help: self._show_command_help(cmd_class) return if (hasattr(cmd_class, 'help_options') and isinstance(cmd_class.help_options, list)): help_option_found = False for help_option, short, desc, func in cmd_class.help_options: if hasattr(opts, help_option.replace('-', '_')): help_option_found = True if hasattr(func, '__call__'): func() else: raise PackagingClassError( "invalid help function %r for help option %r: " "must be a callable object (function, etc.)" % (func, help_option)) if help_option_found: return # Put the options from the command line into their official # holding pen, the 'command_options' dictionary. opt_dict = self.get_option_dict(command) for name, value in vars(opts).items(): opt_dict[name] = ("command line", value) return args def get_option_dict(self, command): """Get the option dictionary for a given command. If that command's option dictionary hasn't been created yet, then create it and return the new dictionary; otherwise, return the existing option dictionary. """ d = self.command_options.get(command) if d is None: d = self.command_options[command] = {} return d def show_help(self): self._show_help(self.parser) def print_usage(self, parser): parser.set_option_table(global_options) actions_ = [' %s: %s' % (name, desc) for name, desc, __ in actions] usage = common_usage % {'actions': '\n'.join(actions_)} parser.print_help(usage + "\nGlobal options:") def _show_help(self, parser, global_options_=True, display_options_=True, commands=[]): # late import because of mutual dependence between these modules from packaging.command.cmd import Command print('Usage: pysetup [options] action [action_options]') print('') if global_options_: self.print_usage(self.parser) print('') if display_options_: parser.set_option_table(display_options) parser.print_help( "Information display options (just display " + "information, ignore any commands)") print('') for command in commands: if isinstance(command, type) and issubclass(command, Command): cls = command else: cls = get_command_class(command) if (hasattr(cls, 'help_options') and isinstance(cls.help_options, list)): parser.set_option_table(cls.user_options + cls.help_options) else: parser.set_option_table(cls.user_options) parser.print_help("Options for %r command:" % cls.__name__) print('') def _show_command_help(self, command): if isinstance(command, str): command = get_command_class(command) name = command.get_command_name() desc = getattr(command, 'description', '(no description available)') print('Description: %s' % desc) print('') if (hasattr(command, 'help_options') and isinstance(command.help_options, list)): self.parser.set_option_table(command.user_options + command.help_options) else: self.parser.set_option_table(command.user_options) self.parser.print_help("Options:") print('') def _get_command_groups(self): """Helper function to retrieve all the command class names divided into standard commands (listed in packaging.command.STANDARD_COMMANDS) and extra commands (given in self.cmdclass and not standard commands). """ extra_commands = [cmd for cmd in self.cmdclass if cmd not in STANDARD_COMMANDS] return STANDARD_COMMANDS, extra_commands def print_commands(self): """Print out a help message listing all available commands with a description of each. The list is divided into standard commands (listed in packaging.command.STANDARD_COMMANDS) and extra commands (given in self.cmdclass and not standard commands). The descriptions come from the command class attribute 'description'. """ std_commands, extra_commands = self._get_command_groups() max_length = max(len(command) for commands in (std_commands, extra_commands) for command in commands) self.print_command_list(std_commands, "Standard commands", max_length) if extra_commands: print() self.print_command_list(extra_commands, "Extra commands", max_length) def print_command_list(self, commands, header, max_length): """Print a subset of the list of all commands -- used by 'print_commands()'. """ print(header + ":") for cmd in commands: cls = self.cmdclass.get(cmd) or get_command_class(cmd) description = getattr(cls, 'description', '(no description available)') print(" %-*s %s" % (max_length, cmd, description)) def __call__(self): if self.action is None: return for action, desc, func in actions: if action == self.action: return func(self, self.args) return -1 def main(args=None): old_level = logger.level old_handlers = copy(logger.handlers) try: dispatcher = Dispatcher(args) if dispatcher.action is None: return return dispatcher() finally: logger.setLevel(old_level) logger.handlers[:] = old_handlers if __name__ == '__main__': sys.exit(main())