ó TR¹Nc@sdZddlZddlZddlmZmZddlZddlmZddl m Z ddl m Z de fd„ƒYZd „Zd efd „ƒYZd efd „ƒYZdefd„ƒYZdefd„ƒYZdd„Zd„ZdS(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 smart_strt 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__(((sH/home/panlixing/Python_Projects/gaeseries/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((sH/home/panlixing/Python_Projects/gaeseries/django/core/management/base.pythandle_default_optionss  t BaseCommandcBsõeZdZeddddddddd d d d dd gddƒedddƒedddƒedddddƒfZdZdZeZeZ e Z d„Z d„Z d„Zd„Zd„Zd„Zd„Zd!e d„Zd „ZRS("sY 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()`` raised a ``CommandError``, ``execute()`` 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 verbositytdefaultt1ttypetchoicetchoicest0t2thelps@Verbosity level; 0=minimal output, 1=normal output, 2=all 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(tself((sH/home/panlixing/Python_Projects/gaeseries/django/core/management/base.pyt__init__Š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#((sH/home/panlixing/Python_Projects/gaeseries/django/core/management/base.pyR&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(targsR(R#t subcommandtusage((sH/home/panlixing/Python_Projects/gaeseries/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)R&R,(R#t prog_nameR(((sH/home/panlixing/Python_Projects/gaeseries/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(R.t print_help(R#R-R(tparser((sH/home/panlixing/Python_Projects/gaeseries/django/core/management/base.pyR/­scCsT|j|d|dƒ}|j|dƒ\}}t|ƒ|j||jŽdS(sƒ Set up any environment changes requested (e.g., Python path and Django settings), then run this command. iiiN(R.t parse_argsRtexecutet__dict__(R#targvR0RR'((sH/home/panlixing/Python_Projects/gaeseries/django/core/management/base.pyt run_from_argv¶s cOsb|jrvy!ddlm}|jdƒWqvtk rr}tjjt|j j d|ƒƒƒtj dƒqvXnyŸ|j r|j ƒn|j||Ž}|r|jrïddlm}|jjƒrï|j j|jjƒƒGHqïn|GH|jr|j jdƒGHqnWnFtk r]}tjjt|j j d|ƒƒƒtj dƒnXdS( s 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. iÿÿÿÿ(t translationsen-uss Error: %s i(t connectionsCOMMIT;N(tcan_import_settingst django.utilsR6tactivatet ImportErrorRtstderrtwriteRR"tERRORtexittrequires_model_validationtvalidatethandletoutput_transactiont django.dbR7topststart_transaction_sqlt SQL_KEYWORDR(R#R'RR6tetoutputR7((sH/home/panlixing/Python_Projects/gaeseries/django/core/management/base.pyR2Ás, &     &cCsÀddlm}yddlm}Wn!tk rGddlm}nX|ƒ}|||ƒ}|r’|jdƒ|jƒ}td|ƒ‚n|r¼d||dkr°dp³d fGHnd 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_errors(tStringIOis'One or more models did not validate: %ss%s error%s founditsR!N(t!django.core.management.validationRJt cStringIORKR;tseektreadR(R#tapptdisplay_num_errorsRJRKRLt num_errorst error_text((sH/home/panlixing/Python_Projects/gaeseries/django/core/management/base.pyRAès    cOs tƒ‚dS(sb The actual logic of the command. Subclasses must implement this method. N(tNotImplementedError(R#R'R((sH/home/panlixing/Python_Projects/gaeseries/django/core/management/base.pyRBýsN(RRRRR,RR'tTrueR8R@tFalseRCR$R&R)R.R/R5R2tNoneRARB(((sH/home/panlixing/Python_Projects/gaeseries/django/core/management/base.pyR+s0J     '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 ( RDRZRtget_appRR;t handle_apptappendtjoin( R#t app_labelsRRZt app_labeltapp_listRHRIRQt app_output((sH/home/panlixing/Python_Projects/gaeseries/django/core/management/base.pyRBs& 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(RU(R#RQR((sH/home/panlixing/Python_Projects/gaeseries/django/core/management/base.pyR\s(RRRR'RBR\(((sH/home/panlixing/Python_Projects/gaeseries/django/core/management/base.pyRYs 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