/snap/core18/2979/usr/lib/python3.6/asyncio/__pycache__
Edit: /snap/core18/2979/usr/lib/python3.6/asyncio/__pycache__/futures.cpython-36.pyc (13747B)
3
Nq i > ã @ s
d Z ddddddgZddlZddlZddlZddlZd d
lmZ d d lm Z d d lm
Z
ej Z ej Z ej
Z
ejZejZejZejZejd ZG d
d„ dƒZG dd„ dƒZeZdd„ Zdd„ Zdd„ Zdd„ Zddœdd„Zy ddl Z W n e k
rú Y n X e j ZZ dS )z.A Future class similar to the one in PEP 3148.ÚCancelledErrorÚ TimeoutErrorÚInvalidStateErrorÚFutureÚ wrap_futureÚisfutureé Né )Ú base_futures)Úcompat)Úeventsc @ s4 e Zd ZdZdZdd„ 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Útbc C s |j | _|j| _|| _d | _d S )N)Ú_loopr
Ú_source_tracebackr r r )ÚselfÚfuturer © r ú%/usr/lib/python3.6/asyncio/futures.pyÚ__init__R s z_TracebackLogger.__init__c C s, | j }|d k r(d | _ tj|j||jƒ| _d S )N)r Ú tracebackÚformat_exceptionÚ __class__Ú
__traceback__r )r r r r r ÚactivateX s
z_TracebackLogger.activatec C s d | _ d | _d S )N)r r )r r r r Úclear_ s z_TracebackLogger.clearc C sb | j r^d}| jr:djtj| jƒƒ}|d7 }|d|jƒ 7 }|dj| j ƒjƒ 7 }| jjd|iƒ d S )Nz*Future/Task exception was never retrieved
Ú z0Future/Task created at (most recent call last):
z%s
Úmessage)r r Újoinr Ú format_listÚrstripr
Úcall_exception_handler)r ÚmsgÚsrcr r r Ú__del__c s z_TracebackLogger.__del__N)r
r r r ) Ú__name__Ú
__module__Ú __qualname__Ú__doc__Ú __slots__r r r r& r r r r r s 0r c @ s¸ e Zd ZdZeZdZdZdZdZ dZ
dZ ddœdd„Z e
jZdd„ ZejrRd d
„ Zd d „ Zd
d„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd „ Z d d „ Z d d „ Z ej r´e Z dS )!r a, This class is *almost* compatible with concurrent.futures.Future.
Differences:
- This class is not thread-safe.
- 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().
- 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.)
NF)r
c C s@ |dkrt jƒ | _n|| _g | _| jjƒ r
ú )r r' r Ú
_repr_info)r r r r Ú__repr__¥ s zFuture.__repr__c C sD | j s
d S | j}d| jj || dœ}| jr4| j|d< | jj|ƒ d S )Nz %s exception was never retrieved)r Ú exceptionr r )Ú_log_tracebackÚ
_exceptionr r' r r r# )r r Úcontextr r r r& ¬ s
zFuture.__del__c C s& d| _ | jtkrdS t| _| 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)r5 Ú_stateÚ_PENDINGÚ
_CANCELLEDÚ_schedule_callbacks)r r r r Úcancel¼ s
z
Future.cancelc C sD | j dd… }|sdS g | j dd…< x|D ]}| jj|| ƒ q*W dS )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)r Z callbacksÚcallbackr r r r; Ê s
zFuture._schedule_callbacksc C s
| j tkS )z(Return True if the future was cancelled.)r8 r: )r r r r Ú cancelledØ s zFuture.cancelledc C s
| j tkS )z™Return True if the future is done.
Done means either that a result / exception are available, or that the
future was cancelled.
)r8 r9 )r r r r ÚdoneÞ s z Future.donec C s< | j tkrt‚| j tkr tdƒ‚d| _| jdk r6| j‚| jS )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)r8 r: r Ú _FINISHEDr r5 r6 Ú_result)r r r r Úresultæ s
z
Future.resultc C s, | j tkrt‚| j tkr tdƒ‚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.F)r8 r: r rA r r5 r6 )r r r r r4 ö s
zFuture.exceptionc C s* | j tkr| jj|| ƒ n | jj|ƒ dS )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)r8 r9 r r= r- Úappend)r Úfnr r r Úadd_done_callback s
zFuture.add_done_callbackc s< ‡ fdd„| j D ƒ}t| j ƒt|ƒ }|r8|| j dd…< |S )z}Remove all instances of a callback from the "call when done" list.
Returns the number of callbacks removed.
c s g | ]}|ˆ kr|‘qS r r )Ú.0Úf)rE r r ú
s z/Future.remove_done_callback..N)r- Úlen)r rE Zfiltered_callbacksZ
removed_countr )rE r Úremove_done_callback s
zFuture.remove_done_callbackc C s4 | j tkr tdj| 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)r8 r9 r ÚformatrB rA r; )r rC r r r Ú
set_result s
zFuture.set_resultc C s‚ | j tkr tdj| j | ƒƒ‚t|tƒr,|ƒ }t|ƒtkr@tdƒ‚|| _t | _ | j
ƒ t j rbd| _
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)r8 r9 r rL Ú
isinstanceÚtypeÚ
StopIterationÚ TypeErrorr6 rA r; r
ÚPY34r5 r Z
_tb_loggerr r= r )r r4 r r r Ú
set_exception, s
zFuture.set_exceptionc c s, | j ƒ sd| _| V | j ƒ s$tdƒ‚| jƒ S )NTz"yield from wasn't used with future)r@ Ú_asyncio_future_blockingÚAssertionErrorrC )r r r r Ú__iter__D s
zFuture.__iter__)!r' r( r) r* r9 r8 rB r6 r r rT r5 r r Z_future_repr_infor2 r3 r
rR r& r< r; r? r@ rC r4 rF rK rM rS rV ZPY35Ú __await__r r r r r n s4
c C s | j ƒ r dS | j|ƒ dS )z?Helper setting the result only if the future was not cancelled.N)r? rM )ZfutrC r r r Ú _set_result_unless_cancelledS s rX c C sZ |j ƒ s t‚|jƒ r | jƒ | jƒ s(dS |jƒ }|dk rD| j|ƒ n|jƒ }| j|ƒ dS )z8Copy state from a future to a concurrent.futures.Future.N) r@ rU r? r< Z set_running_or_notify_cancelr4 rS rC rM )Ú
concurrentÚsourcer4 rC r r r Ú _set_concurrent_future_stateZ s r[ c C sj | j ƒ s t‚|jƒ rdS |j ƒ s&t‚| jƒ r8|jƒ n.| jƒ }|dk rT|j|ƒ n| jƒ }|j|ƒ dS )zqInternal helper to copy state from another Future.
The other Future may be a concurrent.futures.Future.
N)r@ rU r? r< r4 rS rC rM )rZ Údestr4 rC r r r Ú_copy_future_statei s
r] c sª t ˆƒ r"tˆtjjƒ r"tdƒ‚t ˆƒ rDtˆtjjƒ rDtdƒ‚t ˆƒrRˆjnd‰t ˆƒrdˆ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 argumentNc S s" t | ƒrt|| ƒ n
t| |ƒ d S )N)r r] r[ )r Úotherr r r Ú
_set_state s z!_chain_future.._set_statec s2 | j ƒ r.ˆd ksˆˆ kr"ˆjƒ n ˆjˆjƒ d S )N)r? r< Úcall_soon_threadsafe)Ú destination)Ú dest_looprZ Ú source_loopr r Ú_call_check_cancel“ s
z)_chain_future.._call_check_cancelc sJ ˆj ƒ r ˆd k r ˆjƒ r d S ˆd ks,ˆˆkr8ˆ ˆ| ƒ nˆjˆ ˆ| ƒ d S )N)r? Z is_closedr` )rZ )r_ rb ra rc r r Ú_call_set_stateš s z&_chain_future.._call_set_state)r rN rY Úfuturesr rQ r rF )rZ ra rd re r )r_ rb ra rZ rc r Ú
_chain_future} s
rg )r
c C sN t | ƒr | S t| tjjƒs(tdj| ƒƒ‚|dkr8tjƒ }|j ƒ }t
| |ƒ |S )z&Wrap concurrent.futures.Future object.z/concurrent.futures.Future is expected, got {!r}N) r rN rY rf r rU rL r r, Z
create_futurerg )r r
Z
new_futurer r r r § s
) r* Ú__all__Zconcurrent.futuresrY Zloggingr/ r r r r
r r r r r r9 r: rA ÚDEBUGZ STACK_DEBUGr r Z _PyFuturerX r[ r] rg r Z_asyncioÚ ImportErrorZ_CFuturer r r r Ú s>
P c*