o h@stdZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl mZmZmZd d lmZmZd d lmZmZd d lmZd d lmZmZmZd dlmZmZzddl Z Wn e!ykdZ YnwdZ"dZ#ddZ$eddZ%eddZ&GdddZ'ej(Gddde'Z)ej(Gddde'Z*ej(Gddde*Z+ej(Gdd d e)Z,d#d!d"Z-dS)$z3Task results/state and results for groups of tasks.N)deque)contextmanager)proxy)isoparse)cached_property)Thenablebarrierpromise) current_appstates)_set_task_join_will_blocktask_join_will_block)app_or_default)ImproperlyConfiguredIncompleteStream TimeoutError)DependencyGraphGraphFormatter) ResultBase AsyncResult ResultSet GroupResult EagerResultresult_from_tuplezNever call result.get() within a task! See https://docs.celeryq.dev/en/latest/userguide/tasks.html#avoid-launching-synchronous-subtasks cCstrttdSN)r RuntimeError E_WOULDBLOCKrr?/var/www/html/env/lib/python3.10/site-packages/celery/result.pyassert_will_not_block$sr cc0t}tdz dVWt|dSt|wNFrr  reset_valuerrrallow_join_result) r&ccr!NTr#r$rrrdenied_join_result3r'r)c@seZdZdZdZdS)rzBase class for results.N)__name__ __module__ __qualname____doc__parentrrrrr=src @sBeZdZdZdZeZdZdZ   dhddZe ddZ e j ddZ did d Z d d Z d dZddZddZ  djddZ  djddZdddddddddejejf ddZeZddZddZdkdd Zd!d"Zdkd#d$Zd%d&Zd'd(Zd)d*Zd+d,Z dld-d.Z!e!Z"d/d0Z#dmd1d2Z$d3d4Z%d5d6Z&d7d8Z'd9d:Z(d;d<Z)d=d>Z*d?d@Z+dAdBZ,e-dCdDZ.e dEdFZ/e dGdHZ0dIdJZ1dKdLZ2dMdNZ3dOdPZ4e dQdRZ5e5Z6e dSdTZ7e dUdVZ8e8Z9e dWdXZ:e:j dYdXZ:e dZd[Z;e d\d]Ze dbdcZ?e dddeZ@e dfdgZAdS)nrzxQuery task state. Arguments: id (str): See :attr:`id`. backend (Backend): See :attr:`backend`. NcCsd|dur tdt|t|p|j|_||_|p|jj|_||_t|jdd|_ d|_ d|_ dS)Nz#AsyncResult requires valid id, not TweakF) ValueErrortyperappidbackendr.r _on_fulfilledon_ready_cache_ignored)selfr4r5 task_namer3r.rrr__init__Xs  zAsyncResult.__init__cCst|dr|jSdS)z+If True, task result retrieval is disabled.r9F)hasattrr9r:rrrignoredfs zAsyncResult.ignoredcCs ||_dS)z%Enable/disable task result retrieval.N)r9)r:valuerrrr?ms FcCs|jj||d|j||S)Nr/)r5add_pending_resultr7thenr:callbackon_errorr0rrrrBrszAsyncResult.thencCs|j||Srr5remove_pending_resultr:resultrrrr6vs zAsyncResult._on_fulfilledcCs|j}|j|o |fdfSr)r.r4as_tuple)r:r.rrrrJzszAsyncResult.as_tuplecCs0g}|j}||j|dur|||S)zReturn as a list of task IDs.N)r.appendr4extendas_list)r:resultsr.rrrrM~s  zAsyncResult.as_listcCs(d|_|jr |j|j|jdS)z/Forget the result of this task and its parents.N)r8r.forgetr5r4r>rrrrOs zAsyncResult.forgetcCs |jjj|j|||||ddS)aSend revoke signal to all workers. Any worker receiving the task, or having reserved the task, *must* ignore it. Arguments: terminate (bool): Also terminate the process currently working on the task (if any). signal (str): Name of signal to send to process if terminate. Default is TERM. wait (bool): Wait for replies from workers. The ``timeout`` argument specifies the seconds to wait. Disabled by default. timeout (float): Time in seconds to wait for replies when ``wait`` is enabled.  connection terminatesignalreplytimeoutN)r3controlrevoker4r:rQrRrSwaitrUrrrrWs zAsyncResult.revokecCs|jjj||||||ddS)a7Send revoke signal to all workers only for tasks with matching headers values. Any worker receiving the task, or having reserved the task, *must* ignore it. All header fields *must* match. Arguments: headers (dict[str, Union(str, list)]): Headers to match when revoking tasks. terminate (bool): Also terminate the process currently working on the task (if any). signal (str): Name of signal to send to process if terminate. Default is TERM. wait (bool): Wait for replies from workers. The ``timeout`` argument specifies the seconds to wait. Disabled by default. timeout (float): Time in seconds to wait for replies when ``wait`` is enabled. rPN)r3rVrevoke_by_stamped_headers)r:headersrQrRrSrYrUrrrrZs  z%AsyncResult.revoke_by_stamped_headersT?c Cs|jrdS| r tt} |r|r|jrt|jdd} ||r&| ||jr4|r1|j|d|jS|j ||j j |||| ||||dS)aWait until task is ready, and return its result. Warning: Waiting for tasks within a task may lead to deadlocks. Please read :ref:`task-synchronous-subtasks`. Warning: Backends use resources to store and transmit results. To ensure that resources are released, you must eventually call :meth:`~@AsyncResult.get` or :meth:`~@AsyncResult.forget` on EVERY :class:`~@AsyncResult` instance returned after calling a task. Arguments: timeout (float): How long to wait, in seconds, before the operation times out. This is the setting for the publisher (celery client) and is different from `timeout` parameter of `@app.task`, which is the setting for the worker. The task isn't terminated even if timeout occurs. propagate (bool): Re-raise exception if the task failed. interval (float): Time to wait (in seconds) before retrying to retrieve the result. Note that this does not have any effect when using the RPC/redis result store backends, as they don't use polling. no_ack (bool): Enable amqp no ack (automatically acknowledge message). If this is :const:`False` then the message will **not be acked**. follow_parents (bool): Re-raise any exception raised by parent tasks. disable_sync_subtasks (bool): Disable tasks to wait for sub tasks this is the default configuration. CAUTION do not enable this unless you must. Raises: celery.exceptions.TimeoutError: if `timeout` isn't :const:`None` and the result does not arrive within `timeout` seconds. Exception: If the remote call raised an exception then that exception will be re-raised in the caller process. NTr/)rD)rUinterval on_intervalno_ack propagaterD on_message) r?r r r._maybe_reraise_parent_errorrBr8 maybe_throwrIr5rAwait_for_pending) r:rUr`r]r_follow_parentsrDrar^disable_sync_subtasksEXCEPTION_STATESPROPAGATE_STATES _on_intervalrrrgets0-   zAsyncResult.getcCs"tt|D]}|qdSr)reversedlist_parentsrcr:noderrrrbs z'AsyncResult._maybe_reraise_parent_errorccs$|j}|r|V|j}|sdSdSrr.rnrrrrm s  zAsyncResult._parentscks2|j|dD]\}}||jdi|fVqdS)aCollect results as they return. Iterator, like :meth:`get` will wait for the task to complete, but will also follow :class:`AsyncResult` and :class:`ResultSet` returned by the task, yielding ``(result, value)`` tuples for each result in the tree. An example would be having the following tasks: .. code-block:: python from celery import group from proj.celery import app @app.task(trail=True) def A(how_many): return group(B.s(i) for i in range(how_many))() @app.task(trail=True) def B(i): return pow2.delay(i) @app.task(trail=True) def pow2(i): return i ** 2 .. code-block:: pycon >>> from celery.result import ResultBase >>> from proj.tasks import A >>> result = A.delay(10) >>> [v for v in result.collect() ... if not isinstance(v, (ResultBase, tuple))] [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] Note: The ``Task.trail`` option must be enabled so that the list of children is stored in ``result.children``. This is the default but enabled explicitly for illustration. Yields: Tuple[AsyncResult, Any]: tuples containing the result instance of the child task, and the return value of that task.  intermediateNriterdepsrj)r:rrkwargs_Rrrrcollects.zAsyncResult.collectcCs"d}|D]\}}|}q|Srrs)r:r@rvrwrrrget_leafAs zAsyncResult.get_leafc#sntd|fg}| }|r5|\}|fVr,|fddjp'gDn|r1t|s dSdS)Nc3s|]}|fVqdSrr.0childrorr Pz'AsyncResult.iterdeps..)rpopleftreadyrLchildrenr)r:rrstackis_incomplete_streamr.rr}rrtGs    zAsyncResult.iterdepscCs|j|jjvS)zReturn :const:`True` if the task has executed. If the task is still running, pending, or is waiting for retry then :const:`False` is returned. )stater5 READY_STATESr>rrrrUszAsyncResult.readycC |jtjkS)z7Return :const:`True` if the task executed successfully.)rr SUCCESSr>rrr successful] zAsyncResult.successfulcCr)z(Return :const:`True` if the task failed.)rr FAILUREr>rrrfailedarzAsyncResult.failedcOs|jj|i|dSr)r7throwr:argsrurrrreszAsyncResult.throwcCsn|jdur |n|j}|d|d|d}}}|tjvr+|r+|||||dur5||j||S)NstatusrI traceback)r8_get_task_metarjr rhr_to_remote_tracebackr4)r:r`rDcacherr@tbrrrrchs  zAsyncResult.maybe_throwcCs2|rtdur|jjjrtj|SdSdSdSr)tblibr3conftask_remote_tracebacks Traceback from_string as_traceback)r:rrrrrss z AsyncResult._to_remote_tracebackcCsLt|p t|jddd}|j|dD]\}}|||r#|||q|S)Noval)rootshape) formatterrq)rrr4rtadd_arcadd_edge)r:rrrgraphr.rorrr build_graphws  zAsyncResult.build_graphcC t|jSz`str(self) -> self.id`.strr4r>rrr__str__ zAsyncResult.__str__cCrz`hash(self) -> hash(self.id)`.hashr4r>rrr__hash__rzAsyncResult.__hash__cCsdt|jd|jdS)N<: >)r2r*r4r>rrr__repr__szAsyncResult.__repr__cCs.t|tr |j|jkSt|tr||jkStSr) isinstancerr4rNotImplementedr:otherrrr__eq__s    zAsyncResult.__eq__cCs||j|jd|j|jSr) __class__r4r5r3r.r>rrr__copy__szAsyncResult.__copy__cC|j|fSrr__reduce_args__r>rrr __reduce__zAsyncResult.__reduce__cCs|j|jdd|jfSr)r4r5r.r>rrrrzAsyncResult.__reduce_args__cCs|jdur |j|dSdS)z9Cancel pending operations when the instance is destroyed.NrFr>rrr__del__s zAsyncResult.__del__cCs|Sr)rr>rrrrzAsyncResult.graphcCs|jjSr)r5supports_native_joinr>rrrrrz AsyncResult.supports_native_joincC|dS)Nrrrjr>rrrrzAsyncResult.childrencCs:|r|d}|tjvr||j|}|||S|S)Nr)r r _set_cacher5meta_from_decodedr7)r:metardrrr_maybe_set_caches  zAsyncResult._maybe_set_cachecCs$|jdur||j|jS|jSr)r8rr5 get_task_metar4r>rrrrs zAsyncResult._get_task_metacKst|gSr)iterrr:rurrr _iter_metarzAsyncResult._iter_metacs.|d}|rfdd|D|d<|_|S)Nrcsg|]}t|jqSr)rr3rzr>rr  z*AsyncResult._set_cache..)rjr8)r:rrrr>rrs   zAsyncResult._set_cachecC |dS)zTask return value. Note: When the task has been executed, this contains the return value. If the task raised an exception, this will be the exception instance. rIrr>rrrrIs zAsyncResult.resultcCr)z#Get the traceback of a failed task.rrr>rrrrszAsyncResult.tracebackcCr)aThe tasks current state. Possible values includes: *PENDING* The task is waiting for execution. *STARTED* The task has been started. *RETRY* The task is to be retried, possibly because of failure. *FAILURE* The task raised an exception, or has exceeded the retry limit. The :attr:`result` attribute then contains the exception raised by the task. *SUCCESS* The task executed successfully. The :attr:`result` attribute then contains the tasks return value. rrr>rrrrs zAsyncResult.statecC|jS)zCompat. alias to :attr:`id`.r4r>rrrtask_idzAsyncResult.task_idcC ||_dSrr)r:r4rrrrrcCr)Nnamerr>rrrrrzAsyncResult.namecCr)Nrrr>rrrrrzAsyncResult.argscCr)Nrurr>rrrru rzAsyncResult.kwargscCr)Nworkerrr>rrrrrzAsyncResult.workercCs*|d}|rt|tjst|S|S)zUTC date and time. date_done)rrjrdatetimer)r:rrrrrszAsyncResult.date_donecCr)Nretriesrr>rrrrrzAsyncResult.retriescCr)Nqueuerr>rrrrrzAsyncResult.queue)NNNNr"NFNFN)F)TN)FN)Br*r+r,r-r3rr4r5r<propertyr?setterrBr6rJrMrOrWrZr rgrhrjrYrbrmrxryrtrrrrrc maybe_reraiserrrrrrrrrrrrrrrrrrrIinforrrrrrrurrrrrrrrrDs        H 1                     rc@sReZdZdZdZdZdCddZddZddZd d Z d d Z d dZ ddZ ddZ ddZdDddZeZddZddZddZddZ  dEd!d"Zd#d$Zd%d&Z '  dFd(d)Z '  dFd*d+ZdGd,d-Z  dHd.d/Z    dId0d1Zd2d3Zd4d5Zd6d7Zd8d9Z d:d;Z!e"dd?Z$e$j%d@d?Z$e"dAdBZ&dS)JrzpA collection of results. Arguments: results (Sequence[AsyncResult]): List of result instances. NcKsP||_||_tt|fd|_|pt||_|jr&|jt|jdddSdS)N)rTr/) _apprNr rr7r_on_fullrB _on_ready)r:rNr3 ready_barrierrurrrr<1szResultSet.__init__cCs4||jvr|j||jr|j|dSdSdS)zvAdd :class:`AsyncResult` as a new member of the set. Does nothing if the result is already a member. N)rNrKraddrHrrrr9s  z ResultSet.addcCs|jjr |dSdSr)r5is_asyncr7r>rrrrCs zResultSet._on_readycCs@t|tr |j|}z |j|WdStyt|w)z~Remove result from the set; it must be a member. Raises: KeyError: if the result isn't a member. N)rrr3rrNremover1KeyErrorrHrrrrGs   zResultSet.removecCs&z||WdStyYdSw)zbRemove result from the set if it is a member. Does nothing if it's not a member. N)rrrHrrrdiscardTs  zResultSet.discardcsjfdd|DdS)z Extend from iterable of results.c3s|] }|jvr|VqdSrrNr{rr>rrr~`sz#ResultSet.update..N)rNrL)r:rNrr>rupdate^szResultSet.updatecCsg|jdd<dS)z!Remove all results from this set.Nrr>rrrclearbszResultSet.clearcCtdd|jDS)zReturn true if all tasks successful. Returns: bool: true if all of the tasks finished successfully (i.e. didn't raise an exception). cs|]}|VqdSr)rr{rIrrrr~mrz'ResultSet.successful..allrNr>rrrrfzResultSet.successfulcCr)zReturn true if any of the tasks failed. Returns: bool: true if one of the tasks failed. (i.e., raised an exception) csrr)rrrrrr~vrz#ResultSet.failed..anyrNr>rrrrorzResultSet.failedTcCs|jD] }|j||dqdS)N)rDr`)rNrc)r:rDr`rIrrrrcxs zResultSet.maybe_throwcCr)zReturn true if any of the tasks are incomplete. Returns: bool: true if one of the tasks are still waiting for execution. css|]}| VqdSrrrrrrr~sz$ResultSet.waiting..rr>rrrwaiting}rzResultSet.waitingcCr)zDid all of the tasks complete? (either by success of failure). Returns: bool: true if all of the tasks have been executed. csrrrrrrrr~rz"ResultSet.ready..rr>rrrrszResultSet.readycCr)aTask completion count. Note that `complete` means `successful` in this context. In other words, the return value of this method is the number of ``successful`` tasks. Returns: int: the number of complete (i.e. successful) tasks. css|] }t|VqdSr)intrrrrrr~sz,ResultSet.completed_count..)sumrNr>rrrcompleted_counts zResultSet.completed_countcCs|jD]}|qdS)z?Forget about (and possible remove the result of) all the tasks.N)rNrOrHrrrrOs  zResultSet.forgetFcCs*|jjjdd|jD|||||ddS)a[Send revoke signal to all workers for all tasks in the set. Arguments: terminate (bool): Also terminate the process currently working on the task (if any). signal (str): Name of signal to send to process if terminate. Default is TERM. wait (bool): Wait for replies from worker. The ``timeout`` argument specifies the number of seconds to wait. Disabled by default. timeout (float): Time in seconds to wait for replies when the ``wait`` argument is enabled. cSsg|]}|jqSrrrrrrrz$ResultSet.revoke..)rQrUrRrSrTN)r3rVrWrNrXrrrrWs zResultSet.revokecCrr)rrNr>rrr__iter__ zResultSet.__iter__cCs |j|S)z`res[i] -> res.results[i]`.r)r:indexrrr __getitem__rzResultSet.__getitem__r\c Cs&|jr|jn|j||||||||dS)zSee :meth:`join`. This is here for API compatibility with :class:`AsyncResult`, in addition it uses :meth:`join_native` if available for the current result backend. )rUr`r]rDr_rarfr^)r join_nativejoin) r:rUr`r]rDr_rarfr^rrrrjs  z ResultSet.getc  Cs|rtt} d} |durtdg} |jD]/} d} |r.|t| } | dkr.td| j| |||||d} |rB|| j| q| | q| S)aGather the results of all tasks as a list in order. Note: This can be an expensive operation for result store backends that must resort to polling (e.g., database). You should consider using :meth:`join_native` if your backend supports it. Warning: Waiting for tasks within a task may lead to deadlocks. Please see :ref:`task-synchronous-subtasks`. Arguments: timeout (float): The number of seconds to wait for results before the operation times out. propagate (bool): If any of the tasks raises an exception, the exception will be re-raised when this flag is set. interval (float): Time to wait (in seconds) before retrying to retrieve a result from the set. Note that this does not have any effect when using the amqp result store backend, as it does not use polling. callback (Callable): Optional callback to be called for every result received. Must have signature ``(task_id, value)`` No results will be returned by this function if a callback is specified. The order of results is also arbitrary when a callback is used. To get access to the result object for a particular id you'll have to generate an index first: ``index = {r.id: r for r in gres.results.values()}`` Or you can create new result objects on the fly: ``result = app.AsyncResult(task_id)`` (both will take advantage of the backend cache anyway). no_ack (bool): Automatic message acknowledgment (Note that if this is set to :const:`False` then the messages *will not be acknowledged*). disable_sync_subtasks (bool): Disable tasks to wait for sub tasks this is the default configuration. CAUTION do not enable this unless you must. Raises: celery.exceptions.TimeoutError: if ``timeout`` isn't :const:`None` and the operation takes longer than ``timeout`` seconds. Nz,Backend does not support on_message callbackgzjoin operation timed out)rUr`r]r_r^rf) r time monotonicrrNrrjr4rK)r:rUr`r]rDr_rarfr^ time_start remainingrNrIr@rrrrs0/  zResultSet.joincC|j||Srr7rBrCrrrrBrzResultSet.thencCs|jj||||||dS)a0Backend optimized version of :meth:`iterate`. .. versionadded:: 2.2 Note that this does not support collecting the results for different task types using different backends. This is currently only supported by the amqp, Redis and cache result backends. )rUr]r_rar^)r5 iter_native)r:rUr]r_rar^rrrr s  zResultSet.iter_nativec Cs|rt|r dn ddt|jD} |rdn ddtt|D} ||||||D]5\} } t| trCg} | D] }| | q8n| d} |rR| dt j vrR| |rZ|| | q+| | | | <q+| S)a-Backend optimized version of :meth:`join`. .. versionadded:: 2.2 Note that this does not support collecting the results for different task types using different backends. This is currently only supported by the amqp, Redis and cache result backends. NcSsi|]\}}|j|qSrr)r{irIrrr 7rz)ResultSet.join_native..cSsg|]}dqSrr)r{rvrrrr:sz)ResultSet.join_native..rIr) r enumeraterNrangelenr rrlrKrjr rh)r:rUr`r]rDr_rar^rf order_indexaccrrr@children_resultrrrr's*   zResultSet.join_nativecKs.dd|jjdd|jDfddi|DS)Ncss|]\}}|VqdSrr)r{rvrrrrr~Lrz'ResultSet._iter_meta..cSsh|]}|jqSrrrrrr Mrz'ResultSet._iter_meta..max_iterationsr )r5get_manyrNrrrrrKs  zResultSet._iter_metacCsdd|jDS)Ncss.|]}|j|jr|jtjvr|VqdSr)r5 is_cachedr4rr rh)r{resrrrr~Qs  z0ResultSet._failed_join_report..rr>rrr_failed_join_reportPzResultSet._failed_join_reportcCrr)rrNr>rrr__len__UrzResultSet.__len__cCst|tr |j|jkStSr)rrrNrrrrrrXs  zResultSet.__eq__cCs*dt|jdddd|jDdS)Nrz: [, cs|]}|jVqdSrrrrrrr~^z%ResultSet.__repr__..]>)r2r*rrNr>rrrr]s*zResultSet.__repr__cCs$z|jdjWStyYdSwNr)rNr IndexErrorr>rrrr`s  zResultSet.supports_native_joincCs,|jdur|jr|jdjnt|_|jSr)rrNr3r _get_current_objectr>rrrr3gs z ResultSet.appcCrr)r)r:r3rrrr3nrcCs|jr|jjS|jdjSr)r3r5rNr>rrrr5rszResultSet.backendNNr(r)NTr\NTNTNr")Nr\TNN)NTr\NTNNT)'r*r+r,r-rrNr<rrrrrrrrrcrrrrrOrWrrrjrrBr rrrrrrrrr3rr5rrrrr$sl          J  $   rcseZdZdZdZdZdfdd ZfddZd ddZd d d Z d d Z d dZ ddZ e Z ddZddZddZddZddZeddZed!ddZZS)"razLike :class:`ResultSet`, but with an associated id. This type is returned by :class:`~celery.group`. It enables inspection of the tasks state and return values as a single entity. Arguments: id (str): The id of the group. results (Sequence[AsyncResult]): List of result instances. parent (ResultBase): Parent result of this group. Nc s$||_||_tj|fi|dSr)r4r.superr<)r:r4rNr.rurrrr<szGroupResult.__init__cs|j|tdSr)r5rGr#rr>r$rrrs zGroupResult._on_readycCs|p|jj|j|S)zSave group-result for later retrieval using :meth:`restore`. Example: >>> def save_and_restore(result): ... result.save() ... result = GroupResult.restore(result.id) )r3r5 save_groupr4r:r5rrrsaveszGroupResult.savecCs|p|jj|jdS)z.Remove this result if it was previously saved.N)r3r5 delete_groupr4r&rrrdeleteszGroupResult.deletecCrrrr>rrrrrzGroupResult.__reduce__cCs |j|jfSr)r4rNr>rrrr zGroupResult.__reduce_args__cCst|jp|jSr)boolr4rNr>rrr__bool__rzGroupResult.__bool__cCsFt|tr|j|jko|j|jko|j|jkSt|tr!||jkStSr)rrr4rNr.rrrrrrrs      zGroupResult.__eq__c Cs2dt|jd|jdddd|jDdS)Nrrz [rcsrrrrrrrr~rz'GroupResult.__repr__..r)r2r*r4rrNr>rrrrs2zGroupResult.__repr__cCrrrr>rrrrrzGroupResult.__str__cCrrrr>rrrrrzGroupResult.__hash__cCs&|j|jo |jfdd|jDfS)NcSsg|]}|qSr)rJrrrrrsz(GroupResult.as_tuple..)r4r.rJrNr>rrrrJszGroupResult.as_tuplecCrrrr>rrrrszGroupResult.childrencCs.|p t|jts |jnt}|p|j}||S)z&Restore previously saved group result.)rr3rr r5 restore_group)clsr4r5r3rrrrestores   zGroupResult.restore)NNNrr")r*r+r,r-r4rNr<rr'r)rrr, __nonzero__rrrrrJrr classmethodr/ __classcell__rrr$rrws*     rc@seZdZdZd%ddZd&ddZdd Zd d Zd d ZddZ ddZ  d'ddZ e Z ddZ ddZddZeddZeddZedd ZeZed!d"Zed#d$ZdS)(rz.Result that we know has already been executed.NcCs4||_||_||_||_||_t|_||dSr)r4_result_state _traceback_namer r7)r:r4 ret_valuerrrrrrr<szEagerResult.__init__FcCrrr rCrrrrBrzEagerResult.thencCrr)r8r>rrrrszEagerResult._get_task_metacCrrrr>rrrrrzEagerResult.__reduce__cCs|j|j|j|jfSr)r4r3r4r5r>rrrrrzEagerResult.__reduce_args__cCs|\}}||Sr)r)r:r.rrrrrs zEagerResult.__copy__cCdSr(rr>rrrrzEagerResult.readyTcKsN|rt|r |jS|jtjvr%|r"t|jtr|jt|j|jSdSr)r rrIrr rhr Exception)r:rUr`rfrurrrrjs  zEagerResult.getcCsdSrrr>rrrrOr9zEagerResult.forgetcOs tj|_dSr)r REVOKEDr4rrrrrW r*zEagerResult.revokecCsd|jdS)Nzrrrr rzEagerResult.__repr__cCs|j|j|j|j|jdS)N)rrIrrr)r4r3r4r5r6r>rrrr8s zEagerResult._cachecCr)zThe tasks return value.)r3r>rrrrIrzEagerResult.resultcCr)zThe tasks state.)r4r>rrrrrzEagerResult.statecCr)z!The traceback if the task failed.)r5r>rrrr%rzEagerResult.tracebackcCr8r"rr>rrrr*sz EagerResult.supports_native_joinr"r")NTT)r*r+r,r-r<rBrrrrrrjrYrOrWrrr8rIrrrrrrrrrs6        rcstj}t|ts?|\}}t|ttfr|n|df\}}|r&t|}|dur9j|fdd|D|dS|||dS|S)zDeserialize result from tuple.Ncsg|]}t|qSr)rrzr3rrr=sz%result_from_tuple..rp)rrrrrltuplerr)rr3Resultrnodesr4r.rr<rr/s   rr).r-rr collectionsr contextlibrweakrefrdateutil.parserrkombu.utils.objectsrvinerrr r r r4r rr3r exceptionsrrr utils.graphrrr ImportError__all__rr r&r)rregisterrrrrrrrrrsR           bT_W