s ed UdZddlmZgdZddlZddlZddlZddlZddlZddl m Z ddl m Z ej gejfZej dejfZGd d eZGd d ZGd dZGddejZGddZGdde jZGdde jZGdde jZGddZGddejZ Gdde 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*d*e+d+<e(Z,d,e+d-<dS).zAIntegration with worker framework to make API calls asynchronous.) annotations) TaskCanceledErrorCallDuration TaskStatus TaskResult TaskWorker TaskThread TaskContext TaskModifierInsertArgumentTask CancelContextAddCancelContextN)QtCore) singletons.ceZdZdZddZdS)rz&Task was canceled during its workflow.returnstrcdS)z.Prepare string representation of the instance.z'Task was cancelled during its executionselfs ?lib/python3.11/site-packages/navigator_updater/utils/workers.py__str__zTaskCanceledError.__str__s88Nrr)__name__ __module__ __qualname____doc__rrrrrrs.00999999rrcteZdZdZdZ 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)rr'r)r+s r__init__z Call.__init__-s1 <D >F2:AE GM rc|jS)zFunction to call.)r0rs rr'z Call.function= rtyping.Sequence[typing.Any]c|jS)z-Positional arguments to call `function` with.)r1rs rr)z Call.argsB {rtyping.Mapping[str, typing.Any]c|jS)z*Keyword arguments to call `function` with.)r2rs rr+z Call.kwargsG }r typing.Anyc0|j|ji|jS)zCExecute stored function with both positional and keyword arguments.r/rs r__call__z Call.__call__Lst =t}===rNN)r'r(r)r*r+r,rr-rr()rr6)rr9rr<) rr r!r" __slots__r3propertyr'r)r+r>rrrrr"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]stoprr-cb|tj}||_||_dS)z+Initialize new :class:`~Duration` instance.N)datetimenow_Duration__start_Duration__stop)rrGrIs rr3zDuration.__init__`s/ =%))++E8= :> rdatetime.datetimec|jS)zStart of the tracked time span.)rMrs rrGzDuration.startl |rc|jS)zStop of the tracked time span.)rNrs rrIz Duration.stopqr8rtyping.Optional[float]cV|jdS|j|jz S)z*Total number of seconds in this time span.N)rNrM total_secondsrs rtotalzDuration.totalvs, ; 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)rN TypeErrorrKrL)rrIs rfinishzDuration.finish}s? ; "899 9 <$((**D rr?)rGrHrIrHrr-)rrO)rrH)rrSN)rIrHrr-) rr r!r"rBr3rCrGrIrVrYrrrrrQs  &I9=7; ? ? ? ? ?XX<<<X< rrcleZdZdZejZejZejZdS)rz0Possible states of the :class:`~Task` execution.N) rr r!r"enumauto SUCCEEDEDCANCELEDFAILEDrrrrrs;:: Ity{{H TY[[FFFrrceZdZdZdZ dddZeddZeddZeddZ eddZ eddZ dS)ra 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 __durationNcallrstatusrresultr<durationtyping.Optional[Duration]rr-cz|"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) rrYrr_r isinstancerXr` BaseException_TaskResult__call_TaskResult__status_TaskResult__result_TaskResult__duration)rrfrgrhris rr3zTaskResult.__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.)rnrs rrfzTaskResult.callr8rrc|jS)zTask execution duration.)rqrs rrizTaskResult.durationr5rtyping.Optional[BaseException]c>|jtjkrdS|jS)z+Exception, that was raised by the function.Nrorr^rprs 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. rvrs rrhzTaskResult.results$ =J0 0 0= mrc|jS)z!Resulted status of the execution.)rors rrgzTaskResult.statusr;rr?) rfrrgrrhr<rirjrr-rr)rr)rrtrA)rr) rr r!r"rBr3rCrfrirwrhrgrrrrrs  AI "&26 ;;;;;2XXX XXrrceZdZdZejZejeZejeZ ejeZ ejeZ dS) TaskSignalsa Collection of signals for :class:`~TaskWorker`. .. py:attribute:: sig_start Task started it's execution. .. py:attribute:: sig_succeeded Task finished its execution successfully. .. py:attribute:: sig_canceled Task was canceled during it's 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) rr r!r"rSignal sig_startr sig_succeeded sig_canceled sig_failedsig_donerrrr|r|sk6 I!FM*--M 6=,,Lz**Jv}Z((HHHrr|ceZdZdZddfd 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. Nrfrcanceltyping.Optional[ACTION]rr-ctt|_||_||_d|_d|_dS)z-Initialize new :class:`~TaskWorker` instance.FN)superr3r|_TaskWorker__signals_TaskWorker__call_TaskWorker__cancel_TaskWorker__canceled_TaskWorker__result)rrfr __class__s rr3zTaskWorker.__init__sD 4?MM*. ?E %59 rc|jSz8Signature of the function that is executed in this task.)rrs rrfzTaskWorker.callr8rr|c|jS)z4Collection of signals to track task execution state.)rrs rsignalszTaskWorker.signals#s ~rtyping.Optional[TaskResult]c|jSzTask execution result.)rrs rrhzTaskWorker.result(r;rc|jtd|jrtdd|_|j|dSdS)!Cancel execution of current task.NzAlready finishedzAlready canceledT)rrXrrrs rrzTaskWorker.cancel-sZ = $.// / ? 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)rfrgrhri)MANAGERinstance _registerrr~emitrrrrrr^r_ Exceptionr`rYrrrrrr)rriresponsergrws rrunzTaskWorker.run9s ""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_POOLrrGrs rrGzTaskWorker.startes""4(((((r 'TaskThread'cNt|}||S)z)Start a manageable thread with this task.)parent)r rG)rrhs rthreadzTaskWorker.threadis$'t444  rrZ)rfrrrrr-rz)rr|rrrr-)rr)rr r!r"r3rCrfrrhrrrGr __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 rr-cVt||_dS)z-Initialize new :class:`~TaskThread` instance.N)rr3_TaskThread__parent)rrrs rr3zTaskThread.__init__ws$ 28 rrc|jjSr)rrfrs rrfzTaskThread.call|s}!!rrc|jjSr)rrhrs rrhzTaskThread.results}##rc8|jdS)rN)rrrs rrzTaskThread.cancels rc8|jdS)zr Execute the thread. This method is called internally by the Qt. :meta private: N)rrrs rrzTaskThread.runs r)rr rr-rzrr) rr r!r"r3rCrfrhrrrrs@rr r ps 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(r),typing.Optional[typing.Iterable[typing.Any]]r+r,rrrr-c|g}|i}||_t||_t||_||_dS)z.Initialize new :class:`~TaskContext` instance.N)_TaskContext__functionlist_TaskContext__argsdict_TaskContext__kwargs_TaskContext__cancel)rr'r)r+rs rr3zTaskContext.__init__sD <D >F2:=A$ZZ DHLL 17 rtyping.List[typing.Any]c|jS)zNCollection of positional arguments to call :attr:`~TaskContext.function` with.)rrs rr)zTaskContext.argsr8rrcDt|j|j|jS)z8New :class:`~Call` signature from the collected context.r'r)r+)rr'r)r+rs rrfzTaskContext.callsT]4;OOOOrc|jS)z9Function that can cancel function call in a graceful way.rrs rrzTaskContext.cancelr;rvaluec||_dS)zUpdate `cancel` value.Nr)rrs rrzTaskContext.cancels rc|jS)z#Function to call from this context.)rrs rr'zTaskContext.functionr5rtyping.Dict[str, typing.Any]c|jS)zKCollection of keyword arguments to call :attr:`~TaskContext.function` with.)rrs rr+zTaskContext.kwargsr;rr c8t|j|jS)z4New :class:`~TaskWorker` from the collected context.)rfr)r rfrrs rworkerzTaskContext.workersty====r)NNN) r'r(r)rr+r,rrrr-)rrrz)rr)rrrr-r@)rr)rr )rr r!r"rBr3rCr)rfrsetterr'r+rrrrr 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 rr-cdSz9Apply modification to the :class:`~TaskContext` instance.Nrrrs rapplyzTaskModifier.applysrNrr rr-)rr r!r"rBabcabstractmethodrrrrr r sM IHHHHHHrr ) metaclasscXeZdZdZdZddd Zedd Zedd ZddZ dS)r a  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__targetrrr<targettyping.Union[int, str]rr-c"||_||_dS)z1Initialize new :class:`~InsertArgument` instance.N)_InsertArgument__value_InsertArgument__target)rrrs rr3zInsertArgument.__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. )rrs rrzInsertArgument.targets }rc|jS)zValue of the new argument.)rrs rrzInsertArgument.valuerQrrr ct|jtr'|j|j|jdS|j|j|j<dSr)rlrintr)insertrr+rs rrzInsertArgument.applysN dk3 ' ' 5 L   TZ 8 8 8 8 8*.*GN4; ' ' 'rN)r)rr<rrrr-)rrrAr) rr r!r"rBr3rCrrrrrrr r s(IEEEEE XX555555rr cteZdZdZdZddZedd Zedd Z dddZ ddZ d dZ d!dZ d S)"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$ __modifiersr)$typing.Union[FUNCTION, TaskModifier]rr-cd}g}|D]@}t|tr||-||}2td||_t ||_dS)z'Initialize new :class:`~Task` instance.Nz=Task arguments must be TaskModifiers and at most one function)rlr appendrX_Task__functiontuple_Task__modifiers)rr)r' modifiersargs rr3z Task.__init__%s.2/1  a aC#|,, a  %%%%! _```5=JOPYJZJZrr(c<|jtd|jS)z$Function that is used for this task.Nzfunction was not wrapped yet)rAttributeErrorrs rr'z Task.function6s# ? " !?@@ @rtyping.Tuple[TaskModifier, ...]c|jS)z4Collection of modifiers for a :class:`~TaskContext`.)rrs rrzTask.modifiers=s rNrr+r,r ctt|j||}|jD]}|||S)z:Prepare a context for execution or converting into a task.rr)r r'rr)rr)r+rhmodifiers r __contextzTask.__contextBsI-8UYbh,i,i,i + +H NN6N * * * * rr<c|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.rr)r+)rlenrX_Task__contextrfrr)r+s rr>z Task.__call__Ns` ? "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 )rrrs r__get__z Task.__get___s4  KDMMDNMN84L4LMMMMrr c:|||jS)z$Prepare worker to execute this task.r)rrrs rrz Task.workeres~~4~77>>r)r)rrr-r@)rrr?)r)rr+r,rr )r)r<r+r<rr<)rr<rr<rr)r)r<r+r<rr ) rr r!r"rBr3rCr'rrr>rrrrrrrs  .I[[[["X    X BFGK     ????"NNNN ??????rrc"eZdZdZejZejeZejeZ ejeZ ejeZ ejeZ dfd Z ddZddZdd Zdd Zdd Zdd Zdd ZddZxZS) TaskManagerz$Central manager for executing tasks.rr-c|td|_t|_dS)z.Initialize new :class:`~TaskManager` instance.FN)rr3_TaskManager__cancelset_TaskManager__workers)rrs rr3zTaskManager.__init__us/ # ?Buurrr c|j||jrEtjt 5|dddn #1swxYwY|j|dS)zProcess start of a worker.N) raddr contextlibsuppressrXrr~rrrs rrEzTaskManager.__start|s 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.SrZ)_TaskManager__succeeded_rrs rz'TaskManager._register..st7G7G7O7Orc.SrZ)_TaskManager__canceledrs rrz'TaskManager._register..sdoof6M6Mrc.SrZ)_TaskManager__failedrs rrz'TaskManager._register..sDMM&4I4Irc.SrZ)_TaskManager__doners rrz'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) rrrrrrrrXr)rworkersrs 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)rrs rresetzTaskManager.resets  rr)rr rr-)rr r!r"rr}rr r~rrrrr3rrrrrrr!r#rrs@rrrjsO.. 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 Fcanceledboolrr-c||_dS)z0Initialize new :class:`~CancelContext` instance.N_CancelContext__canceled)rr%s rr3zCancelContext.__init__s (rc|jS)zTask was canceled.r(rs rr%zCancelContext.canceledr5rc0|jrtdS)z-Break execution of a task if it was canceled.N)r)rrs rabort_if_canceledzCancelContext.abort_if_canceleds" ? &#%% % & &rcd|_dS)zCancel task execution.TNr(rs rrzCancelContext.cancels rN)F)r%r&rr-)rr&r) rr r!r"rBr3rCr%r,rrrrrrs  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. ) __argumentrargumentrrr-c||_dS)z3Initialize new :class:`~AddCancelContext` instance.N_AddCancelContext__argument)rr0s rr3zAddCancelContext.__init__s -5rc|jS)z4Name of the argument to which context will be added.r2rs rr0zAddCancelContext.argumentr5rr c|j|jvrt|j|j<|j|jj|_dSr)r0r+rrrs rrzAddCancelContext.applys: = . .,9OOGN4= )  6=rNr)r0rrr-rr) rr r!r"rBr3rCr0rrrrrrsr   I66666X>>>>>>rrc&eZdZdZdZd dZd dZdS) ThreadPoolSingletonz:Singleton instance of a :class:`~qtpy.QtCore.QThreadPool`.rrQtCore.QThreadPoolc(tjS)zInitialize singleton instance.)r QThreadPoolrs r_preparezThreadPoolSingleton._prepare s!###rr-cj|j|jdS)zCDestroy singleton instance when :meth:`~Singleton.reset` is called.N)rclear waitForDoners r_releasezThreadPoolSingleton._releases0  !!#####rN)rr8r)rr r!r"rBr;r?rrrr7r7sGDDI$$$$$$$$$$rr7z/typing.Final[singletons.Singleton[TaskManager]]rz6typing.Final[singletons.Singleton[QtCore.QThreadPool]]r)-r" __future__r__all__rrrKr\typingqtpyrrCallableAnyACTIONr(rrrrEnumrrQObjectr| QRunnabler QThreadr r ABCMetar r rrrr Singletonr:r7SingleInstanceOfr__annotations__rrrrrPsHGG""""""       VZ ( ?3 ? +99999 999,>,>,>,>,>,>,>,>^::::::::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$5XR?R?R?R?R?R?R?R?j\\\\\&.\\\~8>>>>>|>>>D $ $ $ $ $*.v/AB $ $ $