HEX
Server: Apache/2.4.52 (Ubuntu)
System: Linux spn-python 5.15.0-89-generic #99-Ubuntu SMP Mon Oct 30 20:42:41 UTC 2023 x86_64
User: arjun (1000)
PHP: 8.1.2-1ubuntu2.20
Disabled: NONE
$ pwd: /lib/python3/dist-packages/twisted/internet/__pycache__/
Upload Files
File: //lib/python3/dist-packages/twisted/internet/__pycache__/task.cpython-38.pyc
U

�bH��	@sldZddlZddlZddlZddlmZmZmZmZm	Z	m
Z
mZmZm
Z
mZmZddlmZddlmZddlmZddlmZmZmZddlmZdd	lmZmZmZdd
l m!Z!m"Z"ddl#m$Z$ddl%m&Z&e
d
�Z'Gdd�d�Z(Gdd�de)�Z*Gdd�de*�Z+Gdd�de*�Z,Gdd�de,�Z-Gdd�de,�Z.Gdd�de,�Z/Gdd�de*�Z0Gdd�d�Z1d Z2egdfed!�d"d#�Z3e
d$�Z4Gd%d&�d&�Z5Gd'd(�d(�Z6e6�Z7ee'eee'd)�d*d+�Z8ee'e5d)�d,d-�Z9ee�Gd.d/�d/��Z:d9ee;eed0e'fe<e<ee'd1�d2d3�Z=d:ed0eee'ed5e<e'fffee'eee
d6�d7d8�Z>dd/dd(d+d3d8gZ?dS);z)
Scheduling utility methods and classes.
�N)�Callable�	Coroutine�Iterable�Iterator�List�NoReturn�Optional�Sequence�TypeVar�Union�cast)�implementer)�Version)�DelayedCall)�Deferred�ensureDeferred�
maybeDeferred)�ReactorNotRunning)�IDelayedCall�IReactorCore�IReactorTime)�log�reflect)�_getDeprecationWarningString)�Failure�_Tc@s2eZdZUdZdZeeed<dZdZ	ee
ded<dZeeed<dZ
dZeeed<dZeeed<ed	efeedd
�dd�Zeee
dd
�dd��Zeeegefdd�dd��Zeed�dd�Zd%eee
dd�dd�Zdd
�dd�Zdd
�dd�Zdd
�dd�Zedd �d!d"�Zed
�d#d$�Z dS)&�LoopingCalla�Call a function repeatedly.

    If C{f} returns a deferred, rescheduling will not take place until the
    deferred has fired. The result value is ignored.

    @ivar f: The function to call.
    @ivar a: A tuple of arguments to pass the function.
    @ivar kw: A dictionary of keyword arguments to pass to the function.
    @ivar clock: A provider of
        L{twisted.internet.interfaces.IReactorTime}.  The default is
        L{twisted.internet.reactor}. Feel free to set this to
        something else, but it probably ought to be set *before*
        calling L{start}.

    @ivar running: A flag which is C{True} while C{f} is scheduled to be called
        (or is currently being called). It is set to C{True} when L{start} is
        called and set to C{False} when L{stop} is called or if C{f} raises an
        exception. In either case, it will be C{False} by the time the
        C{Deferred} returned by L{start} fires its callback or errback.

    @ivar _realLastTime: When counting skips, the time at which the skip
        counter was last invoked.

    @ivar _runAtStart: A flag indicating whether the 'now' argument was passed
        to L{LoopingCall.start}.
    N�callF�	_deferred�interval�	starttime�
_realLastTime.)�f�a�kw�returncOs.||_||_||_ddlm}tt|�|_dS�Nr��reactor)r"r#r$�twisted.internetr(rr�clock)�selfr"r#r$r(�r,�7/usr/lib/python3/dist-packages/twisted/internet/task.py�__init__Ns
zLoopingCall.__init__�r%cCs.tdtdddd�dd�}tj|tdd�|jS)	z�
        DEPRECATED. L{Deferred} fired when loop stops or fails.

        Use the L{Deferred} returned by L{LoopingCall.start}.
        z*twisted.internet.task.LoopingCall.deferred�Twisted�rz the deferred returned by start())�replacement�)�
stacklevel)rr�warnings�warn�DeprecationWarningr)r+�
warningStringr,r,r-�deferredVs�zLoopingCall.deferred)�
countCallabler%cs td���fdd�}||���S)a�
        An alternate constructor for L{LoopingCall} that makes available the
        number of calls which should have occurred since it was last invoked.

        Note that this number is an C{int} value; It represents the discrete
        number of calls that should have been made.  For example, if you are
        using a looping call to display an animation with discrete frames, this
        number would be the number of frames to advance.

        The count is normally 1, but can be higher. For example, if the reactor
        is blocked and takes too long to invoke the L{LoopingCall}, a Deferred
        returned from a previous call is not fired before an interval has
        elapsed, or if the callable itself blocks for longer than an interval,
        preventing I{itself} from being called.

        When running with an interval of 0, count will be always 1.

        @param countCallable: A callable that will be invoked each time the
            resulting LoopingCall is run, with an integer specifying the number
            of calls that should have been invoked.

        @return: An instance of L{LoopingCall} with call counting enabled,
            which provides the count as the first positional argument.

        @since: 9.0
        r/cs��j��}�jdkr"|�_�d�S�j}|dkrj�jdk	sBtd���j}�jrj�jdk	s`td��|�j8}��|�}��|�}||}|dkr�|�_�|�SdS)Nr�z(LoopingCall called before it was startedz&Looping call called with None interval)r*�secondsrr!r �AssertionError�_runAtStart�_intervalOf)�nowZlastTimeZlastIntervalZthisInterval�count�r:r+r,r-�counter�s0

����


z&LoopingCall.withCount.<locals>.counter)�object)�clsr:rCr,rBr-�	withCountfszLoopingCall.withCount)�tr%cCs8|jdk	st�|jdk	st�||j}t||j�}|S)aD
        Determine the number of intervals passed as of the given point in
        time.

        @param t: The specified time (from the start of the L{LoopingCall}) to
            be measured in intervals

        @return: The C{int} number of intervals which have passed as of the
            given point in time.
        N)r r=r�int)r+rGZelapsedTimeZintervalNumr,r,r-r?�s

zLoopingCall._intervalOfT)rr@r%cCsd|jrtd��|dkrtd��d|_t�}|_|j��|_||_||_	|rT|�n|�
|j�|S)a�
        Start running function every interval seconds.

        @param interval: The number of seconds between calls.  May be
        less than one.  Precision will depend on the underlying
        platform, the available hardware, and the load on the system.

        @param now: If True, run this call right now.  Otherwise, wait
        until the interval has elapsed before beginning.

        @return: A Deferred whose callback will be invoked with
        C{self} when C{self.stop} is called, or whose errback will be
        invoked when the function raises an exception or returned a
        deferred that has its errback invoked.
        z.Tried to start an already running LoopingCall.rzinterval must be >= 0T)�runningr=�
ValueErrorrrr*r<r rr>�
_scheduleFrom)r+rr@r9r,r,r-�start�szLoopingCall.startcCsV|jstd��d|_|jdk	rR|j��d|_|jd}|_|dk	sHt�|�|�dS)zStop running function.z1Tried to stop a LoopingCall that was not running.FN)rIr=r�cancelr�callback�r+�dr,r,r-�stop�s

zLoopingCall.stopcCsD|jstd��|jdk	r@|j��d|_|j��|_|�|j�dS)zT
        Skip the next iteration and reset the timer.

        @since: 11.1
        z2Tried to reset a LoopingCall that was not running.N)rIr=rrMr*r<r rK�r+r,r,r-�reset�s

zLoopingCall.resetcs\tdd��fdd�}tdd��fdd�}d�_t�jf�j��j�}|�|�|�|�dS)N��resultr%cs@�jr���j���n$�jd}�_|dk	s2t�|���dS�N)rIrKr*r<rr=rN)rUrPrRr,r-�cb�s
z LoopingCall.__call__.<locals>.cb��failurer%cs.d�_�jd}�_|dk	s t�|�|�dS)NF)rIrr=�errback)rYrPrRr,r-�eb�sz LoopingCall.__call__.<locals>.eb)	rDrrrr"r#r$�addCallback�
addErrback)r+rWr[rPr,rRr-�__call__�s
zLoopingCall.__call__)�whenr%cs*td���fdd�}�j�|����_dS)z�
        Schedule the next iteration of this looping call.

        @param when: The present time from whence the call is scheduled.
        r/csZ�jdkrdS�jdk	st���j}�jdk	s4t��j|�j}��|krV�jS|S)Nr)rr r=)Z
runningForZuntilNextInterval�r+r_r,r-�howLongs

z*LoopingCall._scheduleFrom.<locals>.howLongN)�floatr*�	callLaterr)r+r_rar,r`r-rK�szLoopingCall._scheduleFromcCs�t|jdd�}|dkrPt|jdd�}|dk	rPt|jdd�}|dk	rP|�d|��}|dkrdt�|j�}d�|j|t�|j�t�|j��S)N�__qualname__�__name__�im_class�.z LoopingCall<{!r}>({}, *{}, **{}))�getattrr"r�	safe_repr�formatrr#r$)r+�func�imClassr,r,r-�__repr__%s

�zLoopingCall.__repr__)T)!re�
__module__rd�__doc__rrr�__annotations__rIrrrrbr>r r!rrDr.�propertyr9�classmethodrHrFr?�boolrLrQrSr^rK�strrmr,r,r,r-r*s(
; 
&rc@seZdZdZdS)�SchedulerErrorz�
    The operation could not be completed because the scheduler or one of its
    tasks was in an invalid state.  This exception should not be raised
    directly, but is a superclass of various scheduler-state-related
    exceptions.
    N�rernrdror,r,r,r-ru:sruc@seZdZdZdS)�SchedulerStoppedzt
    The operation could not complete because the scheduler was stopped in
    progress or was already stopped.
    Nrvr,r,r,r-rwCsrwc@seZdZdZdS)�TaskFinishedz�
    The operation could not complete because the task was already completed,
    stopped, encountered an error or otherwise permanently stopped running.
    Nrvr,r,r,r-rxJsrxc@seZdZdZdS)�TaskDonezR
    The operation could not complete because the task was already completed.
    Nrvr,r,r,r-ryQsryc@seZdZdZdS)�TaskStoppedzH
    The operation could not complete because the task was stopped.
    Nrvr,r,r,r-rzWsrzc@seZdZdZdS)�
TaskFailedz]
    The operation could not complete because the task died with an unhandled
    error.
    Nrvr,r,r,r-r{]sr{c@seZdZdZdS)�	NotPausedz^
    This exception is raised when a task is resumed which was not previously
    paused.
    Nrvr,r,r,r-r|dsr|c@s,eZdZdZdd�dd�Zed�dd�ZdS)�_Timerg{�G�z�?Nr/cCst��|j|_dSrV)�time�	MAX_SLICE�endrRr,r,r-r.nsz_Timer.__init__cCst��|jkSrV)r~r�rRr,r,r-r^qsz_Timer.__call__)rernrdrr.rsr^r,r,r,r-r}ksr}g:�0�yE>)�callabler%cCsddlm}tt|��t|�Sr&)r)r(rrrc�_EPSILON)r�r(r,r,r-�_defaultSchedulerxsr��_TaskResultTc@s�eZdZdZeeddd�dd�Zeeed�dd	�Zdd�d
d�Z	dd�dd
�Z
eeeee
fdd�dd�Zdd�dd�Zdd�dd�Zdd�dd�ZdS)�CooperativeTaskaU
    A L{CooperativeTask} is a task object inside a L{Cooperator}, which can be
    paused, resumed, and stopped.  It can also have its completion (or
    termination) monitored.

    @see: L{Cooperator.cooperate}

    @ivar _iterator: the iterator to iterate when this L{CooperativeTask} is
        asked to do work.

    @ivar _cooperator: the L{Cooperator} that this L{CooperativeTask}
        participates in, which is used to re-insert it upon resume.

    @ivar _deferreds: the list of L{Deferred}s to fire when this task
        completes, fails, or finishes.

    @ivar _pauseCount: the number of times that this L{CooperativeTask} has
        been paused; if 0, it is running.

    @ivar _completionState: The completion-state of this L{CooperativeTask}.
        L{None} if the task is not yet completed, an instance of L{TaskStopped}
        if C{stop} was called to stop this task early, of L{TaskFailed} if the
        application code in the iterator raised an exception which caused it to
        terminate, and of L{TaskDone} if it terminated normally via raising
        C{StopIteration}.
    �
CooperatorN)�iterator�
cooperatorr%cCs2||_||_g|_d|_d|_d|_|�|�dS)zq
        A private constructor: to create a new L{CooperativeTask}, see
        L{Cooperator.cooperate}.
        rN)�	_iterator�_cooperator�
_deferreds�_pauseCount�_completionState�_completionResult�_addTask)r+r�r�r,r,r-r.�szCooperativeTask.__init__r/cCs<t�}|jdkr|j�|�n|jdk	s,t�|�|j�|S)a�
        Get a L{Deferred} notification of when this task is complete.

        @return: a L{Deferred} that fires with the C{iterator} that this
            L{CooperativeTask} was created with when the iterator has been
            exhausted (i.e. its C{next} method has raised C{StopIteration}), or
            fails with the exception raised by C{next} if it raises some other
            exception.

        @rtype: L{Deferred}
        N)rr�r��appendr�r=rNrOr,r,r-�whenDone�s
zCooperativeTask.whenDonecCs0|��|jd7_|jdkr,|j�|�dS)a@
        Pause this L{CooperativeTask}.  Stop doing work until
        L{CooperativeTask.resume} is called.  If C{pause} is called more than
        once, C{resume} must be called an equal number of times to resume this
        task.

        @raise TaskFinished: if this task has already finished or completed.
        r;N)�_checkFinishr�r��_removeTaskrRr,r,r-�pause�s	
zCooperativeTask.pausecCsB|jdkrt��|jd8_|jdkr>|jdkr>|j�|�dS)z�
        Resume processing of a paused L{CooperativeTask}.

        @raise NotPaused: if this L{CooperativeTask} is not paused.
        rr;N)r�r|r�r�r�rRr,r,r-�resume�s

zCooperativeTask.resume)�completionState�deferredResultr%cCs8||_||_|js|j�|�|jD]}|�|�q$dS)a
        @param completionState: a L{SchedulerError} exception or a subclass
            thereof, indicating what exception should be raised when subsequent
            operations are performed.

        @param deferredResult: the result to fire all the deferreds with.
        N)r�r�r�r�r�r�rN)r+r�r�rPr,r,r-�
_completeWith�s	
zCooperativeTask._completeWithcCs |��|�t�tt���dS)z�
        Stop further processing of this task.

        @raise TaskFinished: if this L{CooperativeTask} has previously
            completed, via C{stop}, completion, or failure.
        N)r�r�rzrrRr,r,r-rQ�szCooperativeTask.stopcCs|jdk	r|j�dS)zk
        If this task has been stopped, raise the appropriate subclass of
        L{TaskFinished}.
        N)r�rRr,r,r-r��s
zCooperativeTask._checkFinishcs�zt�j�}WnFtk
r2��t��j�Yn^tk
rT��t�t��Yn<Xt|t	�r���
�tdd��fdd�}|��fdd�|�dS)z�
        Perform one unit of work for this task, retrieving one item from its
        iterator, stopping if there are no further items in the iterator, and
        pausing if the result was a L{Deferred}.
        NrXcs��t�|�dSrV)r�r{)rYrRr,r-�	failLatersz/CooperativeTask._oneWorkUnit.<locals>.failLatercs���SrV)r��rUrRr,r-�<lambda>�z.CooperativeTask._oneWorkUnit.<locals>.<lambda>)�nextr��
StopIterationr�ry�
BaseExceptionr{r�
isinstancerr��addCallbacks)r+rUr�r,rRr-�_oneWorkUnits
zCooperativeTask._oneWorkUnit)rernrdrorr�r.rr�r�r�rurrr�rQr�r�r,r,r,r-r��s��
r�c@seZdZdZeedfegegeffeegdfgefed�dd�Z	d e
eee
e
ee
e
ed�dd	�Ze
eed
�dd�Zedd
�dd�Zedd
�dd�Zeed�dd�Zdd�dd�ZdZdd�dd�Zdd�dd�Zdd�dd�Zeed�dd��ZdS)!r�a�
    Cooperative task scheduler.

    A cooperative task is an iterator where each iteration represents an
    atomic unit of work.  When the iterator yields, it allows the
    L{Cooperator} to decide which of its tasks to execute next.  If the
    iterator yields a L{Deferred} then work will pause until the
    L{Deferred} fires and completes its callback chain.

    When a L{Cooperator} has more than one task, it distributes work between
    all tasks.

    There are two ways to add tasks to a L{Cooperator}, L{cooperate} and
    L{coiterate}.  L{cooperate} is the more useful of the two, as it returns a
    L{CooperativeTask}, which can be L{paused<CooperativeTask.pause>},
    L{resumed<CooperativeTask.resume>} and L{waited
    on<CooperativeTask.whenDone>}.  L{coiterate} has the same effect, but
    returns only a L{Deferred} that fires when the task is done.

    L{Cooperator} can be used for many things, including but not limited to:

      - running one or more computationally intensive tasks without blocking
      - limiting parallelism by running a subset of the total tasks
        simultaneously
      - doing one thing, waiting for a L{Deferred} to fire,
        doing the next thing, repeat (i.e. serializing a sequence of
        asynchronous tasks)

    Multiple L{Cooperator}s do not cooperate with each other, so for most
    cases you should use the L{global cooperator<task.cooperate>}.
    TN)�terminationPredicateFactory�	scheduler�startedcCs2g|_td�|_||_||_d|_d|_||_dS)aA
        Create a scheduler-like object to which iterators may be added.

        @param terminationPredicateFactory: A no-argument callable which will
        be invoked at the beginning of each step and should return a
        no-argument callable which will return True when the step should be
        terminated.  The default factory is time-based and allows iterators to
        run for 1/100th of a second at a time.

        @param scheduler: A one-argument callable which takes a no-argument
        callable and should invoke it at some future point.  This will be used
        to schedule each step of this Cooperator.

        @param started: A boolean which indicates whether iterators should be
        stepped as soon as they are added, or if they will be queued up until
        L{Cooperator.start} is called.
        r,NF)�_tasks�iter�
_metarator�_terminationPredicateFactory�
_scheduler�_delayedCall�_stopped�_started)r+r�r�r�r,r,r-r.>s
zCooperator.__init__)r��doneDeferredr%cCs&|dkrt�}t||����|�|S)a�
        Add an iterator to the list of iterators this L{Cooperator} is
        currently running.

        Equivalent to L{cooperate}, but returns a L{Deferred} that will
        be fired when the task is done.

        @param doneDeferred: If specified, this will be the Deferred used as
            the completion deferred.  It is suggested that you use the default,
            which creates a new Deferred for you.

        @return: a Deferred that will fire when the iterator finishes.
        N)rr�r��
chainDeferred)r+r�r�r,r,r-�	coiterate]szCooperator.coiterate�r�r%cCs
t||�S)a	
        Start running the given iterator as a long-running cooperative task, by
        calling next() on it as a periodic timed event.

        @param iterator: the iterator to invoke.

        @return: a L{CooperativeTask} object representing this task.
        )r�)r+r�r,r,r-�	cooperatets	zCooperator.cooperate)�taskr%cCs@|jr(|j�|�|�t�tt���n|j�|�|��dS)zH
        Add a L{CooperativeTask} object to this L{Cooperator}.
        N)r�r�r�r�rwr�_reschedule�r+r�r,r,r-r�s
zCooperator._addTaskcCs,|j�|�|js(|jr(|j��d|_dS)zF
        Remove a L{CooperativeTask} from this L{Cooperator}.
        N)r��remover�rMr�r,r,r-r��s
zCooperator._removeTaskr/ccs>|��}|jr:|jD]}|V|�rdSqt|j�|_qdS)z�
        Yield all L{CooperativeTask} objects in a loop as long as this
        L{Cooperator}'s termination condition has not been met.
        N)r�r�r�r�)r+�
terminatorrGr,r,r-�_tasksWhileNotStopped�s
z Cooperator._tasksWhileNotStoppedcCs(d|_|��D]}|��q|��dS)z)
        Run one scheduler tick.
        N)r�r�r�r��r+ZtaskObjr,r,r-�_tick�s
zCooperator._tickFcCs2|jsd|_dS|jdkr.|jr.|�|j�|_dS�NT)r��_mustScheduleOnStartr�r�r�r�rRr,r,r-r��s
zCooperator._reschedulecCs"d|_d|_|jr|`|��dS)z)
        Begin scheduling steps.
        FTN)r�r�r�r�rRr,r,r-rL�s
zCooperator.startcCsJd|_|jD]}|�t�tt���qg|_|jdk	rF|j��d|_dS)z�
        Stop scheduling steps.  Errback the completion Deferreds of all
        iterators which have been added and forget about them.
        TN)r�r�r�rwrr�rMr�r,r,r-rQ�s


zCooperator.stopcCs|jo|jS)z�
        Is this L{Cooperator} is currently running?

        @return: C{True} if the L{Cooperator} is running, C{False} otherwise.
        @rtype: C{bool}
        )r�r�rRr,r,r-rI�szCooperator.running)N)rernrdror}r�rrsrr.rr�rrr�r�r�r�r�rr�r�r�r�rLrQrqrIr,r,r,r-r�s4"��"�
�

	

r�r�cCs
t�|�S)a%
    Cooperatively iterate over the given iterator, dividing runtime between it
    and all other iterators which have been passed to this function and not yet
    exhausted.

    @param iterator: the iterator to invoke.

    @return: a Deferred that will fire when the iterator finishes.
    )�_theCooperatorr��r�r,r,r-r��s
r�cCs
t�|�S)aS
    Start running the given iterator as a long-running cooperative task, by
    calling next() on it as a periodic timed event.

    This is very useful if you have computationally expensive tasks that you
    want to run without blocking the reactor.  Just break each task up so that
    it yields frequently, pass it in here and the global L{Cooperator} will
    make sure work is distributed between them without blocking longer than a
    single iteration of a single task.

    @param iterator: the iterator to invoke.

    @return: a L{CooperativeTask} object representing this task.
    )r�r�r�r,r,r-r��sr�c@s�eZdZdZdZdd�dd�Zed�dd�Zdd�d	d
�Zee	de
fe
e
ed�d
d�Ze
ed�dd�Zedd�dd�Zeedd�dd�ZdS)�Clockz�
    Provide a deterministic, easily-controlled implementation of
    L{IReactorTime.callLater}.  This is commonly useful for writing
    deterministic unit tests for code which schedules events using this API.
    gNr/cCs
g|_dSrV��callsrRr,r,r-r.szClock.__init__cCs|jS)a
        Pretend to be time.time().  This is used internally when an operation
        such as L{IDelayedCall.reset} needs to determine a time value
        relative to the current time.

        @return: The time which should be considered the current time.
        )�rightNowrRr,r,r-r<sz
Clock.secondscCs|jjdd�d�dS)zR
        Sort the pending calls according to the time they are scheduled.
        cSs|��SrV)�getTime)r#r,r,r-r�r�z"Clock._sortCalls.<locals>.<lambda>)�keyN)r��sortrRr,r,r-�
_sortCallsszClock._sortCalls.)�delayr��argsr$r%cOs>t|��|||||jjdd�|j�}|j�|�|��|S)zL
        See L{twisted.internet.interfaces.IReactorTime.callLater}.
        cSsdSrVr,)�cr,r,r-r�!r�z!Clock.callLater.<locals>.<lambda>)rr<r�r�r�r�)r+r�r�r�r$Zdcr,r,r-rcs
�	zClock.callLatercCs|jS)zQ
        See L{twisted.internet.interfaces.IReactorTime.getDelayedCalls}
        r�rRr,r,r-�getDelayedCalls(szClock.getDelayedCalls)�amountr%cCsb|j|7_|��|jr^|jd��|��kr^|j�d�}d|_|j|j|j	�|��qdS)z�
        Move time on this clock forward by the given amount and run whatever
        pending calls should be run.

        @param amount: The number of seconds which to advance this clock's
        time.
        rr;N)
r�r�r�r�r<�pop�calledrkr�r$)r+r�rr,r,r-�advance.sz
Clock.advance)�timingsr%cCs|D]}|�|�qdS)zB
        Advance incrementally by the given set of times.
        N)r�)r+r�r�r,r,r-�pump>sz
Clock.pump)rernrdror�r.rbr<r�rrDrrcr	r�r�rr�r,r,r,r-r��s

�r�.)r*r�r�r�r$r%csVttdd��fdd�}ttd����fdd�}t|�}|�|�|�||jd��|S)a+
    Call the given function after a certain period of time has passed.

    @param clock: The object which will be used to schedule the delayed
        call.

    @param delay: The number of seconds to wait before calling the function.

    @param callable: The callable to call after the delay, or C{None}.

    @param args: The positional arguments to pass to C{callable}.

    @param kw: The keyword arguments to pass to C{callable}.

    @return: A deferred that fires with the result of the callable when the
        specified time has elapsed.
    N)r9r%cs���dSrV)rM)r9)�delayedCallr,r-�deferLaterCancel_sz$deferLater.<locals>.deferLaterCancelrTcs�dkrdS����SrVr,r�)r�r�r$r,r-rWbszdeferLater.<locals>.cb)rrDrr\rcrN)r*r�r�r�r$r�rWrPr,)r�r�r�r$r-�
deferLaterFs
r�r,zDeferred[_T])�main�argv�_reactorr%cs��dkrddlm}tt|��t|�f|���}d�d�dd��fdd�}��dd	|�ttdd
���fdd��tdd
����fdd�}|�|���	�t
���dS)a�
    Call C{main} and run the reactor until the L{Deferred} it returns fires or
    the coroutine it returns completes.

    This is intended as the way to start up an application with a well-defined
    completion condition.  Use it to write clients or one-off asynchronous
    operations.  Prefer this to calling C{reactor.run} directly, as this
    function will also:

      - Take care to call C{reactor.stop} once and only once, and at the right
        time.
      - Log any failures from the C{Deferred} returned by C{main}.
      - Exit the application when done, with exit code 0 in case of success and
        1 in case of failure. If C{main} fails with a C{SystemExit} error, the
        code returned is used.

    The following demonstrates the signature of a C{main} function which can be
    used with L{react}::
          async def main(reactor, username, password):
              return "ok"

          task.react(main, ("alice", "secret"))

    @param main: A callable which returns a L{Deferred} or
        coroutine. It should take the reactor as its first
        parameter, followed by the elements of C{argv}.

    @param argv: A list of arguments to pass to C{main}. If omitted the
        callable will be invoked with no additional arguments.

    @param _reactor: An implementation detail to allow easier unit testing.  Do
        not supply this parameter.

    @since: 12.3
    Nrr'Fr/csd�dSr�r,r,)�stoppingr,r-�
onShutdown�szreact.<locals>.onShutdown�before�shutdown)rU�stopReactorr%csh|r2�dk	st�z���Wntk
r0YnXt|t�rd|�t�dk	rT|jj�nt	�
|d�d�dS)Nzmain function encountered errorr;)r=rQrr�r�check�
SystemExit�value�coder�err)rUr�)r�r�r,r-rQ�s

zreact.<locals>.stoprTcs.�r�|d�n�dk	st����|d�dS)NFT)r=�callWhenRunningr�)r�rQr�r,r-�cbFinish�szreact.<locals>.cbFinish)r)r(rrr�addSystemEventTriggerrDrs�addBoth�run�sys�exit)r�r�r�r(�finishedr�r�r,)r�r�rQr�r-�reactms+

r�)N)r,N)@ror�r~r5�typingrrrrrrrr	r
rr�zope.interfacer
�incrementalr�twisted.internet.baserZtwisted.internet.deferrrr�twisted.internet.errorr�twisted.internet.interfacesrrr�twisted.pythonrrZtwisted.python.deprecater�twisted.python.failurerrr�	Exceptionrurwrxryrzr{r|r}r�r�r�r�r�r�r�r�r�rbrDr�r��__all__r,r,r,r-�<module>s�4	
:
P��,����X�
@ Telegram