o .iɊ@shdZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z m Z mZdd lmZmZdd lmZmZdd lmZdd lmZmZmZdd lmZmZzddlZWn eyedZYnwdZ dZ!ddZ"eddZ#eddZ$GdddZ%e j&Gddde%Z'e j&Gddde%Z(e j&Gddde(Z)e j&Gddde'Z*d"d d!Z+dS)#z3Task results/state and results for groups of tasks.N)deque)contextmanager)proxy)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_WOULDBLOCKrrH/var/www/html/philips/venv/lib/python3.10/site-packages/celery/result.pyassert_will_not_block#srcc0t}tdz dVWt|dSt|wNFr r  reset_valuerrrallow_join_result( r%ccr NTr"r#rrrdenied_join_result2r&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)selfr3r4 task_namer2r-rrr__init__Ws  zAsyncResult.__init__cCst|dr|jSdS)z+If True, task result retrieval is disabled.r8F)hasattrr8r9rrrignoredes zAsyncResult.ignoredcCs ||_dS)z%Enable/disable task result retrieval.N)r8)r9valuerrrr>ls FcCs|jj||d|j||S)Nr.)r4add_pending_resultr6thenr9callbackon_errorr/rrrrAqszAsyncResult.thencCs|j||Srr4remove_pending_resultr9resultrrrr5us zAsyncResult._on_fulfilledcCs|j}|j|o |fdfSr)r-r3as_tuple)r9r-rrrrIyszAsyncResult.as_tuplecCs0g}|j}||j|dur|||S)zReturn as a list of task IDs.N)r-appendr3extendas_list)r9resultsr-rrrrL}s  zAsyncResult.as_listcCs(d|_|jr |j|j|jdS)z/Forget the result of this task and its parents.N)r7r-forgetr4r3r=rrrrNs 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)r2controlrevoker3r9rPrQrRwaitrTrrrrVs 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. rON)r2rUrevoke_by_stamped_headers)r9headersrPrQrRrXrTrrrrYs  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.)rC)rTinterval on_intervalno_ack propagaterC on_message) r>rrr-_maybe_reraise_parent_errorrAr7 maybe_throwrHr4r@wait_for_pending) r9rTr_r\r^follow_parentsrCr`r]disable_sync_subtasksEXCEPTION_STATESPROPAGATE_STATES _on_intervalrrrgets0-   zAsyncResult.getcCs"tt|D]}|qdSr)reversedlist_parentsrbr9noderrrras z'AsyncResult._maybe_reraise_parent_errorccs$|j}|r|V|j}|sdSdSrr-rmrrrrl 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.  intermediateNriterdepsri)r9rqkwargs_Rrrrcollects.zAsyncResult.collectcCs"d}|D]\}}|}q|Srrr)r9r?rurvrrrget_leaf@s zAsyncResult.get_leafc#sntd|fg}| }|r5|\}|fVr,|fddjp'gDn|r1t|s dSdS)Nc3s|]}|fVqdSrr.0childrnrr Oz'AsyncResult.iterdeps..)rpopleftreadyrKchildrenr)r9rqstackis_incomplete_streamr-rr|rrsFs    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. )stater4 READY_STATESr=rrrrTszAsyncResult.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=rrrfailed`rzAsyncResult.failedcOs|jj|i|dSr)r6throwr9argsrtrrrrdszAsyncResult.throwcCsn|jdur |n|j}|d|d|d}}}|tjvr+|r+|||||dur5||j||S)NstatusrH traceback)r7_get_task_metarir rgr_to_remote_tracebackr3)r9r_rCcacherr?tbrrrrbgs  zAsyncResult.maybe_throwcCs2|rtdur|jjjrtj|SdSdSdSr)tblibr2conftask_remote_tracebacks Traceback from_string as_traceback)r9rrrrrrs z AsyncResult._to_remote_tracebackcCsLt|p t|jddd}|j|dD]\}}|||r#|||q|S)Noval)rootshape) formatterrp)rrr3rsadd_arcadd_edge)r9rqrgraphr-rnrrr build_graphvs  zAsyncResult.build_graphcC t|jSz`str(self) -> self.id`.strr3r=rrr__str__ zAsyncResult.__str__cCrz`hash(self) -> hash(self.id)`.hashr3r=rrr__hash__rzAsyncResult.__hash__cCsdt|jd|jdS)N<: >)r1r)r3r=rrr__repr__szAsyncResult.__repr__cCs.t|tr |j|jkSt|tr||jkStSr) isinstancerr3rNotImplementedr9otherrrr__eq__s    zAsyncResult.__eq__cCs||j|jd|j|jSr) __class__r3r4r2r-r=rrr__copy__szAsyncResult.__copy__cC|j|fSrr__reduce_args__r=rrr __reduce__zAsyncResult.__reduce__cCs|j|jdd|jfSr)r3r4r-r=rrrrzAsyncResult.__reduce_args__cCs|jdur |j|dSdS)z9Cancel pending operations when the instance is destroyed.NrEr=rrr__del__s zAsyncResult.__del__cCs|Sr)rr=rrrrzAsyncResult.graphcCs|jjSr)r4supports_native_joinr=rrrrrz AsyncResult.supports_native_joincC|dS)Nrrrir=rrrrzAsyncResult.childrencCs:|r|d}|tjvr||j|}|||S|S)Nr)r r _set_cacher4meta_from_decodedr6)r9metardrrr_maybe_set_caches  zAsyncResult._maybe_set_cachecCs$|jdur||j|jS|jSr)r7rr4 get_task_metar3r=rrrrs zAsyncResult._get_task_metacKst|gSr)iterrr9rtrrr _iter_metarzAsyncResult._iter_metacs.|d}|rfdd|D|d<|_|S)Nrcsg|]}t|jqSr)rr2ryr=rr  z*AsyncResult._set_cache..)rir7)r9rrrr=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. rHrr=rrrrHs 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`.r3r=rrrtask_idzAsyncResult.task_idcC ||_dSrr)r9r3rrrrrcCr)Nnamerr=rrrrrzAsyncResult.namecCr)Nrrr=rrrrrzAsyncResult.argscCr)Nrtrr=rrrrt rzAsyncResult.kwargscCr)Nworkerrr=rrrrrzAsyncResult.workercCs.|d}|rt|tjstj|S|S)zUTC date and time. date_done)rrirdatetime fromisoformat)r9rrrrrs zAsyncResult.date_donecCr)Nretriesrr=rrrrrzAsyncResult.retriescCr)Nqueuerr=rrrrrzAsyncResult.queue)NNNNr!NFNFN)F)TN)FN)Br)r*r+r,r2rr3r4r;propertyr>setterrAr5rIrLrNrVrYr rfrgrirXrarlrwrxrsrrrrrb maybe_reraiserrrrrrrrrrrrrrrrrrrHinforrrrrrrtrrrrrrrrrCs        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.) _apprMrrr6r_on_fullrA _on_ready)r9rMr2 ready_barrierrtrrrr;0szResultSet.__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)rMrJraddrGrrrr8s  z ResultSet.addcCs|jjr |dSdSr)r4is_asyncr6r=rrrrBs 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)rrr2rrMremover0KeyErrorrGrrrrFs   zResultSet.removecCs&z||WdStyYdSw)zbRemove result from the set if it is a member. Does nothing if it's not a member. N)rrrGrrrdiscardSs  zResultSet.discardcsjfdd|DdS)z Extend from iterable of results.c3s|] }|jvr|VqdSrrMrzrr=rrr}_sz#ResultSet.update..N)rMrK)r9rMrr=rupdate]szResultSet.updatecCsg|jdd<dS)z!Remove all results from this set.Nrr=rrrclearaszResultSet.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)rrzrHrrrr}lr~z'ResultSet.successful..allrMr=rrrrezResultSet.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}ur~z#ResultSet.failed..anyrMr=rrrrnrzResultSet.failedTcCs|jD] }|j||dqdS)N)rCr_)rMrb)r9rCr_rHrrrrbws 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}r~z"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..)sumrMr=rrrcompleted_counts zResultSet.completed_countcCs|jD]}|qdS)z?Forget about (and possible remove the result of) all the tasks.N)rMrNrGrrrrNs  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..)rPrTrQrRrSN)r2rUrVrMrWrrrrVs zResultSet.revokecCrr)rrMr=rrr__iter__ zResultSet.__iter__cCs |j|S)z`res[i] -> res.results[i]`.r)r9indexrrr __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. )rTr_r\rCr^r`rer])r join_nativejoin) r9rTr_r\rCr^r`rer]rrrris  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)rTr_r\r^r]re) rtime monotonicrrMrrir3rJ)r9rTr_r\rCr^r`rer] time_start remainingrMrHr?rrrrs0/  zResultSet.joincC|j||Srr6rArBrrrrArzResultSet.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. )rTr\r^r`r])r4 iter_native)r9rTr\r^r`r]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)rzirHrrr 6rz)ResultSet.join_native..cSsg|]}dqSrr)rzrurrrr9sz)ResultSet.join_native..rHr) r enumeraterMrangelenr rrkrJrir rg)r9rTr_r\rCr^r`r]re order_indexaccrrr?children_resultrrrr&s*   zResultSet.join_nativecKs.dd|jjdd|jDfddi|DS)Ncss|]\}}|VqdSrr)rzrurrrrr}Kr~z'ResultSet._iter_meta..cSsh|]}|jqSrrrrrr Lrz'ResultSet._iter_meta..max_iterationsr )r4get_manyrMrrrrrJs  zResultSet._iter_metacCsdd|jDS)Ncss.|]}|j|jr|jtjvr|VqdSr)r4 is_cachedr3rr rg)rzresrrrr}Ps  z0ResultSet._failed_join_report..rr=rrr_failed_join_reportOzResultSet._failed_join_reportcCrr)rrMr=rrr__len__TrzResultSet.__len__cCst|tr |j|jkStSr)rrrMrrrrrrWs  zResultSet.__eq__cCs*dt|jdddd|jDdS)Nrz: [, cs|]}|jVqdSrrrrrrr}]z%ResultSet.__repr__..]>)r1r)rrMr=rrrr\s*zResultSet.__repr__cCs$z|jdjWStyYdSwNr)rMr IndexErrorr=rrrr_s  zResultSet.supports_native_joincCs,|jdur|jr|jdjnt|_|jSr)rrMr2r _get_current_objectr=rrrr2fs z ResultSet.appcCrr)r)r9r2rrrr2mrcCs|jr|jjS|jdjSr)r2r4rMr=rrrr4qszResultSet.backendNNr'r)NTr[NTNTNr!)Nr[TNN)NTr[NTNNT)'r)r*r+r,rrMr;rrrrrrrrrbrrrrrNrVrrrirrAr rrrrrrrrr2rr4rrrrr#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)r3r-superr;)r9r3rMr-rtrrrr;szGroupResult.__init__cs|j|tdSr)r4rFr#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) )r2r4 save_groupr3r9r4rrrsaveszGroupResult.savecCs|p|jj|jdS)z.Remove this result if it was previously saved.N)r2r4 delete_groupr3r&rrrdeleteszGroupResult.deletecCrrrr=rrrrrzGroupResult.__reduce__cCs |j|jfSr)r3rMr=rrrr zGroupResult.__reduce_args__cCst|jp|jSr)boolr3rMr=rrr__bool__rzGroupResult.__bool__cCsFt|tr|j|jko|j|jko|j|jkSt|tr!||jkStSr)rrr3rMr-rrrrrrrs      zGroupResult.__eq__c Cs2dt|jd|jdddd|jDdS)Nrrz [rcsrrrrrrrr}rz'GroupResult.__repr__..r)r1r)r3rrMr=rrrrs2zGroupResult.__repr__cCrrrr=rrrrrzGroupResult.__str__cCrrrr=rrrrrzGroupResult.__hash__cCs&|j|jo |jfdd|jDfS)NcSsg|]}|qSr)rIrrrrrsz(GroupResult.as_tuple..)r3r-rIrMr=rrrrIszGroupResult.as_tuplecCrrrr=rrrrszGroupResult.childrencCs.|p t|jts |jnt}|p|j}||S)z&Restore previously saved group result.)rr2rr r4 restore_group)clsr3r4r2rrrrestores   zGroupResult.restore)NNNrr")r)r*r+r,r3rMr;rr'r)rrr, __nonzero__rrrrrIrr classmethodr/ __classcell__rrr$rrvs*     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.NcCs.||_||_||_||_t|_||dSr)r3_result_state _tracebackrr6)r9r3 ret_valuerrrrrr;s zEagerResult.__init__FcCrrr rBrrrrArzEagerResult.thencCrr)r7r=rrrrszEagerResult._get_task_metacCrrrr=rrrrrzEagerResult.__reduce__cCs|j|j|j|jfSrr3r3r4r5r=rrrrrzEagerResult.__reduce_args__cCs|\}}||Sr)r)r9r.rrrrrs zEagerResult.__copy__cCdSr'rr=rrrrzEagerResult.readyTcKsN|rt|r |jS|jtjvr%|r"t|jtr|jt|j|jSdSr)rrrHrr rgr Exception)r9rTr_rertrrrris  zEagerResult.getcCsdSrrr=rrrrNr9zEagerResult.forgetcOs tj|_dSr)r REVOKEDr4rrrrrVr*zEagerResult.revokecCsd|jdS)Nz.ro)rrrrrktuplerr)rr2Resultrnodesr3r-rr<rr,s   rr),r,rr collectionsr contextlibrweakrefrkombu.utils.objectsrvinerrrr r r4r r r2r exceptionsrrr utils.graphrrr ImportError__all__rrr%r(rregisterrrrrrrrrrsP          bT_U