|
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 d l 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
m Z m Z d d l
m Z d d l m Z d d l m Z d d l m Z d a d � Z d
� Z d � Z d � Z d
� Z d e f d � � YZ d e f d � � YZ d d � Z d S( i����N( t OptionParsert
NO_DEFAULT( t ImproperlyConfigured( t BaseCommandt CommandErrort handle_default_options( t color_style( t
import_module( t six( t get_versionc C su t j j | d � } yG g t j | � D]/ } | j d � r( | j d � r( | d ^ q( SWn t k
rp g SXd S( s�
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.
t commandst _s .pyi����N( t ost patht joint listdirt
startswitht endswitht OSError( t management_dirt command_dirt f( ( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyt
find_commands s 1
c C s | j d � } | j d � | j � | j � } d } y t j | | � \ } } } Wn: t k
r� } t j j
t j � � | k r� | � q� n X| r� | j � n xS | r� | j � } t j | | r� | g n d � \ } } } | r� | j � q� q� W| S( s�
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.
t .t
managementN(
t splitt appendt reverset popt Nonet impt find_modulet ImportErrorR R
t basenamet getcwdt close( t app_namet partst partR
R t descrt e( ( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyt find_management_module" s$
*c C s t d | | f � } | j � S( s�
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.
s %s.management.commands.%s( R t Command( R$ t namet module( ( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyt load_command_classE s c C s� t d k r� t g t t d � D] } | d f ^ q � a d d l m } y
| j } Wn t k
rq g } n Xxg | D]\ } yB t | � } t j
t g t | � D] } | | f ^ q� � � Wqy t k
r� qy Xqy Wn t S( s_
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 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.
i s django.corei����( t settingsN( t _commandsR t dictR t __path__t django.confR. t INSTALLED_APPSR R) t updateR ( R+ R. t appsR$ R
( ( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyt get_commandsN s /
*
c O s� y t � | } Wn! t k
r4 t d | � � n Xt | t � rM | } n t | | � } i } x@ | j D]5 } | j t k r� d | | j
<ql | j | | j
<ql W| j | � | j | | � S( s
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')
s Unknown command: %rN(
R6 t KeyErrorR t
isinstanceR R- t option_listt defaultR R t destR4 t execute( R+ t argst optionsR$ t klasst defaultst opt( ( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyt call_command| s
t LaxOptionParserc B s2 e Z d Z d � Z d � Z d � Z d � Z RS( s�
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.
c C s d S( N( ( t selft msg( ( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyt error� s c C s d S( s� 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.
N( ( RD ( ( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyt
print_help� s c C s t j | � d S( s� Output the basic options available to every command.
This just redirects to the default print_help() behavior.
N( R RG ( RD ( ( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyt print_lax_help� s c C s� x� | r� | d } y~ | d d !d k rN t | � d k rN | j | | � nB | d d k r� t | � d k r� | j | | � n
| d =t � Wq | j | � q Xq Wd S( s�
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.
i i s --i t -N( t lent _process_long_optt _process_short_optst ExceptionR ( RD t largst rargst valuest arg( ( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyt
_process_args� s
%"
( t __name__t
__module__t __doc__RF RG RH RR ( ( ( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyRC � s
t ManagementUtilityc B sA e Z d Z d d � Z e d � Z d � Z d � Z d � Z RS( s�
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.
c C s3 | p
t j | _ t j j | j d � | _ d S( Ni ( t syst argvR R
R! t prog_name( RD RX ( ( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyt __init__� s c C s+ | r t t � j � � } n d d | j d d g } t j d � � } xY t j t � � D]E \ } } | d k r} d } n | j d � d } | | j | � q\ Wt
� } xm t | j � � D]Y } | j d � | j | j d | � � x) t | | � D] } | j d
| � q� Wq� Wd j | � S( sC
Returns the script's main help text, as a string.
t s> Type '%s help <subcommand>' for help on a specific subcommand.s Available subcommands:c S s g S( N( ( ( ( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyt <lambda>� s s django.coret djangoR i����s [%s]s %ss
(
t sortedR6 t keysRY t collectionst defaultdictR t iteritemst
rpartitionR R t NOTICER ( RD t
commands_onlyt usaget
commands_dictR+ t appt style( ( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyt main_help_text� s&
c C s� t � } y | | } Wn; t k
rT t j j d | | j f � t j d � n Xt | t � rm | } n t | | � } | S( s�
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.
s. Unknown command: %r
Type '%s help' for usage.
i (
R6 R7 RW t stderrt writeRY t exitR8 R R- ( RD t
subcommandR
R$ R? ( ( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyt
fetch_command� s
c
s� d t j k r d St j d j � d } t t j d � } y | | d � Wn t k
rh d � n Xt t � � d g } d g } | d k r� d j t t
� f d
� | � � � GHn�| d | k r�| d d k r�| j | d � } | d d k r6d
d l m
} | g | D] } | d f ^ q7} nn | d d k r�yG d
d l m } | g | j D] } | j d � d
d f ^ qf7} Wq�t k
r�q�Xn | g | j D] }
|
j � |
j f ^ q�7} g | d | d !D] } | j d � d ^ q�} g | D] }
|
d | k r |
^ q } t g | D]' \ } } | j � � r7| | f ^ q7� } x7 | D], } | d } | d r�| d 7} n | GHqnWn t j d � d S( s�
Output completion suggestions for BASH.
The output of this function is passed to BASH's `COMREPLY` variable and
treated as completion suggestions. `COMREPLY` expects a space
separated string as the result.
The `COMP_WORDS` and `COMP_CWORD` BASH environment variables are used
to get information about the cli input. Please refer to the BASH
man-page for more information about this variables.
Subcommand options are saved as pairs. A pair consists of
the long option string (e.g. '--exclude') and a boolean
value indicating if the option requires arguments. When printing to
stdout, a equal sign is appended to options which require arguments.
Note: If debugging this function, it is recommended to write the debug
output in a separate file. Otherwise the debug output will be treated
and formatted as potential completion suggestions.
t DJANGO_AUTO_COMPLETENt
COMP_WORDSi t
COMP_CWORDR[ t helps --helpt c s
| j � � S( N( R ( t x( t curr( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyR\ 9 s i t runfcgii����( t FASTCGI_OPTIONSt dumpdatat sqlt sqlallt sqlcleart sqlcustomt
sqlindexest sqlsequenceresett test( R. R t =( s --helpN( Ry Rz R{ R| R} R~ R s test( R t environR t intt
IndexErrort listR6 R R R^ t filterRo t django.core.servers.fastcgiRx R2 R. R3 R R9 t get_opt_stringt nargsR RW Rm ( RD t cwordst cwordt subcommandsR> t subcommand_clsRx t kR. t at s_optRu t prev_optsRA t vt optiont opt_label( ( Rv sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyt autocomplete sF
) & 7
)1):
c C s� t d d d t � d t j � } | j � y& | j | j � \ } } t | � Wn n Xy | j d } Wn t k
r� d } n X| d k r%t | � d k r� | j
� t j j
| j � d � q�| d d k r� t j j
| j d
t � d � q�| j | d � j | j | d � n� | d k rNt j j
| j � d � nx | j d d g k rgn_ | j d d g d
g f k r�| j
� t j j
| j � d � n | j | � j | j � d S( s�
Given the command-line arguments, this figures out which subcommand is
being run, creates a parser appropriate to that command, and runs it.
Rf s! %prog subcommand [options] [args]t versionR9 i Rs i s
s
--commandsRe s --versions --helps -hN( RC R R R9 R� t
parse_argsRX R R� RJ RH RW t stdoutRl Rj t TrueRo RG RY t
run_from_argv( RD t parserR> R= Rn ( ( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyR< ^ s8
#'
N(
RS RT RU R RZ t FalseRj Ro R� R< ( ( ( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyRV � s Kc C s t | � } | j � d S( s8
A simple method that runs a ManagementUtility.
N( RV R< ( RX t utility( ( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyt execute_from_command_line� s ( R` R RW t optparseR R R t django.core.exceptionsR t django.core.management.baseR R R t django.core.management.colorR t django.utils.importlibR t django.utilsR R] R R R/ R R) R- R6 RB RC t objectRV R� ( ( ( sA /tmp/pip-install-XxeQeY/django/django/core/management/__init__.pyt <module> s& # . %6�