`fdZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl mZmZmZd d lmZmZd d lmZmZd d lmZd d lmZmZmZd dlmZmZ ddl Z n #e!$rdZ YnwxYwdZ"dZ#dZ$edZ%edZ&GddZ'ej(Gdde'Z)ej(Gdde'Z*ej(Gdde*Z+ej(Gdde)Z,ddZ-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 cJtrttdSN)r RuntimeError E_WOULDBLOCK?/var/www/html/env/lib/python3.11/site-packages/celery/result.pyassert_will_not_blockr#$s()<((())r!c#Kt}td dVt|dS#t|wxYwNFrr reset_values r"allow_join_resultr))sV&((Ke$$$/ !+.....!+.... 6Ac#Kt}td dVt|dS#t|wxYwNTr&r's r"denied_join_resultr-3sV&((Kd###/ !+.....!+....r*ceZdZdZdZdS)rzBase class for results.N)__name__ __module__ __qualname____doc__parentr r!r"rr=s!!FFFr!rc eZdZdZdZeZdZdZ d8dZe dZ e j dZ d9dZ dZ d Zd Zd Z d:d Z d:d Zdddddddddejejf dZeZdZdZd;dZdZd;dZdZdZdZdZ de d5Z?e d6Z@e d7ZAdS)>rzxQuery task state. Arguments: id (str): See :attr:`id`. backend (Backend): See :attr:`backend`. Nc|tdt|t|p|j|_||_|p |jj|_||_t|jd|_ d|_ d|_ dS)Nz#AsyncResult requires valid id, not TweakF) ValueErrortyperappidbackendr3r _on_fulfilledon_ready_cache_ignored)selfr;r< task_namer:r3s r"__init__zAsyncResult.__init__Xs :@d2hh@@BB B!#/222$("2   2>>>   r!c4t|dr|jSdS)z+If True, task result retrieval is disabled.r@F)hasattrr@rAs r"ignoredzAsyncResult.ignoredfs# 4 $ $ != ur!c||_dS)z%Enable/disable task result retrieval.N)r@)rAvalues r"rGzAsyncResult.ignoredms r!Fcp|j|||j||S)Nr6)r<add_pending_resultr>thenrAcallbackon_errorr7s r"rLzAsyncResult.thenrs5 ''4'888}!!(H555r!c:|j||Srr<remove_pending_resultrAresults r"r=zAsyncResult._on_fulfilledvs **4000 r!cN|j}|j|o|fdfSr)r3r;as_tuple)rAr3s r"rVzAsyncResult.as_tuplezs*5FOO$5$56<>++ , , ,r!cd|_|jr|j|j|jdS)z/Forget the result of this task and its parents.N)r?r3forgetr<r;rFs r"r]zAsyncResult.forgetsE ; ! K    DG$$$$$r!cZ|jj|j|||||dS)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.revokes@$ J*3F&*G  = = = = =r!cP|jj||||||dS)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`rarbrhrds r"rjz%AsyncResult.revoke_by_stamped_headerssC( 227z=Fv9=w 3 P P P P Pr!T?c |jrdS| rtt} |r3|r1|jr*t|jd} ||r| ||jr|r|||jS|j ||j |||| ||||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) rArdrqrnrpfollow_parentsrNrrrodisable_sync_subtasksEXCEPTION_STATESPROPAGATE_STATES _on_intervals r"getzAsyncResult.gets Z <  F  $ ! # # #yy  /i /DK /"4#C$OOOL  , , . . .  +   k * * * ;  4  ( 333;  ''---|,, '$!-   r!ctt|D]}|dSr)reversedlist_parentsrtrAnodes r"rsz'AsyncResult._maybe_reraise_parent_errorsHT$--//2233  D         r!c#:K|j}|r|V|j}| dSdSrr3rs r"rzAsyncResult._parents sC{ JJJ;D     r!c+dK||D]\}}||jdi|fVdS)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 iterdepsr{)rArkwargs_Rs r"collectzAsyncResult.collectsV\MM|M<< % %DAqUQU__V__$ $ $ $ $ % %r!cfd}|D]\}}|}|Srr)rArIrrs r"get_leafzAsyncResult.get_leafAs6MMOO  DAqEEGGEE r!c#Ktd|fg}| }|rn|\}|fVr)|fdjpgDn|rt |ldSdS)Nc3 K|]}|fV dSrr ).0childrs r" z'AsyncResult.iterdeps..Ps'LLudE]LLLLLLr!)rpopleftreadyrYchildrenr)rArstackis_incomplete_streamr3rs @r"rzAsyncResult.iterdepsGsd|n%%#// - ==??LFD$,   zz|| - LLLL 8KLLLLLLL'-*,,, - - - - -r!c(|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 zT\666r!c,|jtjkS)z7Return :const:`True` if the task executed successfully.)rr SUCCESSrFs r" successfulzAsyncResult.successful]zV^++r!c,|jtjkS)z(Return :const:`True` if the task failed.)rr FAILURErFs r"failedzAsyncResult.failedarr!c*|jj|i|dSr)r>throwrAargsrs r"rzAsyncResult.throwes" T,V,,,,,r!c,|j|n|j}|d|d|d}}}|tjvr+|r)|||||||j||S)NstatusrT traceback)r?_get_task_metar{r ryr_to_remote_tracebackr;)rArqrNcacherrItbs r"rtzAsyncResult.maybe_throwhs)-)<##%%%$+ (OU8_eii .D.Du F+ + + + JJud77;; < < <   HTWe $ $ $ r!c|rItD|jjjr5tj|SdSdSdSr)tblibr:conftask_remote_tracebacks Traceback from_string as_traceback)rArs r"rz AsyncResult._to_remote_tracebackssV  B%# (L#?..r22??AA A B B####r!ct|pt|jd}||D]2\}}|||r|||3|S)Noval)rootshape) formatterr)rrr;radd_arcadd_edge)rArrgraphr3rs r" build_graphzAsyncResult.build_graphwsM>twf#M#M#M   !MM|MDD - -LFD MM$    -vt,,, r!c*t|jSz`str(self) -> self.id`.strr;rFs r"__str__zAsyncResult.__str__47||r!c*t|jSz`hash(self) -> hash(self.id)`.hashr;rFs r"__hash__zAsyncResult.__hash__DG}}r!cBdt|jd|jdS)N<: >)r9r/r;rFs r"__repr__zAsyncResult.__repr__s&44::&44$'4444r!ct|tr|j|jkSt|tr ||jkStSr) isinstancerr;rNotImplementedrAothers r"__eq__zAsyncResult.__eq__sH e[ ) ) $8tw& & s # # $DG# #r!c\||j|jd|j|jSr) __class__r;r<r:r3rFs r"__copy__zAsyncResult.__copy__s+~~ GT\44;   r!c8|j|fSrr__reduce_args__rFs r" __reduce__zAsyncResult.__reduce__~t335555r!c.|j|jdd|jfSr)r;r<r3rFs r"rzAsyncResult.__reduce_args__sw dD$+==r!cL|j|j|dSdS)z9Cancel pending operations when the instance is destroyed.NrQrFs r"__del__zAsyncResult.__del__s. < # L . .t 4 4 4 4 4 $ #r!c*|Sr)rrFs r"rzAsyncResult.graphs!!!r!c|jjSr)r<supports_native_joinrFs r"rz AsyncResult.supports_native_joins |00r!cP|dS)Nrrr{rFs r"rzAsyncResult.childrens"""$$((444r!c|rZ|d}|tjvrD||j|}|||S|S)Nr)r r _set_cacher<meta_from_decodedr>)rAmetards r"_maybe_set_cachezAsyncResult._maybe_set_caches^  NE+++OODL$B$B4$H$HII d### r!c|j2||j|jS|jSr)r?rr< get_task_metar;rFs r"rzAsyncResult._get_task_metas8 ; (()C)CDG)L)LMM M{r!c Ft|gSr)iterrrArs r" _iter_metazAsyncResult._iter_metasT((**+,,,r!cf|d}|rfd|D|d<|_|S)Nrc:g|]}t|jSr )rr:)rrrAs r" z*AsyncResult._set_cache..s37<!%22r!)r{r?)rArrs` r"rzAsyncResult._set_cachesV55$$  @HAjM r!c6|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. rTrrFs r"rTzAsyncResult.results""$$X..r!cP|dS)z#Get the traceback of a failed task.rrrFs r"rzAsyncResult.tracebacks$""$$((555r!c6|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. rrrFs r"rzAsyncResult.states:""$$X..r!c|jS)zCompat. alias to :attr:`id`.r;rFs r"task_idzAsyncResult.task_ids wr!c||_dSrr)rAr;s r"rzAsyncResult.task_ids r!cP|dS)NnamerrFs r"rzAsyncResult.name"""$$((000r!cP|dS)NrrrFs r"rzAsyncResult.argsrr!cP|dS)NrrrFs r"rzAsyncResult.kwargs """$$((222r!cP|dS)NworkerrrFs r"rzAsyncResult.workerrr!c|d}|r)t|tjst |S|S)zUTC date and time. date_done)rr{rdatetimer)rArs r"rzAsyncResult.date_donesS''))--k::  'Z 83DEE 'I&& &r!cP|dS)NretriesrrFs r"rzAsyncResult.retriess"""$$((333r!cP|dS)NqueuerrFs r"r zAsyncResult.queues"""$$((111r!)NNNNr%NFNFN)F)TN)FN)Br/r0r1r2r:rr;r<rCpropertyrGsetterrLr=rVrZr]rfrjr rxryr{rhrsrrrrrrrrrt maybe_reraiserrrrrrrrrrrrrrrrrrrTinforrrrrrrrrrr r r!r"rrDs C L BG#'"&    X  ^^6666===%%%?C#'====,[_6:PPPP0$tD#4#4 G G G G P D /%/%/%/%b - - - -777,,,,,,--- MBBB555   666>>>555 ""_"11X155X5 ---//X/ D 66X6//X/:F X ^^11X111X133X333X3X44X422X222r!rcNeZdZdZdZdZd%dZdZdZdZ dZ dZ d Z d Z d Zd&d ZeZdZdZdZdZ d'dZdZdZ d(dZ d(dZd)dZ d*dZ d+dZdZdZdZdZ d Z!e"d!Z#e"d"Z$e$j%d#Z$e"d$Z&dS),rzpA collection of results. Arguments: results (Sequence[AsyncResult]): List of result instances. Nc ||_||_tt|f|_|pt ||_|jr0|jt|jddSdS)N)rTr6) _appr[r rr>r _on_fullrL _on_ready)rAr[r: ready_barrierrs r"rCzResultSet.__init__1s  eDkk^444 %9)9)9 = C M  wt~DAAA B B B B B C Cr!c||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)r[rXraddrSs r"rz ResultSet.add9s_  % % L   ' ' '} * !!&))))) & % * *r!cJ|jjr|dSdSr)r<is_asyncr>rFs r"rzResultSet._on_readyCs* <   MMOOOOO  r!ct|tr|j|} |j|dS#t $rt|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.removeGsu fc " " 2X))&11F # L   ' ' ' ' ' # # #6"" " #s A A'cT ||dS#t$rYdSwxYw)zbRemove result from the set if it is a member. Does nothing if it's not a member. N)rrrSs r"discardzResultSet.discardTsA   KK         DD s  ''cTjfd|DdS)z Extend from iterable of results.c3.K|]}|jv |VdSrr[)rrrAs r"rz#ResultSet.update..`s/HH!!4<2G2GA2G2G2G2GHHr!N)r[rY)rAr[s` r"updatezResultSet.update^s4 HHHHwHHHHHHHHr!cg|jdd<dS)z!Remove all results from this set.Nr!rFs r"clearzResultSet.clearbs QQQr!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|]}|VdSr)rrrTs r"rz'ResultSet.successful..ms.BB66$$&&BBBBBBr!allr[rFs r"rzResultSet.successfulfs#BBT\BBBBBBr!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|]}|VdSr)rr(s r"rz#ResultSet.failed..vs*>>v6==??>>>>>>r!anyr[rFs r"rzResultSet.failedos#>>>>>>>>r!TcH|jD]}|||dS)N)rNrq)r[rt)rArNrqrTs r"rtzResultSet.maybe_throwxs=l G GF   I  F F F F G Gr!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|]}| VdSrrr(s r"rz$ResultSet.waiting..s-AA&v||~~%AAAAAAr!r-rFs r"waitingzResultSet.waiting}s#AADLAAAAAAr!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|]}|VdSrr2r(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. c3XK|]%}t|V&dSr)intrr(s r"rz,ResultSet.completed_count..s6GG3v((**++GGGGGGr!)sumr[rFs r"completed_countzResultSet.completed_counts#GG$,GGGGGGr!cB|jD]}|dS)z?Forget about (and possible remove the result of) all the tasks.N)r[r]rSs r"r]zResultSet.forgets,l  F MMOOOO  r!Fcn|jjd|jD|||||dS)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. cg|] }|j Sr rrr"s r"rz$ResultSet.revoke..s < < res.results[i]`.r!)rAindexs r" __getitem__zResultSet.__getitem__s|E""r!rlc N|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. )rdrqrnrNrprrrwro)r join_nativejoin) rArdrqrnrNrprrrwros r"r{z ResultSet.getsEMD$=L  49y!9N#     r!c v|rttj} d} |tdg} |jD]x} d} |r.|tj| z z } | dkrt d| | |||||} |r|| j| c| | y| 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)rdrqrnrprorw) r#time monotonicrr[rr{r;rX)rArdrqrnrNrprrrwro time_start remainingr[rTrIs r"rFzResultSet.joins^ ! $ ! # # #^%%   !&>@@ @l & &FI C#t~'7'7*'DE ##&'ABBBJJ!Y!&k&;E  &E****u%%%%r!c8|j||Srr>rLrMs r"rLzResultSet.then}!!(H555r!cB|j||||||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. )rdrnrprrro)r< iter_native)rArdrnrprrros r"rPzResultSet.iter_natives2|'' hv!{(   r!c |rt|rdndt|jD} |rdn%dtt |D} ||||||D]\} } t | tr/g} | D])}| | *n | d} |r| dtj vr| |r || | x| | | | <| 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. Nc$i|] \}}|j|Sr r)rirTs r" z)ResultSet.join_native..7s-- - - &QFIq- - - r!cg|]}dSrr )rrs r"rz)ResultSet.join_native..:s$D$D$DaT$D$D$Dr!rTr) r# enumerater[rangelenrPrr~rXr{r ry)rArdrqrnrNrprrrorw order_indexaccrrrIchildren_results r"rEzResultSet.join_native'sR ! $ ! # # #& dd- - *3DL*A*A- - - Ddd$D$D5T3C3C$D$D$D!--gx.8+GG 2 2MGT$%% '+88OLL!4!4!6!677778X h63J!J!JK 2%((((,1K()) r!c ^d|jjd|jDfddi|DS)Nc3 K|] \}}|V dSrr )rrrs r"rz'ResultSet._iter_meta..Ls6  D      r!ch|] }|j Sr rr>s r" z'ResultSet._iter_meta..Ms ( ( (aQT ( ( (r!max_iterationsr )r<get_manyr[rs r"rzResultSet._iter_metaKs\  $9DL$9 ( (4< ( ( (% % 9:% >D% %     r!c$d|jDS)Nc3~K|]8}|j|jr|jtjv4|V9dSr)r< is_cachedr;rr ry)rress r"rz0ResultSet._failed_join_report..QsW66;((006 V444444466r!r!rFs r"_failed_join_reportzResultSet._failed_join_reportPs$66t|666 6r!c*t|jSr)rXr[rFs r"__len__zResultSet.__len__Us4<   r!cZt|tr|j|jkStSr)rrr[rrs r"rzResultSet.__eq__Xs) eY ' ' 1=DL0 0r!c|dt|jddd|jDdS)Nrz: [, c3$K|] }|jV dSrrr>s r"rz%ResultSet.__repr__..^s$4P4PaQT4P4P4P4P4P4Pr!]>)r9r/rFr[rFs r"rzResultSet.__repr__]sAT4::&TT4994P4P4<4P4P4P+P+PTTTTr!cJ |jdjS#t$rYdSwxYwNr)r[r IndexErrorrFs r"rzResultSet.supports_native_join`s8 <?7 7    DD s  ""c|j1|jr|jdjntj|_|jSro)rr[r:r _get_current_objectrFs r"r:z ResultSet.appgs= 9 04 ;a,,$8:: Iyr!c||_dSr)r)rAr:s r"r:z ResultSet.appns  r!cL|jr |jjn|jdjSro)r:r<r[rFs r"r<zResultSet.backendrs"#'8Htxa1HHr!NNr,r )NTrlNTNTNr%)NrlTNN)NTrlNTNNT)'r/r0r1r2rr[rCrrrrr#r%rrrtrr3rr:r]rfr@rCr{rFrLrPrErrfrhrrr rr:r r<r r!r"rr$s DGCCCC*** # # #IIICCC???GGGG MBBB>>> H H H ?C#'PPPP&"""###:=3748    ;>4859HHHHT6666>B15    $378<15*.""""H   666 !!! UUUX X  ZZIIXIIIr!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 X||_||_tj|fi|dSr)r;r3superrC)rAr;r[r3rrs r"rCzGroupResult.__init__s6 ++F+++++r!c||j|tdSr)r<rRrxr)rArs r"rzGroupResult._on_readys5 **4000 r!cP|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:r< save_groupr;rAr<s r"savezGroupResult.saves&+48+77FFFr!cR|p |jj|jdS)z.Remove this result if it was previously saved.N)r:r< delete_groupr;r|s r"deletezGroupResult.deletes(  $DH$2247;;;;;r!c8|j|fSrrrFs r"rzGroupResult.__reduce__rr!c|j|jfSr)r;r[rFs r"rzGroupResult.__reduce_args__sw $$r!c8t|jp|jSr)boolr;r[rFs r"__bool__zGroupResult.__bool__sDG+t|,,,r!ct|tr0|j|jko|j|jko|j|jkSt|t r ||jkSt Sr)rrr;r[r3rrrs r"rzGroupResult.__eq__sn e[ ) ) $DG#, -,  +  s # # $DG# #r!c dt|jd|jddd|jDdS)Nrrz [rkc3$K|] }|jV dSrrr>s r"rz'GroupResult.__repr__..s$>Z>Zqt>Z>Z>Z>Z>Z>Zr!rm)r9r/r;rFr[rFs r"rzGroupResult.__repr__sK^4::&^^$'^^TYY>Z>ZT\>Z>Z>Z5Z5Z^^^^r!c*t|jSrrrFs r"rzGroupResult.__str__rr!c*t|jSrrrFs r"rzGroupResult.__hash__rr!cr|j|jo|jfd|jDfS)Nc6g|]}|Sr )rVr>s r"rz(GroupResult.as_tuple..s 0 0 0aQZZ\\ 0 0 0r!)r;r3rVr[rFs r"rVzGroupResult.as_tuples> Wdk)rAr; ret_valuerrrs r"rCzEagerResult.__init__sJ   #    dr!Fc8|j||SrrMrMs r"rLzEagerResult.thenrNr!c|jSr)r?rFs r"rzEagerResult._get_task_metas {r!c8|j|fSrrrFs r"rzEagerResult.__reduce__rr!c6|j|j|j|jfSr)r;rrrrFs r"rzEagerResult.__reduce_args__st{DODDr!c:|\}}||Sr)r)rArrs r"rzEagerResult.__copy__s!OO%% TsDzr!cdSr,r rFs r"rzEagerResult.readystr!Tc |rt|r|jS|jtjvr>|r5t |jtr|jnt|j|jSdSr)r#rrTrr ryr Exception)rArdrqrwrs r"r{zEagerResult.gets  $ ! # # # ??   ;  Z62 2 2 H%/K&,&,Hdkk1:4;1G1GH;  3 2r!cdSrr rFs r"r]zEagerResult.forgets r!c(tj|_dSr)r REVOKEDrrs r"rfzEagerResult.revoke sn r!cd|jdS)Nz.=s$FFFu&uc22FFFr!r)rrrrr~tuplerr)r"r:Resultrenodesr;r3s ` r"rr/s   C _F a $ $ ) U&sT5M::KSSd F  4&vs33F  ??FFFFFFF#  vb(((( Hr!r).r2rrH collectionsr contextlibrweakrefrdateutil.parserrkombu.utils.objectsrvinerr r r r rrrr:r exceptionsrrr utils.graphrrr ImportError__all__rr#r)r-rregisterrrrrrr r!r"rs99 %%%%%%$$$$$$//////++++++++++!!!!!!!!CCCCCCCCLLLLLLLLLL88888888LLLL EEE   ))) ////// \2\2\2\2\2*\2\2\2~ OIOIOIOIOI OIOIOId  \)\)\)\)\))\)\)\)~ TTTTT+TTTn      sA!!A+*A+