V.jdZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl mZmZmZd d lmZmZd d lmZmZd d lmZd d lmZmZmZd dlmZmZ ddl Z dZ"dZ#dZ$edZ%edZ&GddZ'ejPGdde'Z)ejPGdde'Z*ejPGdde*Z+ejPGdde)Z,ddZ-y#e!$rdZ YwxYw) 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 c6trttyN)r RuntimeError E_WOULDBLOCKOC:\xampp\htdocs\tradingbinance\backend\.venv\Lib\site-packages\celery/result.pyassert_will_not_blockr#$s<((r!c#vKt}td dt|y#t|wxYwwNFrr reset_values r"allow_join_resultr))s/&(Ke$/ !+.!+.9) 9 69c#vKt}td dt|y#t|wxYwwNTr&r's r"denied_join_resultr-3s/&(Kd#/ !+.!+.r*ceZdZdZdZy)rzBase class for results.N)__name__ __module__ __qualname____doc__parentr r!r"rr=s !Fr!rc eZdZdZdZeZdZdZ d7dZe dZ e jdZ d8dZ dZ dZd Zd Z d9d Z d9d Zdd dd d dddd ej(ej*f dZeZdZdZd:dZdZd:dZdZdZdZdZ d;dZ!e!Z"dZ#de d4Z?e d5Z@e d6ZAy)=rzxQuery task state. Arguments: id (str): See :attr:`id`. backend (Backend): See :attr:`backend`. Nc |tdt|t|xs |j|_||_|xs|jj |_||_t|jd|_ d|_ d|_ y)Nz#AsyncResult requires valid id, not TweakF) ValueErrortyperappidbackendr3r _on_fulfilledon_ready_cache_ignored)selfr;r< task_namer:r3s r"__init__zAsyncResult.__init__Xs :5d2hZ@B B!#/22$(("2"2   2 2>   r!c4t|dr |jSy)z+If True, task result retrieval is disabled.r@F)hasattrr@rAs r"ignoredzAsyncResult.ignoredfs 4 $== r!c||_y)z%Enable/disable task result retrieval.N)r@)rAvalues r"rGzAsyncResult.ignoredms  r!ct|jj|||jj||S)Nr6)r<add_pending_resultr>thenrAcallbackon_errorr7s r"rLzAsyncResult.thenrs0 ''4'8}}!!(H55r!c<|jj||Srr<remove_pending_resultrAresults r"r=zAsyncResult._on_fulfilledvs **40 r!c^|j}|j|xr|jfdfSr)r3r;as_tuple)rAr3s r"rVzAsyncResult.as_tuplezs+5FOO$56<tww   NN6>>+ ,r!cd|_|jr|jj|jj|jy)z/Forget the result of this task and its parents.N)r?r3forgetr<r;rFs r"r]zAsyncResult.forgets6 ;; KK    DGG$r!cn|jjj|j|||||y)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:controlrevoker;)rAr`rarbwaitrds r"rfzAsyncResult.revokes3$ J*3F&*G  =r!cZ|jjj||||||y)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. r_N)r:rerevoke_by_stamped_headers)rAheadersr`rarbrgrds r"riz%AsyncResult.revoke_by_stamped_headerss0( 227z=Fv9=w 3 Pr!T?c |jry| r tt} |r5|r3|jr't|jd} |j |r| j ||j r |r|j||jS|jj||jj|||| ||||S)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. NTr6)rN)rdinterval on_intervalno_ack propagaterN on_message) rGr#r r3_maybe_reraise_parent_errorrLr? maybe_throwrTr<rKwait_for_pending) rArdrprmrofollow_parentsrNrqrndisable_sync_subtasksEXCEPTION_STATESPROPAGATE_STATES _on_intervals r"getzAsyncResult.getsZ <<  ! #y iDKK"4#C#C$OL  , , .    k * ;;  ( 3;;  ''-||,, '$!-  r!crtt|jD]}|jyr)reversedlist_parentsrsrAnodes r"rrz'AsyncResult._maybe_reraise_parent_errors(T$--/23D    4r!c#PK|j}|r||j}|ryywrr3rs r"r~zAsyncResult._parents s%{{J;;Ds!&&c+lK|j|D]\}}||jdi|fyw)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.  intermediateNr iterdepsrz)rArkwargs_Rs r"collectzAsyncResult.collects9\MM|Mz'AsyncResult.iterdeps..PsL8KudE]8Ks)rpopleftreadyrYchildrenr)rArstackis_incomplete_streamr3rs @r"rzAsyncResult.iterdepsGstd|n%#// ==?LFD$, zz| L 8K8KLL'*,,s A4A:8A:cF|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. )stater< READY_STATESrFs r"rzAsyncResult.readyUs zzT\\6666r!c<|jtjk(S)z7Return :const:`True` if the task executed successfully.)rr SUCCESSrFs r" successfulzAsyncResult.successful]zzV^^++r!c<|jtjk(S)z(Return :const:`True` if the task failed.)rr FAILURErFs r"failedzAsyncResult.failedarr!c<|jj|i|yr)r>throwrAargsrs r"rzAsyncResult.throwes T,V,r!c |j|jn |j}|d|d|jd}}}|tjvr#|r!|j ||j ||||j||S)NstatusrT traceback)r?_get_task_metarzr rxr_to_remote_tracebackr;)rArprNcacherrItbs r"rszAsyncResult.maybe_throwhs)-)<##%$++ (OU8_eii .Du F++ + JJud77; <   TWWe $ r!c|rUtN|jjjr-tjj |j Syyyr)tblibr:conftask_remote_tracebacks Traceback from_string as_traceback)rArs r"rz AsyncResult._to_remote_tracebackssC %# (L(L??..r2??A A)M#2r!ct|xst|jd}|j|D]+\}}|j ||s|j ||-|S)Noval)rootshape) formatterr)rrr;radd_arcadd_edge)rArrgraphr3rs r" build_graphzAsyncResult.build_graphws_M>twwf#M !MM|MDLFD MM$ vt,E r!c,t|jSz`str(self) -> self.id`.strr;rFs r"__str__zAsyncResult.__str__477|r!c,t|jSz`hash(self) -> hash(self.id)`.hashr;rFs r"__hash__zAsyncResult.__hash__DGG}r!cNdt|jd|jdS)N<: >)r9r/r;rFs r"__repr__zAsyncResult.__repr__s&4:&&'r$''!44r!ct|tr|j|jk(St|tr||jk(StSr) isinstancerr;rNotImplementedrAothers r"__eq__zAsyncResult.__eq__s> e[ )88tww& & s #DGG# #r!c||j|j|jd|j|jSr) __class__r;r<r:r3rFs r"__copy__zAsyncResult.__copy__s.~~ GGT\\44;;  r!c:|j|jfSrr__reduce_args__rFs r" __reduce__zAsyncResult.__reduce__~~t33555r!cL|j|jdd|jfSr)r;r<r3rFs r"rzAsyncResult.__reduce_args__sww dD$++==r!cT|j|jj|yy)z9Cancel pending operations when the instance is destroyed.NrQrFs r"__del__zAsyncResult.__del__s# << # LL . .t 4 $r!c"|jSr)rrFs r"rzAsyncResult.graphs!!r!c.|jjSr)r<supports_native_joinrFs r"rz AsyncResult.supports_native_joins||000r!c@|jjdSNrrrzrFs r"rzAsyncResult.childrens""$((44r!c|rT|d}|tjvr=|j|jj |}|j ||S|S)Nr)r r _set_cacher<meta_from_decodedr>)rAmetards r"_maybe_set_cachezAsyncResult._maybe_set_cachesO NE+++OODLL$B$B4$HI d# r!c|j4|j|jj|jS|jSr)r?rr< get_task_metar;rFs r"rzAsyncResult._get_task_metas: ;; (()C)CDGG)LM M{{r!c 6t|jgSr)iterr)rArs r" _iter_metazAsyncResult._iter_metasT((*+,,r!c|jd}|r'|Dcgc]}t||jc}|d<||_|Scc}wr)rzrr:r?)rArrrs r"rzAsyncResult._set_cachesO55$ @H@Hu!%2AjM  sAc(|jdS)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. rTrrFs r"rTzAsyncResult.results""$X..r!c@|jjdS)z#Get the traceback of a failed task.rrrFs r"rzAsyncResult.tracebacks""$((55r!c(|jdS)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. rrrFs r"rzAsyncResult.states:""$X..r!c|jS)zCompat. alias to :attr:`id`.r;rFs r"task_idzAsyncResult.task_ids wwr!c||_yrr)rAr;s r"rzAsyncResult.task_ids r!c@|jjdS)NnamerrFs r"rzAsyncResult.name""$((00r!c@|jjdS)NrrrFs r"rzAsyncResult.argsrr!c@|jjdS)NrrrFs r"rzAsyncResult.kwargs ""$((22r!c@|jjdS)NworkerrrFs r"rzAsyncResult.workerrr!c|jjd}|r%t|tjs t |S|S)zUTC date and time. date_done)rrzrdatetimer)rArs r"rzAsyncResult.date_dones@'')--k: Z 83D3DEI& &r!c@|jjdS)NretriesrrFs r"rzAsyncResult.retriess""$((33r!c@|jjdS)NqueuerrFs r"rzAsyncResult.queues""$((11r!)NNNNr%NFNFN)F)TN)FN)Br/r0r1r2r:rr;r<rCpropertyrGsetterrLr=rVrZr]rfrir rwrxrzrgrrr~rrrrrrrrs maybe_reraiserrrrrrrrrrrrrrrrrrrTinforrrrrrrrrrrr r!r"rrDs C L BG#'"&   ^^6=%?C#'=,[_6:P0$tD#44#44 G P D /%b -7,,- MB5 6>5 ""1155 -// D 66//:F  ^^111133334422r!rc>eZdZdZdZdZd"dZdZdZdZ dZ dZ d Z d Z d Zd#d ZeZd ZdZdZdZ d$dZdZdZ d%dZ d%dZd&dZ d'dZ d(dZdZdZdZdZ dZ!e"dZ#e"dZ$e$jJd Z$e"d!Z&y))rzpA collection of results. Arguments: results (Sequence[AsyncResult]): List of result instances. Nc ||_||_tt|f|_|xs t ||_|j r1|j jt|jdyy)N)rTr6) _appr[r rr>r _on_fullrL _on_ready)rAr[r: ready_barrierrs r"rCzResultSet.__init__1s\  eDk^4 %9)9 == MM  wt~~DA B r!c||jvrD|jj||jr|jj|yyy)zvAdd :class:`AsyncResult` as a new member of the set. Does nothing if the result is already a member. N)r[rXraddrSs r"rz ResultSet.add9sE  % LL   '}} !!&) &r!cR|jjr|jyyr)r<is_asyncr>rFs r"rzResultSet._on_readyCs << MMO !r!ct|tr|jj|} |jj |y#t $r t|wxYw)z~Remove result from the set; it must be a member. Raises: KeyError: if the result isn't a member. N)rrr:rr[remover8KeyErrorrSs r"rzResultSet.removeGsS fc "XX))&1F # LL   ' #6" " #s A AcF |j|y#t$rYywxYw)zbRemove result from the set if it is a member. Does nothing if it's not a member. N)rrrSs r"discardzResultSet.discardTs%   KK    s   cNjjfd|Dy)z Extend from iterable of results.c3@K|]}|jvs|ywrr[)rrrAs r"rz#ResultSet.update..`sHw!!4<<2GAwsN)r[rY)rAr[s` r"updatezResultSet.update^s HwHHr!c"g|jddy)z!Remove all results from this set.NrrFs r"clearzResultSet.clearbs Qr!c:td|jDS)zReturn true if all tasks successful. Returns: bool: true if all of the tasks finished successfully (i.e. didn't raise an exception). c3<K|]}|jywr)rrrTs r"rz'ResultSet.successful..msB\66$$&\allr[rFs r"rzResultSet.successfulfsBT\\BBBr!c:td|jDS)zReturn true if any of the tasks failed. Returns: bool: true if one of the tasks failed. (i.e., raised an exception) c3<K|]}|jywr)rr%s r"rz#ResultSet.failed..vs>v6==?r&anyr[rFs r"rzResultSet.failedos>>>>r!cL|jD]}|j||y)N)rNrp)r[rs)rArNrprTs r"rszResultSet.maybe_throwxs#llF   I  F#r!c:td|jDS)zReturn true if any of the tasks are incomplete. Returns: bool: true if one of the tasks are still waiting for execution. c3>K|]}|j ywrrr%s r"rz$ResultSet.waiting..sAL&v||~%Lsr+rFs r"waitingzResultSet.waiting}sADLLAAAr!c:td|jDS)zDid all of the tasks complete? (either by success of failure). Returns: bool: true if all of the tasks have been executed. c3<K|]}|jywrr0r%s r"rz"ResultSet.ready..s= f6<<> r&r'rFs r"rzResultSet.readys = ===r!c:td|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. c3NK|]}t|jywr)intrr%s r"rz,ResultSet.completed_count..sG,3v((*+,s#%)sumr[rFs r"completed_countzResultSet.completed_countsG$,,GGGr!cF|jD]}|jy)z?Forget about (and possible remove the result of) all the tasks.N)r[r]rSs r"r]zResultSet.forgetsllF MMO#r!c|jjj|jDcgc]}|jc}|||||ycc}w)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. )r`rdrarbrcN)r:rerfr[r;)rAr`rarbrgrdrs r"rfzResultSet.revokesJ t|| <|!| <+5w*3F$  P res.results[i]`.r)rAindexs r" __getitem__zResultSet.__getitem__s||E""r!c f|jr |jn |j||||||||S)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. )rdrprmrNrorqrvrn)r join_nativejoin) rArdrprmrNrorqrvrns r"rzz ResultSet.gets=MD$=$=  499y!9N#   r!c b|r ttj} d} | tdg} |jD]n} d} |r*|tj| z z } | dkr t d| j | |||||} |r|| j| ^| j| p| 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)rdrprmrornrv) r#time monotonicrr[rrzr;rX)rArdrprmrNrorqrvrn time_start remainingr[rTrIs r"rBzResultSet.joins^ ! ! #^^%   !&>@ @llFI#t~~'7*'DE #&'ABBJJ!Y!&k&;E E*u%#r!c:|jj||Srr>rLrMs r"rLzResultSet.then}}!!(H55r!cD|jj||||||S)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. )rdrmrorqrn)r< iter_native)rArdrmrorqrns r"rLzResultSet.iter_natives/||'' hv!{(  r!c |r t|rdn2t|jD cic]\} } | j| c} } } |rdn!t t |D cgc]} dc} } |j |||||D]p\}}t|tr)g}|D]!}|j|j#n|d}|r|dtjvr||r |||i|| | |<r| Scc} } wcc} w)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. NrTr) r# enumerater[r;rangelenrLrr}rXrzr rx)rArdrprmrNrorqrnrvirT order_indexraccrrrIchildren_results r"rAzResultSet.join_native's  ! ! #&d*3DLL*A- *AYQFIIqL*A- d5T3C$D3CaT3C$D!--gx.8+GMGT$%'+OLL!4!4!67(,Xh63J3J!JK%(,1K()G %- %Es C4 C:c d|jj|jDchc]}|jc}fddi|DScc}w)Nc3&K|] \}}| ywrr )rrrs r"rz'ResultSet._iter_meta..Ls % D% smax_iterationsr )r<get_manyr[r;)rArrs r"rzResultSet._iter_metaKsR $9DLL$9$9<< (D%   (sA c(d|jDS)Nc3K|]G}|jj|jr |jtj vr|Iywr)r< is_cachedr;rr rx)rress r"rz0ResultSet._failed_join_report..Qs>6|;;((0 V444|sA ArrFs r"_failed_join_reportzResultSet._failed_join_reportPs6t||6 6r!c,t|jSr)rPr[rFs r"__len__zResultSet.__len__Us4<<  r!c`t|tr|j|jk(StSr)rrr[rrs r"rzResultSet.__eq__Xs% eY '==DLL0 0r!czdt|jddjd|jDdS)Nrz: [, c34K|]}|jywrrrrs r"rz%ResultSet.__repr__..^s4P)r9r/rBr[rFs r"rzResultSet.__repr__]s74:&&'s4994P4<<4P+P*QQSTTr!cT |jdjS#t$rYywxYwNr)r[r IndexErrorrFs r"rzResultSet.supports_native_join`s- <<?77 7   s  ''c|j>|jr|jdjntj|_|jSrh)rr[r:r _get_current_objectrFs r"r:z ResultSet.appgs@ 99 04 a,,$88: Iyyr!c||_yr)r)rAr:s r"r:z ResultSet.appns  r!cx|jr|jjS|jdjSrh)r:r<r[rFs r"r<zResultSet.backendrs+#'88txxHa1H1HHr!NNr,r)NTrkNTNTNr%)NrkTNN)NTrkNTNNT)'r/r0r1r2rr[rCrrrrr r"rrrsr r1rr8r]rfr<r?rzrBrLrLrArr]r_rrr rr:r r<r r!r"rr$s: DGC* #IC?G MB> H ?C#'P&"#:=3748 ;>4859HT6>B15 $378<15*."H 6 ! U   ZZIIr!rceZdZdZdZdZdfd ZfdZddZddZ dZ dZ d Z e Z d Zd Zd Zd ZdZedZeddZxZS)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 B||_||_t| |fi|yr)r;r3superrC)rAr;r[r3rrs r"rCzGroupResult.__init__s#  +F+r!cX|jj|t| yr)r<rRrqr)rArs r"rzGroupResult._on_readys  **40 r!cj|xs|jjj|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:r< save_groupr;rAr<s r"savezGroupResult.saves*+488++77FFr!cj|xs|jjj|jy)z.Remove this result if it was previously saved.N)r:r< delete_groupr;rus r"deletezGroupResult.deletes#  $DHH$$22477;r!c:|j|jfSrrrFs r"rzGroupResult.__reduce__rr!c2|j|jfSr)r;r[rFs r"rzGroupResult.__reduce_args__sww $$r!cHt|jxs |jSr)boolr;r[rFs r"__bool__zGroupResult.__bool__sDGG+t||,,r!c t|trO|j|jk(xr4|j|jk(xr|j|jk(St|t r||jk(St Sr)rrr;r[r3rrrs r"rzGroupResult.__eq__sl e[ )DGG#, -,  +  s #DGG# #r!c dt|jd|jddjd|jDdS)Nrrz [rbc34K|]}|jywrrrds r"rz'GroupResult.__repr__..s>Z\qtt\rerf)r9r/r;rBr[rFs r"rzGroupResult.__repr__sA4:&&'r$''"TYY>ZT\\>Z5Z4[[]^^r!c,t|jSrrrFs r"rzGroupResult.__str__rr!c,t|jSrrrFs r"rzGroupResult.__hash__rr!c|j|jxr|jjf|jDcgc]}|jc}fScc}wr)r;r3rVr[)rArs r"rVzGroupResult.as_tuplesM WWdkk)rAr; ret_valuerrrs r"rCzEagerResult.__init__s<   #    dr!c:|jj||SrrIrMs r"rLzEagerResult.thenrJr!c|jSr)r?rFs r"rzEagerResult._get_task_metas {{r!c:|j|jfSrrrFs r"rzEagerResult.__reduce__rr!c^|j|j|j|jfSr)r;rrrrFs r"rzEagerResult.__reduce_args__s!t{{DOODDr!c2|j\}}||Sr)r)rArrs r"rzEagerResult.__copy__sOO% TDzr!cyr,r rFs r"rzEagerResult.readysr!c |r t|jr |jS|jtj vrI|r;t |jtr |jt|j|jSyr)r#rrTrr rxr Exception)rArdrprvrs r"rzzEagerResult.getsr ! # ?? ;;  ZZ622 2%/KK&,dkkH1:4;;1GH;;  3r!cyrr rFs r"r]zEagerResult.forgets r!c.tj|_yr)r REVOKEDrrs r"rfzEagerResult.revoke s nn r!c"d|jdS)Nzrs59 %$/++!CLL8   ) //// \2*\2\2~ OI OIOId  \))\)\)~ T+TTn u  EsC..C87C8