File: //usr/local/lib/python3.9/site-packages/celery/app/__pycache__/base.cpython-39.pyc
a
X>h|� �
@ s, d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl m
Z
m Z m Z ddl
m
Z
ddl
mZ ddlmZ ddlmZ ddlmZ dd lmZmZ dd
lmZ dd lm Z dd l m Z dd
l m Z ddl!m"Z" ddl#m$Z$ ddl%m&Z& ddl'm(Z(m)Z) ddl*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3 ddl4m5Z5m6Z6 ddl7m8Z8 ddl9m:Z:m;Z; ddl<m=Z= ddl>m?Z? ddl@mAZA ddlBmCZCmDZDmEZE ddlFmGZGmHZHmIZI ddlJmKZK dd lLmMZMmNZN dd lOmPZPmZmQZQ d d lRmSZSmTZTmUZU d d lVmWZW d!d"lXmYZYmZZZ d!d#l[m\Z] d!d$l^m_Z_ d!d%l`maZambZb d!d&lcmdZd d!d'lemfZfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZn ejo�r�dd(lpmqZq d)ZreKes�Ztd*hZuejv�wd+�Zxd,Zyd-d.� Zzd/d0� Z{d1d2� Z|d<d4ej}d5ej~f ee�ej�ej�eej~f ej�ej�eej~f d6�d7d8�Z�G d9d:� d:e
e?�Z�G d;d4� d4�Z�e�Z�dS )=z#Actual App instance implementation.� N)�UserDict� defaultdict�deque)�datetime)�timezone��
attrgetter)�Exit)�isoparse)�Exchange�pools)� LamportClock��oid_from)�calculate_routing_key)�register_after_fork)�cached_property)�uuid)� starpromise)� platforms�signals) �_announce_app_finalized�_deregister_app�
_register_app�_set_current_app� _task_stack�connect_on_app_finalize�get_current_app�get_current_worker_task�set_default_app)�AlwaysEagerIgnored�ImproperlyConfigured)�get_loader_cls)� PromiseProxy�maybe_evaluate)�abstract)�AttributeDictMixin)�Signal)�first�
head_from_fun�
maybe_list)�
gen_task_name� instantiate�symbol_by_name)�
get_logger)�FallbackContext�
mro_lookup)�maybe_make_awarer �to_utc� )�annotation_is_class�annotation_issubclass�get_optional_arg)�detect_quorum_queues� )�backends�builtins)�prepare)�add_autoretry_behaviour)�DEFAULT_SECURITY_DIGEST�find_deprecated_settings)� TaskRegistry) �
AppPickler�Settings�_new_key_to_old�_old_key_to_new�
_unpickle_app�_unpickle_app_v2�appstr� bugreport�detect_settings)� BaseModel)�Celeryzcelery.fixups.django:fixupZFORKED_BY_MULTIPROCESSINGz�
The environment variable {0!r} is not set,
and as such the configuration could not be loaded.
Please set this variable and make sure it points to
a valid configuration module.
Example:
{0}="proj.celeryconfig"
c C s t | j|tthtgd�S )z�Return true if app has customized method `attr`.
Note:
This is used for optimizations in cases where we know
how the default behavior works, but need to account
for someone using inheritance to override a method/property.
)�stopZmonkey_patched)r0 � __class__rJ �object�__name__)�app�attr� rQ �9/usr/local/lib/python3.9/site-packages/celery/app/base.py�app_has_customM s �rS c C s t � �| �|� S )z
Unpickle app.)r � _rgetattr)Z reverse_name�argsrQ rQ rR �_unpickle_appattrY s rV c
C sF z | � � W n4 ty@ } z tjd|dd� W Y d }~n
d }~0 0 d S )Nz!after forker raised exception: %rr8 )�exc_info)� _after_fork� Exception�logger�info)rO �excrQ rQ rR �_after_fork_cleanup_app` s r] TrJ .)rO �task_fun� task_name�strict�context� dump_kwargsc
s� zt �d�}W n. ty< } ztd�|�W Y d}~n
d}~0 0 |j� �du rPi ��du r\i ���dd� t����t� ��� �������fdd��}|S )zIWrapper to validate arguments and serialize return values using Pydantic.�pydanticzAYou need to install pydantic to use pydantic model serialization.N�mode�jsonc
s� �j | i |��}|j�� D ]^\}}�j| j}t|�}|d urJ|d urJ|}t|� �r|j|�i ����d��d�|j|< q�|ji |j ��}�j
}t|�} | d ur�| }t |�r�t |� �r�t ||�r�|j
f i ���S |S )N)Z
celery_appZcelery_task_name)r` ra )�bind� arguments�items�
parameters�
annotationr6 r5 Zmodel_validaterU �kwargs�return_annotationr4 �
isinstanceZ
model_dump)
Z task_argsZ task_kwargsZ
bound_argsZarg_name� arg_valueZarg_annotationZ optional_argZreturned_valuerl Zoptional_return_annotation�rI rO ra rb r` r^ r_ Ztask_signaturerQ rR �wrapper� s2
����z!pydantic_wrapper.<locals>.wrapper)
� importlib�
import_module�ModuleNotFoundErrorr! rI �
setdefault�inspect� signature� functools�wraps) rO r^ r_ r` ra rb rc �exrp rQ ro rR �pydantic_wrapperi s
$rz c @ s` e Zd ZdZdZdd� Zdd� Zdd� Zdd � Zd
d � Z d d
� Z
dd� Z dd� Z e
dd� �ZdS )�PendingConfigurationNc C s t �| d|� t �| d|� d S )N�_data�callback)rM � __setattr__)�self�confr} rQ rQ rR �__init__� s z PendingConfiguration.__init__c C s || j |< d S �N�r| �r �key�valuerQ rQ rR � __setitem__� s z PendingConfiguration.__setitem__c C s | j �� d S r� )r| �clear�r rQ rQ rR r� � s zPendingConfiguration.clearc O s | j j|i |�� d S r� )r| �update�r rU rk rQ rQ rR r� � s zPendingConfiguration.updatec O s | j j|i |��S r� )r| rt r� rQ rQ rR rt � s z PendingConfiguration.setdefaultc C s
|| j v S r� r� )r r� rQ rQ rR � __contains__� s z!PendingConfiguration.__contains__c C s
t | j�S r� )�len�datar� rQ rQ rR �__len__� s z PendingConfiguration.__len__c C s
t | j�S r� )�reprr� r� rQ rQ rR �__repr__� s z PendingConfiguration.__repr__c C s | � � S r� )r} r� rQ rQ rR r� � s zPendingConfiguration.data)rN �
__module__� __qualname__r} r| r� r� r� r� rt r� r� r� r r� rQ rQ rQ rR r{ � s r{ c @ s e Zd ZdZeZejZejej ZZ dZ
dZ dZ e
ZdZdZdZdZdZdZdZdZdZdZdZdZd ZdZ dZ dZ dZ d�d d �Z d
d� Z!dd� Z"dd� Z#dd� Z$dd� Z%dd� Z&dd� Z'd�dd �Z(d�d d �Z)d d � Z*d�d!d"�Z+d�e,e,e-j.e-j/e0e-j1f e-j.e-j/e0e-j1f d#�d$d%�Z2d&d'� Z3d(d)� Z4d�d*d+�Z5d,d-� Z6d�d.d/�Z7d�d0d1�Z8d�d3d4�Z9ddddde:d5fd6d7�Z;d�d9d:�Z<d;d<� Z=d=d>� Z>d?d@� Z?d�dBdC�Z@d�dDdE�ZAd�dFdG�ZBd�dHdI�ZCd�dJdK�ZDeCZEd�dLdM�ZFd�dNdO�ZGeGZHd�dPdQ�ZIeIZJdRdS� ZKdTdU� ZLd�dVdW�ZMdXdY� ZNdZd[� ZOd\d]� ZPd^d_� ZQd`da� ZRdbdc� ZSddde� ZTd�dgdh�ZUd�didj�ZVd�dkdl�ZWdmdn� ZXd�dpdq�ZYdrds� ZZdtdu� Z[dvdw� Z\dxdy� Z]dzd{� Z^d|d}� Z_d~d� Z`d�d�� Zaebd�d�� �Zcebd�d�� �Zdebd�d�� �Zeebd�d�� �Zfebd�d�� �Zgebd�d�� �Zhebd�d�� �Ziebd�d�� �Zjekd�d�� �Zlekd�d�� �Zmekd�d�� �Znebd�d�� �Zoekd�d�� �Zpebd�d�� �Zqekd�d�� �Zrerjsd�d�� �Zrekd�d�� �Ztekd�d�� �Zueujsd�d�� �Zuebd�d�� �Zvebd�d�� �Zwebd�d�� �Zxebd�d�� �Zyebd�d�� �Zzebd�d�� �Z{ekd�d�� �Z|d�d�� Z}ebd�d�� �Z~dS )�rJ a� Celery application.
Arguments:
main (str): Name of the main module if running as `__main__`.
This is used as the prefix for auto-generated task names.
Keyword Arguments:
broker (str): URL of the default broker used.
backend (Union[str, Type[celery.backends.base.Backend]]):
The result store backend class, or the name of the backend
class to use.
Default is the value of the :setting:`result_backend` setting.
autofinalize (bool): If set to False a :exc:`RuntimeError`
will be raised if the task registry or tasks are used before
the app is finalized.
set_as_current (bool): Make this the global current app.
include (List[str]): List of modules every worker should import.
amqp (Union[str, Type[AMQP]]): AMQP object or class name.
events (Union[str, Type[celery.app.events.Events]]): Events object or
class name.
log (Union[str, Type[Logging]]): Log object or class name.
control (Union[str, Type[celery.app.control.Control]]): Control object
or class name.
tasks (Union[str, Type[TaskRegistry]]): A task registry, or the name of
a registry class.
fixups (List[str]): List of fix-up plug-ins (e.g., see
:mod:`celery.fixups.django`).
config_source (Union[str, class]): Take configuration from a class,
or object. Attributes may include any settings described in
the documentation.
task_cls (Union[str, Type[celery.app.task.Task]]): base task class to
use. See :ref:`this section <custom-task-cls-app-wide>` for usage.
Nzcelery.app.amqp:AMQPzcelery.app.events:Eventszcelery.app.log:Loggingzcelery.app.control:Controlzcelery.app.task:Taskz celery.app.registry:TaskRegistryFTc s: t �� � _d � _t� � _|� _|p&� j� _|p2� j� _|p@� � � � _
|pL� j � _ |pX� j � _ t
|�px� jtuoxt� jd�� _|p�� j� _|� _t� j�� _tt�� _tt�� _|� _|� _|� _ d� _ |
� _ t � � _ t � � _!d� _"t �#� � _$t � � _%| � _&t'� j&t(��s � �� j&�pi �� _&t)� d�� _*| �p0i � _+t� � _,� �-d|
� � �-d|� � �-d| � |�.� D ]\}}� �-||� �qht/t0� j+� j1�� jt2t3fd�� _4|d u �r�t� j5�n|� _6� fdd �� j6D �� _7� j�r� �8� � j9d u �r�t:d
d �� _9t:d d
hd�� _;t:dd �� _<t:dd �� _=d� _>� �?� t@� � d S )N�task_clsF�__reduce_args__Z
broker_url�result_backend�include)�prefix�keysc s g | ]}t |�� ��qS rQ )r- )�.0�fixupr� rQ rR �
<listcomp>r � z#Celery.__init__.<locals>.<listcomp>zapp.on_configure��namezapp.on_after_configure�source)r� Zproviding_argszapp.on_after_finalizezapp.on_after_fork)A� threading�local�_local�_backend_cacher
Zclock�main�amqp_cls�
events_cls�_get_default_loader�
loader_cls�log_cls� control_cls�boolrL rJ �hasattrZ_custom_task_cls_usedr� �set_as_currentr- � registry_clsr �set� user_options�steps� autofinalize� namespace�
strict_typing�
configured�_config_sourcer �_pending_defaults�_pending_periodic_tasks� finalized�RLock�_finalize_mutex�_pending�_tasksrm r? rS �_using_v1_reduce�_preconf�_preconf_set_by_auto�_Celery__autosetrh rA r{ �_finalize_pending_confrC rB �_conf�builtin_fixups�fixups�_fixups� set_current� on_configurer' �on_after_configure�on_after_finalize�
on_after_forkZuse_fast_trace_task�on_initr )r r� �loader�backend�amqp�events�log�controlr� �tasksZbrokerr� �changes�
config_sourcer� r� r� r� r� rk r� r� rQ r� rR r� , sx
�
�� � zCelery.__init__c C s t j�d�p| jpdS )NZ
CELERY_LOADERz celery.loaders.app:AppLoader)�os�environ�getr� r� rQ rQ rR r� � s
��zCelery._get_default_loaderc C s dS )z!Optional callback called at init.NrQ r� rQ rQ rR r� � s zCelery.on_initc C s" |d ur || j |< | j�|� d S r� )r� r� �addr� rQ rQ rR Z __autoset� s
zCelery.__autosetc C s t | � dS )z*Make this the current app for this thread.N)r r� rQ rQ rR r� � s zCelery.set_currentc C s t | � dS )z*Make this the default app for all threads.N)r r� rQ rQ rR � set_default� s zCelery.set_defaultc C s" | j s d| _ td ur t| t� d S )NT)�_after_fork_registeredr r] r� rQ rQ rR �_ensure_after_fork� s zCelery._ensure_after_forkc C s d| _ t| � dS )aO Clean up after the application.
Only necessary for dynamically created apps, and you should
probably use the :keyword:`with` statement instead.
Example:
>>> with Celery(set_as_current=False) as app:
... with app.connection_for_write() as conn:
... pass
N)�_poolr r� rQ rQ rR �close� s z Celery.closec
C s� ddl m} | |jd _|du r&tj}z\z|j|dd� W n8 tyr } z |jW Y d}~W d|jd _S d}~0 0 W d|jd _nd|jd _0 dS )zgRun :program:`celery` using `argv`.
Uses :data:`sys.argv` if `argv` is not specified.
r )�celeryNF)rU Zstandalone_mode) Zcelery.bin.celeryr� �params�default�sys�argvr� r Z exit_code)r r� r� �erQ rQ rR �start� s �z Celery.startc C s. |du rt j}d|vr td��| j|d� dS )znRun :program:`celery worker` using `argv`.
Uses :data:`sys.argv` if `argv` is not specified.
NZworkerzkThe worker sub-command must be specified in argv.
Use app.start() to programmatically start other commands.)r� )r� r� �
ValueErrorr� )r r� rQ rQ rR � worker_main� s �zCelery.worker_mainc s� t r.|�dd�r.ddlm} ||ddi|��S d � fdd� }t|�dkrnt|d �rf|f i |��|� S td
��|r�td �tt|�t|�g����|f i |��S )
a� Decorator to create a task class out of any callable.
See :ref:`Task options<task-options>` for a list of the
arguments that can be passed to this decorator.
Examples:
.. code-block:: python
@app.task
def refresh_feed(url):
store_feed(feedparser.parse(url))
with setting extra options:
.. code-block:: python
@app.task(exchange='feeds')
def refresh_feed(url):
return store_feed(feedparser.parse(url))
Note:
App Binding: For custom apps the task decorator will return
a proxy object, so that the act of creating the task is not
performed until the task is used or the task registry is accessed.
If you're depending on binding to be deferred, then you must
not access any attributes on the returned object until the
application is fully set up (finalized).
�lazyTr8 )� shared_taskFNc s |� � ����fdd�}|S )Nc sr �r"� �fdd�}� j |_ t|� �r,�jr@�j� fi ���}n"t�j� f�� jd�}�j�|� �rn�|�S |S )Nc s | j � fi ���S r� )�_task_from_fun�rO )�fun�optsrQ rR �cons s zRCelery.task.<locals>.inner_create_task_cls.<locals>._create_task_cls.<locals>.cons)�__doc__)rN r r� r� r# r� r� �append)r� r� �ret)�_filtr� r� r �shared)r� rR �_create_task_cls s
� zDCelery.task.<locals>.inner_create_task_cls.<locals>._create_task_clsrQ )r� �filterr� r� r� r� )r� r� r� r� rR �inner_create_task_cls� s z*Celery.task.<locals>.inner_create_task_clsr z(argument 1 to @task() must be a callablez+@task() takes exactly 1 argument ({} given))TNT) � USING_EXECVr� � r� r� �callable� TypeError�format�sum)r rU r� r� r� rQ r� rR �task� s ��z Celery.taskc C s t t||d��S )N��bound)� staticmethodr) )r r� r rQ rQ rR � type_checker s zCelery.type_checker)rc �pydantic_strict�pydantic_context�pydantic_dump_kwargsc K s� | j s| jstd��|p&| �|j|j�}|p0| j}|| jvr�|du rVt| |||||�}|r^|nt |�}
t
|j|ft | ||
d|j |j|j
| j||d�|
d� fi | ���� } z |j| _W n ty� Y n0 | | j| j< | �| � t| fi | �� n
| j| } | S )N�"Contract breach: app not finalizedTr� ) rO r� �runZ
_decoratedr� r� �__annotations__Z
__header__� __wrapped__)r� r� � RuntimeErrorr+ rN r� �Taskr� rz r �type�dictr� r r r� �AttributeErrorr� rf r< ) r r� r� �baserf rc r r r �optionsr r� rQ rQ rR r� # s<
� �
zCelery._task_from_func K sd t �|�r|� p|}|js4t|�}| �|j|j�|_t|fi |�� || j|j< | |_ |�
| � |S )z�Utility for registering a task-based class.
Note:
This is here for compatibility with old Celery 1.0
style task classes, you should not need to use this for
new projects.
) ru �isclassr� r r+ rN r� r< r� �_apprf )r r� r r� rQ rQ rR �
register_taskP s �
zCelery.register_taskc C s t | ||�S r� )r+ )r r� �modulerQ rQ rR r+ c s zCelery.gen_task_namec C s� | j �v | jsn|r | js td��d| _t| � | j}|rFt|�� � q4| j� � D ]}|�
| � qP| j j | d� W d � n1 s�0 Y dS )z�Finalize the app.
This loads built-in tasks, evaluates pending task decorators,
reads configuration, etc.
r T��senderN)
r� r� r� r
r r� r$ �popleftr� �valuesrf r� �send)r �auto�pendingr� rQ rQ rR �finalizef s
zCelery.finalizec s> t |�s|� fdd� � }| jr.| j�|� �S | j�|� dS )ad Add default configuration from dict ``d``.
If the argument is a callable function then it will be regarded
as a promise, and it won't be loaded until the configuration is
actually needed.
This method can be compared to:
.. code-block:: pycon
>>> celery.conf.update(d)
with a difference that 1) no copy will be made and 2) the dict will
not be transferred when the worker spawns child processes, so
it's important that the same configuration happens at import time
when pickle restores the object on the other side.
c s � S r� rQ rQ ��drQ rR �<lambda>� r� z%Celery.add_defaults.<locals>.<lambda>N)r� r� r� � add_defaultsr� r� )r r� rQ r rR r | s
zCelery.add_defaultsc C s< || _ |p| j| _|s | jr8d| _| jj||d�r8| jS dS )a Read configuration from object.
Object is either an actual object or the name of a module to import.
Example:
>>> celery.config_from_object('myapp.celeryconfig')
>>> from myapp import celeryconfig
>>> celery.config_from_object(celeryconfig)
Arguments:
silent (bool): If true then import errors will be ignored.
force (bool): Force reading configuration immediately.
By default the configuration will be read only when required.
N)�silent)r� r� r� r� r� �config_from_objectr� )r �objr! �forcer� rQ rQ rR r" � s
zCelery.config_from_objectc C s: t j�|�}|s*|rdS tt�� �|���| j|||d�S )a3 Read configuration from environment variable.
The value of the environment variable must be the name
of a module to import.
Example:
>>> os.environ['CELERY_CONFIG_MODULE'] = 'myapp.celeryconfig'
>>> celery.config_from_envvar('CELERY_CONFIG_MODULE')
F)r! r$ )r� r� r� r! �ERR_ENVVAR_NOT_SET�stripr� r" )r Z
variable_namer! r$ � module_namerQ rQ rR �config_from_envvar� s
�zCelery.config_from_envvarr� c C s | j �| j�||�� d S r� )r� r� r� Zcmdline_config_parser)r r� r� rQ rQ rR �config_from_cmdline� s �zCelery.config_from_cmdlinere c
C s$ ddl m} ||||||||| d�S )a; Setup the message-signing serializer.
This will affect all application instances (a global operation).
Disables untrusted serializers and if configured to use the ``auth``
serializer will register the ``auth`` serializer with the provided
settings into the Kombu serializer registry.
Arguments:
allowed_serializers (Set[str]): List of serializer names, or
content_types that should be exempt from being disabled.
key (str): Name of private key file to use.
Defaults to the :setting:`security_key` setting.
key_password (bytes): Password to decrypt the private key.
Defaults to the :setting:`security_key_password` setting.
cert (str): Name of certificate file to use.
Defaults to the :setting:`security_certificate` setting.
store (str): Directory containing certificates.
Defaults to the :setting:`security_cert_store` setting.
digest (str): Digest algorithm used when signing messages.
Default is ``sha256``.
serializer (str): Serializer used to encode messages after
they've been signed. See :setting:`task_serializer` for
the serializers supported. Default is ``json``.
r )�setup_securityr� )Zcelery.securityr* ) r Zallowed_serializersr� � key_password�cert�store�digest�
serializerr* rQ rQ rR r* � s
�zCelery.setup_securityr� c C s0 |r| � ||�S tjjt| j ||�d| d� dS )a� Auto-discover task modules.
Searches a list of packages for a "tasks.py" module (or use
related_name argument).
If the name is empty, this will be delegated to fix-ups (e.g., Django).
For example if you have a directory layout like this:
.. code-block:: text
foo/__init__.py
tasks.py
models.py
bar/__init__.py
tasks.py
models.py
baz/__init__.py
models.py
Then calling ``app.autodiscover_tasks(['foo', 'bar', 'baz'])`` will
result in the modules ``foo.tasks`` and ``bar.tasks`` being imported.
Arguments:
packages (List[str]): List of packages to search.
This argument may also be a callable, in which case the
value returned is used (for lazy evaluation).
related_name (Optional[str]): The name of the module to find. Defaults
to "tasks": meaning "look for 'module.tasks' for every
module in ``packages``.". If ``None`` will only try to import
the package, i.e. "look for 'module'".
force (bool): By default this call is lazy so that the actual
auto-discovery won't happen until an application imports
the default modules. Forcing will cause the auto-discovery
to happen immediately.
F)Zweakr N)�_autodiscover_tasksr Zimport_modules�connectr )r �packages� related_namer$ rQ rQ rR �autodiscover_tasks� s ( ��zCelery.autodiscover_tasksc K s |r| � ||�S | �|�S r� )� _autodiscover_tasks_from_names� _autodiscover_tasks_from_fixups)r r2 r3 rk rQ rQ rR r0 s zCelery._autodiscover_tasksc C s | j �t|�r|� n||�S r� )r� r4 r� )r r2 r3 rQ rQ rR r5 s �z%Celery._autodiscover_tasks_from_namesc C s | j dd� | jD �|d�S )Nc S s( g | ] }t |d �r|�� D ]}|�qqS )r4 )r� r4 )r� r� �pkgrQ rQ rR r� s
�z:Celery._autodiscover_tasks_from_fixups.<locals>.<listcomp>)r3 )r5 r� )r r3 rQ rQ rR r6 s
��z&Celery._autodiscover_tasks_from_fixupsr c 0 K s� d } } | j }!|pt� }|p | }| p(|!j} | j}"|"jrHtjtd�dd� | �dd�}#| � | |p`|||| �} | j
j j j
j}$|s�|�rft| |$�d �rf| �d�}%|%r�|%jjn| d }&|%r�|%jn| d
}'|%r�|%jjn| d }(|&d k�rT|�r t|t�r�t|�}t|�| �� �� }|�rf|dk�rftt |�|'�}'t d
dd�})| �dd� |'| d
< |)| d < nt � d|(� d�� | du�r�t| t ��r�t| �| �� �� }*n*t| t��r�tt| ��| �� �� }*n| }*|*dk �r�t � |� d|* � d�� d}*|*| d< |�r�|�sF| j!} | �rF|�s| j"j#�p| j"j$}|�s(| j"j$}|"j%�rF| �&d| j"j'�d�� |!j(||||||||| ||t)|
�t)|�|�pv| j*||| jj+||||f|#| d�| ��}+| �dg �},|,D ]}-| �|-� �q�|�r�|!j,|dd�}| �-|��f}.|.j �.� �: |#�s�| j/�0|.|� |!j1|.||+fi | �� W d � n1 �s(0 Y W d � n1 �sH0 Y |
�p\| j2|�}/|#|/_3|�r�| �s�| j!d } } | �r�| �4|/� |/S )z�Send task by name.
Supports the same arguments as :meth:`@-Task.apply_async`.
Arguments:
name (str): Name of task to call (e.g., `"tasks.add"`).
result_cls (AsyncResult): Specify custom result class.
Nz,task_always_eager has no effect on send_taskr3 )�
stacklevel�
ignore_resultFr �queue�
exchange_type� routing_key�exchange�directZcelery_delayed_27Ztopic)r zADirect exchanges are not supported with native delayed delivery.
z� is a direct exchange but should be a topic exchange or a fanout exchange in order for native delayed delivery to work properly.
If quorum queues are used, this task may block the worker process until the ETA arrives.z% has an expiration date in the past (aJ s ago).
We assume this is intended and so we have set the expiration date to 0 instead.
According to RabbitMQ's documentation:
"Setting the TTL to 0 causes messages to be expired upon reaching a queue unless they can be delivered to a consumer immediately."
If this was unintended, please check the code which published this task.Z
expiration�priority)r9 �replaced_task_nesting�stamped_headers)Z auto_declareT)5r� r �routerr� Ztask_always_eager�warnings�warnr �popZroute�
producer_pool� connections�
connection� transport� driver_typer7 r� r= r r< r� rm �strr
r1 �now�
total_secondsr �intr rZ �warningr �current_worker_task�request�root_id�idZ task_inherit_parent_priorityrt Z
delivery_infoZcreate_task_messager* �
thread_oidZtask_send_sent_eventZProducer�producer_or_acquireZ_reraise_as_library_errorsr� Z on_task_callZsend_task_message� AsyncResultZignoredZ add_trail)0r r� rU rk Z countdown�etaZtask_id�producerrH rB Z
result_cls�expiresZ publisher�linkZ
link_errorZ
add_to_parentZgroup_idZ group_index�retriesZchordZreply_toZ
time_limitZsoft_time_limitrR Z parent_idZ
route_nameZshadow�chainZ task_typer@ r �parentZ have_parentr� r� r9 rJ r: r; r< Z
exchange_namer= Z expires_s�messagerA Zstamp�P�resultrQ rQ rR � send_task# s�
�� �
�
��
��
��
� � ��� V
zCelery.send_taskc K s | j |p| jjfi |��S )z|Establish connection used for consuming.
See Also:
:meth:`connection` for supported arguments.
)� _connectionr� Zbroker_read_url�r �urlrk rQ rQ rR �connection_for_read� s zCelery.connection_for_readc K s | j |p| jjfi |��S )z|Establish connection used for producing.
See Also:
:meth:`connection` for supported arguments.
)rb r� �broker_write_urlrc rQ rQ rR �connection_for_write� s zCelery.connection_for_writec
K s2 | j |p| jjf|||||||| |
| | d� |
��S )aC Establish a connection to the message broker.
Please use :meth:`connection_for_read` and
:meth:`connection_for_write` instead, to convey the intent
of use for this connection.
Arguments:
url: Either the URL or the hostname of the broker to use.
hostname (str): URL, Hostname/IP-address of the broker.
If a URL is used, then the other argument below will
be taken from the URL instead.
userid (str): Username to authenticate as.
password (str): Password to authenticate with
virtual_host (str): Virtual host to use (domain).
port (int): Port to connect to.
ssl (bool, Dict): Defaults to the :setting:`broker_use_ssl`
setting.
transport (str): defaults to the :setting:`broker_transport`
setting.
transport_options (Dict): Dictionary of transport specific options.
heartbeat (int): AMQP Heartbeat in seconds (``pyamqp`` only).
login_method (str): Custom login method to use (AMQP only).
failover_strategy (str, Callable): Custom failover strategy.
**kwargs: Additional arguments to :class:`kombu.Connection`.
Returns:
kombu.Connection: the lazy connection instance.
) �userid�password� virtual_host�port�ssl�connect_timeoutrI �transport_options� heartbeat� login_method�failover_strategy)rg r� rf )r �hostnamerh ri rj rk rl rm rI rn ro rp rq rk rQ rQ rR rH � s !
���zCelery.connectionc
K sv | j }| jj||p|j|p |j|p&|j|p.|j|p6|j| �d|�|
| pJ|j | pR|j
t |j fi | pbi ��| �d|�d� S )NZbroker_use_sslZbroker_connection_timeout)rI rl ro rp rq rn rm )
r� r� �
ConnectionZ broker_userZbroker_passwordZ broker_vhostZ broker_portZbroker_transport�eitherZbroker_login_methodZbroker_failover_strategyr
Zbroker_transport_options)r rd rh ri rj rk rl rm rI rn ro rp rq rk r� rQ rQ rR rb � s*
����zCelery._connectionc C s |r| j jdd�S | �� S )z)Helper for :meth:`connection_or_acquire`.T��block)�pool�acquirerg )r rw rQ rQ rR �_acquire_connection s zCelery._acquire_connectionc O s t || j|d�S )aR Context used to acquire a connection from the pool.
For use within a :keyword:`with` statement to get a connection
from the pool if one is not already provided.
Arguments:
connection (kombu.Connection): If not provided, a connection
will be acquired from the connection pool.
)rw )r/ ry )r rH rw �_�__rQ rQ rR �connection_or_acquire s
z Celery.connection_or_acquirec C s t || jjdd�S )aE Context used to acquire a producer from the pool.
For use within a :keyword:`with` statement to get a producer
from the pool if one is not already provided
Arguments:
producer (kombu.Producer): If not provided, a producer
will be acquired from the producer pool.
Tru )r/ rF rx )r rX rQ rQ rR rU s
�zCelery.producer_or_acquirec C s t |�S )z<Prepare configuration before it is merged with the defaults.)r> )r �crQ rQ rR �prepare_config, s zCelery.prepare_configc C s t t�tj��}|�| j�S )z/Return the current time and date as a datetime.)r2 r rL �datetime_timezone�utc�
astimezoner )r Z
now_in_utcrQ rQ rR rL 0 s z
Celery.nowc C s | j j�|�S )zxSelect subset of queues.
Arguments:
queues (Sequence[str]): a list of queue names to keep.
)r� �queues�select)r r� rQ rQ rR �
select_queues5 s zCelery.select_queuesc G s t dt d|�t| jj|�g�S )z�Get key from configuration or use default values.
Fallback to the value of a configuration key if none of the
`*values` are true.
N)r( r r� r� )r Z default_key�defaultsrQ rQ rR rt = s �z
Celery.eitherc C s t | �S )z)Return information useful in bug reports.)rG r� rQ rQ rR rG G s zCelery.bugreportc C s( t �| jp| jj| j�\}}|| |d�S )N)rO rd )r9 Zby_url� backend_clsr� r� r� )r r� rd rQ rQ rR � _get_backendK s
�zCelery._get_backendc
C sH z| � � }| _W n0 tyB } zt|j� |�W Y d}~n
d}~0 0 |S )z�Get config value by key and finalize loading the configuration.
Note:
This is used by PendingConfiguration:
as soon as you access a key the configuration is read.
N)� _load_configr� r rs rU )r r� �errrQ rQ rR r� Q s
"z Celery._finalize_pending_confc C s� t | jt�r | jj| d� n| �� | jr8| j�| j� d| _t| � | jj
�| j | j | j
d�}| jd urv| j�|� n|| _| j}|r�| j�t|�� � �� q�| j}|r�|�� \}}| j|i |�� q�| jj| | jd� | jS )Nr T)Z ignore_keysr� )r r� )rm r� r' r r� r� r" r� rH r~ r� r� r� r� r� Z swap_withr� r r$ r r� �_add_periodic_taskr� )r �settingsZ pending_defZ pending_beatZperiodic_task_argsZperiodic_task_kwargsrQ rQ rR r� b s, �
zCelery._load_configc C s@ d | _ zd | jd _W n ttfy, Y n0 | jj| d� d S )Nr� r )r� �__dict__Z_producer_poolr �KeyErrorr� r r� rQ rQ rR rX � s zCelery._after_forkc O s | |d< | j j|i |��S )z:Return a new :class:`~celery.Signature` bound to this app.rO )�_canvasrv r� rQ rQ rR rv � s zCelery.signaturerQ c K sR | j |||||fi |��\}}| jr6| j|||d� n| j�||fd|ig� |S )a
Add a periodic task to beat schedule.
Celery beat store tasks based on `sig` or `name` if provided. Adding the
same signature twice make the second task override the first one. To
avoid the override, use distinct `name` for them.
r� r� )�_sig_to_periodic_task_entryr� r� r� r� ) r �schedule�sigrU rk r� r� r� �entryrQ rQ rR �add_periodic_task� s
��
zCelery.add_periodic_taskc K sd |si n|}t |tj�r$|�||�n| �|j||�}|p>t|�||j|j|jt |j
fi |��d�fS )N)r� r� rU rk r ) rm r% ZCallableSignature�clonerv r� r� rU rk r
r )r r� r� rU rk r� r� rQ rQ rR r� � s
��
�z"Celery._sig_to_periodic_task_entryc C s6 |d u r&|| j jv r&t�d|� d�� || j j|< d S )NzPeriodic task key='zl' shadowed a previous unnamed periodic task. Pass a name kwarg to add_periodic_task to silence this warning.)r� Z
beat_schedulerZ rO )r r� r� r� rQ rQ rR r� � s
�zCelery._add_periodic_taskc C s | j | jddddd�S )z+Create a base task class bound to this app.r r T)r� � attribute� keep_reducer% )�subclass_with_selfr� r� rQ rQ rR �create_task_cls� s �zCelery.create_task_clsrO c s` t |�}� r� n|j� � fdd�}t|| if|j|jd�|��}|sL||d< t|pV|j|f|�S )a� Subclass an app-compatible class.
App-compatible means that the class has a class attribute that
provides the default app it should use, for example:
``class Foo: app = None``.
Arguments:
Class (type): The app-compatible class to subclass.
name (str): Custom name for the target class.
attribute (str): Name of the attribute holding the app,
Default is 'app'.
reverse (str): Reverse path to this object used for pickling
purposes. For example, to get ``app.AsyncResult``,
use ``"AsyncResult"``.
keep_reduce (bool): If enabled a custom ``__reduce__``
implementation won't be provided.
c s t � | �� ffS r� )rV r� r� ��reverserQ rR �
__reduce__� s z-Celery.subclass_with_self.<locals>.__reduce__)r� r� r� )r- rN r
r� r� r ) r ZClassr� r� r� r� �kwr� �attrsrQ r� rR r� � s ���zCelery.subclass_with_selfc C s t |�| �S r� r )r �pathrQ rQ rR rT � s zCelery._rgetattrc C s | S r� rQ r� rQ rQ rR � __enter__� s zCelery.__enter__c G s | � � d S r� )r� )r rW rQ rQ rR �__exit__� s zCelery.__exit__c C s dt | �j� dt| �� d�S )N�<� �>)r rN rF r� rQ rQ rR r� � s zCelery.__repr__c C s | j r| �� S t| j| �� ffS r� )r� �
__reduce_v1__rE rL �__reduce_keys__r� rQ rQ rR r� � s zCelery.__reduce__c C s t | j| jf| �� fS r� )rD rL �Picklerr� r� rQ rQ rR r� � s �zCelery.__reduce_v1__c
C sD | j | jr| jjn| j| j| j| j| j| j | j
| j | j | j
| jd� S )zAKeyword arguments used to reconstruct the object when unpickling.) r� r� r� r� r� r� r� r� r� r� r� r� )r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rQ rQ rR r� � s �zCelery.__reduce_keys__c
C s6 | j | jr| jjni | j| j| j| j| j| j d| j
f
S )z>Deprecated method, please use :meth:`__reduce_keys__` instead.F) r� r� r� r� r� r� r� r� r� r� r� r� rQ rQ rR r� s
�zCelery.__reduce_args__c C s
| � d�S )zNWorker application.
See Also:
:class:`~@Worker`.
zcelery.apps.worker:Worker�r� r� rQ rQ rR �Worker s z
Celery.Workerc K s
| � d�S )zUEmbeddable worker.
See Also:
:class:`~@WorkController`.
z celery.worker:WorkControllerr� �r rk rQ rQ rR �WorkController s zCelery.WorkControllerc K s
| � d�S )zf:program:`celery beat` scheduler application.
See Also:
:class:`~@Beat`.
zcelery.apps.beat:Beatr� r� rQ rQ rR �Beat) s z Celery.Beatc C s | � � S )z Base task class for this app.)r� r� rQ rQ rR r 2 s z Celery.Taskc C s t | jj�S r� )�prepare_annotationsr� Ztask_annotationsr� rQ rQ rR � annotations7 s zCelery.annotationsc C s
| � d�S )zgCreate new result instance.
See Also:
:class:`celery.result.AsyncResult`.
zcelery.result:AsyncResultr� r� rQ rQ rR rV ; s zCelery.AsyncResultc C s
| � d�S )Nzcelery.result:ResultSetr� r� rQ rQ rR � ResultSetD s zCelery.ResultSetc C s
| � d�S )zmCreate new group result instance.
See Also:
:class:`celery.result.GroupResult`.
zcelery.result:GroupResultr� r� rQ rQ rR � GroupResultH s zCelery.GroupResultc C s: | j du r4| �� | jj}t�|� tj| �� | _ | j S )z�Broker connection pool: :class:`~@pool`.
Note:
This attribute is not related to the workers concurrency pool.
N)r� r� r� Zbroker_pool_limitr Z set_limitrG rg )r �limitrQ rQ rR rw Q s
z Celery.poolc C s t jS )z2Instance of task being executed, or :const:`None`.)r �topr� rQ rQ rR � current_task_ s zCelery.current_taskc C s t � S )z�The task currently being executed by a worker or :const:`None`.
Differs from :data:`current_task` in that it's not affected
by tasks calling other tasks directly, or eagerly.
)r r� rQ rQ rR rP d s zCelery.current_worker_taskc C s t | dd�S )z+Universally unique identifier for this app.F��threadsr r� rQ rQ rR �oidm s z
Celery.oidc C s: z
| j jW S ty4 t| dd� | j _}| Y S 0 dS )z*Per-thread unique identifier for this app.Tr� N)r� r� r r )r Znew_oidrQ rQ rR rT v s
zCelery.thread_oidc C s t | j| d�S )z,AMQP related functionality: :class:`~@amqp`.r� )r, r� r� rQ rQ rR r� s z Celery.amqpc C s | j dur| j S t| jdd�S )z�A reference to the backend object
Uses self._backend_cache if it is thread safe.
Otherwise, use self._local
Nr� )r� �getattrr� r� rQ rQ rR �_backend� s
zCelery._backendc C s |j r|| _n|| j_dS )z!Set the backend object on the appN)Z thread_safer� r� r� )r r� rQ rQ rR r� � s c C s | j du r| �� | _ | j S )zCurrent backend instance.N)r� r� r� rQ rQ rR r� � s
zCelery.backendc C s | j du r| �� | _ | j S )zCurrent configuration.N)r� r� r� rQ rQ rR r� � s
z Celery.confc C s
|| _ d S r� )r� )r r rQ rQ rR r� � s c C s t | j| d�S )z#Remote control: :class:`~@control`.r� )r, r� r� rQ rQ rR r� � s zCelery.controlc C s t | j| d�S )z0Consuming and sending events: :class:`~@events`.r� )r, r� r� rQ rQ rR r� � s z
Celery.eventsc C s t | j�| d�S )zCurrent loader instance.r� )r" r� r� rQ rQ rR r� � s z
Celery.loaderc C s t | j| d�S )zLogging: :class:`~@log`.r� )r, r� r� rQ rQ rR r� � s z
Celery.logc C s ddl m} |S )Nr )�canvas)r� r� )r r� rQ rQ rR r� � s zCelery._canvasc C s | j dd� | jS )zoTask registry.
Warning:
Accessing this attribute will also auto-finalize the app.
T)r )r r� r� rQ rQ rR r� � s z Celery.tasksc C s | j jS r� )r� rF r� rQ rQ rR rF � s zCelery.producer_poolc C s | j t jkS )z/Check if the application uses the UTC timezone.)r r� r� rQ rQ rR �uses_utc_timezone� s zCelery.uses_utc_timezonec C s* | j }|js |jrtjS tjS t�|j�S )z�Current timezone for this app.
This is a cached property taking the time zone from the
:setting:`timezone` setting.
)r� r Z
enable_utcr� r� Z get_timezone)r r� rQ rQ rR r � s zCelery.timezone)NNNNNNNTNNNNNNNTNT)N)N)F)NNFFFNN)F)FFN)FF)r� )Nr� F) NNNNNNNNNNNNNTNNr NNNNNNNNNNr )N)N) NNNNNNNNNNNN) NNNNNNNNNNN)T)NT)N)N)rQ rQ N)rQ NN)N)NrO NF)rN r� r� r� r@ r� r ZSYSTEMZIS_macOSZ
IS_WINDOWSr� r� r� �BUILTIN_FIXUPSr� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r� �typing�Optional�DictrK �Anyr� r r+ r r r" r( r) r= r* r4 r0 r5 r6 ra re rg rH rb Zbroker_connectionry r| Zdefault_connectionrU Zdefault_producerr~ rL r� rt rG r� r� r� rX rv r� r� r� r� r� rT r� r� r� r� r� r� r� r r� r� r� r r� rV r� r� �propertyrw r� rP r� rT r� r� �setterr� r� r� r� r� r� r� r� rF r� r rQ rQ rQ rR rJ � st % �
]
H
�� -
�
�
�
. �
�
+ �
# �
�
�
#
)TNN)�r� rw rq ru r� r� r� r� rC � collectionsr r r r r r �operatorr Zclick.exceptionsr Zdateutil.parserr
Zkombur r Z kombu.clocksr
Z kombu.commonr Z'kombu.transport.native_delayed_deliveryr Zkombu.utils.compatr Zkombu.utils.objectsr Zkombu.utils.uuidr Zviner r� r r Z
celery._stater r r r r r r r r Zcelery.exceptionsr r! Zcelery.loadersr" Z celery.localr# r$ Z celery.utilsr% Zcelery.utils.collectionsr& Zcelery.utils.dispatchr' Zcelery.utils.functionalr( r) r* Zcelery.utils.importsr+ r, r- Zcelery.utils.logr. Zcelery.utils.objectsr/ r0 Zcelery.utils.timer1 r2 Zutils.annotationsr4 r5 r6 Zutils.quorum_queuesr7 r� r9 r: r� r; r� Z autoretryr< r� r= r> �registryr? �utilsr@ rA rB rC rD rE rF rG rH �
TYPE_CHECKINGrc rI �__all__rN rZ r� r� r� r� r% rS rV r] �Callabler� rK r� r� r� rz r{ rJ ZApprQ rQ rQ rR �<module> s� , , �
�� @,