V.jdZddlZddlZddlZddlZddlZddlmZmZm Z ddl m Z ddl m Z ddl mZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlm Z ddl!m"Z"m#Z#ddl$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-ddl.m/Z/m0Z0ddl1m2Z2ddl3m4Z4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;ddlZ>m?Z?ddl@mAZAmBZBmCZCddlDmEZEddlFmGZGmHZHddlImJZJm Z mKZKddlLmMZMmNZNddlOmPZQdd lRmSZSdd!lTmUZUmVZVdd"lWmXZXdd#lYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbd$ZceEedZed%hZfejjd&Zid'Zjd(Zkd)Zld*ZmGd+d,ee9ZnGd-d.ZoeoZpy)/z#Actual App instance implementation.N)UserDict defaultdictdeque)datetime)timezone attrgetter)Exit)isoparse)pools) LamportClockoid_from)register_after_fork)cached_property)uuid) starpromise) platformssignals) _announce_app_finalized_deregister_app _register_app_set_current_app _task_stackconnect_on_app_finalizeget_current_appget_current_worker_taskset_default_app)AlwaysEagerIgnoredImproperlyConfigured)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)maybe_make_awarerto_utc)backendsbuiltins)prepare)add_autoretry_behaviour)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" cRt|j|tthtgS)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)r/ __class__rCobject__name__)appattrs QC:\xampp\htdocs\tradingbinance\backend\.venv\Lib\site-packages\celery/app/base.pyapp_has_customrNCs% cmmT0@&.Z 11c:tj||S)z Unpickle app.)r _rgetattr) reverse_nameargss rM_unpickle_appattrrTOs 5?  & &| 4d ;;rOc |jy#t$r"}tjd|dYd}~yd}~wwxYw)Nz!after forker raised exception: %rr2)exc_info) _after_fork Exceptionloggerinfo)rKexcs rM_after_fork_cleanup_appr\Vs:J  J 7q IIJs >9>cTeZdZdZdZdZdZdZdZdZ dZ dZ d Z e d Zy) PendingConfigurationNc`tj|d|tj|d|y)N_datacallback)rI __setattr__)selfconfras rM__init__zPendingConfiguration.__init__js&4$/4X6rOc"||j|<yNr`rckeyvalues rM __setitem__z PendingConfiguration.__setitem__ns 3rOc8|jjyrg)r`clearrcs rMrnzPendingConfiguration.clearqs rOc<|jj|i|yrg)r`updatercrSkwargss rMrqzPendingConfiguration.updatets 4*6*rOc:|jj|i|Srg)r` setdefaultrrs rMruzPendingConfiguration.setdefaultws$tzz$$d5f55rOc||jvSrgrh)rcrjs rM __contains__z!PendingConfiguration.__contains__zsdjj  rOc,t|jSrg)lendataros rM__len__zPendingConfiguration.__len__s499~rOc,t|jSrg)reprrzros rM__repr__zPendingConfiguration.__repr__sDIIrOc"|jSrg)raros rMrzzPendingConfiguration.datas}}rO)rJ __module__ __qualname__rar`rerlrnrqrurwr{r~rrzrOrMr^r^_sJH E7 +6! rOr^cheZdZdZeZejZejejcZZ dZ dZ dZ e ZdZdZdZdZdZdZdZdZdZdZdZdZd ZdZdZdZdZ d_d Z d Z!d Z"d Z#dZ$dZ%dZ&dZ'd`dZ(d`dZ)dZ*dadZ+dbdZ,dZ-dZ.dadZ/dZ0 dcdZ1dddZ2dedZ3ddddde4dfdZ5 dfd Z6d!Z7d"Z8d#Z9 dgd$Z:d`d%Z;d`d&Z< dhd'Z= did(Z>e=Z?djd)Z@dkd*ZAeAZBd`d+ZCeCZDd,ZEd-ZFd`d.ZGd/ZHd0ZId1ZJd2ZKd3ZLd4ZMd5ZN dld6ZO dmd7ZPd`d8ZQd9ZR dnd:ZSd;ZTd<ZUd=ZVd>ZWd?ZXd@ZYdAZZdBZ[e\dCZ]e\dDZ^e\dEZ_e\dFZ`e\dGZae\dHZbe\dIZce\dJZdeedKZfeedLZgeedMZhe\dNZieedOZje\dPZkeedQZleljdRZleedSZneedTZoeojdUZoe\dVZpe\dWZqe\dXZre\dYZse\dZZte\d[Zueed\Zvd]Zwe\d^Zxy)orCaCelery 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:TaskRegistryFc tj|_d|_t |_||_|xs |j|_|xs |j|_|xs|j|_ |xs |j|_ |xs |j|_ t||_|xs |j|_||_t#|j$|_t't(|_t't(|_||_||_||_d|_| |_t9|_t9|_d|_tj@|_!t9|_"| |_#tI|jFtJs$|j%|jFxsi|_#tM|d|_'| xsi|_(t)|_)|jUd| |jUd||jUd| |jWD]\}}|jU||tYt[|jP|j\|j0t^t`f|_1|t)|jdn||_3|jfDcgc]}t#||c}|_4|j r|jk|jltod|_6tod d h |_8tod |_9tod |_:d|_;|jyt{|ycc}w)NF__reduce_args__ broker_urlresult_backendinclude)prefixkeyszapp.on_configurenamezapp.on_after_configuresource)rproviding_argszapp.on_after_finalizezapp.on_after_fork)> threadinglocal_local_backend_cacher clockmainamqp_cls events_cls_get_default_loader loader_clslog_cls control_clsbool_custom_task_cls_usedtask_clsset_as_currentr, registry_clsrset user_optionssteps autofinalize namespace strict_typing configured_config_sourcer_pending_defaults_pending_periodic_tasks finalizedRLock_finalize_mutex_pending_tasks isinstancer9rN_using_v1_reduce_preconf_preconf_set_by_auto_Celery__autosetitemsr;r^_finalize_pending_confr=r<_confbuiltin_fixupsfixups_fixups set_current on_configurer&on_after_configureon_after_finalize on_after_forkuse_fast_trace_taskon_initr)rcrloaderbackendamqpeventslogcontrolrtasksbrokerrchanges config_sourcerrrrrrsrjrkfixups rMrezCelery.__init__s oo' "!^  -   3DOO >D$<$<$>*dll "6d&6&6%)(^" 1DMM ,*4+<+<=', % ("*+!&',w$(0  $++|4++DKK,=2>DK !/t5F G 2 $'E! |V, '1 y'* ,,.JC NN3 &)  t:: <>>!?3   39.c$--.f AEM-u-d3M           $ &,> ?D "()$:# "(-D!E#)<=$)  d+NsM4cdtjjdxs|jxsdS)N CELERY_LOADERzcelery.loaders.app:AppLoader)osenvirongetrros rMrzCelery._get_default_loader:s- JJNN? + + OO + * rOcy)z!Optional callback called at init.Nrros rMrzCelery.on_initBsrOc^|+||j|<|jj|yyrg)rraddris rM __autosetzCelery.__autosetEs/  !&DMM#   % % ) )# . rOct|y)z*Make this the current app for this thread.N)rros rMrzCelery.set_currentJs rOct|y)z*Make this the default app for all threads.N)rros rM set_defaultzCelery.set_defaultNs rOcZ|jsd|_tt|tyyyNT)_after_fork_registeredrr\ros rM_ensure_after_forkzCelery._ensure_after_forkRs.***.D '".#D*AB/+rOc(d|_t|y)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)_poolrros rMclosez Celery.closeXs rOcLddlm}||jd_|tj } |j |d d|jd_y#t$r*}|jcYd}~d|jd_Sd}~wwxYw#d|jd_wxYw)zgRun :program:`celery` using `argv`. Uses :data:`sys.argv` if `argv` is not specified. rceleryNF)rSstandalone_mode) celery.bin.celeryrparamsdefaultsysargvrr exit_code)rcrres rMstartz Celery.startfs -#' a <88D , KKT5K 9(,FMM!  $ ;; '+FMM!  $ (,FMM!  $s/A B  B+B ,B B  B B#cj|tj}d|vr td|j|y)znRun :program:`celery worker` using `argv`. Uses :data:`sys.argv` if `argv` is not specified. NworkerzkThe worker sub-command must be specified in argv. Use app.start() to programmatically start other commands.)r)rr ValueErrorr)rcrs rM worker_mainzCelery.worker_mainys= <88D 4 L   rOc Ftr"|jddrddlm}||ddi|Sd fd }t |dk(r$t |dr |d i||St d|r7t d jtt |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). lazyTr2) shared_taskFc&|fd}|S)Nc(r"fd}j|_t|r jrjfi}n?t jfj }j j|r|S|S)Nc*|jfiSrg)_task_from_fun)rKfunoptss rMconszRCelery.task..inner_create_task_cls.._create_task_cls..conss1s11#>>>rO)__doc__)rJrrrr"rrappend)rrret_filtrrrcshareds` rM_create_task_clszDCelery.task..inner_create_task_cls.._create_task_clss?$'LLDM+D1t~~-$--c:T:C't':':SFD/2{{.inner_create_task_clssE  "$ #rOrz(argument 1 to @task() must be a callablez+@task() takes exactly 1 argument ({} given))TNTr) USING_EXECVrrrycallable TypeErrorformatsum)rcrSrrrs` rMtaskz Celery.tasks< 488FD1 &959D9 9 $, t9>Q 4,4t4d;;FG G =DDTCI./12 2%,t,,rOc.tt||S)Nbound) staticmethodr()rcrr s rM type_checkerzCelery.type_checkersM#U;<> 1 1&'KLL!%'---"7??#45!KK..0DIIdO1&&++4+8" ! !sA!C/A CC ct|s|fdc}|jr |jj|S|jj |y)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. cSrgr)dsrMz%Celery.add_defaults..1s!rON)rrr add_defaultsrr)rcrr.s @rMr0zCelery.add_defaultssI$})FAs ??::**351 1 %%c*rOc||_|xs |j|_|s |jr1d|_|jj ||r |j Syy)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_objectrd)rcobjr2forcers rMr3zCelery.config_from_object6sX"""4dnn DOODJ{{--c&-Ayy B$rOctjj|}|s/|ryttj j ||j|||S)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)r2r5)rrrr ERR_ENVVAR_NOT_SETstriprr3)rc variable_namer2r5 module_names rMconfig_from_envvarzCelery.config_from_envvarNs]jjnn]3 &"((*11-@B B&&{6&OOrOcn|jj|jj||yrg)rrqrcmdline_config_parser)rcrrs rMconfig_from_cmdlinezCelery.config_from_cmdline`s(  KK - -dI > rOjsonc .ddlm}|||||||||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_securityrK)celery.securityrA) rcallowed_serializersrj key_passwordcertstoredigest serializerrAs rMrAzCelery.setup_securityes(8 313 d#VZTC CrOc|r|j||Stjjt |j||d|y)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 (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)weakr%N)_autodiscover_tasksrimport_modulesconnectr)rcpackages related_namer5s rMautodiscover_taskszCelery.autodiscover_taskssMP ++HlC C&&{  $ $h ( d ' $rOc L|r|j||S|j|Srg)_autodiscover_tasks_from_names_autodiscover_tasks_from_fixups)rcrOrPrss rMrLzCelery._autodiscover_taskss) 66xN N33LAArOch|jjt|r ||S||Srg)rrQr)rcrOrPs rMrSz%Celery._autodiscover_tasks_from_namess6{{--"8,HJL  2:L  rOc |j|jDcgc]%}t|dr|jD]}|'c}}|Scc}}w)NrQ)rP)rSrhasattrrQ)rcrPrpkgs rMrTz&Celery._autodiscover_tasks_from_fixupssc22!\\4 )Eu23//1 1 \4 % 3& &4 s*A c dx}} |j}!|xs t}|xs| }| xs |!j} |j}"|"jr t j tdd|jdd}#| j||xs||||}| t| tr+t| |jz j}$nFt| tr4tt!| |jz j}$n| }$|$dkrt"j%|d|$ d d}$|$|d <|r|s|j&}|r|s.|j(j*xs|j(j,}|s|j(j,}|"j.r5|j1d |j(j2j5d |!j6||||||||| ||t9| t9||xs |j:|||jj<||||f|#|d |}%|jd g}&|&D]}'|j|'|r|!j?|d}|jA|5}(|(jBjE5|#s|jFjI|(||!jJ|(||%fi|dddddd| xs |jL|})|#|)_'|r#| s|j&d} }|r|jQ|)|)S#1swYUxYw#1swYYxYw)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_resultFrz% has an expiration date in the past (aJs 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. expirationpriority)r\replaced_task_nestingstamped_headers) auto_declareT))rrrouterrdtask_always_eagerwarningswarnrpoprouterrr0now total_secondsstrr rYwarningcurrent_worker_taskrequestroot_ididtask_inherit_parent_priorityru delivery_inforcreate_task_messager) thread_oidtask_send_sent_eventProducerproducer_or_acquire connection_reraise_as_library_errorsr on_task_callsend_task_message AsyncResultignored add_trail)*rcrrSrs countdownetatask_idproducerrwrb result_clsexpires publisherlink link_error add_to_parentgroup_id group_indexretrieschordreply_to time_limitsoft_time_limitrn parent_id route_nameshadowchain task_typer_rparent have_parentrrdr\ expires_smessager`stampPresults* rM send_taskzCelery.send_tasks/" $#yy#TV(y&4;;yy  ! ! MM,>  OU; ,, Z'4vyB  '8,-#xxz*+8=?GS)-W%')-45B]_$ 1}iDiZLQ++  $-GL !i--F$nn44I8I8IG & 1 1I44&&z'-~~'C'C'G'G 'SU+$** T4C; We t j4  '_ II * * Y  ("7  &>   ( ;:0 /s$ L;'4L/L;/L8 4L;;Mc X|j|xs|jjfi|S)z|Establish connection used for consuming. See Also: :meth:`connection` for supported arguments. ) _connectionrdbroker_read_urlrcurlrss rMconnection_for_readzCelery.connection_for_read/s+  t @tyy'@'@KFKKrOc X|j|xs|jjfi|S)z|Establish connection used for producing. See Also: :meth:`connection` for supported arguments. )rrdbroker_write_urlrs rMconnection_for_writezCelery.connection_for_write7s+  t Atyy'A'ALVLLrOc  p|j|xs|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)rrdr)rchostnamerrrrrrrrrrrrss rMrwzCelery.connection?sWB)t((  2 22 H%Dc+y/9%9J    rOc  |j}|jj||xs |j|xs |j|xs |j |xs |j |xs |j|jd|| | xs |j| xs |jt|jfi| xsi|jd| S)Nbroker_use_sslbroker_connection_timeout)rrrrrrr) rdr Connection broker_userbroker_password broker_vhost broker_portbroker_transporteitherbroker_login_methodbroker_failover_strategyrbroker_transport_options)rcrrrrrrrrrrrrrsrds rMrzCelery._connectionjs yyyy##   &d&&  ,,,  -D--  $D$$84#8#8 ,c2%A)A)A!BT%B%B"--1B1Hb!KK+_!$  rOc^|r|jjdS|jS)z)Helper for :meth:`connection_or_acquire`.Tblock)poolacquirer)rcrs rM_acquire_connectionzCelery._acquire_connections, 99$$4$0 0((**rOc2t||j|S)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)r.r)rcrwr___s rMconnection_or_acquirezCelery.connection_or_acquiresz4+C+C$OOrOcFt||jjdS)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)r. producer_poolr)rcrs rMrvzCelery.producer_or_acquires$ d((00  rOct|S)z)>?@ $$T]]33rOcL|jjj|S)zxSelect subset of queues. Arguments: queues (Sequence[str]): a list of queue names to keep. )rqueuesselect)rcrs rM select_queueszCelery.select_queuess yy&&v..rOcntdtd|t|jj|gS)zGet key from configuration or use default values. Fallback to the value of a configuration key if none of the `*values` are true. N)r'rrdr)rc default_keydefaultss rMrz Celery.eithers3 T $ !;tyy}}k#J   rOct|S)z)Return information useful in bug reports.)rAros rMrAzCelery.bugreports rOctj|jxs|jj|j \}}|||S)N)rKr)r3by_url backend_clsrdrr)rcrrs rM _get_backendzCelery._get_backendsB    8 8 8 KK 4S))rOc~ |jx}|_|S#t$r}t|j|d}~wwxYw)zGet 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_configrrModuleNotFoundErrorrS)rcrderrs rMrzCelery._finalize_pending_confsH : $ 1 1 3 3D4:  :&sxx0c 9  :s <7<c`t|jtr|jj|n|j|jr%|j j |jd|_t|j|j j|j|j|j}|j|jj|n||_|j }|r:|jj#t%|j'|r:|j(}|r(|j'\}}|j*|i||r(|j,j||j|jS)Nr$T) ignore_keysr)r%r)rrr&r(rrr3rrBrrdrrrr swap_withrr0r#r&r_add_periodic_taskr)rcsettings pending_def pending_beatperiodic_task_argsperiodic_task_kwargss rMrzCelery._load_configsb d'' 0    " "$ " /        KK * *4+>+> ?"    0 0 14==11$..  :: ! JJ  *!DJ,,  JJ # #N3H;3F3F3H3J$K L33 7C7K7K7M 4  4 #D # #%7 P;O P $$D$DzzrOcd|_ d|jd_|j j |y#ttf$rY.wxYw)Nrr$)r__dict___producer_poolrKeyErrorrr(ros rMrWzCelery._after_forksQ  37DMM& ! 0 t,)   s:A  A cD||d<|jj|i|S)z:Return a new :class:`~celery.Signature` bound to this app.rK)_canvas signaturerrs rMrzCelery.signature s'u %t||%%t6v66rOc |j|||||fi|\}}|jr|j||||S|jj ||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. rr)_sig_to_periodic_task_entryrrrr) rcschedulesigrSrsrrrjentrys rMadd_periodic_taskzCelery.add_periodic_tasksx6T55 c47157 U ??  # #CT # :   ( ( / /#u~0N O rOc 2|sin|}t|tjr|j||n|j |j ||}|xs t |||j |j|jt|jfi|dfS)N)rrrSrsr) rr$CallableSignatureclonerrr}rSrsrr)rcrrrSrsrrs rMrz"Celery._sig_to_periodic_task_entrys!vS("<"<=yyv&NN388T6:  tCy HHHHjjCKK040 #   rOc|1||jjvrtjd|d||jj|<y)NzPeriodic task key='zl' shadowed a previous unnamed periodic task. Pass a name kwarg to add_periodic_task to silence this warning.)r beat_schedulerYrk)rcrjrrs rMrzCelery._add_periodic_task-sM .__reduce__Ss$w0D0D0F&GG GrO)rrr)r,rJrrrr) rcClassrrrrkwrattrss ` rMrzCelery.subclass_with_self=s~&u%$'%.. H  ''MM  ",E, D*ENNUHe<)rrJr@ros rMr~zCelery.__repr__is&4:&&'qa88rOc~|jr|jSt|j|j ffSrg)r __reduce_v1__r?rH__reduce_keys__ros rMrzCelery.__reduce__ls7  %%' ' 4>>43G3G3I"JKKrOc`t|j|jf|jzfSrg)r>rHPicklerrros rMrzCelery.__reduce_v1__qs/  ^^T\\ *T-A-A-C C  rOc T|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)rrrrrrrrrrrrrrrros rMrzCelery.__reduce_keys__zszII&*oo ""4==oo''MMoo<<''kk!00   rOc |j|jr|jjni|j|j |j |j|j|jd|jf S)z>Deprecated method, please use :meth:`__reduce_keys__` instead.F) rrrrrrrrrrrros rMrzCelery.__reduce_args__s\ 4::--b!1!14==t/?/?t**, ,rOc$|jdS)zNWorker application. See Also: :class:`~@Worker`. zcelery.apps.worker:Workerrros rMWorkerz Celery.Worker&&'BCCrOc $|jdS)zUEmbeddable worker. See Also: :class:`~@WorkController`. zcelery.worker:WorkControllerrrcrss rMWorkControllerzCelery.WorkControllers&&'EFFrOc $|jdS)zf:program:`celery beat` scheduler application. See Also: :class:`~@Beat`. zcelery.apps.beat:Beatrr s rMBeatz Celery.Beats&&'>??rOc"|jS)zBase task class for this app.)rros rMrz Celery.Tasks##%%rOc@t|jjSrg)prepare_annotationsrdtask_annotationsros rM annotationszCelery.annotationss"499#=#=>>rOc$|jdS)zgCreate new result instance. See Also: :class:`celery.result.AsyncResult`. zcelery.result:AsyncResultrros rMr{zCelery.AsyncResultrrOc$|jdS)Nzcelery.result:ResultSetrros rM ResultSetzCelery.ResultSets&&'@AArOc$|jdS)zmCreate new group result instance. See Also: :class:`celery.result.GroupResult`. zcelery.result:GroupResultrros rM GroupResultzCelery.GroupResultrrOc|ja|j|jj}t j |tj |j|_|jS)zBroker connection pool: :class:`~@pool`. Note: This attribute is not related to the workers concurrency pool. )rrrdbroker_pool_limitr set_limit connectionsr)rclimits rMrz Celery.poolsZ ::   # # %II//E OOE "**4+D+D+FGDJzzrOc"tjS)z2Instance of task being executed, or :const:`None`.)rtopros rM current_taskzCelery.current_tasksrOctS)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. )rros rMrlzCelery.current_worker_tasks '((rOct|dS)z+Universally unique identifier for this app.Fthreadsrros rMoidz Celery.oidse,,rOc |jjS#t$r#t|dx|j_}|cYSwxYw)z*Per-thread unique identifier for this app.Tr8)rr:rr)rcnew_oids rMrszCelery.thread_oids@ ;;?? " (0t(D DDKKOgN s)AAc0t|j|S)z,AMQP related functionality: :class:`~@amqp`.rB)r+rros rMrz Celery.amqps4==d33rOc`|j |jSt|jddS)zA reference to the backend object Uses self._backend_cache if it is thread safe. Otherwise, use self._local Nr)rgetattrrros rM_backendzCelery._backends/    *&& &t{{It44rOcN|jr||_y||j_y)z!Set the backend object on the appN) thread_saferrr)rcrs rMr@zCelery._backend s!   ")D ")DKK rOc\|j|j|_|jS)zCurrent backend instance.)r@rros rMrzCelery.backends( ==  --/DM}}rOc\|j|j|_|jS)zCurrent configuration.)rrros rMrdz Celery.confs( :: **,DJzzrOc||_yrg)r)rcr.s rMrdz Celery.conf!s  rOc0t|j|S)z#Remote control: :class:`~@control`.rB)r+rros rMrzCelery.control%s4++66rOc0t|j|S)z0Consuming and sending events: :class:`~@events`.rB)r+rros rMrz Celery.events*s4??55rOc:t|j|S)zCurrent loader instance.rB)r!rros rMrz Celery.loader/s/~doo.488rOc0t|j|S)zLogging: :class:`~@log`.rB)r+rros rMrz Celery.log4s4<|jd|jS)zoTask registry. Warning: Accessing this attribute will also auto-finalize the app. T)r))r+rros rMrz Celery.tasks>s 4  {{rOc.|jjSrg)rrros rMrzCelery.producer_poolHsyy&&&rOc<|jtjk(S)z/Check if the application uses the UTC timezone.)rrros rMuses_utc_timezonezCelery.uses_utc_timezoneLs}} ,,rOc|j}|js,|jrtjStjStj |jS)zCurrent timezone for this app. This is a cached property taking the time zone from the :setting:`timezone` setting. )rdr enable_utcrr get_timezone)rcrds rMrzCelery.timezonePsDyy}}||#~~%$$T]]33rO)NNNNNNNTNNNNNNNTNTrg)F)NNF)FFN)FFr)NrF)NNNNNNNNNNNNNTNNrNNNNNNNNNNr) NNNNNNNNNNNN) NNNNNNNNNNN)Tr)rrN)rNN)NrKNF)yrJrrrr:rrSYSTEMIS_macOS IS_WINDOWSrrrBUILTIN_FIXUPSrrrrrrrrrrrrrrrrrrrerrrrrrrrrrr rr r*r+r0r3r;r>r7rArQrLrSrTrrrrwrbroker_connectionrrdefault_connectionrvdefault_producerrrhrrrArrrrWrrrrrrrQr rr~rrrrrrr!r#rr(r{r+r-propertyrr5rlr:rsrr@setterrrdrrrrrrrrOrrrOrMrCrCs"JG   F$--y/C/CHj DL E#N%HK+JJ&G.K%H5LFG E E"LM7;;?GKIMBF Vp 0/ C ,& E-N=>&19,+2AE!0P$ 264dY]!*A"(C@+/7<,$\B  &AEDH8<8C5:!=F&9L   $,DDGG@@&&??DDBBDD  ))--4455__**   [[77669933''- 4 4rOrC)qrrrrrrd collectionsrrrrrroperatorr click.exceptionsr dateutil.parserr kombur kombu.clocksr kombu.commonrkombu.utils.compatrkombu.utils.objectsrkombu.utils.uuidrvinerrrr celery._staterrrrrrrrrcelery.exceptionsrr celery.loadersr! celery.localr"r# celery.utilsr$celery.utils.collectionsr%celery.utils.dispatchr&celery.utils.functionalr'r(r)celery.utils.importsr*r+r,celery.utils.logr-celery.utils.objectsr.r/celery.utils.timer0r1rr3r4r(r5r& autoretryr6rr7r8registryr9utilsr:r;r<r=r>r?r@rArB__all__rJrYrVrrrr7rNrTr\r^rCApprrOrMrxs) 442!$%!2/!%oooF)5!7(DDKK'<@@!7.G"000  H !jjnn89   1<J)8%7)XR4R4j& rO