ó ø¢TQc@sdZddlZddlZddlmZmZddlZddlZddlm Z ddl m Z ddl m Z ddlmZdefd „ƒYZd „Zd efd „ƒYZd efd„ƒYZdefd„ƒYZdefd„ƒYZdefd„ƒYZdS(s„ Base classes for writing management commands (named commands which can be executed through ``django-admin.py`` or ``manage.py``). iÿÿÿÿN(t make_optiont OptionParser(tImproperlyConfigured(t color_style(t force_str(tStringIOt CommandErrorcBseZdZRS(sÛ Exception class indicating a problem while executing a management command. If this exception is raised during the execution of a management 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. (t__name__t __module__t__doc__(((s4../Django//lib/python/django/core/management/base.pyRs cCsB|jr|jtjdtjjd|jƒndS(s¡ Include any default options that all commands should accept here so that ManagementUtility can handle them before searching for user commands. tDJANGO_SETTINGS_MODULEiN(tsettingstostenviront pythonpathtsystpathtinsert(toptions((s4../Django//lib/python/django/core/management/base.pythandle_default_options#s  t OutputWrappercBs5eZdZddd„Zd„Zddd„ZRS(s& Wrapper around stdout/stderr s cCsF||_d|_t|dƒr9|jƒr9||_n||_dS(Ntisatty(t_outtNonet style_functhasattrRtending(tselftoutRR((s4../Django//lib/python/django/core/management/base.pyt__init__4s    cCst|j|ƒS(N(tgetattrR(Rtname((s4../Django//lib/python/django/core/management/base.pyt __getattr__;scCs–|dkr|jp|}|r>|j|ƒ r>||7}ng||jd„fD]}|dk rT|^qTd}|jjt||ƒƒƒdS(NcSs|S(N((tx((s4../Django//lib/python/django/core/management/base.pytBsi(RRtendswithRRtwriteR(RtmsgRRtf((s4../Django//lib/python/django/core/management/base.pyR$>s  N(RRR RRR R$(((s4../Django//lib/python/django/core/management/base.pyR0s t BaseCommandcBsøeZdZeddddddddd d d d dd dgddƒedddƒedddƒedddddƒfZdZdZeZeZ e Z d„Z d„Z d„Zd„Zd„Zd„Zd„Zd"e d „Zd!„ZRS(#s‹ The base class from which all management commands ultimately derive. Use this class if you want access to all of the mechanisms which parse the command-line arguments and work out what code to call in response; if you don't need to change any of that behavior, consider using one of the subclasses defined in this file. If you are interested in overriding/customizing various aspects of the command-parsing and -execution behavior, the normal flow works as follows: 1. ``django-admin.py`` or ``manage.py`` loads the command class and calls its ``run_from_argv()`` method. 2. The ``run_from_argv()`` method calls ``create_parser()`` to get an ``OptionParser`` for the arguments, parses them, performs any environment changes requested by options like ``pythonpath``, and then calls the ``execute()`` method, passing the parsed arguments. 3. The ``execute()`` method attempts to carry out the command by calling the ``handle()`` method with the parsed arguments; any output produced by ``handle()`` will be printed to standard output and, if the command is intended to produce a block of SQL statements, will be wrapped in ``BEGIN`` and ``COMMIT``. 4. If ``handle()`` or ``execute()`` raised any exception (e.g. ``CommandError``), ``run_from_argv()`` will instead print an error message to ``stderr``. Thus, the ``handle()`` method is typically the starting point for subclasses; many built-in commands and command types either place 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 ''. ``can_import_settings`` A boolean indicating whether the command needs to be able to import Django settings; if ``True``, ``execute()`` will verify that this is possible before proceeding. Default value is ``True``. ``help`` A short description of the command, which will be printed in help messages. ``option_list`` This is the list of ``optparse`` options which will be fed into the command's ``OptionParser`` for parsing arguments. ``output_transaction`` A boolean indicating whether the command outputs SQL statements; if ``True``, the output will automatically be wrapped with ``BEGIN;`` and ``COMMIT;``. Default value is ``False``. ``requires_model_validation`` A boolean; if ``True``, validation of installed models will be 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. s-vs --verbositytactiontstoretdestt verbositytdefaultt1ttypetchoicetchoicest0t2t3thelps[Verbosity level; 0=minimal output, 1=normal output, 2=verbose output, 3=very verbose outputs --settingss›The Python path to a settings module, e.g. "myproject.settings.main". If this isn't provided, the DJANGO_SETTINGS_MODULE environment variable will be used.s --pythonpathsMA directory to add to the Python path, e.g. "/home/djangoprojects/myproject".s --tracebackt store_truesPrint traceback on exceptiontcCstƒ|_dS(N(Rtstyle(R((s4../Django//lib/python/django/core/management/base.pyR§scCs tjƒS(s« Return the Django version, which should be correct for all built-in Django commands. User-supplied commands should override this method. (tdjangot get_version(R((s4../Django//lib/python/django/core/management/base.pyR9ªscCs5d||jf}|jr-d||jfS|SdS(s~ Return a brief description of how to use this command, by default from the attribute ``self.help``. s%%prog %s [options] %ss%s %sN(targsR4(Rt subcommandtusage((s4../Django//lib/python/django/core/management/base.pyR<³s c Cs1td|d|j|ƒd|jƒd|jƒS(s| Create and return the ``OptionParser`` which will be used to parse the arguments to this command. tprogR<tversiont option_list(RR<R9R?(Rt prog_nameR;((s4../Django//lib/python/django/core/management/base.pyt create_parser¿s  cCs |j||ƒ}|jƒdS(sb Print the help message for this command, derived from ``self.usage()``. N(RAt print_help(RR@R;tparser((s4../Django//lib/python/django/core/management/base.pyRBÊscCsÛ|j|d|dƒ}|j|dƒ\}}t|ƒy|j||jŽWn€tk rÖ}t|dttj |j j ƒƒ}|j r©|j t jƒƒn|j d|jj|fƒtjdƒnXdS(sê Set up any environment changes requested (e.g., Python path and Django settings), then run this command. If the command raises a ``CommandError``, intercept it and print it sensibly to stderr. iiitstderrs%s: %sN(RAt parse_argsRtexecutet__dict__t ExceptionRRRRDR7tERRORt tracebackR$t format_exct __class__Rtexit(RtargvRCRR:teRD((s4../Django//lib/python/django/core/management/base.pyt run_from_argvÓs $ c Os”d }t|jdtjƒƒ|_t|jdtjƒ|jjƒ|_|jr€ddl m }|j ƒ}|j dƒnzð|j r©|jdƒ r©|jƒn|j||Ž}|ro|jr0ddlm}m}||jd|ƒ}|jjƒr0|jj|jj|jjƒƒƒq0n|jj|ƒ|jro|jjd |jjd ƒƒqonWd |d k r|j |ƒnXd S( s Try to execute this command, performing model validation if needed (as controlled by the attribute ``self.requires_model_validation``, except if force-skipped). tstdoutRDiÿÿÿÿ(t translationsen-ustskip_validation(t connectionstDEFAULT_DB_ALIAStdatabases sCOMMIT;N(RRtgetRRQRDR7RItcan_import_settingst django.utilsRRt get_languagetactivatetrequires_model_validationtvalidatethandletoutput_transactiont django.dbRTRUtopststart_transaction_sqlR$t SQL_KEYWORD( RR:Rt saved_langRRtoutputRTRUt connection((s4../Django//lib/python/django/core/management/base.pyRFès, '    + * cCs“ddlm}tƒ}|||ƒ}|rZ|jdƒ|jƒ}td|ƒ‚n|r|jjd||dkrdp„dfƒnd S( s• Validates the given app, raising CommandError for any errors. If app is None, then this will validate all installed apps. iÿÿÿÿ(tget_validation_errorsis'One or more models did not validate: %ss%s error%s founditsR6N(t!django.core.management.validationRgRtseektreadRRQR$(Rtapptdisplay_num_errorsRgRht num_errorst error_text((s4../Django//lib/python/django/core/management/base.pyR]s   cOs tƒ‚dS(sb The actual logic of the command. Subclasses must implement this method. N(tNotImplementedError(RR:R((s4../Django//lib/python/django/core/management/base.pyR^ sN(RRR RR?R4R:tTrueRXR\tFalseR_RR9R<RARBRPRFRR]R^(((s4../Django//lib/python/django/core/management/base.pyR'Gs0K      't AppCommandcBs&eZdZdZd„Zd„ZRS(s 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. sc OsÃddlm}|s%tdƒ‚ny&g|D]}|j|ƒ^q/}Wn)ttfk rv}td|ƒ‚nXg}x6|D].}|j||} | r„|j| ƒq„q„Wdj|ƒS(Niÿÿÿÿ(tmodelssEnter at least one appname.s8%s. Are you sure your INSTALLED_APPS setting is correct?s ( R`RtRtget_appRt ImportErrort handle_apptappendtjoin( Rt app_labelsRRtt app_labeltapp_listROReRlt app_output((s4../Django//lib/python/django/core/management/base.pyR^4s& cKs tƒ‚dS(s­ Perform the command's actions for ``app``, which will be the Python module corresponding to an application name given on the command line. N(Rp(RRlR((s4../Django//lib/python/django/core/management/base.pyRwCs(RRR R:R^Rw(((s4../Django//lib/python/django/core/management/base.pyRs)s t LabelCommandcBs,eZdZdZdZd„Zd„ZRS(s€ A management command which takes one or more arbitrary arguments (labels) on the command line, and does something with each of them. 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. s