|
Server : Apache System : Linux cvar2.toservers.com 3.10.0-962.3.2.lve1.5.73.el7.x86_64 #1 SMP Wed Aug 24 21:31:23 UTC 2022 x86_64 User : njnconst ( 1116) PHP Version : 8.4.18 Disable Function : NONE Directory : /lib64/python2.7/site-packages/django/core/management/ |
Upload File : |
�
r�\c @ s! d Z d d l m Z d d l Z d d l Z d d l m Z m Z d d l Z d d l m
Z
d d l m Z d d l
m Z d d l m Z d e f d
� � YZ d � Z d e f d
� � YZ d e f d � � YZ d e f d � � YZ d e f d � � YZ d e f d � � YZ d S( u�
Base classes for writing management commands (named commands which can
be executed through ``django-admin.py`` or ``manage.py``).
i����( t unicode_literalsN( t make_optiont OptionParser( t ImproperlyConfigured( t color_style( t force_str( t StringIOt CommandErrorc B s e Z d Z RS( u�
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__( ( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyR s c C sB | j r | j t j d <n | j r> t j j d | j � n d S( u�
Include any default options that all commands should accept here
so that ManagementUtility can handle them before searching for
user commands.
u DJANGO_SETTINGS_MODULEi N( t settingst ost environt
pythonpatht syst patht insert( t options( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyt handle_default_options$ s t
OutputWrapperc B s5 e Z d Z d d d � Z d � Z d d d � Z RS( u&
Wrapper around stdout/stderr
u
c C sF | | _ d | _ t | d � r9 | j � r9 | | _ n | | _ d S( Nu isatty( t _outt Nonet
style_funct hasattrt isattyt ending( t selft outR R ( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyt __init__5 s
c C s t | j | � S( N( t getattrR ( R t name( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyt __getattr__< s c C s� | d k r | j n | } | r> | j | � r> | | 7} n g | | j d � f D] } | d k rT | ^ qT d } | j j t | | � � � d S( Nc S s | S( N( ( t x( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyt <lambda>C s i ( R R t endswithR R t writeR ( R t msgR R t f( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyR$ ? s
N( R R R
R R R R$ ( ( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyR 1 s t BaseCommandc B s� e Z d Z e d d d d d d d d d d
d d d d
d g d d �e d d d �e d d d �e d d d d d �f Z d Z d Z e Z e Z e
Z e
Z d � Z
d � Z d � Z d � Z d � Z d � Z d � Z d" e
d � Z d! � Z RS(# u�
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 '<appname
appname ...>'.
``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.
``leave_locale_alone``
A boolean indicating whether the locale set in settings should be
preserved during the execution of the command instead of being
forcibly set to 'en-us'.
Default value is ``False``.
Make sure you know what you are doing if you decide to change the value
of this option in your custom command if it creates database content
that is locale-sensitive and such content shouldn't contain any
translations (like it happens e.g. with django.contrim.auth
permissions) as making the locale differ from the de facto default
'en-us' might cause unintended effects.
This option can't be False when the can_import_settings option is set
to False too because attempting to set the locale needs access to
settings. This condition will generate a CommandError.
u -vu --verbosityt actionu storet destu verbosityt defaultu 1t typeu choicet choicesu 0u 2u 3t helpu[ Verbosity level; 0=minimal output, 1=normal output, 2=verbose output, 3=very verbose outputu
--settingsu� 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.u --pythonpathuM A directory to add to the Python path, e.g. "/home/djangoprojects/myproject".u --tracebacku
store_trueu Raise on exceptionu c C s t � | _ d S( N( R t style( R ( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyR � s c C s
t j � S( u�
Return the Django version, which should be correct for all
built-in Django commands. User-supplied commands should
override this method.
( t djangot get_version( R ( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyR0 � s c C s5 d | | j f } | j r- d | | j f S| Sd S( u~
Return a brief description of how to use this command, by
default from the attribute ``self.help``.
u %%prog %s [options] %su %s
%sN( t argsR- ( R t
subcommandt usage( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyR3 � s c C s1 t d | d | j | � d | j � d | j � S( u|
Create and return the ``OptionParser`` which will be used to
parse the arguments to this command.
t progR3 t versiont option_list( R R3 R0 R6 ( R t prog_nameR2 ( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyt
create_parser� s c C s | j | | � } | j � d S( ub
Print the help message for this command, derived from
``self.usage()``.
N( R8 t
print_help( R R7 R2 t parser( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyR9 � s c C s� | j | d | d � } | j | d � \ } } t | � y | j | | j � Wn� t k
r� } | j s t | t � r� � n t | d t
t j | j
j � � } | j d | j j | f � t j d � n Xd S( uZ
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. If the ``--traceback`` option is present or the raised
``Exception`` is not ``CommandError``, raise it.
i i i u stderru %s: %sN( R8 t
parse_argsR t executet __dict__t Exceptiont tracebackt
isinstanceR R R R t stderrR. t ERRORR$ t __class__R t exit( R t argvR: R R1 t eRA ( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyt
run_from_argv� s
$ c
O s� t | j d t j � � | _ t | j d t j � | j j � | _ | j ra d d l m } n d
} | j s� | j s� t d | j | j f � � n d d l
m } | j � } | j d � n z� | j r� | j d � r� | j � n | j | | � } | r�| j rtd d l m } m } | | j d
| � } | j j � rt| j j | j j | j j � � � qtn | j j | � | j r�| j j d | j j d � � q�n Wd
| d
k r�| j | � n Xd
S( u�
Try to execute this command, performing model validation if
needed (as controlled by the attribute
``self.requires_model_validation``, except if force-skipped).
u stdoutu stderri����( R u` Incompatible values of 'leave_locale_alone' (%s) and 'can_import_settings' (%s) command options.( t translationu en-usu skip_validation( t connectionst DEFAULT_DB_ALIASu databaseu
u COMMIT;N( R t getR t stdoutRA R. RB t can_import_settingst django.confR R t leave_locale_aloneR t django.utilsRH t get_languaget activatet requires_model_validationt validatet handlet output_transactiont django.dbRI RJ t opst start_transaction_sqlR$ t SQL_KEYWORD(
R R1 R R t saved_localeRH t outputRI RJ t
connection( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyR< � s8 '
+ * c C s� d d l m } t � } | | | � } | rZ | j d � | j � } t d | � � n | r� | j j d | | d k r� d n d f � n d S(
u�
Validates the given app, raising CommandError for any errors.
If app is None, then this will validate all installed apps.
i����( t get_validation_errorsi u' One or more models did not validate:
%su %s error%s foundi u u sN( t! django.core.management.validationR^ R t seekt readR RL R$ ( R t appt display_num_errorsR^ t st
num_errorst
error_text( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyRT - s
c O s
t � � d S( ub
The actual logic of the command. Subclasses must implement
this method.
N( t NotImplementedError( R R1 R ( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyRU > s N( R R R
R R6 R- R1 t TrueRM RS t FalseRV RO R R0 R3 R8 R9 RG R< R RT RU ( ( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyR' H s2 \ 1t
AppCommandc B s& e Z d Z d Z d � Z d � Z RS( u
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.
u <appname appname ...>c
O s� d d l m } | s% t d � � n y& g | D] } | j | � ^ q/ } Wn) t t f k
rv } t d | � � n Xg } x6 | D]. } | j | | � } | r� | j | � q� q� Wd j | � S( Ni����( t modelsu Enter at least one appname.u8 %s. Are you sure your INSTALLED_APPS setting is correct?u
( RW Rk R t get_appR t ImportErrort
handle_appt appendt join(
R t
app_labelsR Rk t app_labelt app_listRF R\ Rb t
app_output( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyRU R s &
c K s
t � � d S( u�
Perform the command's actions for ``app``, which will be the
Python module corresponding to an application name given on
the command line.
N( Rg ( R Rb R ( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyRn a s ( R R R
R1 RU Rn ( ( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyRj G s t LabelCommandc B s, e Z d Z d Z d Z d � Z d � Z RS( u�
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.
u <label label ...>u labelc O sh | s t d | j � � n g } x6 | D]. } | j | | � } | r) | j | � q) q) Wd j | � S( Nu Enter at least one %s.u
( R t labelt handle_labelRo Rp ( R t labelsR R\ Rv t label_output( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyRU { s
c K s
t � � d S( u~
Perform the command's actions for ``label``, which will be the
string as given on the command line.
N( Rg ( R Rv R ( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyRw � s ( R R R
R1 Rv RU Rw ( ( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyRu k s
t
NoArgsCommandc B s& e Z d Z d Z d � Z d � Z RS( u8
A command which takes no arguments on the command line.
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``.
u c O s" | r t d � � n | j | � S( Nu$ Command doesn't accept any arguments( R t
handle_noargs( R R1 R ( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyRU � s c K s
t � � d S( u2
Perform this command's actions.
N( Rg ( R R ( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyR{ � s ( R R R
R1 RU R{ ( ( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyRz � s
( R
t
__future__R R R t optparseR R R/ t django.core.exceptionsR t django.core.management.colorR t django.utils.encodingR t django.utils.sixR R> R R t objectR R' Rj Ru Rz ( ( ( s= /tmp/pip-install-XxeQeY/django/django/core/management/base.pyt <module> s
�$$