U .eɊ@sjdZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z m Z mZdd lmZmZdd lmZmZdd lmZdd lmZmZmZdd lmZmZz ddlZWnek rdZYnXdZ 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_WOULDBLOCKrr1/tmp/pip-unpacked-wheel-f4liivr4/celery/result.pyassert_will_not_block#srccs(t}tdz dVW5t|XdSNFr r Z reset_valuerrrallow_join_result(s  r#ccs(t}tdz dVW5t|XdSNTr!r"rrrdenied_join_result2s  r%c@seZdZdZdZdS)rzBase class for results.N)__name__ __module__ __qualname____doc__parentrrrrr<src @s4eZdZdZdZeZdZdZdhddZe ddZ e j ddZ did d Z d d Z d dZddZddZdjddZdkddZdddddddddejejf ddZeZddZddZdldd Zd!d"Zdmd#d$Zd%d&Zd'd(Zd)d*Zd+d,Z dnd-d.Z!e!Z"d/d0Z#dod1d2Z$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)przxQuery task state. Arguments: id (str): See :attr:`id`. backend (Backend): See :attr:`backend`. NcCsd|dkrtdt|t|p$|j|_||_|p:|jj|_||_t|jdd|_ d|_ d|_ dS)Nz#AsyncResult requires valid id, not TweakF) ValueErrortyperappidbackendr*r _on_fulfilledon_ready_cache_ignored)selfr0r1Z task_namer/r*rrr__init__Ws zAsyncResult.__init__cCst|dr|jSdS)z+If True, task result retrieval is disabled.r5F)hasattrr5r6rrrignoredes zAsyncResult.ignoredcCs ||_dS)z%Enable/disable task result retrieval.N)r5)r6valuerrrr:lsFcCs|jj||d|j||S)Nr+)r1add_pending_resultr3thenr6callbackZon_errorr,rrrr=qszAsyncResult.thencCs|j||Srr1remove_pending_resultr6resultrrrr2us zAsyncResult._on_fulfilledcCs|j}|j|o|fdfSr)r*r0as_tuple)r6r*rrrrDyszAsyncResult.as_tuplecCs0g}|j}||j|dk r,|||S)zReturn as a list of task IDs.N)r*appendr0extendas_list)r6resultsr*rrrrG}s  zAsyncResult.as_listcCs(d|_|jr|j|j|jdS)z/Forget the result of this task and its parents.N)r4r*forgetr1r0r9rrrrIs 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)r/controlrevoker0r6rKrLrMwaitrOrrrrQs 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. rJN)r/rPrevoke_by_stamped_headers)r6headersrKrLrMrSrOrrrrTs  z%AsyncResult.revoke_by_stamped_headersT?c Cs|jr dS| rtt} |r>|r>|jr>t|jdd} ||rL| ||jrh|rb|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+)r?)rOinterval on_intervalno_ack propagater? on_message) r:rrr*_maybe_reraise_parent_errorr=r4 maybe_throwrCr1r<Zwait_for_pending) r6rOrZrWrYZfollow_parentsr?r[rXdisable_sync_subtasksEXCEPTION_STATESPROPAGATE_STATESZ _on_intervalrrrgets2-   zAsyncResult.getcCs"tt|D] }|qdSr)reversedlist_parentsr]r6noderrrr\sz'AsyncResult._maybe_reraise_parent_errorccs|j}|r|V|j}qdSrr*rerrrrd szAsyncResult._parentscks,|j|dD]\}}||jf|fVq dS)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.  intermediateNiterdepsra)r6rikwargs_Rrrrcollects.zAsyncResult.collectcCs"d}|D]\}}|}q |Srrj)r6r;rmrnrrrget_leaf@s zAsyncResult.get_leafc#sftd|fg}| }|rb|\}|fVrV|fddjpLgDq|rtqdS)Nc3s|]}|fVqdSrr.0childrfrr Osz'AsyncResult.iterdeps..)rpopleftreadyrFchildrenr)r6ristackZis_incomplete_streamr*rrtrrkFs   zAsyncResult.iterdepscCs|j|jjkS)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. )stater1 READY_STATESr9rrrrwTszAsyncResult.readycCs |jtjkS)z7Return :const:`True` if the task executed successfully.)rzr SUCCESSr9rrr successful\szAsyncResult.successfulcCs |jtjkS)z(Return :const:`True` if the task failed.)rzr FAILUREr9rrrfailed`szAsyncResult.failedcOs|jj||dSr)r3throwr6argsrlrrrrdszAsyncResult.throwcCsn|jdkr|n|j}|d|d|d}}}|tjkrV|rV|||||dk rj||j||S)NstatusrC traceback)r4_get_task_metarar r`r_to_remote_tracebackr0)r6rZr?cacherzr;tbrrrr]gs  zAsyncResult.maybe_throwcCs*|r&tdk r&|jjjr&tj|SdSr)tblibr/confZtask_remote_tracebacks TracebackZ from_stringZ as_traceback)r6rrrrrrsz AsyncResult._to_remote_tracebackcCsLt|pt|jddd}|j|dD]"\}}|||r$|||q$|S)NZoval)rootshape) formatterrh)rrr0rkZadd_arcZadd_edge)r6rirgraphr*rfrrr build_graphvs zAsyncResult.build_graphcCs t|jSz`str(self) -> self.id`.strr0r9rrr__str__szAsyncResult.__str__cCs t|jSz`hash(self) -> hash(self.id)`.hashr0r9rrr__hash__szAsyncResult.__hash__cCsdt|jd|jdS)N<: >)r.r&r0r9rrr__repr__szAsyncResult.__repr__cCs.t|tr|j|jkSt|tr*||jkStSr) isinstancerr0rNotImplementedr6otherrrr__eq__s     zAsyncResult.__eq__cCs||j|jd|j|jSr) __class__r0r1r/r*r9rrr__copy__szAsyncResult.__copy__cCs|j|fSrr__reduce_args__r9rrr __reduce__szAsyncResult.__reduce__cCs|j|jdd|jfSr)r0r1r*r9rrrrszAsyncResult.__reduce_args__cCs|jdk r|j|dS)z9Cancel pending operations when the instance is destroyed.Nr@r9rrr__del__s zAsyncResult.__del__cCs|Sr)rr9rrrrszAsyncResult.graphcCs|jjSr)r1supports_native_joinr9rrrrsz AsyncResult.supports_native_joincCs|dS)Nrxrrar9rrrrxszAsyncResult.childrencCs:|r6|d}|tjkr6||j|}|||S|S)Nr)r r{ _set_cacher1Zmeta_from_decodedr3)r6metarzdrrr_maybe_set_caches  zAsyncResult._maybe_set_cachecCs$|jdkr||j|jS|jSr)r4rr1Z get_task_metar0r9rrrrs zAsyncResult._get_task_metacKst|gSr)iterrr6rlrrr _iter_metaszAsyncResult._iter_metacs.|d}|r$fdd|D|d<|_|S)Nrxcsg|]}t|jqSr)rr/rqr9rr sz*AsyncResult._set_cache..)rar4)r6rrxrr9rrs   zAsyncResult._set_cachecCs |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. rCrr9rrrrCs zAsyncResult.resultcCs|dS)z#Get the traceback of a failed task.rrr9rrrrszAsyncResult.tracebackcCs |dS)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. rrr9rrrrzszAsyncResult.statecCs|jS)zCompat. alias to :attr:`id`.r0r9rrrtask_idszAsyncResult.task_idcCs ||_dSrr)r6r0rrrrscCs|dS)Nnamerr9rrrrszAsyncResult.namecCs|dS)Nrrr9rrrrszAsyncResult.argscCs|dS)Nrlrr9rrrrl szAsyncResult.kwargscCs|dS)Nworkerrr9rrrrszAsyncResult.workercCs.|d}|r*t|tjs*tj|S|S)zUTC date and time. date_done)rrardatetime fromisoformat)r6rrrrrs zAsyncResult.date_donecCs|dS)Nretriesrr9rrrrszAsyncResult.retriescCs|dS)Nqueuerr9rrrrszAsyncResult.queue)NNNN)NF)NFNFN)NFNFN)F)F)TN)FN)Br&r'r(r)r/rr0r1r7propertyr:setterr=r2rDrGrIrQrTr r_r`rarSr\rdrorprkrwr}rrr] maybe_reraiserrrrrrrrrrrrrrxrrrrrCinforrzrrrrrlrrrrrrrrrCs        H 1                   rc@s6eZdZdZdZdZdCddZddZddZd d Z d d Z d dZ ddZ ddZ ddZdDddZeZddZddZddZddZdEd!d"Zd#d$Zd%d&ZdFd(d)ZdGd*d+ZdHd,d-ZdId.d/ZdJd0d1Zd2d3Zd4d5Zd6d7Zd8d9Z d:d;Z!e"dd?Z$e$j%d@d?Z$e"dAdBZ&dS)KrzpA collection of results. Arguments: results (Sequence[AsyncResult]): List of result instances. NcKsL||_||_tt|fd|_|p(t||_|jrH|jt|jdddS)N)rTr+) _apprHrrr3r_on_fullr= _on_ready)r6rHr/Z ready_barrierrlrrrr70s zResultSet.__init__cCs,||jkr(|j||jr(|j|dS)zvAdd :class:`AsyncResult` as a new member of the set. Does nothing if the result is already a member. N)rHrEraddrBrrrr8s  z ResultSet.addcCs|jjr|dSr)r1Zis_asyncr3r9rrrrBszResultSet._on_readycCsHt|tr|j|}z|j|Wntk rBt|YnXdS)z~Remove result from the set; it must be a member. Raises: KeyError: if the result isn't a member. N)rrr/rrHremover-KeyErrorrBrrrrFs   zResultSet.removecCs(z||Wntk r"YnXdS)zbRemove result from the set if it is a member. Does nothing if it's not a member. N)rrrBrrrdiscardSszResultSet.discardcsjfdd|DdS)z Extend from iterable of results.c3s|]}|jkr|VqdSrrHrrrr9rrru_s z#ResultSet.update..N)rHrF)r6rHrr9rupdate]szResultSet.updatecCsg|jdd<dS)z!Remove all results from this set.Nrr9rrrclearaszResultSet.clearcCstdd|jDS)zReturn true if all tasks successful. Returns: bool: true if all of the tasks finished successfully (i.e. didn't raise an exception). css|]}|VqdSr)r}rrrCrrrrulsz'ResultSet.successful..allrHr9rrrr}eszResultSet.successfulcCstdd|jDS)zReturn true if any of the tasks failed. Returns: bool: true if one of the tasks failed. (i.e., raised an exception) css|]}|VqdSr)rrrrrruusz#ResultSet.failed..anyrHr9rrrrnszResultSet.failedTcCs|jD]}|j||dqdS)N)r?rZ)rHr])r6r?rZrCrrrr]ws zResultSet.maybe_throwcCstdd|jDS)zReturn true if any of the tasks are incomplete. Returns: bool: true if one of the tasks are still waiting for execution. css|]}| VqdSrrwrrrrrusz$ResultSet.waiting..rr9rrrwaiting|szResultSet.waitingcCstdd|jDS)zDid all of the tasks complete? (either by success of failure). Returns: bool: true if all of the tasks have been executed. css|]}|VqdSrrrrrrrusz"ResultSet.ready..rr9rrrrwszResultSet.readycCstdd|jDS)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)intr}rrrrrusz,ResultSet.completed_count..)sumrHr9rrrcompleted_counts zResultSet.completed_countcCs|jD] }|qdS)z?Forget about (and possible remove the result of) all the tasks.N)rHrIrBrrrrIs 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|] }|jqSrrrrrrrsz$ResultSet.revoke..)rKrOrLrMrNN)r/rPrQrHrRrrrrQszResultSet.revokecCs t|jSr)rrHr9rrr__iter__szResultSet.__iter__cCs |j|S)z`res[i] -> res.results[i]`.r)r6indexrrr __getitem__szResultSet.__getitem__rVc 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. )rOrZrWr?rYr[r^rX)r join_nativejoin) r6rOrZrWr?rYr[r^rXrrrras z ResultSet.getc  Cs|r tt} d} |dk r&tdg} |jD]^} d} |r\|t| } | dkr\td| j| |||||d} |r|| j| q0| | q0| 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)rOrZrWrYrXr^) rtime monotonicrrHrrar0rE)r6rOrZrWr?rYr[r^rXZ time_start remainingrHrCr;rrrrs6/  zResultSet.joincCs|j||Srr3r=r>rrrr=szResultSet.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. )rOrWrYr[rX)r1 iter_native)r6rOrWrYr[rXrrrrs zResultSet.iter_nativec Cs|r t|rdnddt|jD} |r.dnddtt|D} ||||||D]j\} } t| trg} | D]}| | qpn| d} |r| dt j kr| |r|| | qV| | | | <qV| 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)rrirCrrr 6sz)ResultSet.join_native..cSsg|]}dqSrr)rrrmrrrr9sz)ResultSet.join_native..rCr) r enumeraterHrangelenrrrcrErar r`)r6rOrZrWr?rYr[rXr^Z order_indexaccrrr;Zchildren_resultrrrr&s*    zResultSet.join_nativecKs.dd|jjdd|jDfddi|DS)Ncss|]\}}|VqdSrr)rrrmrrrrruKsz'ResultSet._iter_meta..cSsh|] }|jqSrrrrrr Lsz'ResultSet._iter_meta..Zmax_iterationsr )r1Zget_manyrHrrrrrJs zResultSet._iter_metacCsdd|jDS)Ncss,|]$}|j|jr|jtjkr|VqdSr)r1Z is_cachedr0rzr r`)rrresrrrruPs z0ResultSet._failed_join_report..rr9rrr_failed_join_reportOszResultSet._failed_join_reportcCs t|jSr)rrHr9rrr__len__TszResultSet.__len__cCst|tr|j|jkStSr)rrrHrrrrrrWs  zResultSet.__eq__cCs*dt|jdddd|jDdS)Nrz: [, css|] }|jVqdSrrrrrrru]sz%ResultSet.__repr__..]>)r.r&rrHr9rrrr\szResultSet.__repr__cCs(z|jdjWStk r"YnXdSNr)rHr IndexErrorr9rrrr_szResultSet.supports_native_joincCs,|jdkr&|jr|jdjnt|_|jSr)rrHr/r Z_get_current_objectr9rrrr/fs  z ResultSet.appcCs ||_dSr)r)r6r/rrrr/mscCs|jr|jjS|jdjSr)r/r1rHr9rrrr1qszResultSet.backend)NN)NT)NFNFN)NTrVNTNTN)NTrVNTNTN)NF)NrVTNN)NTrVNTNNT)'r&r'r(r)rrHr7rrrrrrr}rr]rrrwrrIrQrrrarr=rrrrrrrrrr/rr1rrrrr#s           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|f|dSr)r0r*superr7)r6r0rHr*rlrrrr7szGroupResult.__init__cs|j|tdSr)r1rArrr9rrrrs 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) )r/r1Z save_groupr0r6r1rrrsaveszGroupResult.savecCs|p |jj|jdS)z.Remove this result if it was previously saved.N)r/r1Z delete_groupr0rrrrdeleteszGroupResult.deletecCs|j|fSrrr9rrrrszGroupResult.__reduce__cCs |j|jfSr)r0rHr9rrrrszGroupResult.__reduce_args__cCst|jp |jSr)boolr0rHr9rrr__bool__szGroupResult.__bool__cCsFt|tr.|j|jko,|j|jko,|j|jkSt|trB||jkStSr)rrr0rHr*rrrrrrrs      zGroupResult.__eq__c Cs2dt|jd|jdddd|jDdS)Nrrz [rcss|] }|jVqdSrrrrrrrusz'GroupResult.__repr__..r)r.r&r0rrHr9rrrrszGroupResult.__repr__cCs t|jSrrr9rrrrszGroupResult.__str__cCs t|jSrrr9rrrrszGroupResult.__hash__cCs&|j|jo|jfdd|jDfS)NcSsg|] }|qSr)rDrrrrrsz(GroupResult.as_tuple..)r0r*rDrHr9rrrrDszGroupResult.as_tuplecCs|jSrrr9rrrrxszGroupResult.childrencCs.|pt|jts|jnt}|p"|j}||S)z&Restore previously saved group result.)rr/rr r1Z restore_group)clsr0r1r/rrrrestores  zGroupResult.restore)NNN)N)N)NN)r&r'r(r)r0rHr7rrrrrr __nonzero__rrrrrDrrx classmethodr __classcell__rrrrrvs(    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)r0_result_state _tracebackrr3)r6r0Z ret_valuerzrrrrr7s zEagerResult.__init__FcCs|j||Srrr>rrrr=szEagerResult.thencCs|jSr)r4r9rrrrszEagerResult._get_task_metacCs|j|fSrrr9rrrrszEagerResult.__reduce__cCs|j|j|j|jfSrr0rrrr9rrrrszEagerResult.__reduce_args__cCs|\}}||Sr)r)r6rrrrrrs zEagerResult.__copy__cCsdSr$rr9rrrrwszEagerResult.readyTcKsN|r t|r|jS|jtjkrJ|rDt|jtr:|jnt|j|jSdSr)rr}rCrzr r`r Exception)r6rOrZr^rlrrrras  zEagerResult.getcCsdSrrr9rrrrIszEagerResult.forgetcOs tj|_dSr)r ZREVOKEDrrrrrrQszEagerResult.revokecCsd|jdS)Nz.rg)rrrrrctuplerr)rr/ZResultrZnodesr0r*rrrr,s   r)N),r)rr collectionsr contextlibrweakrefrZkombu.utils.objectsrZvinerrrr r rr r r/r exceptionsrrrZ utils.graphrrr ImportError__all__rrr#r%rregisterrrrrrrrrrsL         bT_U