mirror of https://github.com/python/cpython
666 lines
22 KiB
Python
666 lines
22 KiB
Python
"""Main command line parser. Implements the pysetup script."""
|
|
|
|
import os
|
|
import re
|
|
import sys
|
|
import getopt
|
|
import logging
|
|
|
|
from packaging import logger
|
|
from packaging.dist import Distribution
|
|
from packaging.util import _is_archive_file, generate_setup_py
|
|
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
|
|
"""
|
|
|
|
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("""\
|
|
Usage: pysetup create
|
|
or: pysetup create --help
|
|
|
|
Create a new Python project.
|
|
""")
|
|
def _create(distpatcher, args, **kw):
|
|
from packaging.create import main
|
|
return main()
|
|
|
|
|
|
@action_help("""\
|
|
Usage: pysetup generate-setup
|
|
or: pysetup generate-setup --help
|
|
|
|
Generate a setup.py script for backward-compatibility purposes.
|
|
""")
|
|
def _generate(distpatcher, args, **kw):
|
|
generate_setup_py()
|
|
logger.info('The setup.py was generated')
|
|
|
|
|
|
@action_help("""\
|
|
Usage: pysetup graph dist
|
|
or: pysetup graph --help
|
|
|
|
Print dependency graph for the distribution.
|
|
|
|
positional arguments:
|
|
dist installed distribution name
|
|
""")
|
|
def _graph(dispatcher, args, **kw):
|
|
name = args[1]
|
|
dist = get_distribution(name, use_egg_info=True)
|
|
if dist is None:
|
|
logger.warning('Distribution not found.')
|
|
return 1
|
|
else:
|
|
dists = get_distributions(use_egg_info=True)
|
|
graph = generate_graph(dists)
|
|
print(graph.repr_node(dist))
|
|
|
|
|
|
@action_help("""\
|
|
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
|
|
""")
|
|
def _install(dispatcher, args, **kw):
|
|
# first check if we are in a source directory
|
|
if len(args) < 2:
|
|
# are we inside a project dir?
|
|
if os.path.isfile('setup.cfg') or os.path.isfile('setup.py'):
|
|
args.insert(1, os.getcwd())
|
|
else:
|
|
logger.warning('No project to install.')
|
|
return 1
|
|
|
|
target = args[1]
|
|
# installing from a source dir or archive file?
|
|
if os.path.isdir(target) or _is_archive_file(target):
|
|
return not install_local_project(target)
|
|
else:
|
|
# download from PyPI
|
|
return not install(target)
|
|
|
|
|
|
@action_help("""\
|
|
Usage: pysetup metadata [dist]
|
|
or: pysetup metadata [dist] [-f field ...]
|
|
or: pysetup metadata --help
|
|
|
|
Print metadata for the distribution.
|
|
|
|
positional arguments:
|
|
dist installed distribution name
|
|
|
|
optional arguments:
|
|
-f metadata field to print; omit to get all fields
|
|
""")
|
|
def _metadata(dispatcher, args, **kw):
|
|
opts = _parse_args(args[1:], 'f:', [])
|
|
if opts['args']:
|
|
name = opts['args'][0]
|
|
dist = get_distribution(name, use_egg_info=True)
|
|
if dist is None:
|
|
logger.warning('%r not installed', name)
|
|
return 1
|
|
elif os.path.isfile('setup.cfg'):
|
|
logger.info('searching local dir for metadata')
|
|
dist = Distribution() # XXX use config module
|
|
dist.parse_config_files()
|
|
else:
|
|
logger.warning('no argument given and no local setup.cfg found')
|
|
return 1
|
|
|
|
metadata = dist.metadata
|
|
|
|
if 'f' in opts:
|
|
keys = (k for k in opts['f'] if k in metadata)
|
|
else:
|
|
keys = metadata.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("""\
|
|
Usage: pysetup remove dist [-y]
|
|
or: pysetup remove --help
|
|
|
|
Uninstall a Python distribution.
|
|
|
|
positional arguments:
|
|
dist installed distribution name
|
|
|
|
optional arguments:
|
|
-y auto confirm distribution removal
|
|
""")
|
|
def _remove(distpatcher, args, **kw):
|
|
opts = _parse_args(args[1:], 'y', [])
|
|
if 'y' in opts:
|
|
auto_confirm = True
|
|
else:
|
|
auto_confirm = False
|
|
|
|
retcode = 0
|
|
for dist in set(opts['args']):
|
|
try:
|
|
remove(dist, auto_confirm=auto_confirm)
|
|
except PackagingError:
|
|
logger.warning('%r not installed', dist)
|
|
retcode = 1
|
|
|
|
return retcode
|
|
|
|
|
|
@action_help("""\
|
|
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
|
|
""")
|
|
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()
|
|
|
|
for cmd in dispatcher.commands:
|
|
dist.run_command(cmd, dispatcher.command_options[cmd])
|
|
|
|
# XXX this is crappy
|
|
return dist
|
|
|
|
|
|
@action_help("""\
|
|
Usage: pysetup list [dist ...]
|
|
or: pysetup list --help
|
|
|
|
Print name, version and location for the matching installed distributions.
|
|
|
|
positional arguments:
|
|
dist installed distribution name; omit to get all distributions
|
|
""")
|
|
def _list(dispatcher, args, **kw):
|
|
opts = _parse_args(args[1:], '', [])
|
|
dists = get_distributions(use_egg_info=True)
|
|
if opts['args']:
|
|
results = (d for d in dists if d.name.lower() in opts['args'])
|
|
listall = False
|
|
else:
|
|
results = dists
|
|
listall = True
|
|
|
|
number = 0
|
|
for dist in results:
|
|
print('%r %s (from %r)' % (dist.name, dist.version, dist.path))
|
|
number += 1
|
|
|
|
if number == 0:
|
|
if listall:
|
|
logger.info('Nothing seems to be installed.')
|
|
else:
|
|
logger.warning('No matching distribution found.')
|
|
return 1
|
|
else:
|
|
logger.info('Found %d projects installed.', number)
|
|
|
|
|
|
@action_help("""\
|
|
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] whether to use the xmlrpc index or not. If an url is
|
|
specified, it will be used rather than the default one.
|
|
|
|
--simple [url] whether 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.
|
|
""")
|
|
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)
|
|
logger.error('not implemented')
|
|
return 1
|
|
|
|
|
|
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', 'List installed projects', _list),
|
|
('graph', 'Display a graph', _graph),
|
|
('create', 'Create a project', _create),
|
|
('generate-setup', 'Generate a backward-comptatible setup.py', _generate),
|
|
]
|
|
|
|
|
|
class Dispatcher:
|
|
"""Reads the command-line options
|
|
"""
|
|
def __init__(self, args=None):
|
|
self.verbose = 1
|
|
self.dry_run = False
|
|
self.help = False
|
|
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()
|
|
self.args = args
|
|
|
|
# for display options we return immediately
|
|
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)
|
|
|
|
desc = getattr(command, 'description', '(no description available)')
|
|
print('Description:', 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 = list(logger.handlers)
|
|
try:
|
|
dispatcher = Dispatcher(args)
|
|
if dispatcher.action is None:
|
|
return
|
|
return dispatcher()
|
|
except KeyboardInterrupt:
|
|
logger.info('interrupted')
|
|
return 1
|
|
except (IOError, os.error, PackagingError, CCompilerError) as exc:
|
|
logger.exception(exc)
|
|
return 1
|
|
finally:
|
|
logger.setLevel(old_level)
|
|
logger.handlers[:] = old_handlers
|
|
|
|
|
|
if __name__ == '__main__':
|
|
sys.exit(main())
|