o wvXj@sdZddlmZmZddlZddlZddlZddlmZm Z ddl m Z ddl m Z ddl mZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZmZddl m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)ddl*m+Z+m,Z,m-Z-m.Z.ddl/m0Z0m1Z1m2Z2m3Z3ddl4m5Z5ddl6m7Z7m8Z8ddl9m:Z:ddl;mZ>ddl?m@Z@mAZAmBZBddlCmDZDmEZEmFZFddlGmHZHddlImJZJmKZKddlLmMZMmNZNmOZOddlPmQZQddlPmRZRdd lSmTZUdd!lVmWZWmXZXdd"lYmZZZdd#l[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdd$ZeeHefZgd%hZhejijd&Zkd'Zld(d)Zmd*d+Znd,d-ZoGd.d/d/e0e<Zpe2Gd0d1d1eqZrerZsdS)2z#Actual App instance implementation.)absolute_importunicode_literalsN) defaultdictdeque)datetime attrgetter)pools) LamportClockoid_from)register_after_fork)cached_property)uuid) starpromise)wraps) platformssignals) _announce_app_finalized_deregister_app _register_app_set_current_app _task_stackconnect_on_app_finalizeget_current_appget_current_worker_taskset_default_app)AlwaysEagerIgnoredImproperlyConfiguredIgnoreRetry)UserDict bytes_if_py2python_2_unicode_compatiblevalues)get_loader_cls) PromiseProxymaybe_evaluate)abstract)AttributeDictMixin)Signal)first head_from_fun maybe_list) gen_task_name instantiatesymbol_by_name) get_logger)FallbackContext mro_lookup) get_exponential_backoff_intervaltimezoneto_utc)builtins)backends)prepare)DEFAULT_SECURITY_DIGESTfind_deprecated_settings) TaskRegistry) AppPicklerSettings_new_key_to_old_old_key_to_new _unpickle_app_unpickle_app_v2appstr bugreportdetect_settings)Celeryzcelery.fixups.django:fixupFORKED_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" cCst|j|tthtgdS)zReturn 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. )stopmonkey_patched)r3 __class__rGobject__name__)appattrrPL/var/www/html/myproject/venv/lib/python3.10/site-packages/celery/app/base.pyapp_has_customHsrRcCst||S)z Unpickle app.)r _rgetattr) reverse_nameargsrPrPrQ_unpickle_appattrTsrVc CsFz|WdSty"}ztjd|ddWYd}~dSd}~ww)Nz!after forker raised exception: %rr7)exc_info) _after_fork Exceptionloggerinfo)rNexcrPrPrQ_after_fork_cleanup_app[s r]c@s`eZdZdZdZddZddZddZdd Zd d Z d d Z ddZ ddZ e ddZdS)PendingConfigurationNcCs t|d|t|d|dS)N_datacallback)rL __setattr__)selfconfr`rPrPrQ__init__oszPendingConfiguration.__init__cCs||j|<dSNr_rbkeyvaluerPrPrQ __setitem__sz PendingConfiguration.__setitem__cCs|jdSre)r_clearrbrPrPrQrlvrkzPendingConfiguration.clearcOs|jj|i|dSre)r_updaterbrUkwargsrPrPrQrnyzPendingConfiguration.updatecOs|jj|i|Sre)r_ setdefaultrorPrPrQrr|zPendingConfiguration.setdefaultcCs ||jvSrerf)rbrhrPrPrQ __contains__s z!PendingConfiguration.__contains__cC t|jSre)lendatarmrPrPrQ__len__ zPendingConfiguration.__len__cCrure)reprrwrmrPrPrQ__repr__ryzPendingConfiguration.__repr__cC|Sre)r`rmrPrPrQrwzPendingConfiguration.data)rM __module__ __qualname__r`r_rdrjrlrnrrrtrxr{rrwrPrPrPrQr^dsr^c@seZdZdZeZejZejej ZZ dZ dZ dZ e ZdZdZdZdZdZdZdZdZdZdZdZd ZdZdZdZdZ     dd d Zd dZ ddZ!ddZ"ddZ#ddZ$ddZ%ddZ&dddZ'dddZ(dd Z)dd!d"Z*d#d$Z+d%d&Z,dd'd(Z-d)d*Z. dd+d,Z/dd-d.Z0dd0d1Z1dddde2d2fd3d4Z3  dd6d7Z4d8d9Z5d:d;Z6dddKdLZ?e?Z@ddMdNZAeAZBdOdPZCdQdRZDddSdTZEdUdVZFdWdXZGdYdZZHd[d\ZId]d^ZJd_d`ZKdadbZL ddddeZM ddfdgZNdhdiZOdjdkZP l ddmdnZQdodpZRdqdrZSdsdtZTdudvZUdwdxZVdydzZWd{d|ZXd}d~ZYeZddZ[eZddZ\eZddZ]eZddZ^eZddZ_eZddZ`eZddZaeZddZbecddZdecddZeecddZfeZddZgeZddZheZddZiecddZjejjkddZjeZddZleZddZmeZddZneZddZoeZddZpeZddZqecddZrddZseZddZtdS)rGaCelery 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 ` for usage. Nzcelery.app.amqp:AMQPzcelery.app.events:Eventszcelery.app.log:Loggingzcelery.app.control:Controlzcelery.app.task:Taskz celery.app.registry:TaskRegistryFTc st_|_|p j_|pj_|p_|pj_|p$j_|p*j _ |_ t j _ t t_t t_|_|_|_d_| _t_t_d_t_t_| _tjt st jpqi_t!d_"| p}i_#t_$%d| %d|%d| %d|&d%d|&dt't(j#j)jt*t+fd_,|durtj-n|_.fd d j.D_/j rՈ0j1durt2d d _1t2d dhd_3t2dd _4t2dd _56t7dS)NF__reduce_args__ broker_urlresult_backendincludebroker_use_sslredis_backend_use_ssl)prefixkeyscsg|]}t|qSrP)r0).0fixuprmrPrQ sz#Celery.__init__..zapp.on_configure)namezapp.on_after_configuresource)rproviding_argszapp.on_after_finalizezapp.on_after_fork)8r clockmainamqp_cls events_cls_get_default_loader loader_clslog_cls control_clstask_clsset_as_currentr0 registry_clsrset user_optionssteps autofinalize namespace strict_typing configured_config_sourcer_pending_defaults_pending_periodic_tasks finalized threadingLock_finalize_mutex_pending_tasks isinstancer=rR_using_v1_reduce_preconf_preconf_set_by_auto_Celery__autosetgetr?r^_finalize_pending_confrAr@_confbuiltin_fixupsfixups_fixups set_current on_configurer*on_after_configureon_after_finalize on_after_forkon_initr)rbrloaderbackendamqpeventslogcontrolrtasksbrokerrchanges config_sourcerrrrrrprPrmrQrdsl                    zCelery.__init__cCstjdp |jp dS)N CELERY_LOADERzcelery.loaders.app:AppLoader)osenvironrrrmrPrPrQr3s zCelery._get_default_loadercCsdS)z!Optional callback called at init.NrPrmrPrPrQr;zCelery.on_initcCs"|r||j|<|j|dSdSre)rraddrgrPrPrQ __autoset>s zCelery.__autosetcC t|dS)z*Make this the current app for this thread.N)rrmrPrPrQrC zCelery.set_currentcCr)z*Make this the default app for all threads.N)rrmrPrPrQ set_defaultGrzCelery.set_defaultcCs*|jsd|_tdurt|tdSdSdSNT)_after_fork_registeredr r]rmrPrPrQ_ensure_after_forkKs zCelery._ensure_after_forkcCsd|_t|dS)aOClean 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)_poolrrmrPrPrQcloseQs z Celery.closecCtd|d|S)zgRun :program:`celery` using `argv`. Uses :data:`sys.argv` if `argv` is not specified. zcelery.bin.celery:CeleryCommandrNr/execute_from_commandlinerbargvrPrPrQstart_ z Celery.startcCr)znRun :program:`celery worker` using `argv`. Uses :data:`sys.argv` if `argv` is not specified. zcelery.bin.worker:workerrrrrPrPrQ worker_mainhrzCelery.worker_maincstr|ddrddlm}||ddi|Sd fdd }t|dkr7t|d r3|d i||Std |rHtd tt|t|g|d i|S)aDecorator to create a task class out of any callable. See :ref:`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). lazyTr7) shared_taskFNcs|fdd}|S)Ncsrrfdd}j|_t|rjr jfi}ntjfjd}j|r7|S|S)Ncs|jfiSre)_task_from_funr)funoptsrPrQconsrszRCelery.task..inner_create_task_cls.._create_task_cls..cons)__doc__)rMrrrr&rrappend)rrret)_filtrrrbshared)rrQ_create_task_clss   zDCelery.task..inner_create_task_cls.._create_task_clsrP)rfilterrrrrm)rrrrrQinner_create_task_clssz*Celery.task..inner_create_task_clsrz(argument 1 to @task() must be a callablez,@task() takes exactly 1 argument ({0} given))TNTrP) USING_EXECVrrrvcallable TypeErrorformatsum)rbrUrrrrPrmrQtaskqs   z Celery.taskc s|js |js td|p||j|j}|p|j}||jvr|r"|nt|}t |j|ft |||d|j |jtt ||d|dfi|z|j _ Wn tyUYnw|jj<|t|dtdd|dtdit|dtdd t|d td d |d td drtd stjfdd}j|__S|j|S)N"Contract breach: app not finalizedT)bound)rNrrun _decoratedrr~ __header__ __wrapped__ autoretry_forrP retry_kwargs retry_backoffFretry_backoff_maxiX retry_jitter _orig_runc sxz j|i|WStytyy;}zr-tjjdd<jdd|id}~ww)N)factorretriesmaximum full_jitter countdownr\rP)rrr r4requestrretry)rUrpr\rrrrrrrPrQrs$  z"Celery._task_from_fun..run)rr RuntimeErrorr.rMr~Taskr staticmethodtypedictrr,rAttributeErrorrbindtuplergetattrinthasattrrrr)rbrrbaser optionsrrPrrQrsj               zCelery._task_from_funcCs@|jst|}||j|j|_||j|j<||_|||S)zUtility 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. )rrr.rMr~r_appr )rbrrrPrPrQ register_tasks  zCelery.register_taskcCs t|||Sre)r.)rbrmodulerPrPrQr. zCelery.gen_task_namecCs|jE|js@|r|jstdd|_t||j}|r$t||st|j D]}| |q)|j j |dWddSWddS1sKwYdS)zFinalize the app. This loads built-in tasks, evaluates pending task decorators, reads configuration, etc. rTsenderN) rrrrrrr'popleftr$rr rsend)rbautopendingrrPrPrQfinalizes    "zCelery.finalizecs>t|s |fdd}|jr|j|S|j|dS)adAdd 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. csSrerPrPdrPrQ=rz%Celery.add_defaults..N)rrr add_defaultsrr)rbrrPrrQr*s zCelery.add_defaultscCs@||_|p|j|_|s|jrd|_|jj||dr|jSdSdS)aRead 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)rrrrrconfig_from_objectrc)rbobjr forcerrPrPrQr!Bs  zCelery.config_from_objectcCs:tj|}|s|r dStt||j|||dS)a3Read 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#)rrrrERR_ENVVAR_NOT_SETstriprr!)rb variable_namer r# module_namerPrPrQconfig_from_envvarZs  zCelery.config_from_envvarcelerycCs|j|j||dSre)rrnrcmdline_config_parser)rbrrrPrPrQconfig_from_cmdlinels zCelery.config_from_cmdlinejsonc Cs"ddlm}||||||||dS)aSetup 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. 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)celery.securityr-)rballowed_serializersrhcertstoredigest serializerr-rPrPrQr-qs zCelery.setup_securityrcCs0|r|||Stjjt|j||d|ddS)aAuto-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 (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)weakrN)_autodiscover_tasksrimport_modulesconnectr)rbpackages related_namer#rPrPrQautodiscover_taskss(  zCelery.autodiscover_taskscKs|r|||S||Sre)_autodiscover_tasks_from_names_autodiscover_tasks_from_fixups)rbr8r9rprPrPrQr5s  zCelery._autodiscover_taskscCs |jt|r ||S||Sre)rr:r)rbr8r9rPrPrQr;s z%Celery._autodiscover_tasks_from_namescCs|jdd|jD|dS)NcSs(g|]}|D] }t|dr|qqS)r:)r:r)rrpkgrPrPrQrsz:Celery._autodiscover_tasks_from_fixups..)r9)r;r)rbr9rPrPrQr<s z&Celery._autodiscover_tasks_from_fixupsrc%Ksd}}|j}|p t}|p| }| p|j} |j} | jr$tjtddd|dd}!| ||p0||||}|r9|s\|j }|r\|sH|j j pG|j j }|sN|j j }| jr\|d|j jd|j|||||||| ||t| t||pr|j|||jj|||||d|d d }"|r|j|dd }||1}#|#j|!s|j|#||j|#||"fi|Wdn1swYWdn1swY| p|j|}$|!|$_|r|s|j d }}|r||$|$S) zSend 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_task) stacklevel ignore_resultFpriorityargsrepr kwargsrepr)rBrC) auto_declareT) rrrouterrctask_always_eagerwarningswarnrpoproutecurrent_worker_taskrroot_ididtask_inherit_parent_priorityrr delivery_inforcreate_task_messager-oidtask_send_sent_eventProducerproducer_or_acquire connection_reraise_as_library_errorsr on_task_callsend_task_message AsyncResultignored add_trail)%rbrrUrpretatask_idproducerrUrE result_clsexpires publisherlink link_error add_to_parentgroup_idrchordreply_to time_limitsoft_time_limitrL parent_id route_nameshadowchain task_typerparent have_parentrrcignored_resultmessagePresultrPrPrQ send_tasksn           zCelery.send_taskcK|j|p|jjfi|S)z|Establish connection used for consuming. See Also: :meth:`connection` for supported arguments. ) _connectionrcbroker_read_urlrburlrprPrPrQconnection_for_readzCelery.connection_for_readcKrv)z|Establish connection used for producing. See Also: :meth:`connection` for supported arguments. )rwrcbroker_write_urlryrPrPrQconnection_for_write"r|zCelery.connection_for_writec Ks2|j|p|jjf|||||||| | | | d | S)aCEstablish 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. ) useridpassword virtual_hostportsslconnect_timeout transporttransport_options heartbeat login_methodfailover_strategy)r~rcr})rbhostnamerrrrrrrrrrrrprPrPrQrU*s! zCelery.connectionc Ksv|j}|jj||p |j|p|j|p|j|p|j|p|j|d|| | p%|j | p)|j t |j fi| p1i|d|d S)Nrbroker_connection_timeout)rrrrrrr) rcr Connection broker_userbroker_password broker_vhost broker_portbroker_transporteitherbroker_login_methodbroker_failover_strategyrbroker_transport_options)rbrzrrrrrrrrrrrrprcrPrPrQrwUs* zCelery._connectioncCs|r |jjddS|S)z)Helper for :meth:`connection_or_acquire`.Tblock)poolacquirer~)rbrrPrPrQ_acquire_connectionqszCelery._acquire_connectioncOst||j|dS)aRContext 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. )r)r2r)rbrUr___rPrPrQconnection_or_acquirews zCelery.connection_or_acquirecCst||jjddS)aEContext 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. Tr)r2 producer_poolr)rbr^rPrPrQrTs zCelery.producer_or_acquirecCst|S)z.__reduce__)r~rr)r0rMrr~rrr") rbClassrrrrkwrattrsrPrrQrs zCelery.subclass_with_selfcCs t||Srer)rbpathrPrPrQrS6rzCelery._rgetattrcCs|SrerPrmrPrPrQ __enter__9szCelery.__enter__cGs |dSre)r)rbrWrPrPrQ__exit__<rzCelery.__exit__cCsdt|jt|S)Nz <{0} {1}>)rrrMrDrmrPrPrQr{?rqzCelery.__repr__cCs |jr|St|j|ffSre)r __reduce_v1__rCrK__reduce_keys__rmrPrPrQrBszCelery.__reduce__cCst|j|jf|fSre)rBrKPicklerrrmrPrPrQrGszCelery.__reduce_v1__c CsD|j|jr |jjn|j|j|j|j|j|j |j |j |j |j |jd S)zAKeyword arguments used to reconstruct the object when unpickling.) rrrrrrrrrrrr)rrrrrrrrrrrrrrrrmrPrPrQrPszCelery.__reduce_keys__c Cs6|j|jr |jjni|j|j|j|j|j|j d|j f S)z>Deprecated method, please use :meth:`__reduce_keys__` instead.F) rrrrrrrrrrrrmrPrPrQrbs   zCelery.__reduce_args__cC |dS)zNWorker application. See Also: :class:`~@Worker`. zcelery.apps.worker:WorkerrrmrPrPrQWorkeri z Celery.WorkercKr)zUEmbeddable worker. See Also: :class:`~@WorkController`. zcelery.worker:WorkControllerrrbrprPrPrQWorkControllerrrzCelery.WorkControllercKr)zf:program:`celery beat` scheduler application. See Also: :class:`~@Beat`. zcelery.apps.beat:BeatrrrPrPrQBeat{rz Celery.BeatcCr|)zBase task class for this app.)rrmrPrPrQrz Celery.TaskcCs t|jjSre)prepare_annotationsrctask_annotationsrmrPrPrQ annotationsrzCelery.annotationscCr)zgCreate new result instance. See Also: :class:`celery.result.AsyncResult`. zcelery.result:AsyncResultrrmrPrPrQrYrzCelery.AsyncResultcCr)Nzcelery.result:ResultSetrrmrPrPrQ ResultSet zCelery.ResultSetcCr)zmCreate new group result instance. See Also: :class:`celery.result.GroupResult`. zcelery.result:GroupResultrrmrPrPrQ GroupResultrzCelery.GroupResultcCs:|jdur||jj}t|tj||_|jS)zBroker connection pool: :class:`~@pool`. Note: This attribute is not related to the workers concurrency pool. N)rrrcbroker_pool_limitr set_limit connectionsr~)rblimitrPrPrQrs  z Celery.poolcCstjS)z2Instance of task being executed, or :const:`None`.)rtoprmrPrPrQ current_taskszCelery.current_taskcCstS)zThe 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. )rrmrPrPrQrKszCelery.current_worker_taskcCs t|ddS)z+Universally unique identifier for this app.F)threadsr rmrPrPrQrQs z Celery.oidcCt|j|dS)z,AMQP related functionality: :class:`~@amqp`.r)r/rrmrPrPrQrz Celery.amqpcCr|)zCurrent backend instance.)rrmrPrPrQrrzCelery.backendcCs|jdur ||_|jS)zCurrent configuration.N)rrrmrPrPrQrcs  z Celery.confcCs ||_dSre)r)rbrrPrPrQrcrcCr)z#Remote control: :class:`~@control`.r)r/rrmrPrPrQrrzCelery.controlcCr)z0Consuming and sending events: :class:`~@events`.r)r/rrmrPrPrQrrz Celery.eventscCst|j|dS)zCurrent loader instance.r)r%rrmrPrPrQrsz Celery.loadercCr)zLogging: :class:`~@log`.r)r/rrmrPrPrQrrz Celery.logcCsddlm}|S)Nr)canvas)r)r)rbrrPrPrQrs zCelery._canvascCs|jdd|jS)zoTask registry. Warning: Accessing this attribute will also auto-finalize the app. T)r)rrrmrPrPrQrs z Celery.taskscCs|jjSre)rrrmrPrPrQrr}zCelery.producer_poolcCs |jtjkS)z/Check if the application uses the UTC timezone.)r5utcrmrPrPrQuses_utc_timezonerzCelery.uses_utc_timezonecCs*|j}|js|jr tjStjSt|jS)zCurrent timezone for this app. This is a cached property taking the time zone from the :setting:`timezone` setting. )rcr5 enable_utcrlocal get_timezonerrPrPrQr5s  zCelery.timezone)NNNNNNNTNNNNNNNTNTre)NNF)F)FFN)FF)r))NrF)NNNNNNNNNNNNNTNrNNNNNNNNNN) NNNNNNNNNNNN) NNNNNNNNNNN)Tr)rPrPN)rPNN)NrNNF)urMr~rrr>rrSYSTEMIS_macOS IS_WINDOWSrrrBUILTIN_FIXUPSrrrrrrrrrrrrrrrrrrdrrrrrrrrrrrrr.rrr!r(r+r;r-r:r5r;r<rur{r~rUrwbroker_connectionrrdefault_connectionrTdefault_producerrrrrrErrrrXrrrrrrrSrrr{rrrrrrrrrrrYrrpropertyrrrKrQrrrcsetterrrrrrrrrr5rPrPrPrQrGsJ% M   GH     . K  +        "   #                        rG)tr __future__rrrrrG collectionsrrroperatorrkombur kombu.clocksr kombu.commonr kombu.utils.compatr kombu.utils.objectsrkombu.utils.uuidrviner vine.utilsrr)rr celery._staterrrrrrrrrcelery.exceptionsrrrr celery.fiver!r"r#r$celery.loadersr% celery.localr&r' celery.utilsr(celery.utils.collectionsr)celery.utils.dispatchr*celery.utils.functionalr+r,r-celery.utils.importsr.r/r0celery.utils.logr1celery.utils.objectsr2r3celery.utils.timer4r5r6rr8r9rr:rrr;r<registryr=utilsr>r?r@rArBrCrDrErF__all__rMrZrrrrr$rRrVr]r^rLrGApprPrPrPrQst          ,         ,    ,