File: //usr/lib/python3/dist-packages/django/core/management/__pycache__/base.cpython-310.pyc
o
3�a�X � @ s d Z ddlZddlZddlZddlmZmZ ddlmZ ddl Z ddl
m Z ddl m
Z
ddlmZmZ ddlmZmZ dd lmZ d
ZG d d � d e�ZG d
d� de�ZG dd� de�Zdd� Zdd� Z G dd� de�Z G dd� de�Z G dd� d�Z G dd � d e �Z G d d � d e �Z!dS ) z�
Base classes for writing management commands (named commands which can
be executed through ``django-admin`` or ``manage.py``).
� N)�ArgumentParser�
HelpFormatter)�
TextIOBase)�checks)�ImproperlyConfigured)� color_style�no_style)�DEFAULT_DB_ALIAS� connections)�RemovedInDjango41Warning�__all__c s& e Zd ZdZdd�� fdd�
Z� ZS )� CommandErrora�
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.
� )�
returncodec s || _ t� j|i |�� d S �N)r �super�__init__)�selfr �args�kwargs�� __class__� �=/usr/lib/python3/dist-packages/django/core/management/base.pyr ! s zCommandError.__init__)�__name__�
__module__� __qualname__�__doc__r �
__classcell__r r r r r
s r
c @ s e Zd ZdZdS )�SystemCheckErrorzC
The system check framework detected unrecoverable errors.
N)r r r r r r r r r & s r c sB e Zd ZdZddd�� fdd�
Zd
� fdd� Z� fdd �Z� ZS ) �
CommandParserz�
Customized ArgumentParser class to improve some error messages and prevent
SystemExit in several occasions, as SystemExit is unacceptable when a
command is called programmatically.
N)�missing_args_message�called_from_command_linec s" || _ || _t� jdi |�� d S )Nr )r! r" r r )r r! r" r r r r r 3 s zCommandParser.__init__c s6 | j r|stdd� |D ��s| �| j � t� �||�S )Nc s s � | ] }|� d � V qdS )�-N)�
startswith)�.0�argr r r � <genexpr>; s � z+CommandParser.parse_args.<locals>.<genexpr>)r! �any�errorr �
parse_args)r r � namespacer r r r* 8 s �� zCommandParser.parse_argsc s" | j r t� �|� d S td| ��)Nz Error: %s)r" r r) r
)r �messager r r r) ? s zCommandParser.error)NN)r r r r r r* r) r r r r r r - s
r c C s0 | j r | j tjd< | jrtj�d| j� dS dS )z�
Include any default options that all commands should accept here
so that ManagementUtility can handle them before searching for
user commands.
�DJANGO_SETTINGS_MODULEr N)�settings�os�environ�
pythonpath�sys�path�insert)�optionsr r r �handle_default_optionsF s
�r6 c s � fdd�}|S )zEDecorator that forces a command to run with translations deactivated.c sZ ddl m} |�� }|�� z� | i |��}W |d ur |�|� |S |d ur,|�|� w w )Nr )� translation)� django.utilsr7 � get_language�deactivate_all�activate)r r r7 � saved_locale�res�� handle_funcr r �wrappedT s
� �z no_translations.<locals>.wrappedr )r? r@ r r> r �no_translationsR s
rA c s< e Zd ZdZh d�Zdd� Z� fdd�Z� fdd�Z� ZS ) �DjangoHelpFormatterz�
Customized formatter so that command-specific arguments appear in the
--help output before arguments common to all commands.
> � --version�
--no-color�
--settings� --traceback� --verbosity� --pythonpath�
--force-color�
--skip-checksc s t |� fdd�d�S )Nc s t | j�� j@ t � kS r )�set�option_strings� show_last)�a�r r r �<lambda>n � z8DjangoHelpFormatter._reordered_actions.<locals>.<lambda>)�key)�sorted�r �actionsr rO r �_reordered_actionsk s
�z&DjangoHelpFormatter._reordered_actionsc s& t � j|| �|�g|�R i |�� d S r )r � add_usagerV )r �usagerU r r r r r rW q s &z DjangoHelpFormatter.add_usagec s t � �| �|�� d S r )r �
add_argumentsrV rT r r r rY t � z!DjangoHelpFormatter.add_arguments) r r r r rM rV rW rY r r r r r rB a s rB c @ sV e Zd ZdZedd� �Zejdd� �Zddd�Zdd � Zd
d � Z d d
� Z
ddd�Z dS )�
OutputWrapperz&
Wrapper around stdout/stderr
c C s | j S r )� _style_funcrO r r r �
style_func| s zOutputWrapper.style_funcc C s$ |r | � � r || _d S dd� | _d S )Nc S � | S r r ��xr r r rP � � z*OutputWrapper.style_func.<locals>.<lambda>)�isattyr\ )r r] r r r r] � s
�
c C s || _ d | _|| _d S r )�_outr] �ending)r �outre r r r r � s
zOutputWrapper.__init__c C s t | j|�S r )�getattrrd )r �namer r r � __getattr__� s zOutputWrapper.__getattr__c C s t | jd�r
| j�� d S d S )N�flush)�hasattrrd rj rO r r r rj � s �zOutputWrapper.flushc C s t | jd�o
| j�� S )Nrb )rk rd rb rO r r r rb � rZ zOutputWrapper.isatty� Nc C sF |d u r| j n|}|r|�|�s||7 }|p| j}| j�||�� d S r )re �endswithr] rd �write)r �msgr] re r r r rn � s
zOutputWrapper.write)rc )rl NN) r r r r �propertyr] �setterr ri rj rb rn r r r r r[ x s
r[ c @ s� e Zd ZdZdZdZdZdZdZdZ dZ
d dd �Z d
d � Z d d
� Z
dd� Zdd� Zdd� Zdd� Zddddejdfdd�Zdd� Zdd� ZdS ) � BaseCommanda
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`` 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 ``ArgumentParser`` 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:
``help``
A short description of the command, which will be printed in
help messages.
``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_migrations_checks``
A boolean; if ``True``, the command prints a warning if the set of
migrations on disk don't match the migrations in the database.
``requires_system_checks``
A list or tuple of tags, e.g. [Tags.staticfiles, Tags.models]. System
checks registered in the chosen tags will be checked for errors prior
to executing the command. The value '__all__' can be used to specify
that all system checks should be performed. Default value is '__all__'.
To validate an individual application's models
rather than all applications' models, call
``self.check(app_configs)`` from ``handle()``, where ``app_configs``
is the list of application's configuration provided by the
app registry.
``stealth_options``
A tuple of any options the command uses which aren't defined by the
argument parser.
rl Fr )�stderr�stdoutr Nc C s� t |ptj�| _t |p
tj�| _|r|rtd��|r t� | _n t|�| _| jj| j_ | j
dv r=t � dt
� | j
r:tng | _
t| j
ttf�sN| j
tkrPtd��d S d S )Nz4'no_color' and 'force_color' can't be used together.)FTz�Using a boolean value for requires_system_checks is deprecated. Use '__all__' instead of True, and [] (an empty list) instead of False.z/requires_system_checks must be a list or tuple.)r[ r2 rt rs r
r �styler �ERRORr] �requires_system_checks�warnings�warnr �
ALL_CHECKS�
isinstance�list�tuple� TypeError)r rt rs �no_color� force_colorr r r r � s(
��
�zBaseCommand.__init__c C s t �� S )z�
Return the Django version, which should be correct for all built-in
Django commands. User-supplied commands can override this method to
return their own version.
)�django� get_versionrO r r r r� s zBaseCommand.get_versionc
K s� t d dtj�|�|f | jpdtt| dd�t| dd�d�|��}|jdd| �� d� |jd d
d t g d �d
d� |jddd� |jddd� |jdddd� |jdddd� |jdddd� | j
rh|jd dd d� | � |� |S ) z}
Create and return the ``ArgumentParser`` which will be used to
parse the arguments to this command.
z%s %sNr! �_called_from_command_line)�prog� description�formatter_classr! r" rC �version)�actionr� z-vrG r )r r � � z[Verbosity level; 0=minimal output, 1=normal output, 2=verbose output, 3=very verbose output)�default�type�choices�helprE z�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.)r� rH zMA directory to add to the Python path, e.g. "/home/djangoprojects/myproject".rF �
store_truez Raise on CommandError exceptions)r� r� rD z"Don't colorize the command output.rI z)Force colorization of the command output.rJ zSkip system checks.r ) r r/ r3 �basenamer� rB rg � add_argumentr� �intrw rY )r � prog_name�
subcommandr �parserr r r �
create_parser sN
��������
zBaseCommand.create_parserc C s dS )zN
Entry point for subclassed commands to add custom arguments.
Nr �r r� r r r rY C s zBaseCommand.add_argumentsc C s | � ||�}|�� dS )za
Print the help message for this command, derived from
``self.usage()``.
N)r� �
print_help)r r� r� r� r r r r� I s zBaseCommand.print_helpc C s d| _ | �|d |d �}|�|dd� �}t|�}|�dd�}t|� zWz
| j|i |�� W n9 tyh } z-|jr;� t |t
�rL| j � t
|�dd � � n | j � d
|jj|f � t�|j� W Y d}~nd}~ww W zt�� W dS ty{ Y dS w zt�� W w ty� Y w w ) aZ
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.
Tr r r� Nr r c S r^ r r r_ r r r rP i ra z+BaseCommand.run_from_argv.<locals>.<lambda>z%s: %s)r� r� r* �vars�popr6 �executer
� tracebackr{ r rs rn �strr r r2 �exitr r
� close_allr )r �argvr� r5 � cmd_optionsr �er r r �
run_from_argvQ s8
��� �� �zBaseCommand.run_from_argvc O s |d r |d r t d��|d rtdd�| _n |d r#t� | _d| j_|�d�r/t|d �| _|�d�r;t|d �| _| j rS|d sS| j t
krL| � � n| j | j d
� | j rZ| �
� | j|i |��}|r�| jr�t|�d t� }d | j�|j�� �|| j�|j�� �f }| j�|� |S )
z�
Try to execute this command, performing system checks if needed (as
controlled by the ``requires_system_checks`` attribute, except if
force-skipped).
r� r z@The --no-color and --force-color options can't be used together.T)r� Nrt rs � skip_checks)�tags�databasez%s
%s
%s)r
r ru r rs r] �getr[ rt rw rz �check�requires_migrations_checks�check_migrations�handle�output_transactionr
r � SQL_KEYWORD�ops�start_transaction_sql�end_transaction_sqlrn )r r r5 �output�
connectionr r r r� u s8
� zBaseCommand.executec s� t j||||d�}d\}} }
d} |rmdd� |D �} dd� |D �}
dd� |D �}dd� |D �}d d� |D �}|d
f|d f|d f|
d
f| dfg}|D ]$\}}|rl| t|�7 } �fdd�|D �}d�t|��}| d||f 7 } qH| rqd}|r�| ry|
d7 }
|
d| dkr�dn | dkr�dnd| t|�| f 7 }
t� fdd�|D ��r��j�d| �| |
}t|��|| |
}|r�| rÈj �
|dd � � d S �j �
|� d S d S ) a
Use the system check framework to validate entire Django project.
Raise CommandError for any serious message (error or critical errors).
If there are only light messages (like warnings), print them to stderr
and don't raise an exception.
)� app_configsr� �include_deployment_checks� databases)rl rl rl r c S s$ g | ]}|j tjk r|�� s|�qS r )�levelr �INFO� is_silenced�r% r� r r r �
<listcomp>� � $ z%BaseCommand.check.<locals>.<listcomp>c S �6 g | ]}t j|j krt jk rn n|�� s|�qS r )r r� r� �WARNINGr� r� r r r r� � � 6 c S r� r )r r� r� rv r� r� r r r r� � r� c S r� r )r rv r� �CRITICALr� r� r r r r� � r� c S s$ g | ]}t j|jkr|�� s|�qS r )r r� r� r� r� r r r r� � r� � CRITICALS�ERRORS�WARNINGS�INFOS�DEBUGSc 3 s8 � | ]}|� � r� j�t|��n� j�t|��V qd S r )�
is_seriousru rv r� r� r� rO r r r' � s � ��
�z$BaseCommand.check.<locals>.<genexpr>rc z
%s:
%s
z%System check identified some issues:
z)System check identified %s (%s silenced).z no issuesr z1 issuez %s issuesc 3 s$ � | ]
}|� � �o
|�� V qd S r )r� r� r� )�
fail_levelr r r' � s �" zSystemCheckError: %sc S r^ r r r_ r r r rP � ra z#BaseCommand.check.<locals>.<lambda>N) r �
run_checks�len�joinrS r( ru rv r rs rn rt )r r� r� �display_num_errorsr� r� r� �
all_issues�header�body�footer�visible_issue_count�debugs�infosrx �errors� criticals�
sorted_issues�issues�
group_name� formattedro r )r� r r r� � sb �
�
��
� �zBaseCommand.checkc C s� ddl m} z|tt �}W n
ty Y dS w |�|jj�� �}|rMt dd� |D ��}| j
� | j �
dt|�d�|�d� �� | j
� | j �
d �� dS dS )
zv
Print a warning if the set of migrations on disk don't match the
migrations in the database.
r )�MigrationExecutorNc S s h | ]\}}|j �qS r )� app_label)r% � migration� backwardsr r r � <setcomp>� rQ z/BaseCommand.check_migrations.<locals>.<setcomp>z�
You have %(unapplied_migration_count)s unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): %(apps_waiting_migration)s.z, )�unapplied_migration_count�apps_waiting_migrationz-Run 'python manage.py migrate' to apply them.)� django.db.migrations.executorr� r
r r �migration_plan�loader�graph�
leaf_nodesrS rt rn ru �NOTICEr� r� )r r� �executor�planr� r r r r� � s( �����
�z BaseCommand.check_migrationsc O � t d��)za
The actual logic of the command. Subclasses must implement
this method.
z8subclasses of BaseCommand must provide a handle() method��NotImplementedError)r r r5 r r r r� � � zBaseCommand.handle)NNFF)r r r r r� r� r� r� rw �base_stealth_options�stealth_optionsr r� r� rY r� r� r� r rv r� r� r� r r r r rr � s, G
0$%
�E rr c @ s, e Zd ZdZdZdd� Zdd� Zdd� Zd S )
�
AppCommanda
A management command which takes one or more installed application labels
as arguments, and does something with each of them.
Rather than implementing ``handle()``, subclasses must implement
``handle_app_config()``, which will be called once for each application.
z%Enter at least one application label.c C s |j ddddd� d S )Nr r� �+z One or more application label.)�metavar�nargsr� )r� r� r r r rY rZ zAppCommand.add_argumentsc
s� ddl m� z � fdd�|D �}W n ttfy% } ztd| ��d }~ww g }|D ]}| j|fi |��}|r<|�|� q*d�|�S )Nr ��appsc s g | ]}� � |��qS r )�get_app_config)r% r� r� r r r� rQ z%AppCommand.handle.<locals>.<listcomp>z8%s. Are you sure your INSTALLED_APPS setting is correct?rc )� django.appsr� � LookupError� ImportErrorr
�handle_app_config�appendr� )r �
app_labelsr5 r� r� r� �
app_config�
app_outputr r� r r� s ��
�
zAppCommand.handlec K r� )z�
Perform the command's actions for app_config, an AppConfig instance
corresponding to an application label given on the command line.
zBSubclasses of AppCommand must providea handle_app_config() method.r� )r r� r5 r r r r� s �z AppCommand.handle_app_configN)r r r r r! rY r� r� r r r r r� s
r� c @ s4 e Zd ZdZdZde Zdd� Zdd� Zdd � Zd
S ) � LabelCommanda
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.
�labelzEnter at least one %s.c C s |j d| jdd� d S )Nr r� )r� r� )r� r� r� r r r rY 5 rZ zLabelCommand.add_argumentsc O s8 g }|D ]}| j |fi |��}|r|�|� qd�|�S )Nrc )� handle_labelr� r� )r �labelsr5 r� r� � label_outputr r r r� 8 s
�
zLabelCommand.handlec K r� )z}
Perform the command's actions for ``label``, which will be the
string as given on the command line.
z?subclasses of LabelCommand must provide a handle_label() methodr� )r r� r5 r r r r� @ r� zLabelCommand.handle_labelN) r r r r r� r! rY r� r� r r r r r� & s r� )"r r/ r2 rx �argparser r �ior r� � django.corer �django.core.exceptionsr � django.core.management.colorr r � django.dbr r
�django.utils.deprecationr rz � Exceptionr
r r r6 rA rB r[ rr r� r� r r r r �<module> s2 & f$