blinkster: comparison web/lib/django/core/management/base.py

equal deleted inserted replaced

-:b758351d191f
+:cc9b7e14412b
 from optparse import make_option, OptionParser
 import django
 from django.core.exceptions import ImproperlyConfigured
 from django.core.management.color import color_style
+from django.utils.encoding import smart_str
-try:
-set
-except NameError:
-from sets import Set as set     # For Python 2.3
 class CommandError(Exception):
 """
 Exception class indicating a problem while executing a management
 command.
 command, it will be caught and turned into a nicely-printed error
 message to the appropriate output stream (i.e., stderr); as a
 result, raising this exception (with a sensible description of the
 error) is the preferred way to indicate that something has gone
 wrong in the execution of a command.
 """
 pass
 def handle_default_options(options):
 """
 Include any default options that all commands should accept here
 so that ManagementUtility can handle them before searching for
 user commands.
 """
 if options.settings:
 os.environ['DJANGO_SETTINGS_MODULE'] = options.settings
 if options.pythonpath:
 sys.path.insert(0, options.pythonpath)
 all of their logic in ``handle()``, or perform some additional
 parsing work in ``handle()`` and then delegate from it to more
 specialized methods as needed.
 Several attributes affect behavior at various steps along the way:
 ``args``
 A string listing the arguments accepted by the command,
 suitable for use in help messages; e.g., a command which takes
 a list of application names might set this to '<appname
 appname ...>'.
 performed prior to executing the command. Default value is
 ``True``. To validate an individual application's models
 rather than all applications' models, call
 ``self.validate(app)`` from ``handle()``, where ``app`` is the
 application's Python module.
 """
 # Metadata about this command.
 option_list = (
 make_option('-v', '--verbosity', action='store', dest='verbosity', default='1',
 type='choice', choices=['0', '1', '2'],
 def get_version(self):
 """
 Return the Django version, which should be correct for all
 built-in Django commands. User-supplied commands should
 override this method.
 """
 return django.get_version()
 def usage(self, subcommand):
 """
 Return a brief description of how to use this command, by
 default from the attribute ``self.help``.
 """
 usage = '%%prog %s [options] %s' % (subcommand, self.args)
 if self.help:
 return '%s\n\n%s' % (usage, self.help)
 else:
 def create_parser(self, prog_name, subcommand):
 """
 Create and return the ``OptionParser`` which will be used to
 parse the arguments to this command.
 """
 return OptionParser(prog=prog_name,
 usage=self.usage(subcommand),
 version=self.get_version(),
 option_list=self.option_list)
 def print_help(self, prog_name, subcommand):
 """
 Print the help message for this command, derived from
 ``self.usage()``.
 """
 parser = self.create_parser(prog_name, subcommand)
 parser.print_help()
 def run_from_argv(self, argv):
 """
 Set up any environment changes requested (e.g., Python path
 and Django settings), then run this command.
 """
 parser = self.create_parser(argv[0], argv[1])
 options, args = parser.parse_args(argv[2:])
 handle_default_options(options)
 self.execute(*args, **options.__dict__)
 Try to execute this command, performing model validation if
 needed (as controlled by the attribute
 ``self.requires_model_validation``). If the command raises a
 ``CommandError``, intercept it and print it sensibly to
 stderr.
 """
 # Switch to English, because django-admin.py creates database content
 # like permissions, and those shouldn't contain any translations.
 # But only do this if we can assume we have a working settings file,
 # because django.utils.translation requires settings.
 from django.utils import translation
 translation.activate('en-us')
 except ImportError, e:
 # If settings should be available, but aren't,
 # raise the error and quit.
-sys.stderr.write(self.style.ERROR(str('Error: %s\n' % e)))
+sys.stderr.write(smart_str(self.style.ERROR('Error: %s\n' % e)))
 sys.exit(1)
 try:
 if self.requires_model_validation:
 self.validate()
 output = self.handle(*args, **options)
 print self.style.SQL_KEYWORD(connection.ops.start_transaction_sql())
 print output
 if self.output_transaction:
 print self.style.SQL_KEYWORD("COMMIT;")
 except CommandError, e:
-sys.stderr.write(self.style.ERROR(str('Error: %s\n' % e)))
+sys.stderr.write(smart_str(self.style.ERROR('Error: %s\n' % e)))
 sys.exit(1)
 def validate(self, app=None, display_num_errors=False):
 """
 Validates the given app, raising CommandError for any errors.
 If app is None, then this will validate all installed apps.
 """
 from django.core.management.validation import get_validation_errors
 try:
 from cStringIO import StringIO
 except ImportError:
 def handle(self, *args, **options):
 """
 The actual logic of the command. Subclasses must implement
 this method.
 """
 raise NotImplementedError()
 class AppCommand(BaseCommand):
 """
 A management command which takes one or more installed application
 names as arguments, and does something with each of them.
 Rather than implementing ``handle()``, subclasses must implement
 ``handle_app()``, which will be called once for each application.
 """
 args = '<appname appname ...>'
 def handle(self, *app_labels, **options):
 from django.db import models
 def handle_app(self, app, **options):
 """
 Perform the command's actions for ``app``, which will be the
 Python module corresponding to an application name given on
 the command line.
 """
 raise NotImplementedError()
 class LabelCommand(BaseCommand):
 """
 Rather than implementing ``handle()``, subclasses must implement
 ``handle_label()``, which will be called once for each label.
 If the arguments should be names of installed applications, use
 ``AppCommand`` instead.
 """
 args = '<label label ...>'
 label = 'label'
 def handle(self, *labels, **options):
 def handle_label(self, label, **options):
 """
 Perform the command's actions for ``label``, which will be the
 string as given on the command line.
 """
 raise NotImplementedError()
 class NoArgsCommand(BaseCommand):
 """
 Rather than implementing ``handle()``, subclasses must implement
 ``handle_noargs()``; ``handle()`` itself is overridden to ensure
 no arguments are passed to the command.
 Attempting to pass arguments will raise ``CommandError``.
 """
 args = ''
 def handle(self, *args, **options):
 if args:
 return self.handle_noargs(**options)
 def handle_noargs(self, **options):
 """
 Perform this command's actions.
 """
 raise NotImplementedError()
 def copy_helper(style, app_or_project, name, directory, other_name=''):
 """
 def _make_writeable(filename):
 """
 Make sure that the file is writeable. Useful if our source is
 read-only.
 """
 import stat
 if sys.platform.startswith('java'):
 # On Jython there is no os.access()
 return

changeset 29	cc9b7e14412b
parent 0	0d40e90630ef