Operation   : Linux premium131.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
Software     : Apache
Server IP    : 162.0.232.56 | Your IP: 216.73.216.111
Domains      : 1034 Domain(s)
Permission   : [ 0755 ]



��Yf�D�@sN
dZd
dddddgZ
ddlZddlZddlZddlZddlZd	d
lm	Z	
d	dlm
Z

dZd
ZdZ
ejjjZejjZejjZejd	ZGdd�de�ZGdd�d�Zdd�ZGdd�d�Zdd�Zdd�Zdd�Zdd�Zdddd�
ZdS)z.A Future class similar to the one in PEP 3148.�CancelledError�TimeoutError�InvalidStateError�Future�wrap_future�isfuture�N�
)
�compat)
�eventsZPENDINGZ	CANCELLEDZFINISHEDc
@seZ
dZd
ZdS)rz+The operation is not allowed in this state.N)�__name__�
__module__�__qualname__�__doc__�rr�4/opt/alt/python35/lib64/python3.5/asyncio/futures.pyrs
c@sLeZ
dZd
ZdZdd�Zdd	�Zd
d�Zdd
�ZdS)�_TracebackLoggera
Helper to log a traceback upon destruction if not cleared.

    This solves a nasty problem with Futures and Tasks that have an
    exception set: if nobody asks for the exception, the exception is
    never logged.  This violates the Zen of Python: 'Errors should
    never pass silently.  Unless explicitly silenced.'

    However, we don't want to log the exception as soon as
    set_exception() is called: if the calling code is written
    properly, it will get the exception and handle it properly.  But
    we *do* want to log it if result() or exception() was never called
    -- otherwise developers waste a lot of time wondering why their
    buggy code fails silently.

    An earlier attempt added a __del__() method to the Future class
    itself, but this backfired because the presence of __del__()
    prevents garbage collection from breaking cycles.  A way out of
    this catch-22 is to avoid having a __del__() method on the Future
    class itself, but instead to have a reference to a helper object
    with a __del__() method that logs the traceback, where we ensure
    that the helper object doesn't participate in cycles, and only the
    Future has a reference to it.

    The helper object is added when set_exception() is called.  When
    the Future is collected, and the helper is present, the helper
    object is also collected, and its __del__() method will log the
    traceback.  When the Future's result() or exception() method is
    called (and a helper object is present), it removes the helper
    object, after calling its clear() method to prevent it from
    logging.

    One downside is that we do a fair amount of work to extract the
    traceback from the exception, even when it is never logged.  It
    would seem cheaper to just store the exception object, but that
    references the traceback, which references stack frames, which may
    reference the Future, which references the _TracebackLogger, and
    then the _TracebackLogger would be included in a cycle, which is
    what we're trying to avoid!  As an optimization, we don't
    immediately format the exception; we only do the work when
    activate() is called, which call is delayed until after all the
    Future's callbacks have run.  Since usually a Future has at least
    one callback (typically set by 'yield from') and usually that
    callback extracts the callback, thereby removing the need to
    format the exception.

    PS. I don't claim credit for this solution.  I first heard of it
    in a discussion about closing files when they are collected.
    �loop�source_traceback�exc�tbcCs.|
j|_
|
j|_||_d|_dS)
N)�_loopr�_source_tracebackrrr)�self�futurerrrr�__init__Us


	
z_TracebackLogger.__init__c
Cs@|j}
|
dk	r<d|_t
j|
j|
|
j�|_dS)
N)r�	traceback�format_exception�	__class__�
__traceback__r)rrrrr�activate[s

	

	

z_TracebackLogger.activatec

Csd|_d|_
dS)
N)rr)
rrrr�clearbs
	
z_TracebackLogger.clearc
Cs�|jr�d
}
|j
rQdjtj|j
�
�
}|
d7}
|
d|j�7}
|
dj|j�
j�7}
|jjd|
i
�

dS)Nz*Future/Task exception was never retrieved
�z0Future/Task created at (most recent call last):
z%s
�message)rr�joinr�format_list�rstripr�call_exception_handler)r�msg�srcrrr�__del__fs
	

	





z_TracebackLogger.__del__N)rrrr)	rrr
r�	__slots__rrr r)rrrrr!s0rc

Cst|j
d
�o|jdk	S)z�Check for a Future.

    This returns True when obj is a Future instance or is advertising
    itself as duck-type compatible by setting _asyncio_future_blocking.
    See comment in Future for more details.
    �_asyncio_future_blockingN)�hasattrrr+)
�objrrrrqs
c@s$
eZ
dZd
ZeZdZdZdZdZ	dZ
dZdZdddd�
Z
dd�Zd	d
�Zdd�Zejr�d
d�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zejr 
eZ dS)%raThis class is *almost* compatible with concurrent.futures.Future.

    Differences:

    - result() and exception() do not take a timeout argument and
      raise an exception when the future isn't done yet.

    - Callbacks registered with add_done_callback() are always called
      via the event loop's call_soon_threadsafe().

    - This class is not compatible with the wait() and as_completed()
      methods in the concurrent.futures package.

    (In Python 3.4 or later we may be able to unify the implementations.)
    NFrc

Cs^|
d
krtj
�|_n	|
|_g|_|jj�rZtjtjd�
�
|_	d
S)z�Initialize the future.

        The optional event_loop argument allows explicitly setting the event
        loop object used by the future. If it's not provided, the future uses
        the default event loop.
        Nr)
r
�get_event_loopr�
_callbacksZ	get_debugr�
extract_stack�sys�	_getframer)rrrrrr�s
	
	

zFuture.__init__c
Cs�|j}
t
|
�
}|s!d
}
dd�}|dkrL||
d�
}
nn|dkr�dj||
d�
||
d�
�}
n9|dkr�dj||
d�
|d||
d
�
�}
d	|
S)Nr!c

Sstj
|f�S)
N)r
Z_format_callback_source)
�callbackrrr�	format_cb�s
z,Future.__format_callbacks.<locals>.format_cbrr�z{}, {}z{}, <{} more>, {}zcb=[%s]���)r/�len�format)r�cb�sizer4rrrZ__format_callbacks�s
	





)




zFuture.__format_callbacksc
Cs�|jj
�g
}
|jtkrt|jdk	rL|
jd
j|j�
�

n(tj|j�
}|
jdj|�
�

|j	r�|
j|j
��

|jr�|jd}|
jd|d|df�

|
S)Nzexception={!r}z	result={}rzcreated at %s:%srr6)�_state�lower�	_FINISHED�
_exception�appendr8�reprlib�repr�_resultr/�_Future__format_callbacksr)r�info�result�framerrr�
_repr_info�s





	

	



zFuture._repr_infoc
Cs)|j�}
d
|j
jdj|
�
fS)Nz<%s %s>�
 )rGrrr#)rrDrrr�__repr__�s

zFuture.__repr__c
Csb|js
dS|j
}
d
d|jjd|
d|i}|jrN|j|d<|jj|�

dS)Nr"z %s exception was never retrieved�	exceptionrr)�_log_tracebackr>rrrrr&)rr�contextrrrr)�s
	
	



	


zFuture.__del__c

Cs3d
|_|j
tkrd
St|_
|j�
dS)z�Cancel the future and schedule callbacks.

        If the future is already done or cancelled, return False.  Otherwise,
        change the future's state to cancelled, schedule the callbacks and
        return True.
        FT)rKr;�_PENDING�
_CANCELLED�_schedule_callbacks)
rrrr�cancel�s	


	


z
Future.cancelc
CsX|jd
d
�}
|
sd
Sg|jd
d
�<x!|
D]}|j
j||�
q7Wd
S)z�Internal: Ask the event loop to call all callbacks.

        The callbacks are scheduled to be called as soon as possible. Also
        clears the callback list.
        N)r/r�	call_soon)rZ	callbacksr3rrrrO�s




zFuture._schedule_callbacksc

Cs
|jt
kS)
z(Return True if the future was cancelled.)r;rN)
rrrr�	cancelled
szFuture.cancelledc

Cs
|jt
kS)
z�Return True if the future is done.

        Done means either that a result / exception are available, or that the
        future was cancelled.
        )r;rM)
rrrr�done
szFuture.donec

Cs}|jt
krt�
|jtkr0td
�
�
d|_|jdk	r^|jj�
d|_|jdk	rv|j�
|j	S)a
Return the result this future represents.

        If the future has been cancelled, raises CancelledError.  If the
        future's result isn't yet available, raises InvalidStateError.  If
        the future is done and has an exception set, this exception is raised.
        zResult is not ready.FN)
r;rNr
r=rrK�
_tb_loggerr r>rB)
rrrrrE
s



	



	

	
z
Future.resultc

Cse|jt
krt�
|jtkr0td
�
�
d|_|jdk	r^|jj�
d|_|jS)a&
Return the exception that was set on this future.

        The exception (or None if no exception was set) is returned only if
        the future is done.  If the future has been cancelled, raises
        CancelledError.  If the future isn't done yet, raises
        InvalidStateError.
        zException is not set.FN)	r;rNr
r=rrKrTr r>)
rrrrrJ)
s



	



	
zFuture.exceptioncCs9|jt
kr%|jj|
|�
n|jj|
�

d
S)z�Add a callback to be run when the future becomes done.

        The callback is called with a single argument - the future object. If
        the future is already done when this is called, the callback is
        scheduled with call_soon.
        N)r;rMrrQr/r?)r�fnrrr�add_done_callback;
s
zFuture.add_done_callbackcsR�f
d
d�|jD�
}t
|j�
t
|�
}|rN||jdd�<|S)z}Remove all instances of a callback from the "call when done" list.

        Returns the number of callbacks removed.
        c
s"g|]}
|
�kr|
�qSrr)�.0�
f)
rUrr�
<listcomp>N
s	z/Future.remove_done_callback.<locals>.<listcomp>N)r/r7)rrUZfiltered_callbacksZ
removed_countr)
rUr�remove_done_callbackI
s




zFuture.remove_done_callbackcCsJ|jt
kr*td
j|j|��
�
|
|_t|_|j�
dS)z�Mark the future done and set its result.

        If the future is already done when this method is called, raises
        InvalidStateError.
        z{}: {!r}N)r;rMrr8rBr=rO)rrErrr�
set_resultV
s


	
	
zFuture.set_resultcCs�|jt
kr*td
j|j|��
�
t|
t�rB|
�}
t|
�
tkr`td�
�
|
|_t	|_|j
�
tjr�d|_
n(t||
�|_|jj|jj�

dS)z�Mark the future done and set an exception.

        If the future is already done when this method is called, raises
        InvalidStateError.
        z{}: {!r}zPStopIteration interacts badly with generators and cannot be raised into a FutureTN)r;rMrr8�
isinstance�type�
StopIteration�	TypeErrorr>r=rOr	�PY34rKrrTrrQr)rrJrrr�
set_exceptionb
s


	

	
	


	
zFuture.set_exceptionc

cs<|j�sd
|_
|V
|j�s2td�
�
|j�S)NTz"yield from wasn't used with future)rSr+�AssertionErrorrE)
rrrr�__iter__z
s


	


zFuture.__iter__)!rrr
rrMr;rBr>rrr+rKrTrrCrGrIr	r`r)rPrOrRrSrErJrVrZr[rarcZPY35�	__await__rrrrr|s8





	

	
cCs!|j�rd
S|j
|
�

d
S)z?Helper setting the result only if the future was not cancelled.N)rRr[)ZfutrErrr�_set_result_unless_cancelled�
s

recCs}|
j�st
�
|
j�r(|j�
|j�s8d
S|
j�}|d
k	r`|j|�

n|
j�}|j|�

d
S)z8Copy state from a future to a concurrent.futures.Future.N)	rSrbrRrPZset_running_or_notify_cancelrJrarEr[)�
concurrent�sourcerJrErrr�_set_concurrent_future_state�
s








rhcCs�|j�st
�
|
j�r"d
S|
j�s5t
�
|j�rN|
j�
nA|j�}|d
k	rv|
j|�

n|j�}|
j|�

d
S)zqInternal helper to copy state from another Future.

    The other Future may be a concurrent.futures.Future.
    N)rSrbrRrPrJrarEr[)rg�destrJrErrr�_copy_future_state�
s








rjcs�t��
r/t
�tjj�r/td
�
�
t��
r^t
�tjj�r^td�
�
t��
rs�jnd�t��
r��jnd�
dd���
��fdd�}��
��fdd	�}�j|�

�j|�

dS)
a
Chain two futures so that when one completes, so does the other.

    The result (or exception) of source will be copied to destination.
    If destination is cancelled, source gets cancelled too.
    Compatible with both asyncio.Future and concurrent.futures.Future.
    z(A future is required for source argumentz-A future is required for destination argumentNcSs-t|�
rt
|
|�
n
t||
�
dS)
N)rrjrh)r�otherrrr�
_set_state�
s

z!_chain_future.<locals>._set_statec

sE|j�rA�dks$��kr1�
j
�
n�j�
j
�

dS)
N)rRrP�call_soon_threadsafe)
�destination)�	dest_looprg�source_looprr�_call_check_cancel�
s



z)_chain_future.<locals>._call_check_cancelc

s?�
dks�
�kr(��|�
n�
j��|�
dS)
N)
rm)
rg)rlrornrprr�_call_set_state�
s

z&_chain_future.<locals>._call_set_state)rr\rf�futuresrr_rrV)rgrnrqrrr)rlrornrgrpr�
_chain_future�
s








rtrc

Csot|�
r|St
|tjj�s:td
j|�
�
�
|
dkrRtj�}
|
j	�}t
||�
|S)z&Wrap concurrent.futures.Future object.z/concurrent.futures.Future is expected, got {!r}N)rr\rfrsrrbr8r
r.Z
create_futurert)rrZ
new_futurerrrr�
s








)r�__all__Zconcurrent.futures._baserfZloggingr@r1rr!r	r
rMrNr=rsZ_base�Errorr
r�DEBUGZSTACK_DEBUGrrrrrerhrjrtrrrrr�<module>
s6











P�
'