ceifUdZddlmZgdZddlZddlZddlZddlZddlZddl m Z ddl m Z ej gejfZej dejfZGd d eZGd d eZGd deZGddZGddZGddejZGddZGdde jZGdde jZGdde jZGddZ Gdd ej!!Z"Gd"d#e"Z#Gd$d%e"Z$Gd&d'Z%Gd(d)e jZ&Gd*d+Z'Gd,d-e"Z(Gd.d/e j)e j*Z+e j,e&Z-d0e.d1<e+Z/d2e.d3<d7d6Z0dS)8zAIntegration with worker framework to make API calls asynchronous.) annotations)TaskCanceledErrorTaskFailedErrorCallDuration TaskStatus TaskResult TaskWorker TaskThread TaskContext TaskModifierInsertArgumentTask CancelContextAddCancelContextN)QtCore) singletons.ceZdZdZdS) TaskErrorzGeneral issue running a task.N)__name__ __module__ __qualname____doc__@lib/python3.11/site-packages/anaconda_navigator/utils/workers.pyrrs''''rrceZdZdZddZdS)rz&Task was canceled during its workflow.returnstrcdS).Prepare string representation of the instance.z'Task was cancelled during its executionrselfs r__str__zTaskCanceledError.__str__!s88rNrr rrrrr%rrrrrs.00999999rrceZdZdZddZdS)rz Task failed during its workflow.rr cdS)r"z Task failed during its executionrr#s rr%zTaskFailedError.__str__)s11rNr&r'rrrrr&s.**222222rrcteZdZdZdZ ddd Zedd ZeddZeddZ ddZ dS)rz Signature of a function call. :param function: Function to call. :param args: Positional arguments for the `function`. :param kwargs: Keyword arguments for the `function`. ) __function__args__kwargsNfunctionFUNCTIONargs,typing.Optional[typing.Sequence[typing.Any]]kwargs0typing.Optional[typing.Mapping[str, typing.Any]]rNonec@|d}|i}||_||_||_dS)z'Initialize new :class:`~Call` instance.Nr_Call__function _Call__args _Call__kwargs)r$r.r0r2s r__init__z Call.__init__9s1 <D >F2:AE GM rc|jS)zFunction to call.)r7r#s rr.z Call.functionI rtyping.Sequence[typing.Any]c|jS)z-Positional arguments to call `function` with.)r8r#s rr0z Call.argsN {rtyping.Mapping[str, typing.Any]c|jS)z*Keyword arguments to call `function` with.)r9r#s rr2z Call.kwargsS }r typing.Anyc0|j|ji|jS)zCExecute stored function with both positional and keyword arguments.r6r#s r__call__z Call.__call__Xst =t}===rNN)r.r/r0r1r2r3rr4rr/)rr=)rr@rrC) rrrr __slots__r:propertyr.r0r2rErrrrr.s5I BFGK NNNNN XXX>>>>>>rrcveZdZdZdZ ddd Zedd Zedd ZeddZ dddZ dS)raU Simple helper to track execution duration. :param start: Optional start of the tracked time span. If it is not provided - current timestamp will be used. :param stop: Optional end of the tracked time span. Might be omitted on initialization and then set with :meth:`~Duration.finish`. )__start__stopNstart"typing.Optional[datetime.datetime]stoprr4cb|tj}||_||_dS)z+Initialize new :class:`~Duration` instance.N)datetimenow_Duration__start_Duration__stop)r$rNrPs rr:zDuration.__init__ls/ =%))++E8= :> rdatetime.datetimec|jS)zStart of the tracked time span.)rTr#s rrNzDuration.startx |rc|jS)zStop of the tracked time span.)rUr#s rrPz Duration.stop}r?rtyping.Optional[float]cV|jdS|j|jz S)z*Total number of seconds in this time span.N)rUrT total_secondsr#s rtotalzDuration.totals, ; 4 dl*99;;;rc|jtd|tj}||_dS)a Set the stop value for this duration. Might be set only once (either with this method or on initialization). :param stop: Value to set stop to. If it is not provided - current timestamp will be used. NzDuration is already closed)rU TypeErrorrRrS)r$rPs rfinishzDuration.finishs? ; "899 9 <$((**D rrF)rNrOrPrOrr4)rrV)rrO)rrZN)rPrOrr4) rrrrrIr:rJrNrPr]r`rrrrr]s  &I9=7; ? ? ? ? ?XX<<<X< rrcleZdZdZejZejZejZdS)rz0Possible states of the :class:`~Task` execution.N) rrrrenumauto SUCCEEDEDCANCELEDFAILEDrrrrrs;:: Ity{{H TY[[FFFrrceZdZdZdZ dddZeddZeddZeddZ eddZ eddZ dS)r a Details of task execution. Instances of this class are provided through the task signals. :param call: Signature of the function that was called. :param status: Resulted status of the execution. :param result: Function output. Must be an exact value for succeeded executions, and exception for failed executions. :param duration: Optional information about task execution duration. )__call__status__result __durationNcallrstatusrresultrCdurationtyping.Optional[Duration]rr4cz|"t}||tjkr6|t }nYt |tst dn4|tjkr$t |tst d||_ ||_ ||_ ||_ dS)z-Initialize new :class:`~TaskResult` instance.Nz=result must be a TaskCanceledError instance if task is failedz-result must be an exception if task is failed) rr`rrfr isinstancer_rg BaseException_TaskResult__call_TaskResult__status_TaskResult__result_TaskResult__duration)r$rmrnrorps rr:zTaskResult.__init__s  zzH OO    Z( ( (~*,,(9:: a _``` a )))Jv}4U4U)KLL L*. 28 28 2:rc|jS)z*Signature of the function that was called.)rur#s rrmzTaskResult.callr?rrc|jS)zTask execution duration.)rxr#s rrpzTaskResult.durationr<rtyping.Optional[BaseException]c>|jtjkrdS|jS)z+Exception, that was raised by the function.Nrvrrerwr#s r exceptionzTaskResult.exceptions! =J0 0 04}rcH|jtjkr|jS|j)zw Function output. If function raised an error - this property will also raise the same error. r}r#s rrozTaskResult.results$ =J0 0 0= mrc|jS)z!Resulted status of the execution.)rvr#s rrnzTaskResult.statusrBrrF) rmrrnrrorCrprqrr4rr)rr)rr{rH)rr) rrrrrIr:rJrmrpr~rornrrrr r s  AI "&26 ;;;;;2XXX XXrr ceZdZdZejZejeZejeZ ejeZ ejeZ dS) TaskSignalsa Collection of signals for :class:`~TaskWorker`. .. py:attribute:: sig_start Task started its execution. .. py:attribute:: sig_succeeded Task finished its execution successfully. .. py:attribute:: sig_canceled Task was canceled during its execution. .. py:attribute:: sig_failed Task raised an error. .. py:attribute:: sig_done Task finished its execution. This signal is called regardless of execution result. N) rrrrrSignal sig_startr sig_succeeded sig_canceled sig_failedsig_donerrrrrsk6 I!FM*--M 6=,,Lz**Jv}Z((HHHrrceZdZdZddfd Zedd Zedd ZeddZddZ ddZ ddZ ddZ xZ S)r a Executor for tasks. :param call: Signature of the function to call with the worker. :param cancel: Optional cancel function. This function might be called to change `function` execution context, so it would be aware that it should be canceled. If it is not provided - `function` execution will still be finished gracefully, but result will contain only information about cancelled function call, unless it will raise an exception. Nrmrcanceltyping.Optional[ACTION]rr4ctt|_||_||_d|_d|_dS)z-Initialize new :class:`~TaskWorker` instance.FN)superr:r_TaskWorker__signals_TaskWorker__call_TaskWorker__cancel_TaskWorker__canceled_TaskWorker__result)r$rmr __class__s rr:zTaskWorker.__init__ sD 4?MM*. ?E %59 rc|jSz8Signature of the function that is executed in this task.)rr#s rrmzTaskWorker.call*r?rrc|jS)z4Collection of signals to track task execution state.)rr#s rsignalszTaskWorker.signals/s ~rtyping.Optional[TaskResult]c|jSzTask execution result.)rr#s rrozTaskWorker.result4rBrc|jtd|jrtdd|_|j|dSdS)!Cancel execution of current task.NzAlready finishedzAlready canceledT)rr_rrr#s rrzTaskWorker.cancel9sZ = $.// / ? 0.// / = $ MMOOOOO % $rctj||jjt } |jrt| }tj }nE#t$r}|}tj }Yd}~n(d}~wt$r}|}tj}Yd}~nd}~wwxYw||jrt}tj }n:#||jrt}tj }wxYwt!|j ||||_tj |jjtj |jjtj|jji||j|jj|jdS)zl Execute task. This method is called internally by the Qt. :meta private: N)rmrnrorp)MANAGERinstance _registerrremitrrrrrrerf Exceptionrgr`r rrrrr)r$rpresponsernr~s rrunzTaskWorker.runEs ""4((( ##%%%,4:: - *'))){{}}H)FF  ) ) ) H(FFFFFF ' ' ' H&FFFFFF ' OO    -,..#, OO    -,..#,,,,,"       $,"<  !:  t|6    $t}%%% ""4=11111sB 5BC> C B C> C-C;C>CC>>7D5cDtj|dS)zLaunch this task.N) THREAD_POOLrrNr#s rrNzTaskWorker.startqs""4(((((r 'TaskThread'cNt|}||S)z)Start a manageable thread with this task.)parent)r rN)r$ros rthreadzTaskWorker.threadus$'t444  rra)rmrrrrr4r)rrrrrr4)rr)rrrrr:rJrmrrorrrNr __classcell__rs@rr r s  :::::::XXX    *2*2*2*2X))))rr cdeZdZdZd fd ZeddZedd Zdd Zdd Z xZ S)r z Wrapper for a :class:`~TaskWorker`, that provides a manageable :class:`~qtpy.QtCore.QThread` interface. Should be initialized from :class:`~TaskWorker` instance via :meth:`~TaskWorker.thread`. rr rr4cVt||_dS)z-Initialize new :class:`~TaskThread` instance.N)rr:_TaskThread__parent)r$rrs rr:zTaskThread.__init__s$ 28 rrc|jjSr)rrmr#s rrmzTaskThread.calls}!!rrc|jjSr)rror#s rrozTaskThread.results}##rc8|jdS)rN)rrr#s rrzTaskThread.cancels rc8|jdS)zr Execute the thread. This method is called internally by the Qt. :meta private: N)rrr#s rrzTaskThread.runs r)rr rr4rrr) rrrrr:rJrmrorrrrs@rr r |s 999999 """X"$$$X$rr ceZdZdZdZ dddZeddZeddZeddZ e j d dZ ed!dZ ed"dZ ed#dZ dS)$r a) Context for task signature. This is used to prepare contexts for both function :class:`~Call` and/or :class:`~TaskWorker`. :param function: Function that should be called. :param args: Initial collection of positional arguments to call function with. :param kwargs: Initial collection of keyword arguments to call function with. :param cancel: Initial value for cancel function, which may be used by :class:`~TaskWorker`. Values of `args`, `kwargs` and `cancel` might be modified by :class:`~TaskModifier` instances. )r+r,r-__cancelNr.r/r0,typing.Optional[typing.Iterable[typing.Any]]r2r3rrrr4c|g}|i}||_t||_t||_||_dS)z.Initialize new :class:`~TaskContext` instance.N)_TaskContext__functionlist_TaskContext__argsdict_TaskContext__kwargs_TaskContext__cancel)r$r.r0r2rs rr:zTaskContext.__init__sD <D >F2:=A$ZZ DHLL 17 rtyping.List[typing.Any]c|jS)zNCollection of positional arguments to call :attr:`~TaskContext.function` with.)rr#s rr0zTaskContext.argsr?rrcDt|j|j|jS)z8New :class:`~Call` signature from the collected context.r.r0r2)rr.r0r2r#s rrmzTaskContext.callsT]4;OOOOrc|jS)z9Function that can cancel function call in a graceful way.rr#s rrzTaskContext.cancelrBrvaluec||_dS)zUpdate `cancel` value.Nr)r$rs rrzTaskContext.cancels rc|jS)z#Function to call from this context.)rr#s rr.zTaskContext.functionr<rtyping.Dict[str, typing.Any]c|jS)zKCollection of keyword arguments to call :attr:`~TaskContext.function` with.)rr#s rr2zTaskContext.kwargsrBrr c8t|j|jS)z4New :class:`~TaskWorker` from the collected context.)rmr)r rmrr#s rworkerzTaskContext.workersty====r)NNN) r.r/r0rr2r3rrrr4)rrr)rr)rrrr4rG)rr)rr )rrrrrIr:rJr0rmrsetterr.r2rrrrr r s2  AI BFGK.2 88888$XPPPXPX ]]XX>>>X>>>rr c8eZdZdZdZejd dZdS) r z Common interface for all :class:`~TaskContext` modifiers. This is used to separate context modifiers from the actual function in :class:`~Task`. rcontextr rr4cdSz9Apply modification to the :class:`~TaskContext` instance.Nrr$rs rapplyzTaskModifier.applyrNrr rr4)rrrrrIabcabstractmethodrrrrr r sM IHHHHHHrr ) metaclasscXeZdZdZdZddd Zedd Zedd ZddZ dS)ra  Insert new positional argument. Places `value` at `target` in :attr:`~TaskContext.args` or :attr:`~TaskContext.kwargs`. :param value: Value of the argument to add. :param target: Index of the positional or Key of the keyword argument to add. )__value__targetrrrCtargettyping.Union[int, str]rr4c"||_||_dS)z1Initialize new :class:`~InsertArgument` instance.N)_InsertArgument__value_InsertArgument__target)r$rrs rr:zInsertArgument.__init__s16 >D rc|jS)z Location for the new argument. Might be :code:`int` index for positional arguments, or :code:`str` key for keyword arguments. )rr#s rrzInsertArgument.targets }rc|jS)zValue of the new argument.)rr#s rrzInsertArgument.valuerXrrr ct|jtr'|j|j|jdS|j|j|j<dSr)rsrintr0insertrr2rs rrzInsertArgument.applysN dk3 ' ' 5 L   TZ 8 8 8 8 8*.*GN4; ' ' 'rN)r)rrCrrrr4)rrrHr) rrrrrIr:rJrrrrrrrrs(IEEEEE XX555555rrc>eZdZdZdZd dZeddZdd Zd S)AddCancelCallbackzg Add new callback to use for canceling a task. :param callback: Callback function to use. ) __callbackcallbackACTIONrr4c||_dS)z4Initialize new :class:`~AddCancelCallback` instance.N_AddCancelCallback__callback)r$rs rr:zAddCancelCallback.__init__%s 08rc|jS)z.Callback function to use for canceling a task.rr#s rrzAddCancelCallback.callback)r<rrr c|j|_dSr)rrrs rrzAddCancelCallback.apply.srN)rrrr4)rrr) rrrrrIr:rJrrrrrrrsm  I9999X''''''rrceZdZdZdZejddZejdd Zd d Zed!d Z ed"dZ d#d$dZ d%dZ d&dZ d'dZdS)(ra Decorator for functions and methods to convert them to tasks. After decoration - functions and methods might still be called usual way. :meth:`~Task.worker` might be used to create a worker for a task. :param args: :class:`~TaskModifier` instances to modify a :class:`~TaskContext` before execution. .. note:: Decorator can be called in both :code:`@Task` and :code:`@Task(...)` ways. Both will work. )r+ __modifiersr0r rr4cdS'Initialize new :class:`~Task` instance.Nr)r$r0s rr:z Task.__init__Hrrr.r/cdSrr)r$r.r0s rr:z Task.__init__Lrr$typing.Union[FUNCTION, TaskModifier]cd}g}|D]@}t|tr||-||}2td||_t ||_dS)rNz=Task arguments must be TaskModifiers and at most one function)rsr appendr__Task__functiontuple_Task__modifiers)r$r0r. modifiersargs rr:z Task.__init__Ps.2/1  a aC#|,, a  %%%%! _```5=JOPYJZJZrc<|jtd|jS)z$Function that is used for this task.Nzfunction was not wrapped yet)rAttributeErrorr#s rr.z Task.functionas# ? " !?@@ @rtyping.Tuple[TaskModifier, ...]c|jS)z4Collection of modifiers for a :class:`~TaskContext`.)rr#s rrzTask.modifiershs rNrr2r3r ctt|j||}|jD]}|||S)z:Prepare a context for execution or converting into a task.rr)r r.rr)r$r0r2romodifiers r __contextzTask.__contextmsI-8UYbh,i,i,i + +H NN6N * * * * rrCc|j3t|dks|rtd|d|_|S|||S)z Execute a function in a usual way. .. note:: This method might be also called when the decorator is called in a :code:`@Task(...)` way to finalize function/method wrapping. Nrz9function must be the only provided argument for wrapping.rr0r2)rlenr__Task__contextrmr$r0r2s rrEz Task.__call__ys` ? "D Q6 [\\\"1gDOK~~4~77<<>>>rrowner'Task'cV||St|jg|jt|RS)zCPrepare a bound task for a methods called for a specific instances.)rr.rr)r$rr s r__get__z Task.__get__s4  KDMMDNMN84L4LMMMMrr c:|||jS)z$Prepare worker to execute this task.r)r rr s rrz Task.workers~~4~77>>r)r0r rr4)r.r/r0r rr4)r0rrr4rG)rrrF)r0rr2r3rr )r0rCr2rCrrC)rrCr rCrr )r0rCr2rCrr )rrrrrItypingoverloadr:rJr.rr rErrrrrrr8s"  .I _666_6 _666_6[[[["X    X BFGK     ????"NNNN ??????rrc"eZdZdZejZejeZejeZ ejeZ ejeZ ejeZ dfd Z ddZddZdd Zdd Zdd Zdd Zdd ZddZxZS) TaskManagerz$Central manager for executing tasks.rr4c|td|_t|_dS)z.Initialize new :class:`~TaskManager` instance.FN)rr:_TaskManager__cancelset_TaskManager__workers)r$rs rr:zTaskManager.__init__s/ # ?Buurrr c|j||jrEtjt 5|dddn #1swxYwY|j|dS)zProcess start of a worker.N) raddr contextlibsuppressr_rrrr$rs rrLzTaskManager.__starts 6""" = $Y//                   F#####sAA #A cP||jvrdS|j|dS)zProcess success of a worker.N)rrrrs r __succeededzTaskManager.__succeededs1  ' ' F '''''rcP||jvrdS|j|dS)zProcess cancel of a worker.N)rrrrs r __canceledzTaskManager.__canceleds1  ' ' F v&&&&&rcP||jvrdS|j|dS)zProcess fail of a worker.N)rrrrs r__failedzTaskManager.__faileds0  ' ' F V$$$$$rc |j|n#t$rYdSwxYw|j||js|jdSdS)z"Process worker finished execution.N)rremove LookupErrorrr sig_emptyrs r__donezTaskManager.__dones  N ! !& ) ) ) )    FF  6"""~ " N   ! ! ! ! ! " "s  ++cbjvrdSjjfdjjfdjjfdjjfddS)z-Register worker when it starts its execution.Nc.Sra)_TaskManager__succeeded_r$rs rz'TaskManager._register..st7G7G7O7Orc.Sra)_TaskManager__canceledr,s rr.z'TaskManager._register..sdoof6M6Mrc.Sra)_TaskManager__failedr,s rr.z'TaskManager._register..sDMM&4I4Irc.Sra)_TaskManager__doner,s rr.z'TaskManager._register..s$++f2E2Er)r_TaskManager__startrrconnectrrrrs``rrzTaskManager._registers T^ # # F V$,,-O-O-O-O-OPPP#++,M,M,M,M,MNNN!))*I*I*I*I*IJJJ''(E(E(E(E(EFFFFFrc d|_t|j}|s|jdS|D]G}t jt5|dddn #1swxYwYHdS)z&Cancel all running and future workers.TN) rrrr'rrrr_r)r$workersrs r cancel_allzTaskManager.cancel_alls /3DN/C/C  N   ! ! ! F  F$Y//                    sA77A; >A; cd|_dS)z Reset task processing. This might be useful to allow executing new tasks after calling :meth:`~TaskManager.cancel_all`. FN)rr#s rresetzTaskManager.resets  rr)rr rr4)rrrrrrr'r rrrrrr:r5r+r0r2r4rr9r;rrs@rrrsO.. I j))I!FM*--M 6=,,Lz**Jv}Z((HEEEEEE$$$$((((''''%%%% " " " " G G G G     rrcHeZdZdZdZd ddZedd Zdd Zdd Z d S)rz` Simplistic context with a canceled flag. :param canceled: Initial canceled state. )r!Fcanceledboolrr4c||_dS)z0Initialize new :class:`~CancelContext` instance.N_CancelContext__canceled)r$r=s rr:zCancelContext.__init__s (rc|jS)zTask was canceled.r@r#s rr=zCancelContext.canceledr<rc0|jrtdS)z-Break execution of a task if it was canceled.N)rArr#s rabort_if_canceledzCancelContext.abort_if_canceleds" ? &#%% % & &rcd|_dS)zCancel task execution.TNr@r#s rrzCancelContext.cancel s rN)F)r=r>rr4)rr>r) rrrrrIr:rJr=rDrrrrrrs  I)))))X&&&& rrc@eZdZdZdZd ddZedd Zdd Zd S)ra Add new :class:`~CancelContext` to the :class:`~TaskContext`. This adds new :class:`~CancelContext` instance to the function kwargs and modifies :attr:`~TaskContext.cancel` to use the context. :param argument: Name of the keyword argument to add context to. .. warning:: Context will be provided if only it was not provided before (with a regular keyword argument). Otherwise - it will reuse provided value. ) __argumentrargumentr rr4c||_dS)z3Initialize new :class:`~AddCancelContext` instance.N_AddCancelContext__argument)r$rHs rr:zAddCancelContext.__init__"s -5rc|jS)z4Name of the argument to which context will be added.rJr#s rrHzAddCancelContext.argument&r<rr c|j|jvrt|j|j<|j|jj|_dSr)rHr2rrrs rrzAddCancelContext.apply+s: = . .,9OOGN4= )  6=rNr)rHr rr4r&r) rrrrrIr:rJrHrrrrrrsr   I66666X>>>>>>rrc&eZdZdZdZd dZd dZdS) ThreadPoolSingletonz:Singleton instance of a :class:`~qtpy.QtCore.QThreadPool`.rrQtCore.QThreadPoolc(tjS)zInitialize singleton instance.)r QThreadPoolr#s r_preparezThreadPoolSingleton._prepare7s!###rr4cj|j|jdS)zCDestroy singleton instance when :meth:`~Singleton.reset` is called.N)rclear waitForDoner#s r_releasezThreadPoolSingleton._release;s0  !!#####rN)rrPr)rrrrrIrSrWrrrrOrO2sGDDI$$$$$$$$$$rrOz/typing.Final[singletons.Singleton[TaskManager]]rz6typing.Final[singletons.Singleton[QtCore.QThreadPool]]rrr4cttjtdS)zFinish all background workers.N)rrr9rr;rrrteardownrYEs/ !!!rr)1r __future__r__all__rrrRrcrqtpyrrCallableAnyrr/rrrrrrEnumrr QObjectr QRunnabler QThreadr r ABCMetar rrrrrr SingletonrRrOSingleInstanceOfr__annotations__rrYrrrrhsuHGG""""""       VZ ( ?3 ? +((((( (((99999 99922222i222,>,>,>,>,>,>,>,>^::::::::zHHHHHHHHV")")")")")&.")")")Jggggg!gggT""""""""JC>C>C>C>C>C>C>C>L H H H H HS[ H H H H$5$5$5$5$5\$5$5$5N''''' '''8Z?Z?Z?Z?Z?Z?Z?Z?z\\\\\&.\\\~8>>>>>|>>>D $ $ $ $ $*.v/AB $ $ $