diff options
Diffstat (limited to 'webapp/django/core/management/__init__.py')
| -rw-r--r-- | webapp/django/core/management/__init__.py | 334 |
1 files changed, 334 insertions, 0 deletions
diff --git a/webapp/django/core/management/__init__.py b/webapp/django/core/management/__init__.py new file mode 100644 index 0000000000..fc1e82b8fc --- /dev/null +++ b/webapp/django/core/management/__init__.py @@ -0,0 +1,334 @@ +import os +import sys +from optparse import OptionParser +import imp + +import django +from django.core.management.base import BaseCommand, CommandError, handle_default_options + +# For backwards compatibility: get_version() used to be in this module. +get_version = django.get_version + +# A cache of loaded commands, so that call_command +# doesn't have to reload every time it's called. +_commands = None + +def find_commands(management_dir): + """ + Given a path to a management directory, returns a list of all the command + names that are available. + + Returns an empty list if no commands are defined. + """ + command_dir = os.path.join(management_dir, 'commands') + try: + return [f[:-3] for f in os.listdir(command_dir) + if not f.startswith('_') and f.endswith('.py')] + except OSError: + return [] + +def find_management_module(app_name): + """ + Determines the path to the management module for the given app_name, + without actually importing the application or the management module. + + Raises ImportError if the management module cannot be found for any reason. + """ + parts = app_name.split('.') + parts.append('management') + parts.reverse() + part = parts.pop() + path = None + + # When using manage.py, the project module is added to the path, + # loaded, then removed from the path. This means that + # testproject.testapp.models can be loaded in future, even if + # testproject isn't in the path. When looking for the management + # module, we need look for the case where the project name is part + # of the app_name but the project directory itself isn't on the path. + try: + f, path, descr = imp.find_module(part,path) + except ImportError,e: + if os.path.basename(os.getcwd()) != part: + raise e + + while parts: + part = parts.pop() + f, path, descr = imp.find_module(part, path and [path] or None) + return path + +def load_command_class(app_name, name): + """ + Given a command name and an application name, returns the Command + class instance. All errors raised by the import process + (ImportError, AttributeError) are allowed to propagate. + """ + return getattr(__import__('%s.management.commands.%s' % (app_name, name), + {}, {}, ['Command']), 'Command')() + +def get_commands(): + """ + Returns a dictionary mapping command names to their callback applications. + + This works by looking for a management.commands package in django.core, and + in each installed application -- if a commands package exists, all commands + in that package are registered. + + Core commands are always included. If a settings module has been + specified, user-defined commands will also be included, the + startproject command will be disabled, and the startapp command + will be modified to use the directory in which the settings module appears. + + The dictionary is in the format {command_name: app_name}. Key-value + pairs from this dictionary can then be used in calls to + load_command_class(app_name, command_name) + + If a specific version of a command must be loaded (e.g., with the + startapp command), the instantiated module can be placed in the + dictionary in place of the application name. + + The dictionary is cached on the first call and reused on subsequent + calls. + """ + global _commands + if _commands is None: + _commands = dict([(name, 'django.core') for name in find_commands(__path__[0])]) + + # Find the installed apps + try: + from django.conf import settings + apps = settings.INSTALLED_APPS + except (AttributeError, EnvironmentError, ImportError): + apps = [] + + # Find the project directory + try: + from django.conf import settings + project_directory = setup_environ( + __import__( + settings.SETTINGS_MODULE, {}, {}, + (settings.SETTINGS_MODULE.split(".")[-1],) + ) + ) + except (AttributeError, EnvironmentError, ImportError): + project_directory = None + + # Find and load the management module for each installed app. + for app_name in apps: + try: + path = find_management_module(app_name) + _commands.update(dict([(name, app_name) + for name in find_commands(path)])) + except ImportError: + pass # No management module - ignore this app + + if project_directory: + # Remove the "startproject" command from self.commands, because + # that's a django-admin.py command, not a manage.py command. + del _commands['startproject'] + + # Override the startapp command so that it always uses the + # project_directory, not the current working directory + # (which is default). + from django.core.management.commands.startapp import ProjectCommand + _commands['startapp'] = ProjectCommand(project_directory) + + return _commands + +def call_command(name, *args, **options): + """ + Calls the given command, with the given options and args/kwargs. + + This is the primary API you should use for calling specific commands. + + Some examples: + call_command('syncdb') + call_command('shell', plain=True) + call_command('sqlall', 'myapp') + """ + try: + app_name = get_commands()[name] + if isinstance(app_name, BaseCommand): + # If the command is already loaded, use it directly. + klass = app_name + else: + klass = load_command_class(app_name, name) + except KeyError: + raise CommandError, "Unknown command: %r" % name + return klass.execute(*args, **options) + +class LaxOptionParser(OptionParser): + """ + An option parser that doesn't raise any errors on unknown options. + + This is needed because the --settings and --pythonpath options affect + the commands (and thus the options) that are available to the user. + """ + def error(self, msg): + pass + + def print_help(self): + """Output nothing. + + The lax options are included in the normal option parser, so under + normal usage, we don't need to print the lax options. + """ + pass + + def print_lax_help(self): + """Output the basic options available to every command. + + This just redirects to the default print_help() behaviour. + """ + OptionParser.print_help(self) + + def _process_args(self, largs, rargs, values): + """ + Overrides OptionParser._process_args to exclusively handle default + options and ignore args and other options. + + This overrides the behavior of the super class, which stop parsing + at the first unrecognized option. + """ + while rargs: + arg = rargs[0] + try: + if arg[0:2] == "--" and len(arg) > 2: + # process a single long option (possibly with value(s)) + # the superclass code pops the arg off rargs + self._process_long_opt(rargs, values) + elif arg[:1] == "-" and len(arg) > 1: + # process a cluster of short options (possibly with + # value(s) for the last one only) + # the superclass code pops the arg off rargs + self._process_short_opts(rargs, values) + else: + # it's either a non-default option or an arg + # either way, add it to the args list so we can keep + # dealing with options + del rargs[0] + raise error + except: + largs.append(arg) + +class ManagementUtility(object): + """ + Encapsulates the logic of the django-admin.py and manage.py utilities. + + A ManagementUtility has a number of commands, which can be manipulated + by editing the self.commands dictionary. + """ + def __init__(self, argv=None): + self.argv = argv or sys.argv[:] + self.prog_name = os.path.basename(self.argv[0]) + + def main_help_text(self): + """ + Returns the script's main help text, as a string. + """ + usage = ['',"Type '%s help <subcommand>' for help on a specific subcommand." % self.prog_name,''] + usage.append('Available subcommands:') + commands = get_commands().keys() + commands.sort() + for cmd in commands: + usage.append(' %s' % cmd) + return '\n'.join(usage) + + def fetch_command(self, subcommand): + """ + Tries to fetch the given subcommand, printing a message with the + appropriate command called from the command line (usually + "django-admin.py" or "manage.py") if it can't be found. + """ + try: + app_name = get_commands()[subcommand] + if isinstance(app_name, BaseCommand): + # If the command is already loaded, use it directly. + klass = app_name + else: + klass = load_command_class(app_name, subcommand) + except KeyError: + sys.stderr.write("Unknown command: %r\nType '%s help' for usage.\n" % \ + (subcommand, self.prog_name)) + sys.exit(1) + return klass + + def execute(self): + """ + Given the command-line arguments, this figures out which subcommand is + being run, creates a parser appropriate to that command, and runs it. + """ + # Preprocess options to extract --settings and --pythonpath. + # These options could affect the commands that are available, so they + # must be processed early. + parser = LaxOptionParser(usage="%prog subcommand [options] [args]", + version=get_version(), + option_list=BaseCommand.option_list) + try: + options, args = parser.parse_args(self.argv) + handle_default_options(options) + except: + pass # Ignore any option errors at this point. + + try: + subcommand = self.argv[1] + except IndexError: + sys.stderr.write("Type '%s help' for usage.\n" % self.prog_name) + sys.exit(1) + + if subcommand == 'help': + if len(args) > 2: + self.fetch_command(args[2]).print_help(self.prog_name, args[2]) + else: + parser.print_lax_help() + sys.stderr.write(self.main_help_text() + '\n') + sys.exit(1) + # Special-cases: We want 'django-admin.py --version' and + # 'django-admin.py --help' to work, for backwards compatibility. + elif self.argv[1:] == ['--version']: + # LaxOptionParser already takes care of printing the version. + pass + elif self.argv[1:] == ['--help']: + parser.print_lax_help() + sys.stderr.write(self.main_help_text() + '\n') + else: + self.fetch_command(subcommand).run_from_argv(self.argv) + +def setup_environ(settings_mod): + """ + Configures the runtime environment. This can also be used by external + scripts wanting to set up a similar environment to manage.py. + Returns the project directory (assuming the passed settings module is + directly in the project directory). + """ + # Add this project to sys.path so that it's importable in the conventional + # way. For example, if this file (manage.py) lives in a directory + # "myproject", this code would add "/path/to/myproject" to sys.path. + project_directory, settings_filename = os.path.split(settings_mod.__file__) + if project_directory == os.curdir or not project_directory: + project_directory = os.getcwd() + project_name = os.path.basename(project_directory) + settings_name = os.path.splitext(settings_filename)[0] + sys.path.append(os.path.join(project_directory, os.pardir)) + project_module = __import__(project_name, {}, {}, ['']) + sys.path.pop() + + # Set DJANGO_SETTINGS_MODULE appropriately. + os.environ['DJANGO_SETTINGS_MODULE'] = '%s.%s' % (project_name, settings_name) + return project_directory + +def execute_from_command_line(argv=None): + """ + A simple method that runs a ManagementUtility. + """ + utility = ManagementUtility(argv) + utility.execute() + +def execute_manager(settings_mod, argv=None): + """ + Like execute_from_command_line(), but for use by manage.py, a + project-specific django-admin.py utility. + """ + setup_environ(settings_mod) + utility = ManagementUtility(argv) + utility.execute() |