Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found
in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 88
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 215
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 216
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 217
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 218
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 219
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 220
PK ! Sq ]e ]e sslproto.pynu [ import collections
import warnings
try:
import ssl
except ImportError: # pragma: no cover
ssl = None
from . import base_events
from . import compat
from . import protocols
from . import transports
from .log import logger
def _create_transport_context(server_side, server_hostname):
if server_side:
raise ValueError('Server side SSL needs a valid SSLContext')
# Client side may pass ssl=True to use a default
# context; in that case the sslcontext passed is None.
# The default is secure for client connections.
if hasattr(ssl, 'create_default_context'):
# Python 3.4+: use up-to-date strong settings.
sslcontext = ssl.create_default_context()
if not server_hostname:
sslcontext.check_hostname = False
else:
# Fallback for Python 3.3.
sslcontext = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
sslcontext.options |= ssl.OP_NO_SSLv2
sslcontext.options |= ssl.OP_NO_SSLv3
sslcontext.set_default_verify_paths()
sslcontext.verify_mode = ssl.CERT_REQUIRED
return sslcontext
def _is_sslproto_available():
return hasattr(ssl, "MemoryBIO")
# States of an _SSLPipe.
_UNWRAPPED = "UNWRAPPED"
_DO_HANDSHAKE = "DO_HANDSHAKE"
_WRAPPED = "WRAPPED"
_SHUTDOWN = "SHUTDOWN"
class _SSLPipe(object):
"""An SSL "Pipe".
An SSL pipe allows you to communicate with an SSL/TLS protocol instance
through memory buffers. It can be used to implement a security layer for an
existing connection where you don't have access to the connection's file
descriptor, or for some reason you don't want to use it.
An SSL pipe can be in "wrapped" and "unwrapped" mode. In unwrapped mode,
data is passed through untransformed. In wrapped mode, application level
data is encrypted to SSL record level data and vice versa. The SSL record
level is the lowest level in the SSL protocol suite and is what travels
as-is over the wire.
An SslPipe initially is in "unwrapped" mode. To start SSL, call
do_handshake(). To shutdown SSL again, call unwrap().
"""
max_size = 256 * 1024 # Buffer size passed to read()
def __init__(self, context, server_side, server_hostname=None):
"""
The *context* argument specifies the ssl.SSLContext to use.
The *server_side* argument indicates whether this is a server side or
client side transport.
The optional *server_hostname* argument can be used to specify the
hostname you are connecting to. You may only specify this parameter if
the _ssl module supports Server Name Indication (SNI).
"""
self._context = context
self._server_side = server_side
self._server_hostname = server_hostname
self._state = _UNWRAPPED
self._incoming = ssl.MemoryBIO()
self._outgoing = ssl.MemoryBIO()
self._sslobj = None
self._need_ssldata = False
self._handshake_cb = None
self._shutdown_cb = None
@property
def context(self):
"""The SSL context passed to the constructor."""
return self._context
@property
def ssl_object(self):
"""The internal ssl.SSLObject instance.
Return None if the pipe is not wrapped.
"""
return self._sslobj
@property
def need_ssldata(self):
"""Whether more record level data is needed to complete a handshake
that is currently in progress."""
return self._need_ssldata
@property
def wrapped(self):
"""
Whether a security layer is currently in effect.
Return False during handshake.
"""
return self._state == _WRAPPED
def do_handshake(self, callback=None):
"""Start the SSL handshake.
Return a list of ssldata. A ssldata element is a list of buffers
The optional *callback* argument can be used to install a callback that
will be called when the handshake is complete. The callback will be
called with None if successful, else an exception instance.
"""
if self._state != _UNWRAPPED:
raise RuntimeError('handshake in progress or completed')
self._sslobj = self._context.wrap_bio(
self._incoming, self._outgoing,
server_side=self._server_side,
server_hostname=self._server_hostname)
self._state = _DO_HANDSHAKE
self._handshake_cb = callback
ssldata, appdata = self.feed_ssldata(b'', only_handshake=True)
assert len(appdata) == 0
return ssldata
def shutdown(self, callback=None):
"""Start the SSL shutdown sequence.
Return a list of ssldata. A ssldata element is a list of buffers
The optional *callback* argument can be used to install a callback that
will be called when the shutdown is complete. The callback will be
called without arguments.
"""
if self._state == _UNWRAPPED:
raise RuntimeError('no security layer present')
if self._state == _SHUTDOWN:
raise RuntimeError('shutdown in progress')
assert self._state in (_WRAPPED, _DO_HANDSHAKE)
self._state = _SHUTDOWN
self._shutdown_cb = callback
ssldata, appdata = self.feed_ssldata(b'')
assert appdata == [] or appdata == [b'']
return ssldata
def feed_eof(self):
"""Send a potentially "ragged" EOF.
This method will raise an SSL_ERROR_EOF exception if the EOF is
unexpected.
"""
self._incoming.write_eof()
ssldata, appdata = self.feed_ssldata(b'')
assert appdata == [] or appdata == [b'']
def feed_ssldata(self, data, only_handshake=False):
"""Feed SSL record level data into the pipe.
The data must be a bytes instance. It is OK to send an empty bytes
instance. This can be used to get ssldata for a handshake initiated by
this endpoint.
Return a (ssldata, appdata) tuple. The ssldata element is a list of
buffers containing SSL data that needs to be sent to the remote SSL.
The appdata element is a list of buffers containing plaintext data that
needs to be forwarded to the application. The appdata list may contain
an empty buffer indicating an SSL "close_notify" alert. This alert must
be acknowledged by calling shutdown().
"""
if self._state == _UNWRAPPED:
# If unwrapped, pass plaintext data straight through.
if data:
appdata = [data]
else:
appdata = []
return ([], appdata)
self._need_ssldata = False
if data:
self._incoming.write(data)
ssldata = []
appdata = []
try:
if self._state == _DO_HANDSHAKE:
# Call do_handshake() until it doesn't raise anymore.
self._sslobj.do_handshake()
self._state = _WRAPPED
if self._handshake_cb:
self._handshake_cb(None)
if only_handshake:
return (ssldata, appdata)
# Handshake done: execute the wrapped block
if self._state == _WRAPPED:
# Main state: read data from SSL until close_notify
while True:
chunk = self._sslobj.read(self.max_size)
appdata.append(chunk)
if not chunk: # close_notify
break
elif self._state == _SHUTDOWN:
# Call shutdown() until it doesn't raise anymore.
self._sslobj.unwrap()
self._sslobj = None
self._state = _UNWRAPPED
if self._shutdown_cb:
self._shutdown_cb()
elif self._state == _UNWRAPPED:
# Drain possible plaintext data after close_notify.
appdata.append(self._incoming.read())
except (ssl.SSLError, ssl.CertificateError) as exc:
if getattr(exc, 'errno', None) not in (
ssl.SSL_ERROR_WANT_READ, ssl.SSL_ERROR_WANT_WRITE,
ssl.SSL_ERROR_SYSCALL):
if self._state == _DO_HANDSHAKE and self._handshake_cb:
self._handshake_cb(exc)
raise
self._need_ssldata = (exc.errno == ssl.SSL_ERROR_WANT_READ)
# Check for record level data that needs to be sent back.
# Happens for the initial handshake and renegotiations.
if self._outgoing.pending:
ssldata.append(self._outgoing.read())
return (ssldata, appdata)
def feed_appdata(self, data, offset=0):
"""Feed plaintext data into the pipe.
Return an (ssldata, offset) tuple. The ssldata element is a list of
buffers containing record level data that needs to be sent to the
remote SSL instance. The offset is the number of plaintext bytes that
were processed, which may be less than the length of data.
NOTE: In case of short writes, this call MUST be retried with the SAME
buffer passed into the *data* argument (i.e. the id() must be the
same). This is an OpenSSL requirement. A further particularity is that
a short write will always have offset == 0, because the _ssl module
does not enable partial writes. And even though the offset is zero,
there will still be encrypted data in ssldata.
"""
assert 0 <= offset <= len(data)
if self._state == _UNWRAPPED:
# pass through data in unwrapped mode
if offset < len(data):
ssldata = [data[offset:]]
else:
ssldata = []
return (ssldata, len(data))
ssldata = []
view = memoryview(data)
while True:
self._need_ssldata = False
try:
if offset < len(view):
offset += self._sslobj.write(view[offset:])
except ssl.SSLError as exc:
# It is not allowed to call write() after unwrap() until the
# close_notify is acknowledged. We return the condition to the
# caller as a short write.
if exc.reason == 'PROTOCOL_IS_SHUTDOWN':
exc.errno = ssl.SSL_ERROR_WANT_READ
if exc.errno not in (ssl.SSL_ERROR_WANT_READ,
ssl.SSL_ERROR_WANT_WRITE,
ssl.SSL_ERROR_SYSCALL):
raise
self._need_ssldata = (exc.errno == ssl.SSL_ERROR_WANT_READ)
# See if there's any record level data back for us.
if self._outgoing.pending:
ssldata.append(self._outgoing.read())
if offset == len(view) or self._need_ssldata:
break
return (ssldata, offset)
class _SSLProtocolTransport(transports._FlowControlMixin,
transports.Transport):
def __init__(self, loop, ssl_protocol, app_protocol):
self._loop = loop
# SSLProtocol instance
self._ssl_protocol = ssl_protocol
self._app_protocol = app_protocol
self._closed = False
def get_extra_info(self, name, default=None):
"""Get optional transport information."""
return self._ssl_protocol._get_extra_info(name, default)
def set_protocol(self, protocol):
self._app_protocol = protocol
def get_protocol(self):
return self._app_protocol
def is_closing(self):
return self._closed
def close(self):
"""Close the transport.
Buffered data will be flushed asynchronously. No more data
will be received. After all buffered data is flushed, the
protocol's connection_lost() method will (eventually) called
with None as its argument.
"""
self._closed = True
self._ssl_protocol._start_shutdown()
# On Python 3.3 and older, objects with a destructor part of a reference
# cycle are never destroyed. It's not more the case on Python 3.4 thanks
# to the PEP 442.
if compat.PY34:
def __del__(self):
if not self._closed:
warnings.warn("unclosed transport %r" % self, ResourceWarning)
self.close()
def pause_reading(self):
"""Pause the receiving end.
No data will be passed to the protocol's data_received()
method until resume_reading() is called.
"""
self._ssl_protocol._transport.pause_reading()
def resume_reading(self):
"""Resume the receiving end.
Data received will once again be passed to the protocol's
data_received() method.
"""
self._ssl_protocol._transport.resume_reading()
def set_write_buffer_limits(self, high=None, low=None):
"""Set the high- and low-water limits for write flow control.
These two values control when to call the protocol's
pause_writing() and resume_writing() methods. If specified,
the low-water limit must be less than or equal to the
high-water limit. Neither value can be negative.
The defaults are implementation-specific. If only the
high-water limit is given, the low-water limit defaults to an
implementation-specific value less than or equal to the
high-water limit. Setting high to zero forces low to zero as
well, and causes pause_writing() to be called whenever the
buffer becomes non-empty. Setting low to zero causes
resume_writing() to be called only once the buffer is empty.
Use of zero for either limit is generally sub-optimal as it
reduces opportunities for doing I/O and computation
concurrently.
"""
self._ssl_protocol._transport.set_write_buffer_limits(high, low)
def get_write_buffer_size(self):
"""Return the current size of the write buffer."""
return self._ssl_protocol._transport.get_write_buffer_size()
def write(self, data):
"""Write some data bytes to the transport.
This does not block; it buffers the data and arranges for it
to be sent out asynchronously.
"""
if not isinstance(data, (bytes, bytearray, memoryview)):
raise TypeError("data: expecting a bytes-like instance, got {!r}"
.format(type(data).__name__))
if not data:
return
self._ssl_protocol._write_appdata(data)
def can_write_eof(self):
"""Return True if this transport supports write_eof(), False if not."""
return False
def abort(self):
"""Close the transport immediately.
Buffered data will be lost. No more data will be received.
The protocol's connection_lost() method will (eventually) be
called with None as its argument.
"""
self._ssl_protocol._abort()
class SSLProtocol(protocols.Protocol):
"""SSL protocol.
Implementation of SSL on top of a socket using incoming and outgoing
buffers which are ssl.MemoryBIO objects.
"""
def __init__(self, loop, app_protocol, sslcontext, waiter,
server_side=False, server_hostname=None,
call_connection_made=True):
if ssl is None:
raise RuntimeError('stdlib ssl module not available')
if not sslcontext:
sslcontext = _create_transport_context(server_side, server_hostname)
self._server_side = server_side
if server_hostname and not server_side:
self._server_hostname = server_hostname
else:
self._server_hostname = None
self._sslcontext = sslcontext
# SSL-specific extra info. More info are set when the handshake
# completes.
self._extra = dict(sslcontext=sslcontext)
# App data write buffering
self._write_backlog = collections.deque()
self._write_buffer_size = 0
self._waiter = waiter
self._loop = loop
self._app_protocol = app_protocol
self._app_transport = _SSLProtocolTransport(self._loop,
self, self._app_protocol)
# _SSLPipe instance (None until the connection is made)
self._sslpipe = None
self._session_established = False
self._in_handshake = False
self._in_shutdown = False
# transport, ex: SelectorSocketTransport
self._transport = None
self._call_connection_made = call_connection_made
def _wakeup_waiter(self, exc=None):
if self._waiter is None:
return
if not self._waiter.cancelled():
if exc is not None:
self._waiter.set_exception(exc)
else:
self._waiter.set_result(None)
self._waiter = None
def connection_made(self, transport):
"""Called when the low-level connection is made.
Start the SSL handshake.
"""
self._transport = transport
self._sslpipe = _SSLPipe(self._sslcontext,
self._server_side,
self._server_hostname)
self._start_handshake()
def connection_lost(self, exc):
"""Called when the low-level connection is lost or closed.
The argument is an exception object or None (the latter
meaning a regular EOF is received or the connection was
aborted or closed).
"""
if self._session_established:
self._session_established = False
self._loop.call_soon(self._app_protocol.connection_lost, exc)
self._transport = None
self._app_transport = None
self._wakeup_waiter(exc)
def pause_writing(self):
"""Called when the low-level transport's buffer goes over
the high-water mark.
"""
self._app_protocol.pause_writing()
def resume_writing(self):
"""Called when the low-level transport's buffer drains below
the low-water mark.
"""
self._app_protocol.resume_writing()
def data_received(self, data):
"""Called when some SSL data is received.
The argument is a bytes object.
"""
try:
ssldata, appdata = self._sslpipe.feed_ssldata(data)
except ssl.SSLError as e:
if self._loop.get_debug():
logger.warning('%r: SSL error %s (reason %s)',
self, e.errno, e.reason)
self._abort()
return
for chunk in ssldata:
self._transport.write(chunk)
for chunk in appdata:
if chunk:
self._app_protocol.data_received(chunk)
else:
self._start_shutdown()
break
def eof_received(self):
"""Called when the other end of the low-level stream
is half-closed.
If this returns a false value (including None), the transport
will close itself. If it returns a true value, closing the
transport is up to the protocol.
"""
try:
if self._loop.get_debug():
logger.debug("%r received EOF", self)
self._wakeup_waiter(ConnectionResetError)
if not self._in_handshake:
keep_open = self._app_protocol.eof_received()
if keep_open:
logger.warning('returning true from eof_received() '
'has no effect when using ssl')
finally:
self._transport.close()
def _get_extra_info(self, name, default=None):
if name in self._extra:
return self._extra[name]
elif self._transport is not None:
return self._transport.get_extra_info(name, default)
else:
return default
def _start_shutdown(self):
if self._in_shutdown:
return
if self._in_handshake:
self._abort()
else:
self._in_shutdown = True
self._write_appdata(b'')
def _write_appdata(self, data):
self._write_backlog.append((data, 0))
self._write_buffer_size += len(data)
self._process_write_backlog()
def _start_handshake(self):
if self._loop.get_debug():
logger.debug("%r starts SSL handshake", self)
self._handshake_start_time = self._loop.time()
else:
self._handshake_start_time = None
self._in_handshake = True
# (b'', 1) is a special value in _process_write_backlog() to do
# the SSL handshake
self._write_backlog.append((b'', 1))
self._loop.call_soon(self._process_write_backlog)
def _on_handshake_complete(self, handshake_exc):
self._in_handshake = False
sslobj = self._sslpipe.ssl_object
try:
if handshake_exc is not None:
raise handshake_exc
peercert = sslobj.getpeercert()
if not hasattr(self._sslcontext, 'check_hostname'):
# Verify hostname if requested, Python 3.4+ uses check_hostname
# and checks the hostname in do_handshake()
if (self._server_hostname
and self._sslcontext.verify_mode != ssl.CERT_NONE):
ssl.match_hostname(peercert, self._server_hostname)
except BaseException as exc:
if self._loop.get_debug():
if isinstance(exc, ssl.CertificateError):
logger.warning("%r: SSL handshake failed "
"on verifying the certificate",
self, exc_info=True)
else:
logger.warning("%r: SSL handshake failed",
self, exc_info=True)
self._transport.close()
if isinstance(exc, Exception):
self._wakeup_waiter(exc)
return
else:
raise
if self._loop.get_debug():
dt = self._loop.time() - self._handshake_start_time
logger.debug("%r: SSL handshake took %.1f ms", self, dt * 1e3)
# Add extra info that becomes available after handshake.
self._extra.update(peercert=peercert,
cipher=sslobj.cipher(),
compression=sslobj.compression(),
ssl_object=sslobj,
)
if self._call_connection_made:
self._app_protocol.connection_made(self._app_transport)
self._wakeup_waiter()
self._session_established = True
# In case transport.write() was already called. Don't call
# immediately _process_write_backlog(), but schedule it:
# _on_handshake_complete() can be called indirectly from
# _process_write_backlog(), and _process_write_backlog() is not
# reentrant.
self._loop.call_soon(self._process_write_backlog)
def _process_write_backlog(self):
# Try to make progress on the write backlog.
if self._transport is None:
return
try:
for i in range(len(self._write_backlog)):
data, offset = self._write_backlog[0]
if data:
ssldata, offset = self._sslpipe.feed_appdata(data, offset)
elif offset:
ssldata = self._sslpipe.do_handshake(
self._on_handshake_complete)
offset = 1
else:
ssldata = self._sslpipe.shutdown(self._finalize)
offset = 1
for chunk in ssldata:
self._transport.write(chunk)
if offset < len(data):
self._write_backlog[0] = (data, offset)
# A short write means that a write is blocked on a read
# We need to enable reading if it is paused!
assert self._sslpipe.need_ssldata
if self._transport._paused:
self._transport.resume_reading()
break
# An entire chunk from the backlog was processed. We can
# delete it and reduce the outstanding buffer size.
del self._write_backlog[0]
self._write_buffer_size -= len(data)
except BaseException as exc:
if self._in_handshake:
# BaseExceptions will be re-raised in _on_handshake_complete.
self._on_handshake_complete(exc)
else:
self._fatal_error(exc, 'Fatal error on SSL transport')
if not isinstance(exc, Exception):
# BaseException
raise
def _fatal_error(self, exc, message='Fatal error on transport'):
# Should be called from exception handler only.
if isinstance(exc, base_events._FATAL_ERROR_IGNORE):
if self._loop.get_debug():
logger.debug("%r: %s", self, message, exc_info=True)
else:
self._loop.call_exception_handler({
'message': message,
'exception': exc,
'transport': self._transport,
'protocol': self,
})
if self._transport:
self._transport._force_close(exc)
def _finalize(self):
self._sslpipe = None
if self._transport is not None:
self._transport.close()
def _abort(self):
try:
if self._transport is not None:
self._transport.abort()
finally:
self._finalize()
PK ! /(W __init__.pynu [ """The asyncio package, tracking PEP 3156."""
import sys
# The selectors module is in the stdlib in Python 3.4 but not in 3.3.
# Do this first, so the other submodules can use "from . import selectors".
# Prefer asyncio/selectors.py over the stdlib one, as ours may be newer.
try:
from . import selectors
except ImportError:
import selectors # Will also be exported.
if sys.platform == 'win32':
# Similar thing for _overlapped.
try:
from . import _overlapped
except ImportError:
import _overlapped # Will also be exported.
# This relies on each of the submodules having an __all__ variable.
from .base_events import *
from .coroutines import *
from .events import *
from .futures import *
from .locks import *
from .protocols import *
from .queues import *
from .streams import *
from .subprocess import *
from .tasks import *
from .transports import *
__all__ = (base_events.__all__ +
coroutines.__all__ +
events.__all__ +
futures.__all__ +
locks.__all__ +
protocols.__all__ +
queues.__all__ +
streams.__all__ +
subprocess.__all__ +
tasks.__all__ +
transports.__all__)
if sys.platform == 'win32': # pragma: no cover
from .windows_events import *
__all__ += windows_events.__all__
else:
from .unix_events import * # pragma: no cover
__all__ += unix_events.__all__
PK !
NNR' R'
transports.pynu [ """Abstract Transport class."""
from asyncio import compat
__all__ = ['BaseTransport', 'ReadTransport', 'WriteTransport',
'Transport', 'DatagramTransport', 'SubprocessTransport',
]
class BaseTransport:
"""Base class for transports."""
def __init__(self, extra=None):
if extra is None:
extra = {}
self._extra = extra
def get_extra_info(self, name, default=None):
"""Get optional transport information."""
return self._extra.get(name, default)
def is_closing(self):
"""Return True if the transport is closing or closed."""
raise NotImplementedError
def close(self):
"""Close the transport.
Buffered data will be flushed asynchronously. No more data
will be received. After all buffered data is flushed, the
protocol's connection_lost() method will (eventually) called
with None as its argument.
"""
raise NotImplementedError
def set_protocol(self, protocol):
"""Set a new protocol."""
raise NotImplementedError
def get_protocol(self):
"""Return the current protocol."""
raise NotImplementedError
class ReadTransport(BaseTransport):
"""Interface for read-only transports."""
def pause_reading(self):
"""Pause the receiving end.
No data will be passed to the protocol's data_received()
method until resume_reading() is called.
"""
raise NotImplementedError
def resume_reading(self):
"""Resume the receiving end.
Data received will once again be passed to the protocol's
data_received() method.
"""
raise NotImplementedError
class WriteTransport(BaseTransport):
"""Interface for write-only transports."""
def set_write_buffer_limits(self, high=None, low=None):
"""Set the high- and low-water limits for write flow control.
These two values control when to call the protocol's
pause_writing() and resume_writing() methods. If specified,
the low-water limit must be less than or equal to the
high-water limit. Neither value can be negative.
The defaults are implementation-specific. If only the
high-water limit is given, the low-water limit defaults to an
implementation-specific value less than or equal to the
high-water limit. Setting high to zero forces low to zero as
well, and causes pause_writing() to be called whenever the
buffer becomes non-empty. Setting low to zero causes
resume_writing() to be called only once the buffer is empty.
Use of zero for either limit is generally sub-optimal as it
reduces opportunities for doing I/O and computation
concurrently.
"""
raise NotImplementedError
def get_write_buffer_size(self):
"""Return the current size of the write buffer."""
raise NotImplementedError
def write(self, data):
"""Write some data bytes to the transport.
This does not block; it buffers the data and arranges for it
to be sent out asynchronously.
"""
raise NotImplementedError
def writelines(self, list_of_data):
"""Write a list (or any iterable) of data bytes to the transport.
The default implementation concatenates the arguments and
calls write() on the result.
"""
data = compat.flatten_list_bytes(list_of_data)
self.write(data)
def write_eof(self):
"""Close the write end after flushing buffered data.
(This is like typing ^D into a UNIX program reading from stdin.)
Data may still be received.
"""
raise NotImplementedError
def can_write_eof(self):
"""Return True if this transport supports write_eof(), False if not."""
raise NotImplementedError
def abort(self):
"""Close the transport immediately.
Buffered data will be lost. No more data will be received.
The protocol's connection_lost() method will (eventually) be
called with None as its argument.
"""
raise NotImplementedError
class Transport(ReadTransport, WriteTransport):
"""Interface representing a bidirectional transport.
There may be several implementations, but typically, the user does
not implement new transports; rather, the platform provides some
useful transports that are implemented using the platform's best
practices.
The user never instantiates a transport directly; they call a
utility function, passing it a protocol factory and other
information necessary to create the transport and protocol. (E.g.
EventLoop.create_connection() or EventLoop.create_server().)
The utility function will asynchronously create a transport and a
protocol and hook them up by calling the protocol's
connection_made() method, passing it the transport.
The implementation here raises NotImplemented for every method
except writelines(), which calls write() in a loop.
"""
class DatagramTransport(BaseTransport):
"""Interface for datagram (UDP) transports."""
def sendto(self, data, addr=None):
"""Send data to the transport.
This does not block; it buffers the data and arranges for it
to be sent out asynchronously.
addr is target socket address.
If addr is None use target address pointed on transport creation.
"""
raise NotImplementedError
def abort(self):
"""Close the transport immediately.
Buffered data will be lost. No more data will be received.
The protocol's connection_lost() method will (eventually) be
called with None as its argument.
"""
raise NotImplementedError
class SubprocessTransport(BaseTransport):
def get_pid(self):
"""Get subprocess id."""
raise NotImplementedError
def get_returncode(self):
"""Get subprocess returncode.
See also
http://docs.python.org/3/library/subprocess#subprocess.Popen.returncode
"""
raise NotImplementedError
def get_pipe_transport(self, fd):
"""Get transport for pipe with number fd."""
raise NotImplementedError
def send_signal(self, signal):
"""Send signal to subprocess.
See also:
docs.python.org/3/library/subprocess#subprocess.Popen.send_signal
"""
raise NotImplementedError
def terminate(self):
"""Stop the subprocess.
Alias for close() method.
On Posix OSs the method sends SIGTERM to the subprocess.
On Windows the Win32 API function TerminateProcess()
is called to stop the subprocess.
See also:
http://docs.python.org/3/library/subprocess#subprocess.Popen.terminate
"""
raise NotImplementedError
def kill(self):
"""Kill the subprocess.
On Posix OSs the function sends SIGKILL to the subprocess.
On Windows kill() is an alias for terminate().
See also:
http://docs.python.org/3/library/subprocess#subprocess.Popen.kill
"""
raise NotImplementedError
class _FlowControlMixin(Transport):
"""All the logic for (write) flow control in a mix-in base class.
The subclass must implement get_write_buffer_size(). It must call
_maybe_pause_protocol() whenever the write buffer size increases,
and _maybe_resume_protocol() whenever it decreases. It may also
override set_write_buffer_limits() (e.g. to specify different
defaults).
The subclass constructor must call super().__init__(extra). This
will call set_write_buffer_limits().
The user may call set_write_buffer_limits() and
get_write_buffer_size(), and their protocol's pause_writing() and
resume_writing() may be called.
"""
def __init__(self, extra=None, loop=None):
super().__init__(extra)
assert loop is not None
self._loop = loop
self._protocol_paused = False
self._set_write_buffer_limits()
def _maybe_pause_protocol(self):
size = self.get_write_buffer_size()
if size <= self._high_water:
return
if not self._protocol_paused:
self._protocol_paused = True
try:
self._protocol.pause_writing()
except Exception as exc:
self._loop.call_exception_handler({
'message': 'protocol.pause_writing() failed',
'exception': exc,
'transport': self,
'protocol': self._protocol,
})
def _maybe_resume_protocol(self):
if (self._protocol_paused and
self.get_write_buffer_size() <= self._low_water):
self._protocol_paused = False
try:
self._protocol.resume_writing()
except Exception as exc:
self._loop.call_exception_handler({
'message': 'protocol.resume_writing() failed',
'exception': exc,
'transport': self,
'protocol': self._protocol,
})
def get_write_buffer_limits(self):
return (self._low_water, self._high_water)
def _set_write_buffer_limits(self, high=None, low=None):
if high is None:
if low is None:
high = 64*1024
else:
high = 4*low
if low is None:
low = high // 4
if not high >= low >= 0:
raise ValueError('high (%r) must be >= low (%r) must be >= 0' %
(high, low))
self._high_water = high
self._low_water = low
def set_write_buffer_limits(self, high=None, low=None):
self._set_write_buffer_limits(high=high, low=low)
self._maybe_pause_protocol()
def get_write_buffer_size(self):
raise NotImplementedError
PK ! yPa a
exceptions.pynu [ """asyncio exceptions."""
__all__ = ('CancelledError', 'InvalidStateError', 'TimeoutError',
'IncompleteReadError', 'LimitOverrunError',
'SendfileNotAvailableError')
class CancelledError(BaseException):
"""The Future or Task was cancelled."""
class TimeoutError(Exception):
"""The operation exceeded the given deadline."""
class InvalidStateError(Exception):
"""The operation is not allowed in this state."""
class SendfileNotAvailableError(RuntimeError):
"""Sendfile syscall is not available.
Raised if OS does not support sendfile syscall for given socket or
file type.
"""
class IncompleteReadError(EOFError):
"""
Incomplete read error. Attributes:
- partial: read bytes string before the end of stream was reached
- expected: total number of expected bytes (or None if unknown)
"""
def __init__(self, partial, expected):
r_expected = 'undefined' if expected is None else repr(expected)
super().__init__(f'{len(partial)} bytes read on a total of '
f'{r_expected} expected bytes')
self.partial = partial
self.expected = expected
def __reduce__(self):
return type(self), (self.partial, self.expected)
class LimitOverrunError(Exception):
"""Reached the buffer limit while looking for a separator.
Attributes:
- consumed: total number of to be consumed bytes.
"""
def __init__(self, message, consumed):
super().__init__(message)
self.consumed = consumed
def __reduce__(self):
return type(self), (self.args[0], self.consumed)
PK ! n
base_tasks.pynu [ import linecache
import traceback
from . import base_futures
from . import coroutines
def _task_repr_info(task):
info = base_futures._future_repr_info(task)
if task._must_cancel:
# replace status
info[0] = 'cancelling'
info.insert(1, 'name=%r' % task.get_name())
coro = coroutines._format_coroutine(task._coro)
info.insert(2, f'coro=<{coro}>')
if task._fut_waiter is not None:
info.insert(3, f'wait_for={task._fut_waiter!r}')
return info
def _task_get_stack(task, limit):
frames = []
if hasattr(task._coro, 'cr_frame'):
# case 1: 'async def' coroutines
f = task._coro.cr_frame
elif hasattr(task._coro, 'gi_frame'):
# case 2: legacy coroutines
f = task._coro.gi_frame
elif hasattr(task._coro, 'ag_frame'):
# case 3: async generators
f = task._coro.ag_frame
else:
# case 4: unknown objects
f = None
if f is not None:
while f is not None:
if limit is not None:
if limit <= 0:
break
limit -= 1
frames.append(f)
f = f.f_back
frames.reverse()
elif task._exception is not None:
tb = task._exception.__traceback__
while tb is not None:
if limit is not None:
if limit <= 0:
break
limit -= 1
frames.append(tb.tb_frame)
tb = tb.tb_next
return frames
def _task_print_stack(task, limit, file):
extracted_list = []
checked = set()
for f in task.get_stack(limit=limit):
lineno = f.f_lineno
co = f.f_code
filename = co.co_filename
name = co.co_name
if filename not in checked:
checked.add(filename)
linecache.checkcache(filename)
line = linecache.getline(filename, lineno, f.f_globals)
extracted_list.append((filename, lineno, name, line))
exc = task._exception
if not extracted_list:
print(f'No stack for {task!r}', file=file)
elif exc is not None:
print(f'Traceback for {task!r} (most recent call last):', file=file)
else:
print(f'Stack for {task!r} (most recent call last):', file=file)
traceback.print_list(extracted_list, file=file)
if exc is not None:
for line in traceback.format_exception_only(exc.__class__, exc):
print(line, file=file, end='')
PK ! fTY TY events.pynu [ """Event loop and event loop policy."""
__all__ = ['AbstractEventLoopPolicy',
'AbstractEventLoop', 'AbstractServer',
'Handle', 'TimerHandle',
'get_event_loop_policy', 'set_event_loop_policy',
'get_event_loop', 'set_event_loop', 'new_event_loop',
'get_child_watcher', 'set_child_watcher',
'_set_running_loop', '_get_running_loop',
]
import functools
import inspect
import os
import reprlib
import socket
import subprocess
import sys
import threading
import traceback
from asyncio import compat
def _get_function_source(func):
if compat.PY34:
func = inspect.unwrap(func)
elif hasattr(func, '__wrapped__'):
func = func.__wrapped__
if inspect.isfunction(func):
code = func.__code__
return (code.co_filename, code.co_firstlineno)
if isinstance(func, functools.partial):
return _get_function_source(func.func)
if compat.PY34 and isinstance(func, functools.partialmethod):
return _get_function_source(func.func)
return None
def _format_args_and_kwargs(args, kwargs):
"""Format function arguments and keyword arguments.
Special case for a single parameter: ('hello',) is formatted as ('hello').
"""
# use reprlib to limit the length of the output
items = []
if args:
items.extend(reprlib.repr(arg) for arg in args)
if kwargs:
items.extend('{}={}'.format(k, reprlib.repr(v))
for k, v in kwargs.items())
return '(' + ', '.join(items) + ')'
def _format_callback(func, args, kwargs, suffix=''):
if isinstance(func, functools.partial):
suffix = _format_args_and_kwargs(args, kwargs) + suffix
return _format_callback(func.func, func.args, func.keywords, suffix)
if hasattr(func, '__qualname__'):
func_repr = getattr(func, '__qualname__')
elif hasattr(func, '__name__'):
func_repr = getattr(func, '__name__')
else:
func_repr = repr(func)
func_repr += _format_args_and_kwargs(args, kwargs)
if suffix:
func_repr += suffix
return func_repr
def _format_callback_source(func, args):
func_repr = _format_callback(func, args, None)
source = _get_function_source(func)
if source:
func_repr += ' at %s:%s' % source
return func_repr
class Handle:
"""Object returned by callback registration methods."""
__slots__ = ('_callback', '_args', '_cancelled', '_loop',
'_source_traceback', '_repr', '__weakref__')
def __init__(self, callback, args, loop):
self._loop = loop
self._callback = callback
self._args = args
self._cancelled = False
self._repr = None
if self._loop.get_debug():
self._source_traceback = traceback.extract_stack(sys._getframe(1))
else:
self._source_traceback = None
def _repr_info(self):
info = [self.__class__.__name__]
if self._cancelled:
info.append('cancelled')
if self._callback is not None:
info.append(_format_callback_source(self._callback, self._args))
if self._source_traceback:
frame = self._source_traceback[-1]
info.append('created at %s:%s' % (frame[0], frame[1]))
return info
def __repr__(self):
if self._repr is not None:
return self._repr
info = self._repr_info()
return '<%s>' % ' '.join(info)
def cancel(self):
if not self._cancelled:
self._cancelled = True
if self._loop.get_debug():
# Keep a representation in debug mode to keep callback and
# parameters. For example, to log the warning
# "Executing took 2.5 second"
self._repr = repr(self)
self._callback = None
self._args = None
def _run(self):
try:
self._callback(*self._args)
except Exception as exc:
cb = _format_callback_source(self._callback, self._args)
msg = 'Exception in callback {}'.format(cb)
context = {
'message': msg,
'exception': exc,
'handle': self,
}
if self._source_traceback:
context['source_traceback'] = self._source_traceback
self._loop.call_exception_handler(context)
self = None # Needed to break cycles when an exception occurs.
class TimerHandle(Handle):
"""Object returned by timed callback registration methods."""
__slots__ = ['_scheduled', '_when']
def __init__(self, when, callback, args, loop):
assert when is not None
super().__init__(callback, args, loop)
if self._source_traceback:
del self._source_traceback[-1]
self._when = when
self._scheduled = False
def _repr_info(self):
info = super()._repr_info()
pos = 2 if self._cancelled else 1
info.insert(pos, 'when=%s' % self._when)
return info
def __hash__(self):
return hash(self._when)
def __lt__(self, other):
return self._when < other._when
def __le__(self, other):
if self._when < other._when:
return True
return self.__eq__(other)
def __gt__(self, other):
return self._when > other._when
def __ge__(self, other):
if self._when > other._when:
return True
return self.__eq__(other)
def __eq__(self, other):
if isinstance(other, TimerHandle):
return (self._when == other._when and
self._callback == other._callback and
self._args == other._args and
self._cancelled == other._cancelled)
return NotImplemented
def __ne__(self, other):
equal = self.__eq__(other)
return NotImplemented if equal is NotImplemented else not equal
def cancel(self):
if not self._cancelled:
self._loop._timer_handle_cancelled(self)
super().cancel()
class AbstractServer:
"""Abstract server returned by create_server()."""
def close(self):
"""Stop serving. This leaves existing connections open."""
return NotImplemented
def wait_closed(self):
"""Coroutine to wait until service is closed."""
return NotImplemented
class AbstractEventLoop:
"""Abstract event loop."""
# Running and stopping the event loop.
def run_forever(self):
"""Run the event loop until stop() is called."""
raise NotImplementedError
def run_until_complete(self, future):
"""Run the event loop until a Future is done.
Return the Future's result, or raise its exception.
"""
raise NotImplementedError
def stop(self):
"""Stop the event loop as soon as reasonable.
Exactly how soon that is may depend on the implementation, but
no more I/O callbacks should be scheduled.
"""
raise NotImplementedError
def is_running(self):
"""Return whether the event loop is currently running."""
raise NotImplementedError
def is_closed(self):
"""Returns True if the event loop was closed."""
raise NotImplementedError
def close(self):
"""Close the loop.
The loop should not be running.
This is idempotent and irreversible.
No other methods should be called after this one.
"""
raise NotImplementedError
def shutdown_asyncgens(self):
"""Shutdown all active asynchronous generators."""
raise NotImplementedError
# Methods scheduling callbacks. All these return Handles.
def _timer_handle_cancelled(self, handle):
"""Notification that a TimerHandle has been cancelled."""
raise NotImplementedError
def call_soon(self, callback, *args):
return self.call_later(0, callback, *args)
def call_later(self, delay, callback, *args):
raise NotImplementedError
def call_at(self, when, callback, *args):
raise NotImplementedError
def time(self):
raise NotImplementedError
def create_future(self):
raise NotImplementedError
# Method scheduling a coroutine object: create a task.
def create_task(self, coro):
raise NotImplementedError
# Methods for interacting with threads.
def call_soon_threadsafe(self, callback, *args):
raise NotImplementedError
def run_in_executor(self, executor, func, *args):
raise NotImplementedError
def set_default_executor(self, executor):
raise NotImplementedError
# Network I/O methods returning Futures.
def getaddrinfo(self, host, port, *, family=0, type=0, proto=0, flags=0):
raise NotImplementedError
def getnameinfo(self, sockaddr, flags=0):
raise NotImplementedError
def create_connection(self, protocol_factory, host=None, port=None, *,
ssl=None, family=0, proto=0, flags=0, sock=None,
local_addr=None, server_hostname=None):
raise NotImplementedError
def create_server(self, protocol_factory, host=None, port=None, *,
family=socket.AF_UNSPEC, flags=socket.AI_PASSIVE,
sock=None, backlog=100, ssl=None, reuse_address=None,
reuse_port=None):
"""A coroutine which creates a TCP server bound to host and port.
The return value is a Server object which can be used to stop
the service.
If host is an empty string or None all interfaces are assumed
and a list of multiple sockets will be returned (most likely
one for IPv4 and another one for IPv6). The host parameter can also be a
sequence (e.g. list) of hosts to bind to.
family can be set to either AF_INET or AF_INET6 to force the
socket to use IPv4 or IPv6. If not set it will be determined
from host (defaults to AF_UNSPEC).
flags is a bitmask for getaddrinfo().
sock can optionally be specified in order to use a preexisting
socket object.
backlog is the maximum number of queued connections passed to
listen() (defaults to 100).
ssl can be set to an SSLContext to enable SSL over the
accepted connections.
reuse_address tells the kernel to reuse a local socket in
TIME_WAIT state, without waiting for its natural timeout to
expire. If not specified will automatically be set to True on
UNIX.
reuse_port tells the kernel to allow this endpoint to be bound to
the same port as other existing endpoints are bound to, so long as
they all set this flag when being created. This option is not
supported on Windows.
"""
raise NotImplementedError
def create_unix_connection(self, protocol_factory, path, *,
ssl=None, sock=None,
server_hostname=None):
raise NotImplementedError
def create_unix_server(self, protocol_factory, path, *,
sock=None, backlog=100, ssl=None):
"""A coroutine which creates a UNIX Domain Socket server.
The return value is a Server object, which can be used to stop
the service.
path is a str, representing a file systsem path to bind the
server socket to.
sock can optionally be specified in order to use a preexisting
socket object.
backlog is the maximum number of queued connections passed to
listen() (defaults to 100).
ssl can be set to an SSLContext to enable SSL over the
accepted connections.
"""
raise NotImplementedError
def create_datagram_endpoint(self, protocol_factory,
local_addr=None, remote_addr=None, *,
family=0, proto=0, flags=0,
reuse_address=None, reuse_port=None,
allow_broadcast=None, sock=None):
"""A coroutine which creates a datagram endpoint.
This method will try to establish the endpoint in the background.
When successful, the coroutine returns a (transport, protocol) pair.
protocol_factory must be a callable returning a protocol instance.
socket family AF_INET or socket.AF_INET6 depending on host (or
family if specified), socket type SOCK_DGRAM.
reuse_address tells the kernel to reuse a local socket in
TIME_WAIT state, without waiting for its natural timeout to
expire. If not specified it will automatically be set to True on
UNIX.
reuse_port tells the kernel to allow this endpoint to be bound to
the same port as other existing endpoints are bound to, so long as
they all set this flag when being created. This option is not
supported on Windows and some UNIX's. If the
:py:data:`~socket.SO_REUSEPORT` constant is not defined then this
capability is unsupported.
allow_broadcast tells the kernel to allow this endpoint to send
messages to the broadcast address.
sock can optionally be specified in order to use a preexisting
socket object.
"""
raise NotImplementedError
# Pipes and subprocesses.
def connect_read_pipe(self, protocol_factory, pipe):
"""Register read pipe in event loop. Set the pipe to non-blocking mode.
protocol_factory should instantiate object with Protocol interface.
pipe is a file-like object.
Return pair (transport, protocol), where transport supports the
ReadTransport interface."""
# The reason to accept file-like object instead of just file descriptor
# is: we need to own pipe and close it at transport finishing
# Can got complicated errors if pass f.fileno(),
# close fd in pipe transport then close f and vise versa.
raise NotImplementedError
def connect_write_pipe(self, protocol_factory, pipe):
"""Register write pipe in event loop.
protocol_factory should instantiate object with BaseProtocol interface.
Pipe is file-like object already switched to nonblocking.
Return pair (transport, protocol), where transport support
WriteTransport interface."""
# The reason to accept file-like object instead of just file descriptor
# is: we need to own pipe and close it at transport finishing
# Can got complicated errors if pass f.fileno(),
# close fd in pipe transport then close f and vise versa.
raise NotImplementedError
def subprocess_shell(self, protocol_factory, cmd, *, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
**kwargs):
raise NotImplementedError
def subprocess_exec(self, protocol_factory, *args, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
**kwargs):
raise NotImplementedError
# Ready-based callback registration methods.
# The add_*() methods return None.
# The remove_*() methods return True if something was removed,
# False if there was nothing to delete.
def add_reader(self, fd, callback, *args):
raise NotImplementedError
def remove_reader(self, fd):
raise NotImplementedError
def add_writer(self, fd, callback, *args):
raise NotImplementedError
def remove_writer(self, fd):
raise NotImplementedError
# Completion based I/O methods returning Futures.
def sock_recv(self, sock, nbytes):
raise NotImplementedError
def sock_sendall(self, sock, data):
raise NotImplementedError
def sock_connect(self, sock, address):
raise NotImplementedError
def sock_accept(self, sock):
raise NotImplementedError
# Signal handling.
def add_signal_handler(self, sig, callback, *args):
raise NotImplementedError
def remove_signal_handler(self, sig):
raise NotImplementedError
# Task factory.
def set_task_factory(self, factory):
raise NotImplementedError
def get_task_factory(self):
raise NotImplementedError
# Error handlers.
def get_exception_handler(self):
raise NotImplementedError
def set_exception_handler(self, handler):
raise NotImplementedError
def default_exception_handler(self, context):
raise NotImplementedError
def call_exception_handler(self, context):
raise NotImplementedError
# Debug flag management.
def get_debug(self):
raise NotImplementedError
def set_debug(self, enabled):
raise NotImplementedError
class AbstractEventLoopPolicy:
"""Abstract policy for accessing the event loop."""
def get_event_loop(self):
"""Get the event loop for the current context.
Returns an event loop object implementing the BaseEventLoop interface,
or raises an exception in case no event loop has been set for the
current context and the current policy does not specify to create one.
It should never return None."""
raise NotImplementedError
def set_event_loop(self, loop):
"""Set the event loop for the current context to loop."""
raise NotImplementedError
def new_event_loop(self):
"""Create and return a new event loop object according to this
policy's rules. If there's need to set this loop as the event loop for
the current context, set_event_loop must be called explicitly."""
raise NotImplementedError
# Child processes handling (Unix only).
def get_child_watcher(self):
"Get the watcher for child processes."
raise NotImplementedError
def set_child_watcher(self, watcher):
"""Set the watcher for child processes."""
raise NotImplementedError
class BaseDefaultEventLoopPolicy(AbstractEventLoopPolicy):
"""Default policy implementation for accessing the event loop.
In this policy, each thread has its own event loop. However, we
only automatically create an event loop by default for the main
thread; other threads by default have no event loop.
Other policies may have different rules (e.g. a single global
event loop, or automatically creating an event loop per thread, or
using some other notion of context to which an event loop is
associated).
"""
_loop_factory = None
class _Local(threading.local):
_loop = None
_set_called = False
def __init__(self):
self._local = self._Local()
def get_event_loop(self):
"""Get the event loop.
This may be None or an instance of EventLoop.
"""
if (self._local._loop is None and
not self._local._set_called and
isinstance(threading.current_thread(), threading._MainThread)):
self.set_event_loop(self.new_event_loop())
if self._local._loop is None:
raise RuntimeError('There is no current event loop in thread %r.'
% threading.current_thread().name)
return self._local._loop
def set_event_loop(self, loop):
"""Set the event loop."""
self._local._set_called = True
assert loop is None or isinstance(loop, AbstractEventLoop)
self._local._loop = loop
def new_event_loop(self):
"""Create a new event loop.
You must call set_event_loop() to make this the current event
loop.
"""
return self._loop_factory()
# Event loop policy. The policy itself is always global, even if the
# policy's rules say that there is an event loop per thread (or other
# notion of context). The default policy is installed by the first
# call to get_event_loop_policy().
_event_loop_policy = None
# Lock for protecting the on-the-fly creation of the event loop policy.
_lock = threading.Lock()
# A TLS for the running event loop, used by _get_running_loop.
class _RunningLoop(threading.local):
_loop = None
_pid = None
_running_loop = _RunningLoop()
def _get_running_loop():
"""Return the running event loop or None.
This is a low-level function intended to be used by event loops.
This function is thread-specific.
"""
running_loop = _running_loop._loop
if running_loop is not None and _running_loop._pid == os.getpid():
return running_loop
def _set_running_loop(loop):
"""Set the running event loop.
This is a low-level function intended to be used by event loops.
This function is thread-specific.
"""
_running_loop._pid = os.getpid()
_running_loop._loop = loop
def _init_event_loop_policy():
global _event_loop_policy
with _lock:
if _event_loop_policy is None: # pragma: no branch
from . import DefaultEventLoopPolicy
_event_loop_policy = DefaultEventLoopPolicy()
def get_event_loop_policy():
"""Get the current event loop policy."""
if _event_loop_policy is None:
_init_event_loop_policy()
return _event_loop_policy
def set_event_loop_policy(policy):
"""Set the current event loop policy.
If policy is None, the default policy is restored."""
global _event_loop_policy
assert policy is None or isinstance(policy, AbstractEventLoopPolicy)
_event_loop_policy = policy
def get_event_loop():
"""Return an asyncio event loop.
When called from a coroutine or a callback (e.g. scheduled with call_soon
or similar API), this function will always return the running event loop.
If there is no running event loop set, the function will return
the result of `get_event_loop_policy().get_event_loop()` call.
"""
current_loop = _get_running_loop()
if current_loop is not None:
return current_loop
return get_event_loop_policy().get_event_loop()
def set_event_loop(loop):
"""Equivalent to calling get_event_loop_policy().set_event_loop(loop)."""
get_event_loop_policy().set_event_loop(loop)
def new_event_loop():
"""Equivalent to calling get_event_loop_policy().new_event_loop()."""
return get_event_loop_policy().new_event_loop()
def get_child_watcher():
"""Equivalent to calling get_event_loop_policy().get_child_watcher()."""
return get_event_loop_policy().get_child_watcher()
def set_child_watcher(watcher):
"""Equivalent to calling
get_event_loop_policy().set_child_watcher(watcher)."""
return get_event_loop_policy().set_child_watcher(watcher)
PK ! 3
subprocess.pynu [ __all__ = ['create_subprocess_exec', 'create_subprocess_shell']
import subprocess
from . import events
from . import protocols
from . import streams
from . import tasks
from .coroutines import coroutine
from .log import logger
PIPE = subprocess.PIPE
STDOUT = subprocess.STDOUT
DEVNULL = subprocess.DEVNULL
class SubprocessStreamProtocol(streams.FlowControlMixin,
protocols.SubprocessProtocol):
"""Like StreamReaderProtocol, but for a subprocess."""
def __init__(self, limit, loop):
super().__init__(loop=loop)
self._limit = limit
self.stdin = self.stdout = self.stderr = None
self._transport = None
self._process_exited = False
self._pipe_fds = []
def __repr__(self):
info = [self.__class__.__name__]
if self.stdin is not None:
info.append('stdin=%r' % self.stdin)
if self.stdout is not None:
info.append('stdout=%r' % self.stdout)
if self.stderr is not None:
info.append('stderr=%r' % self.stderr)
return '<%s>' % ' '.join(info)
def connection_made(self, transport):
self._transport = transport
stdout_transport = transport.get_pipe_transport(1)
if stdout_transport is not None:
self.stdout = streams.StreamReader(limit=self._limit,
loop=self._loop)
self.stdout.set_transport(stdout_transport)
self._pipe_fds.append(1)
stderr_transport = transport.get_pipe_transport(2)
if stderr_transport is not None:
self.stderr = streams.StreamReader(limit=self._limit,
loop=self._loop)
self.stderr.set_transport(stderr_transport)
self._pipe_fds.append(2)
stdin_transport = transport.get_pipe_transport(0)
if stdin_transport is not None:
self.stdin = streams.StreamWriter(stdin_transport,
protocol=self,
reader=None,
loop=self._loop)
def pipe_data_received(self, fd, data):
if fd == 1:
reader = self.stdout
elif fd == 2:
reader = self.stderr
else:
reader = None
if reader is not None:
reader.feed_data(data)
def pipe_connection_lost(self, fd, exc):
if fd == 0:
pipe = self.stdin
if pipe is not None:
pipe.close()
self.connection_lost(exc)
return
if fd == 1:
reader = self.stdout
elif fd == 2:
reader = self.stderr
else:
reader = None
if reader != None:
if exc is None:
reader.feed_eof()
else:
reader.set_exception(exc)
if fd in self._pipe_fds:
self._pipe_fds.remove(fd)
self._maybe_close_transport()
def process_exited(self):
self._process_exited = True
self._maybe_close_transport()
def _maybe_close_transport(self):
if len(self._pipe_fds) == 0 and self._process_exited:
self._transport.close()
self._transport = None
class Process:
def __init__(self, transport, protocol, loop):
self._transport = transport
self._protocol = protocol
self._loop = loop
self.stdin = protocol.stdin
self.stdout = protocol.stdout
self.stderr = protocol.stderr
self.pid = transport.get_pid()
def __repr__(self):
return '<%s %s>' % (self.__class__.__name__, self.pid)
@property
def returncode(self):
return self._transport.get_returncode()
@coroutine
def wait(self):
"""Wait until the process exit and return the process return code.
This method is a coroutine."""
return (yield from self._transport._wait())
def send_signal(self, signal):
self._transport.send_signal(signal)
def terminate(self):
self._transport.terminate()
def kill(self):
self._transport.kill()
@coroutine
def _feed_stdin(self, input):
debug = self._loop.get_debug()
self.stdin.write(input)
if debug:
logger.debug('%r communicate: feed stdin (%s bytes)',
self, len(input))
try:
yield from self.stdin.drain()
except (BrokenPipeError, ConnectionResetError) as exc:
# communicate() ignores BrokenPipeError and ConnectionResetError
if debug:
logger.debug('%r communicate: stdin got %r', self, exc)
if debug:
logger.debug('%r communicate: close stdin', self)
self.stdin.close()
@coroutine
def _noop(self):
return None
@coroutine
def _read_stream(self, fd):
transport = self._transport.get_pipe_transport(fd)
if fd == 2:
stream = self.stderr
else:
assert fd == 1
stream = self.stdout
if self._loop.get_debug():
name = 'stdout' if fd == 1 else 'stderr'
logger.debug('%r communicate: read %s', self, name)
output = yield from stream.read()
if self._loop.get_debug():
name = 'stdout' if fd == 1 else 'stderr'
logger.debug('%r communicate: close %s', self, name)
transport.close()
return output
@coroutine
def communicate(self, input=None):
if input is not None:
stdin = self._feed_stdin(input)
else:
stdin = self._noop()
if self.stdout is not None:
stdout = self._read_stream(1)
else:
stdout = self._noop()
if self.stderr is not None:
stderr = self._read_stream(2)
else:
stderr = self._noop()
stdin, stdout, stderr = yield from tasks.gather(stdin, stdout, stderr,
loop=self._loop)
yield from self.wait()
return (stdout, stderr)
@coroutine
def create_subprocess_shell(cmd, stdin=None, stdout=None, stderr=None,
loop=None, limit=streams._DEFAULT_LIMIT, **kwds):
if loop is None:
loop = events.get_event_loop()
protocol_factory = lambda: SubprocessStreamProtocol(limit=limit,
loop=loop)
transport, protocol = yield from loop.subprocess_shell(
protocol_factory,
cmd, stdin=stdin, stdout=stdout,
stderr=stderr, **kwds)
return Process(transport, protocol, loop)
@coroutine
def create_subprocess_exec(program, *args, stdin=None, stdout=None,
stderr=None, loop=None,
limit=streams._DEFAULT_LIMIT, **kwds):
if loop is None:
loop = events.get_event_loop()
protocol_factory = lambda: SubprocessStreamProtocol(limit=limit,
loop=loop)
transport, protocol = yield from loop.subprocess_exec(
protocol_factory,
program, *args,
stdin=stdin, stdout=stdout,
stderr=stderr, **kwds)
return Process(transport, protocol, loop)
PK ! mX3
3
__main__.pynu [ import ast
import asyncio
import code
import concurrent.futures
import inspect
import sys
import threading
import types
import warnings
from . import futures
class AsyncIOInteractiveConsole(code.InteractiveConsole):
def __init__(self, locals, loop):
super().__init__(locals)
self.compile.compiler.flags |= ast.PyCF_ALLOW_TOP_LEVEL_AWAIT
self.loop = loop
def runcode(self, code):
future = concurrent.futures.Future()
def callback():
global repl_future
global repl_future_interrupted
repl_future = None
repl_future_interrupted = False
func = types.FunctionType(code, self.locals)
try:
coro = func()
except SystemExit:
raise
except KeyboardInterrupt as ex:
repl_future_interrupted = True
future.set_exception(ex)
return
except BaseException as ex:
future.set_exception(ex)
return
if not inspect.iscoroutine(coro):
future.set_result(coro)
return
try:
repl_future = self.loop.create_task(coro)
futures._chain_future(repl_future, future)
except BaseException as exc:
future.set_exception(exc)
loop.call_soon_threadsafe(callback)
try:
return future.result()
except SystemExit:
raise
except BaseException:
if repl_future_interrupted:
self.write("\nKeyboardInterrupt\n")
else:
self.showtraceback()
class REPLThread(threading.Thread):
def run(self):
try:
banner = (
f'asyncio REPL {sys.version} on {sys.platform}\n'
f'Use "await" directly instead of "asyncio.run()".\n'
f'Type "help", "copyright", "credits" or "license" '
f'for more information.\n'
f'{getattr(sys, "ps1", ">>> ")}import asyncio'
)
console.interact(
banner=banner,
exitmsg='exiting asyncio REPL...')
finally:
warnings.filterwarnings(
'ignore',
message=r'^coroutine .* was never awaited$',
category=RuntimeWarning)
loop.call_soon_threadsafe(loop.stop)
if __name__ == '__main__':
sys.audit("cpython.run_stdin")
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
repl_locals = {'asyncio': asyncio}
for key in {'__name__', '__package__',
'__loader__', '__spec__',
'__builtins__', '__file__'}:
repl_locals[key] = locals()[key]
console = AsyncIOInteractiveConsole(repl_locals, loop)
repl_future = None
repl_future_interrupted = False
try:
import readline # NoQA
except ImportError:
pass
repl_thread = REPLThread()
repl_thread.daemon = True
repl_thread.start()
while True:
try:
loop.run_forever()
except KeyboardInterrupt:
if repl_future and not repl_future.done():
repl_future.cancel()
repl_future_interrupted = True
continue
else:
break
PK !
base_futures.pynu [ __all__ = ()
import reprlib
from _thread import get_ident
from . import format_helpers
# States for Future.
_PENDING = 'PENDING'
_CANCELLED = 'CANCELLED'
_FINISHED = 'FINISHED'
def isfuture(obj):
"""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.
"""
return (hasattr(obj.__class__, '_asyncio_future_blocking') and
obj._asyncio_future_blocking is not None)
def _format_callbacks(cb):
"""helper function for Future.__repr__"""
size = len(cb)
if not size:
cb = ''
def format_cb(callback):
return format_helpers._format_callback_source(callback, ())
if size == 1:
cb = format_cb(cb[0][0])
elif size == 2:
cb = '{}, {}'.format(format_cb(cb[0][0]), format_cb(cb[1][0]))
elif size > 2:
cb = '{}, <{} more>, {}'.format(format_cb(cb[0][0]),
size - 2,
format_cb(cb[-1][0]))
return f'cb=[{cb}]'
# bpo-42183: _repr_running is needed for repr protection
# when a Future or Task result contains itself directly or indirectly.
# The logic is borrowed from @reprlib.recursive_repr decorator.
# Unfortunately, the direct decorator usage is impossible because of
# AttributeError: '_asyncio.Task' object has no attribute '__module__' error.
#
# After fixing this thing we can return to the decorator based approach.
_repr_running = set()
def _future_repr_info(future):
# (Future) -> str
"""helper function for Future.__repr__"""
info = [future._state.lower()]
if future._state == _FINISHED:
if future._exception is not None:
info.append(f'exception={future._exception!r}')
else:
key = id(future), get_ident()
if key in _repr_running:
result = '...'
else:
_repr_running.add(key)
try:
# use reprlib to limit the length of the output, especially
# for very long strings
result = reprlib.repr(future._result)
finally:
_repr_running.discard(key)
info.append(f'result={result}')
if future._callbacks:
info.append(_format_callbacks(future._callbacks))
if future._source_traceback:
frame = future._source_traceback[-1]
info.append(f'created at {frame[0]}:{frame[1]}')
return info
PK ! ҰɥN N proactor_events.pynu [ """Event loop using a proactor and related classes.
A proactor is a "notify-on-completion" multiplexer. Currently a
proactor is only implemented on Windows with IOCP.
"""
__all__ = ['BaseProactorEventLoop']
import socket
import warnings
from . import base_events
from . import compat
from . import constants
from . import futures
from . import sslproto
from . import transports
from .log import logger
class _ProactorBasePipeTransport(transports._FlowControlMixin,
transports.BaseTransport):
"""Base class for pipe and socket transports."""
def __init__(self, loop, sock, protocol, waiter=None,
extra=None, server=None):
super().__init__(extra, loop)
self._set_extra(sock)
self._sock = sock
self._protocol = protocol
self._server = server
self._buffer = None # None or bytearray.
self._read_fut = None
self._write_fut = None
self._pending_write = 0
self._conn_lost = 0
self._closing = False # Set when close() called.
self._eof_written = False
if self._server is not None:
self._server._attach()
self._loop.call_soon(self._protocol.connection_made, self)
if waiter is not None:
# only wake up the waiter when connection_made() has been called
self._loop.call_soon(futures._set_result_unless_cancelled,
waiter, None)
def __repr__(self):
info = [self.__class__.__name__]
if self._sock is None:
info.append('closed')
elif self._closing:
info.append('closing')
if self._sock is not None:
info.append('fd=%s' % self._sock.fileno())
if self._read_fut is not None:
info.append('read=%s' % self._read_fut)
if self._write_fut is not None:
info.append("write=%r" % self._write_fut)
if self._buffer:
bufsize = len(self._buffer)
info.append('write_bufsize=%s' % bufsize)
if self._eof_written:
info.append('EOF written')
return '<%s>' % ' '.join(info)
def _set_extra(self, sock):
self._extra['pipe'] = sock
def set_protocol(self, protocol):
self._protocol = protocol
def get_protocol(self):
return self._protocol
def is_closing(self):
return self._closing
def close(self):
if self._closing:
return
self._closing = True
self._conn_lost += 1
if not self._buffer and self._write_fut is None:
self._loop.call_soon(self._call_connection_lost, None)
if self._read_fut is not None:
self._read_fut.cancel()
self._read_fut = None
# On Python 3.3 and older, objects with a destructor part of a reference
# cycle are never destroyed. It's not more the case on Python 3.4 thanks
# to the PEP 442.
if compat.PY34:
def __del__(self):
if self._sock is not None:
warnings.warn("unclosed transport %r" % self, ResourceWarning)
self.close()
def _fatal_error(self, exc, message='Fatal error on pipe transport'):
if isinstance(exc, base_events._FATAL_ERROR_IGNORE):
if self._loop.get_debug():
logger.debug("%r: %s", self, message, exc_info=True)
else:
self._loop.call_exception_handler({
'message': message,
'exception': exc,
'transport': self,
'protocol': self._protocol,
})
self._force_close(exc)
def _force_close(self, exc):
if self._closing:
return
self._closing = True
self._conn_lost += 1
if self._write_fut:
self._write_fut.cancel()
self._write_fut = None
if self._read_fut:
self._read_fut.cancel()
self._read_fut = None
self._pending_write = 0
self._buffer = None
self._loop.call_soon(self._call_connection_lost, exc)
def _call_connection_lost(self, exc):
try:
self._protocol.connection_lost(exc)
finally:
# XXX If there is a pending overlapped read on the other
# end then it may fail with ERROR_NETNAME_DELETED if we
# just close our end. First calling shutdown() seems to
# cure it, but maybe using DisconnectEx() would be better.
if hasattr(self._sock, 'shutdown'):
self._sock.shutdown(socket.SHUT_RDWR)
self._sock.close()
self._sock = None
server = self._server
if server is not None:
server._detach()
self._server = None
def get_write_buffer_size(self):
size = self._pending_write
if self._buffer is not None:
size += len(self._buffer)
return size
class _ProactorReadPipeTransport(_ProactorBasePipeTransport,
transports.ReadTransport):
"""Transport for read pipes."""
def __init__(self, loop, sock, protocol, waiter=None,
extra=None, server=None):
super().__init__(loop, sock, protocol, waiter, extra, server)
self._paused = False
self._loop.call_soon(self._loop_reading)
def pause_reading(self):
if self._closing:
raise RuntimeError('Cannot pause_reading() when closing')
if self._paused:
raise RuntimeError('Already paused')
self._paused = True
if self._loop.get_debug():
logger.debug("%r pauses reading", self)
def resume_reading(self):
if not self._paused:
raise RuntimeError('Not paused')
self._paused = False
if self._closing:
return
self._loop.call_soon(self._loop_reading, self._read_fut)
if self._loop.get_debug():
logger.debug("%r resumes reading", self)
def _loop_reading(self, fut=None):
if self._paused:
return
data = None
try:
if fut is not None:
assert self._read_fut is fut or (self._read_fut is None and
self._closing)
self._read_fut = None
data = fut.result() # deliver data later in "finally" clause
if self._closing:
# since close() has been called we ignore any read data
data = None
return
if data == b'':
# we got end-of-file so no need to reschedule a new read
return
# reschedule a new read
self._read_fut = self._loop._proactor.recv(self._sock, 4096)
except ConnectionAbortedError as exc:
if not self._closing:
self._fatal_error(exc, 'Fatal read error on pipe transport')
elif self._loop.get_debug():
logger.debug("Read error on pipe transport while closing",
exc_info=True)
except ConnectionResetError as exc:
self._force_close(exc)
except OSError as exc:
self._fatal_error(exc, 'Fatal read error on pipe transport')
except futures.CancelledError:
if not self._closing:
raise
else:
self._read_fut.add_done_callback(self._loop_reading)
finally:
if data:
self._protocol.data_received(data)
elif data is not None:
if self._loop.get_debug():
logger.debug("%r received EOF", self)
keep_open = self._protocol.eof_received()
if not keep_open:
self.close()
class _ProactorBaseWritePipeTransport(_ProactorBasePipeTransport,
transports.WriteTransport):
"""Transport for write pipes."""
def write(self, data):
if not isinstance(data, (bytes, bytearray, memoryview)):
msg = ("data argument must be a bytes-like object, not '%s'" %
type(data).__name__)
raise TypeError(msg)
if self._eof_written:
raise RuntimeError('write_eof() already called')
if not data:
return
if self._conn_lost:
if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
logger.warning('socket.send() raised exception.')
self._conn_lost += 1
return
# Observable states:
# 1. IDLE: _write_fut and _buffer both None
# 2. WRITING: _write_fut set; _buffer None
# 3. BACKED UP: _write_fut set; _buffer a bytearray
# We always copy the data, so the caller can't modify it
# while we're still waiting for the I/O to happen.
if self._write_fut is None: # IDLE -> WRITING
assert self._buffer is None
# Pass a copy, except if it's already immutable.
self._loop_writing(data=bytes(data))
elif not self._buffer: # WRITING -> BACKED UP
# Make a mutable copy which we can extend.
self._buffer = bytearray(data)
self._maybe_pause_protocol()
else: # BACKED UP
# Append to buffer (also copies).
self._buffer.extend(data)
self._maybe_pause_protocol()
def _loop_writing(self, f=None, data=None):
try:
assert f is self._write_fut
self._write_fut = None
self._pending_write = 0
if f:
f.result()
if data is None:
data = self._buffer
self._buffer = None
if not data:
if self._closing:
self._loop.call_soon(self._call_connection_lost, None)
if self._eof_written:
self._sock.shutdown(socket.SHUT_WR)
# Now that we've reduced the buffer size, tell the
# protocol to resume writing if it was paused. Note that
# we do this last since the callback is called immediately
# and it may add more data to the buffer (even causing the
# protocol to be paused again).
self._maybe_resume_protocol()
else:
self._write_fut = self._loop._proactor.send(self._sock, data)
if not self._write_fut.done():
assert self._pending_write == 0
self._pending_write = len(data)
self._write_fut.add_done_callback(self._loop_writing)
self._maybe_pause_protocol()
else:
self._write_fut.add_done_callback(self._loop_writing)
except ConnectionResetError as exc:
self._force_close(exc)
except OSError as exc:
self._fatal_error(exc, 'Fatal write error on pipe transport')
def can_write_eof(self):
return True
def write_eof(self):
self.close()
def abort(self):
self._force_close(None)
class _ProactorWritePipeTransport(_ProactorBaseWritePipeTransport):
def __init__(self, *args, **kw):
super().__init__(*args, **kw)
self._read_fut = self._loop._proactor.recv(self._sock, 16)
self._read_fut.add_done_callback(self._pipe_closed)
def _pipe_closed(self, fut):
if fut.cancelled():
# the transport has been closed
return
assert fut.result() == b''
if self._closing:
assert self._read_fut is None
return
assert fut is self._read_fut, (fut, self._read_fut)
self._read_fut = None
if self._write_fut is not None:
self._force_close(BrokenPipeError())
else:
self.close()
class _ProactorDuplexPipeTransport(_ProactorReadPipeTransport,
_ProactorBaseWritePipeTransport,
transports.Transport):
"""Transport for duplex pipes."""
def can_write_eof(self):
return False
def write_eof(self):
raise NotImplementedError
class _ProactorSocketTransport(_ProactorReadPipeTransport,
_ProactorBaseWritePipeTransport,
transports.Transport):
"""Transport for connected sockets."""
def _set_extra(self, sock):
self._extra['socket'] = sock
try:
self._extra['sockname'] = sock.getsockname()
except (socket.error, AttributeError):
if self._loop.get_debug():
logger.warning("getsockname() failed on %r",
sock, exc_info=True)
if 'peername' not in self._extra:
try:
self._extra['peername'] = sock.getpeername()
except (socket.error, AttributeError):
if self._loop.get_debug():
logger.warning("getpeername() failed on %r",
sock, exc_info=True)
def can_write_eof(self):
return True
def write_eof(self):
if self._closing or self._eof_written:
return
self._eof_written = True
if self._write_fut is None:
self._sock.shutdown(socket.SHUT_WR)
class BaseProactorEventLoop(base_events.BaseEventLoop):
def __init__(self, proactor):
super().__init__()
logger.debug('Using proactor: %s', proactor.__class__.__name__)
self._proactor = proactor
self._selector = proactor # convenient alias
self._self_reading_future = None
self._accept_futures = {} # socket file descriptor => Future
proactor.set_loop(self)
self._make_self_pipe()
def _make_socket_transport(self, sock, protocol, waiter=None,
extra=None, server=None):
return _ProactorSocketTransport(self, sock, protocol, waiter,
extra, server)
def _make_ssl_transport(self, rawsock, protocol, sslcontext, waiter=None,
*, server_side=False, server_hostname=None,
extra=None, server=None):
if not sslproto._is_sslproto_available():
raise NotImplementedError("Proactor event loop requires Python 3.5"
" or newer (ssl.MemoryBIO) to support "
"SSL")
ssl_protocol = sslproto.SSLProtocol(self, protocol, sslcontext, waiter,
server_side, server_hostname)
_ProactorSocketTransport(self, rawsock, ssl_protocol,
extra=extra, server=server)
return ssl_protocol._app_transport
def _make_duplex_pipe_transport(self, sock, protocol, waiter=None,
extra=None):
return _ProactorDuplexPipeTransport(self,
sock, protocol, waiter, extra)
def _make_read_pipe_transport(self, sock, protocol, waiter=None,
extra=None):
return _ProactorReadPipeTransport(self, sock, protocol, waiter, extra)
def _make_write_pipe_transport(self, sock, protocol, waiter=None,
extra=None):
# We want connection_lost() to be called when other end closes
return _ProactorWritePipeTransport(self,
sock, protocol, waiter, extra)
def close(self):
if self.is_running():
raise RuntimeError("Cannot close a running event loop")
if self.is_closed():
return
# Call these methods before closing the event loop (before calling
# BaseEventLoop.close), because they can schedule callbacks with
# call_soon(), which is forbidden when the event loop is closed.
self._stop_accept_futures()
self._close_self_pipe()
self._proactor.close()
self._proactor = None
self._selector = None
# Close the event loop
super().close()
def sock_recv(self, sock, n):
return self._proactor.recv(sock, n)
def sock_sendall(self, sock, data):
return self._proactor.send(sock, data)
def sock_connect(self, sock, address):
return self._proactor.connect(sock, address)
def sock_accept(self, sock):
return self._proactor.accept(sock)
def _socketpair(self):
raise NotImplementedError
def _close_self_pipe(self):
if self._self_reading_future is not None:
self._self_reading_future.cancel()
self._self_reading_future = None
self._ssock.close()
self._ssock = None
self._csock.close()
self._csock = None
self._internal_fds -= 1
def _make_self_pipe(self):
# A self-socket, really. :-)
self._ssock, self._csock = self._socketpair()
self._ssock.setblocking(False)
self._csock.setblocking(False)
self._internal_fds += 1
self.call_soon(self._loop_self_reading)
def _loop_self_reading(self, f=None):
try:
if f is not None:
f.result() # may raise
f = self._proactor.recv(self._ssock, 4096)
except futures.CancelledError:
# _close_self_pipe() has been called, stop waiting for data
return
except Exception as exc:
self.call_exception_handler({
'message': 'Error on reading from the event loop self pipe',
'exception': exc,
'loop': self,
})
else:
self._self_reading_future = f
f.add_done_callback(self._loop_self_reading)
def _write_to_self(self):
self._csock.send(b'\0')
def _start_serving(self, protocol_factory, sock,
sslcontext=None, server=None, backlog=100):
def loop(f=None):
try:
if f is not None:
conn, addr = f.result()
if self._debug:
logger.debug("%r got a new connection from %r: %r",
server, addr, conn)
protocol = protocol_factory()
if sslcontext is not None:
self._make_ssl_transport(
conn, protocol, sslcontext, server_side=True,
extra={'peername': addr}, server=server)
else:
self._make_socket_transport(
conn, protocol,
extra={'peername': addr}, server=server)
if self.is_closed():
return
f = self._proactor.accept(sock)
except OSError as exc:
if sock.fileno() != -1:
self.call_exception_handler({
'message': 'Accept failed on a socket',
'exception': exc,
'socket': sock,
})
sock.close()
elif self._debug:
logger.debug("Accept failed on socket %r",
sock, exc_info=True)
except futures.CancelledError:
sock.close()
else:
self._accept_futures[sock.fileno()] = f
f.add_done_callback(loop)
self.call_soon(loop)
def _process_events(self, event_list):
# Events are processed in the IocpProactor._poll() method
pass
def _stop_accept_futures(self):
for future in self._accept_futures.values():
future.cancel()
self._accept_futures.clear()
def _stop_serving(self, sock):
self._stop_accept_futures()
self._proactor._stop_serving(sock)
sock.close()
PK ! #)! ! $ __pycache__/protocols.cpython-38.pycnu [ U
if @ sb d Z dZG dd dZG dd deZG dd deZG dd d eZG d
d d eZd d
ZdS )z Abstract Protocol base classes.) BaseProtocolProtocolDatagramProtocolSubprocessProtocolBufferedProtocolc @ s4 e Zd ZdZdZdd Zdd Zdd Zd d
Zd S ) r a Common base class for protocol interfaces.
Usually user implements protocols that derived from BaseProtocol
like Protocol or ProcessProtocol.
The only case when BaseProtocol should be implemented directly is
write-only transport like write pipe
c C s dS )zCalled when a connection is made.
The argument is the transport representing the pipe connection.
To receive data, wait for data_received() calls.
When the connection is closed, connection_lost() is called.
Nr )selfZ transportr r 6/opt/alt/python38/lib64/python3.8/asyncio/protocols.pyconnection_made s z BaseProtocol.connection_madec C s dS )zCalled when the connection is lost or closed.
The argument is an exception object or None (the latter
meaning a regular EOF is received or the connection was
aborted or closed).
Nr r excr r r connection_lost s z BaseProtocol.connection_lostc C s dS )a Called when the transport's buffer goes over the high-water mark.
Pause and resume calls are paired -- pause_writing() is called
once when the buffer goes strictly over the high-water mark
(even if subsequent writes increases the buffer size even
more), and eventually resume_writing() is called once when the
buffer size reaches the low-water mark.
Note that if the buffer size equals the high-water mark,
pause_writing() is not called -- it must go strictly over.
Conversely, resume_writing() is called when the buffer size is
equal or lower than the low-water mark. These end conditions
are important to ensure that things go as expected when either
mark is zero.
NOTE: This is the only Protocol callback that is not called
through EventLoop.call_soon() -- if it were, it would have no
effect when it's most needed (when the app keeps writing
without yielding until pause_writing() is called).
Nr r r r r
pause_writing% s zBaseProtocol.pause_writingc C s dS )zvCalled when the transport's buffer drains below the low-water mark.
See pause_writing() for details.
Nr r
r r r resume_writing; s zBaseProtocol.resume_writingN) __name__
__module__ __qualname____doc__ __slots__r r r r r r r r r s r c @ s$ e Zd ZdZdZdd Zdd ZdS )r an Interface for stream protocol.
The user should implement this interface. They can inherit from
this class but don't need to. The implementations here do
nothing (they don't raise exceptions).
When the user wants to requests a transport, they pass a protocol
factory to a utility function (e.g., EventLoop.create_connection()).
When the connection is made successfully, connection_made() is
called with a suitable transport object. Then data_received()
will be called 0 or more times with data (bytes) received from the
transport; finally, connection_lost() will be called exactly once
with either an exception object or None as an argument.
State machine of calls:
start -> CM [-> DR*] [-> ER?] -> CL -> end
* CM: connection_made()
* DR: data_received()
* ER: eof_received()
* CL: connection_lost()
r c C s dS )zTCalled when some data is received.
The argument is a bytes object.
Nr )r datar r r
data_received^ s zProtocol.data_receivedc C s dS zCalled when the other end calls write_eof() or equivalent.
If this returns a false value (including None), the transport
will close itself. If it returns a true value, closing the
transport is up to the protocol.
Nr r
r r r eof_receivedd s zProtocol.eof_receivedN)r r r r r r r r r r r r B s r c @ s, e Zd ZdZdZdd Zdd Zdd Zd S )
r a Interface for stream protocol with manual buffer control.
Important: this has been added to asyncio in Python 3.7
*on a provisional basis*! Consider it as an experimental API that
might be changed or removed in Python 3.8.
Event methods, such as `create_server` and `create_connection`,
accept factories that return protocols that implement this interface.
The idea of BufferedProtocol is that it allows to manually allocate
and control the receive buffer. Event loops can then use the buffer
provided by the protocol to avoid unnecessary data copies. This
can result in noticeable performance improvement for protocols that
receive big amounts of data. Sophisticated protocols can allocate
the buffer only once at creation time.
State machine of calls:
start -> CM [-> GB [-> BU?]]* [-> ER?] -> CL -> end
* CM: connection_made()
* GB: get_buffer()
* BU: buffer_updated()
* ER: eof_received()
* CL: connection_lost()
r c C s dS )aP Called to allocate a new receive buffer.
*sizehint* is a recommended minimal size for the returned
buffer. When set to -1, the buffer size can be arbitrary.
Must return an object that implements the
:ref:`buffer protocol `.
It is an error to return a zero-sized buffer.
Nr )r sizehintr r r
get_buffer s zBufferedProtocol.get_bufferc C s dS )zCalled when the buffer was updated with the received data.
*nbytes* is the total number of bytes that were written to
the buffer.
Nr )r nbytesr r r buffer_updated s z BufferedProtocol.buffer_updatedc C s dS r r r
r r r r s z BufferedProtocol.eof_receivedN)r r r r r r r r r r r r r m s
r c @ s$ e Zd ZdZdZdd Zdd ZdS )r z Interface for datagram protocol.r c C s dS )z&Called when some datagram is received.Nr )r r Zaddrr r r datagram_received s z"DatagramProtocol.datagram_receivedc C s dS )z~Called when a send or receive operation raises an OSError.
(Other than BlockingIOError or InterruptedError.)
Nr r
r r r error_received s z DatagramProtocol.error_receivedN)r r r r r r r r r r r r s r c @ s, e Zd ZdZdZdd Zdd Zdd Zd S )
r z,Interface for protocol for subprocess calls.r c C s dS )zCalled when the subprocess writes data into stdout/stderr pipe.
fd is int file descriptor.
data is bytes object.
Nr )r fdr r r r pipe_data_received s z%SubprocessProtocol.pipe_data_receivedc C s dS )zCalled when a file descriptor associated with the child process is
closed.
fd is the int file descriptor that was closed.
Nr )r r r r r r pipe_connection_lost s z'SubprocessProtocol.pipe_connection_lostc C s dS )z"Called when subprocess has exited.Nr r
r r r process_exited s z!SubprocessProtocol.process_exitedN)r r r r r r r! r" r r r r r s
r c C s t |}|r| |}t |}|s*td||krL||d |< | | d S |d | |d |< | | ||d }t |}qd S )Nz%get_buffer() returned an empty buffer)lenr RuntimeErrorr )protor Zdata_lenZbufZbuf_lenr r r _feed_data_to_buffered_proto s
r& N)r __all__r r r r r r& r r r r s 9+9PK ! مT T * __pycache__/constants.cpython-38.opt-1.pycnu [ U
ifx @ s2 d dl Z dZdZdZdZdZG dd de jZdS ) N
g N@i c @ s$ e Zd Ze Ze Ze ZdS )
_SendfileModeN)__name__
__module__ __qualname__enumautoZ UNSUPPORTEDZ
TRY_NATIVEZFALLBACK r r 6/opt/alt/python38/lib64/python3.8/asyncio/constants.pyr s r )r Z!LOG_THRESHOLD_FOR_CONNLOST_WRITESZACCEPT_RETRY_DELAYZDEBUG_STACK_DEPTHZSSL_HANDSHAKE_TIMEOUTZ!SENDFILE_FALLBACK_READBUFFER_SIZEEnumr r r r r s PK ! #)! ! * __pycache__/protocols.cpython-38.opt-1.pycnu [ U
if @ sb d Z dZG dd dZG dd deZG dd deZG dd d eZG d
d d eZd d
ZdS )z Abstract Protocol base classes.) BaseProtocolProtocolDatagramProtocolSubprocessProtocolBufferedProtocolc @ s4 e Zd ZdZdZdd Zdd Zdd Zd d
Zd S ) r a Common base class for protocol interfaces.
Usually user implements protocols that derived from BaseProtocol
like Protocol or ProcessProtocol.
The only case when BaseProtocol should be implemented directly is
write-only transport like write pipe
c C s dS )zCalled when a connection is made.
The argument is the transport representing the pipe connection.
To receive data, wait for data_received() calls.
When the connection is closed, connection_lost() is called.
Nr )selfZ transportr r 6/opt/alt/python38/lib64/python3.8/asyncio/protocols.pyconnection_made s z BaseProtocol.connection_madec C s dS )zCalled when the connection is lost or closed.
The argument is an exception object or None (the latter
meaning a regular EOF is received or the connection was
aborted or closed).
Nr r excr r r connection_lost s z BaseProtocol.connection_lostc C s dS )a Called when the transport's buffer goes over the high-water mark.
Pause and resume calls are paired -- pause_writing() is called
once when the buffer goes strictly over the high-water mark
(even if subsequent writes increases the buffer size even
more), and eventually resume_writing() is called once when the
buffer size reaches the low-water mark.
Note that if the buffer size equals the high-water mark,
pause_writing() is not called -- it must go strictly over.
Conversely, resume_writing() is called when the buffer size is
equal or lower than the low-water mark. These end conditions
are important to ensure that things go as expected when either
mark is zero.
NOTE: This is the only Protocol callback that is not called
through EventLoop.call_soon() -- if it were, it would have no
effect when it's most needed (when the app keeps writing
without yielding until pause_writing() is called).
Nr r r r r
pause_writing% s zBaseProtocol.pause_writingc C s dS )zvCalled when the transport's buffer drains below the low-water mark.
See pause_writing() for details.
Nr r
r r r resume_writing; s zBaseProtocol.resume_writingN) __name__
__module__ __qualname____doc__ __slots__r r r r r r r r r s r c @ s$ e Zd ZdZdZdd Zdd ZdS )r an Interface for stream protocol.
The user should implement this interface. They can inherit from
this class but don't need to. The implementations here do
nothing (they don't raise exceptions).
When the user wants to requests a transport, they pass a protocol
factory to a utility function (e.g., EventLoop.create_connection()).
When the connection is made successfully, connection_made() is
called with a suitable transport object. Then data_received()
will be called 0 or more times with data (bytes) received from the
transport; finally, connection_lost() will be called exactly once
with either an exception object or None as an argument.
State machine of calls:
start -> CM [-> DR*] [-> ER?] -> CL -> end
* CM: connection_made()
* DR: data_received()
* ER: eof_received()
* CL: connection_lost()
r c C s dS )zTCalled when some data is received.
The argument is a bytes object.
Nr )r datar r r
data_received^ s zProtocol.data_receivedc C s dS zCalled when the other end calls write_eof() or equivalent.
If this returns a false value (including None), the transport
will close itself. If it returns a true value, closing the
transport is up to the protocol.
Nr r
r r r eof_receivedd s zProtocol.eof_receivedN)r r r r r r r r r r r r B s r c @ s, e Zd ZdZdZdd Zdd Zdd Zd S )
r a Interface for stream protocol with manual buffer control.
Important: this has been added to asyncio in Python 3.7
*on a provisional basis*! Consider it as an experimental API that
might be changed or removed in Python 3.8.
Event methods, such as `create_server` and `create_connection`,
accept factories that return protocols that implement this interface.
The idea of BufferedProtocol is that it allows to manually allocate
and control the receive buffer. Event loops can then use the buffer
provided by the protocol to avoid unnecessary data copies. This
can result in noticeable performance improvement for protocols that
receive big amounts of data. Sophisticated protocols can allocate
the buffer only once at creation time.
State machine of calls:
start -> CM [-> GB [-> BU?]]* [-> ER?] -> CL -> end
* CM: connection_made()
* GB: get_buffer()
* BU: buffer_updated()
* ER: eof_received()
* CL: connection_lost()
r c C s dS )aP Called to allocate a new receive buffer.
*sizehint* is a recommended minimal size for the returned
buffer. When set to -1, the buffer size can be arbitrary.
Must return an object that implements the
:ref:`buffer protocol `.
It is an error to return a zero-sized buffer.
Nr )r sizehintr r r
get_buffer s zBufferedProtocol.get_bufferc C s dS )zCalled when the buffer was updated with the received data.
*nbytes* is the total number of bytes that were written to
the buffer.
Nr )r nbytesr r r buffer_updated s z BufferedProtocol.buffer_updatedc C s dS r r r
r r r r s z BufferedProtocol.eof_receivedN)r r r r r r r r r r r r r m s
r c @ s$ e Zd ZdZdZdd Zdd ZdS )r z Interface for datagram protocol.r c C s dS )z&Called when some datagram is received.Nr )r r Zaddrr r r datagram_received s z"DatagramProtocol.datagram_receivedc C s dS )z~Called when a send or receive operation raises an OSError.
(Other than BlockingIOError or InterruptedError.)
Nr r
r r r error_received s z DatagramProtocol.error_receivedN)r r r r r r r r r r r r s r c @ s, e Zd ZdZdZdd Zdd Zdd Zd S )
r z,Interface for protocol for subprocess calls.r c C s dS )zCalled when the subprocess writes data into stdout/stderr pipe.
fd is int file descriptor.
data is bytes object.
Nr )r fdr r r r pipe_data_received s z%SubprocessProtocol.pipe_data_receivedc C s dS )zCalled when a file descriptor associated with the child process is
closed.
fd is the int file descriptor that was closed.
Nr )r r r r r r pipe_connection_lost s z'SubprocessProtocol.pipe_connection_lostc C s dS )z"Called when subprocess has exited.Nr r
r r r process_exited s z!SubprocessProtocol.process_exitedN)r r r r r r r! r" r r r r r s
r c C s t |}|r| |}t |}|s*td||krL||d |< | | d S |d | |d |< | | ||d }t |}qd S )Nz%get_buffer() returned an empty buffer)lenr RuntimeErrorr )protor Zdata_lenZbufZbuf_lenr r r _feed_data_to_buffered_proto s
r& N)r __all__r r r r r r& r r r r s 9+9PK ! ) y y , __pycache__/base_events.cpython-38.opt-1.pycnu [ U
if @ s d Z ddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl
Z
ddlZddlZddlZddlZz ddlZW n ek
r dZY nX ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ dd lmZ dd
lmZ dd lm Z dd lm Z dd
lm Z ddlm Z ddl m!Z! dZ"dZ#dZ$e%e dZ&dZ'e( Z)dd Z*dd Z+dd Z,d+dd Z-d,d d Z.d d Z/e%e d!rd"d# Z0nd$d# Z0G d%d& d&ej1Z2G d'd( d(ej3Z4G d)d* d*ej5Z6dS )-a Base implementation of event loop.
The event loop can be broken up into a multiplexer (the part
responsible for notifying us of I/O events) and the event loop proper,
which wraps a multiplexer with functionality for scheduling callbacks,
immediately or at a given time in the future.
Whenever a public API takes a callback, subsequent positional
arguments will be passed to the callback if/when it is called. This
avoids the proliferation of trivial lambdas implementing closures.
Keyword arguments for the callback are not supported; this is a
conscious design decision, leaving the door open for keyword arguments
to modify the meaning of the API call itself.
N ) constants)
coroutines)events)
exceptions)futures) protocols)sslproto) staggered)tasks)
transports)trsock)logger)
BaseEventLoopd g ?AF_INET6iQ c C s0 | j }tt|dd tjr$t|jS t| S d S )N__self__)Z _callback
isinstancegetattrr Taskreprr str)handlecb r 8/opt/alt/python38/lib64/python3.8/asyncio/base_events.py_format_handleJ s
r c C s( | t jkrdS | t jkr dS t| S d S )Nzz)
subprocessPIPESTDOUTr )fdr r r _format_pipeS s
r! c C sL t tdstdn4z| tjtjd W n tk
rF tdY nX d S )N SO_REUSEPORTz)reuse_port not supported by socket moduler zTreuse_port not supported by socket module, SO_REUSEPORT defined but not implemented.)hasattrsocket
ValueError
setsockopt
SOL_SOCKETr" OSErrorsockr r r _set_reuseport\ s
r+ c C s t tdsd S |dtjtjhks(| d kr,d S |tjkr>tj}n|tjkrPtj}nd S |d krbd}nXt|trz|dkrzd}n@t|tr|dkrd}n(z t |}W n t
t fk
r Y d S X |tj krtj
g}tr|tj n|g}t| tr| d} d| krd S |D ]t}zVt|| trJ|tjkrJ|||d| |||ffW S |||d| |ffW S W n tk
rz Y nX q
d S )N inet_ptonr Zidna%)r# r$ IPPROTO_TCPZ IPPROTO_UDP SOCK_STREAM
SOCK_DGRAMr bytesr int TypeErrorr% AF_UNSPECAF_INET _HAS_IPv6appendr decoder, r( ) hostportfamilytypeprotoZflowinfoZscopeidZafsafr r r _ipaddr_infog sN
rA c C s t }| D ]*}|d }||kr(g ||< || | q t| }g }|dkr|||d d|d |d d|d = |dd tjtj | D |S )z-Interleave list of addrinfo tuples by family.r r Nc s s | ]}|d k r|V qd S Nr ).0ar r r s z(_interleave_addrinfos..)
collections OrderedDictr9 listvaluesextend itertoolschain
from_iterable zip_longest)Z addrinfosZfirst_address_family_countZaddrinfos_by_familyaddrr= Zaddrinfos_listsZ reorderedr r r _interleave_addrinfos s"
rP c C s4 | s"| }t|ttfr"d S t| d S rB ) cancelled exceptionr
SystemExitKeyboardInterruptr Z _get_loopstop)futexcr r r _run_until_complete_cb s
rX TCP_NODELAYc C s@ | j tjtjhkr<| jtjkr<| jtjkr<| tjtj d d S Nr )
r= r$ r7 r r> r1 r? r0 r& rY r) r r r _set_nodelay s
r[ c C s d S rB r r) r r r r[ s c @ sT e Zd Zdd Zdd Zdd Zdd Zd d
Zd d Zd
d Z dd Z
dd Z dS )_SendfileFallbackProtocolc C sh t |tjstd|| _| | _| | _|j | _
| | | | j
r^| jj
| _nd | _d S )Nz.transport should be _FlowControlMixin instance)r r Z_FlowControlMixinr5
_transportZ get_protocol_protoZ
is_reading_should_resume_readingZ_protocol_paused_should_resume_writing
pause_reading set_protocol_loop
create_future_write_ready_fut)selftranspr r r __init__ s
z"_SendfileFallbackProtocol.__init__c s2 | j rtd| j}|d kr$d S |I d H d S )NzConnection closed by peer)r]
is_closingConnectionErrorre )rf rV r r r drain s
z _SendfileFallbackProtocol.drainc C s t dd S )Nz?Invalid state: connection should have been established already. RuntimeError)rf transportr r r connection_made s z)_SendfileFallbackProtocol.connection_madec C s@ | j d k r0|d kr$| j td n | j | | j| d S )Nz Connection is closed by peer)re Z
set_exceptionrj r^ connection_lost)rf rW r r r rp s
z)_SendfileFallbackProtocol.connection_lostc C s | j d k rd S | jj | _ d S rB )re r] rc rd rf r r r
pause_writing s
z'_SendfileFallbackProtocol.pause_writingc C s$ | j d krd S | j d d | _ d S )NF)re
set_resultrq r r r resume_writing s
z(_SendfileFallbackProtocol.resume_writingc C s t dd S Nz'Invalid state: reading should be pausedrl )rf datar r r
data_received s z'_SendfileFallbackProtocol.data_receivedc C s t dd S ru rl rq r r r eof_received s z&_SendfileFallbackProtocol.eof_receivedc sF | j | j | jr | j | jd k r2| j | jrB| j d S rB ) r] rb r^ r_ resume_readingre cancelr` rt rq r r r restore s
z!_SendfileFallbackProtocol.restoreN) __name__
__module__ __qualname__rh rk ro rp rr rt rw rx r{ r r r r r\ s r\ c @ sx e Zd Zdd Zdd Zdd Zdd Zd d
Zd d Zd
d Z dd Z
e dd Z dd Z
dd Zdd Zdd ZdS ) Serverc C s@ || _ || _d| _g | _|| _|| _|| _|| _d| _d | _ d S )Nr F)
rc _sockets
_active_count_waiters_protocol_factory_backlog _ssl_context_ssl_handshake_timeout_serving_serving_forever_fut)rf loopsocketsprotocol_factoryZ ssl_contextbacklogssl_handshake_timeoutr r r rh s zServer.__init__c C s d| j j d| jdS )N) __class__r| r rq r r r __repr__ s zServer.__repr__c C s | j d7 _ d S rZ )r rq r r r _attach# s zServer._attachc C s. | j d8 _ | j dkr*| jd kr*| d S )Nr r )r r _wakeuprq r r r _detach' s zServer._detachc C s, | j }d | _ |D ]}| s|| qd S rB )r doners )rf waiterswaiterr r r r - s
zServer._wakeupc C sJ | j r
d S d| _ | jD ].}|| j | j| j|| j| | j| j qd S )NT) r r Zlistenr rc _start_servingr r r )rf r* r r r r 4 s
zServer._start_servingc C s | j S rB )rc rq r r r get_loop> s zServer.get_loopc C s | j S rB )r rq r r r
is_servingA s zServer.is_servingc C s" | j d krdS tdd | j D S )Nr c s s | ]}t |V qd S rB )r
ZTransportSocket)rC sr r r rE H s z!Server.sockets..)r tuplerq r r r r D s
zServer.socketsc C sn | j }|d krd S d | _ |D ]}| j| q d| _| jd k rX| j sX| j d | _| jdkrj| d S )NFr ) r rc Z
_stop_servingr r r rz r r )rf r r* r r r closeJ s
z Server.closec s" | tjd| jdI d H d S )Nr r )r r sleeprc rq r r r
start_serving] s zServer.start_servingc s | j d k rtd| d| jd kr4td| d| | j | _ zLz| j I d H W n6 tjk
r z| | I d H W 5 X Y nX W 5 d | _ X d S )Nzserver z, is already being awaited on serve_forever()z
is closed)
r rm r r rc rd r ZCancelledErrorr wait_closedrq r r r
serve_foreverc s
zServer.serve_foreverc s< | j d ks| jd krd S | j }| j| |I d H d S rB )r r rc rd r9 )rf r r r r r x s
zServer.wait_closedN)r| r} r~ rh r r r r r r r propertyr r r r r r r r r r s
r c @ sP e Zd Zdd Zdd Zdd Zddd d
Zd d Zd
d ZddddddZ ddddddddddZ
dddZ dddZ ddd Z
dd d Zd d Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Zd+d, Zd-d. Zd/d0 Zd1d2 Zd3d4 Zd5d6 Zej fd7d8Z d9d: Z d;d< Z dd=d>d?Z dd=d@dAZ!dd=dBdCZ"dDdE Z#dFdG Z$dHdI Z%dd=dJdKZ&dLdM Z'dNdO Z(dPdQ Z)dRdRdRdRdSdTdUZ*ddVdWZ+dddXdYdZZ,d[d\ Z-d]d^ Z.d_d` Z/ddadbZ0dddRdRdRdddddddc
dddeZ1ddfdgZ2dddXdhdiZ3djdk Z4dldm Z5ddddndodpZ6ddRdRdRe7ddddqdrdsZ8dRe9j:dRdRdSdtduZ;dvdw Zddxddddddy dzd{Z?ddd|d}d~Z@dd ZAdd ZBdd ZCeDjEeDjEeDjEdddRdddd ddZFeDjEeDjEeDjEdddRdddd ddZGdd ZHdd ZIdd ZJdd ZKdd ZLdd ZMdd ZNdd ZOdd ZPdd ZQdd ZRdS )r c C s d| _ d| _d| _t | _g | _d | _d| _d | _ t
dj | _
d | _| t d| _d | _d | _d| _d | _t | _d| _d S )Nr F monotonicg?)_timer_cancelled_count_closed _stoppingrF deque_ready
_scheduled_default_executorZ
_internal_fds
_thread_idtimeget_clock_infoZ
resolution_clock_resolution_exception_handler set_debugr Z_is_debug_modeslow_callback_duration_current_handle
_task_factory"_coroutine_origin_tracking_enabled&_coroutine_origin_tracking_saved_depthweakrefZWeakSet
_asyncgens_asyncgens_shutdown_calledrq r r r rh s$
zBaseEventLoop.__init__c C s. d| j j d| d| d| d S )Nr z running=z closed=z debug=r )r r|
is_running is_closed get_debugrq r r r r s ,zBaseEventLoop.__repr__c C s t j| dS )z,Create a Future object attached to the loop.r )r ZFuturerq r r r rd s zBaseEventLoop.create_futureN)namec C sN | | jdkr2tj|| |d}|jrJ|jd= n| | |}t|| |S )zDSchedule a coroutine object.
Return a task object.
N)r r )
_check_closedr r r _source_tracebackZ_set_task_name)rf coror Ztaskr r r create_task s
zBaseEventLoop.create_taskc C s" |dk rt |std|| _dS )aw Set a task factory that will be used by loop.create_task().
If factory is None the default task factory will be set.
If factory is a callable, it should have a signature matching
'(loop, coro)', where 'loop' will be a reference to the active
event loop, 'coro' will be a coroutine object. The callable
must return a Future.
Nz'task factory must be a callable or None)callabler5 r )rf factoryr r r set_task_factory s
z BaseEventLoop.set_task_factoryc C s | j S )z s z4BaseEventLoop.shutdown_asyncgens..)Zreturn_exceptionsr z;an error occurred during closing of asynchronous generator )messagerR Zasyncgen) r lenr rH clearr gatherzipr Exceptioncall_exception_handler)rf Z
closing_agensZresultsresultr r r r shutdown_asyncgens s"
z BaseEventLoop.shutdown_asyncgensc C s( | rtdt d k r$tdd S )Nz"This event loop is already runningz7Cannot run the event loop while another loop is running)r rm r Z_get_running_looprq r r r _check_running& s z BaseEventLoop._check_runningc C s | | | | j t | _t }tj | j
| j d z t
| | | j rLq^qLW 5 d| _ d| _t
d | d tj | X dS )zRun until stop() is called.) firstiter finalizerFN)r r _set_coroutine_origin_tracking_debug threading get_identr sysget_asyncgen_hooksset_asyncgen_hooksr r r r Z_set_running_loop _run_once)rf Zold_agen_hooksr r r run_forever- s$
zBaseEventLoop.run_foreverc C s | | t| }tj|| d}|r4d|_|t z|jd= |S )aT Arrange for a callback to be called as soon as possible.
This operates as a FIFO queue: callbacks are called in the
order in which they are registered. Each callback will be
called exactly once.
Any positional arguments after the callback will be passed to
the callback when it is called.
call_soonr )r r r r
_call_soonr rf r r r r r r r r s
zBaseEventLoop.call_soonc C sD t |st |r$td| dt|s@td| d|d S )Nz coroutines cannot be used with z()z"a callable object was expected by z(), got )r Z iscoroutineZiscoroutinefunctionr5 r )rf r methodr r r r s
z BaseEventLoop._check_callbackc C s. t ||| |}|jr |jd= | j| |S )Nr )r ZHandler r r9 )rf r r r r r r r r s
zBaseEventLoop._call_soonc C s, | j dkrdS t }|| j kr(tddS )ao Check that the current thread is the thread running the event loop.
Non-thread-safe methods of this class make this assumption and will
likely behave incorrectly when the assumption is violated.
Should only be called when (self._debug == True). The caller is
responsible for checking this condition for performance reasons.
NzMNon-thread-safe operation invoked on an event loop other than the current one)r r r rm )rf Z thread_idr r r r s
zBaseEventLoop._check_threadc G sB | | jr| |d | |||}|jr6|jd= | |S )z"Like call_soon(), but thread-safe.r r )r r r r r r r r r r r s z"BaseEventLoop.call_soon_threadsafec G sZ | | jr| |d |d kr@| j}|d kr@tj }|| _tj|j|f| | dS )Nrun_in_executorr ) r r r r
concurrentr ThreadPoolExecutorZ wrap_futureZsubmit)rf r
funcr r r r r s
z BaseEventLoop.run_in_executorc C s& t |tjjs tdtd || _d S )Nz{Using the default executor that is not an instance of ThreadPoolExecutor is deprecated and will be prohibited in Python 3.9 )r r r r r r DeprecationWarningr r r r r set_default_executor s z"BaseEventLoop.set_default_executorc C s | d|g}|r$| d| |r8| d| |rL| d| |r`| d| d|}td| | }t||||||} | | }
d| d |
d
d d | }|
| jkrt| n
t| | S )
N:zfamily=ztype=zproto=zflags=, zGet address info %szGetting address info z took g @@z.3fzms: ) r9 joinr r r r$ getaddrinfor info) rf r; r< r= r> r? flagsmsgt0addrinfodtr r r _getaddrinfo_debug s&
z BaseEventLoop._getaddrinfo_debugr r= r> r? r& c
s2 | j r| j}ntj}| d |||||||I d H S rB )r r+ r$ r$ r )rf r; r< r= r> r? r& Z getaddr_funcr r r r$ 2 s zBaseEventLoop.getaddrinfoc s | d tj||I d H S rB )r r$ getnameinfo)rf Zsockaddrr& r r r r- < s zBaseEventLoop.getnameinfo)fallbackc
s | j r| dkrtd| |||| z| ||||I d H W S tjk
rl } z
|s\ W 5 d }~X Y nX | ||||I d H S )Nr z the socket must be non-blocking)r Z
gettimeoutr% _check_sendfile_params_sock_sendfile_nativer SendfileNotAvailableError_sock_sendfile_fallback)rf r* fileoffsetcountr. rW r r r
sock_sendfile@ s zBaseEventLoop.sock_sendfilec s t d|dd S )Nz-syscall sendfile is not available for socket z and file {file!r} combinationr r1 rf r* r3 r4 r5 r r r r0 N s
z#BaseEventLoop._sock_sendfile_nativec
s |r| | |r t|tjntj}t|}d}zt|rNt|| |}|dkrNqt|d | }| d |j|I d H } | szq| ||d | I d H || 7 }q2|W S |dkrt|dr| || X d S )Nr seek)
r9 minr Z!SENDFILE_FALLBACK_READBUFFER_SIZE bytearrayr#
memoryviewr readintoZ sock_sendall)
rf r* r3 r4 r5 blocksizebuf
total_sentviewreadr r r r2 U s,
z%BaseEventLoop._sock_sendfile_fallbackc C s dt |ddkrtd|jtjks,td|d k rbt|tsLtd||dkrbtd|t|tsztd||dk rtd|d S )Nbmodez$file should be opened in binary modez+only SOCK_STREAM type sockets are supportedz+count must be a positive integer (got {!r})r z0offset must be a non-negative integer (got {!r})) r r% r> r$ r1 r r4 r5 formatr8 r r r r/ o s2
z$BaseEventLoop._check_sendfile_paramsc s@ g }| | |\}}}}} d}
ztj|||d}
|
d |dk r|D ]r\}}}}} z|
| W qW qH tk
r } z0d| d| j }
t| j|
} | | W 5 d} ~ X Y qHX qH| | |
| I dH |
W S tk
r } z"| | |
dk r
|
W 5 d} ~ X Y n |
dk r4|
Y nX dS )z$Create, bind and connect one socket.Nr= r> r? Fz*error while attempting to bind on address : ) r9 r$ setblockingbindr( strerrorlowererrnopop sock_connectr )rf r Z addr_infoZlocal_addr_infosZ
my_exceptionsr= Ztype_r? _r r* ZladdrrW r' r r r
_connect_sock s:
zBaseEventLoop._connect_sock)
sslr= r? r& r*
local_addrr r happy_eyeballs_delay
interleavec
sl |
dk r|st d|
dkr0|r0|s,t d|}
| dk rD|sDt d| dk rX|
dkrXd}
|dk sj|dk r|dk rzt dj||f|tj||dI dH }|std| dk r܈j| |tj||dI dH stdnd|
rt||
}g | dkrH|D ]D}z |I dH }W qvW n tk
r@ Y q Y nX q n.tj fd d
|D | d I dH \}}}|dkr d d
D t dkr d nJt
d t fdd
D r҈ d td d
dd
D n.|dkrt d|jtjkr t d|j||||
| dI dH \}}jrd|d}td||||| ||fS )a Connect to a TCP server.
Create a streaming transport connection to a given Internet host and
port: socket family AF_INET or socket.AF_INET6 depending on host (or
family if specified), socket type SOCK_STREAM. protocol_factory must be
a callable returning a protocol instance.
This method is a coroutine which will try to establish the connection
in the background. When successful, the coroutine returns a
(transport, protocol) pair.
Nz+server_hostname is only meaningful with sslz:You must set server_hostname when using ssl without a host1ssl_handshake_timeout is only meaningful with sslr 8host/port and sock can not be specified at the same timer= r> r? r& r !getaddrinfo() returned empty listc 3 s | ]}t j |V qd S rB ) functoolspartialrP )rC r) )r laddr_infosrf r r rE s z2BaseEventLoop.create_connection..r c S s g | ]}|D ]}|q qS r r )rC subrW r r r r s z3BaseEventLoop.create_connection..r c 3 s | ]}t | kV qd S rB r rC rW )modelr r rE s zMultiple exceptions: {}r" c s s | ]}t |V qd S rB r] r^ r r r rE
s z5host and port was not specified and no sock specified"A Stream Socket was expected, got )r r$ z %r connected to %s:%r: (%r, %r))r% _ensure_resolvedr$ r1 r( rP rP r
Zstaggered_racer r allrE r# r> _create_connection_transportr get_extra_infor r )rf r r; r< rQ r= r? r& r* rR r r rS rT infosr) rO rn r r )r r[ r_ rf r create_connection s
z BaseEventLoop.create_connectionc s | d | }| }|rHt|tr*d n|} | j||| ||||d}
n| |||}
z|I d H W n |
Y nX |
|fS )NFr r r )rH rd r boolr r r ) rf r* r rQ r r r r r r rn r r r rc % s*
z*BaseEventLoop._create_connection_transportc
s | rtdt|dtjj}|tjjkr:td||tjjkrz| ||||I dH W S tj k
r } z
|sx W 5 d}~X Y nX |std||
||||I dH S )a Send a file to transport.
Return the total number of bytes which were sent.
The method uses high-performance os.sendfile if available.
file must be a regular file object opened in binary mode.
offset tells from where to start reading the file. If specified,
count is the total number of bytes to transmit as opposed to
sending the file until EOF is reached. File position is updated on
return or also in case of error in which case file.tell()
can be used to figure out the number of bytes
which were sent.
fallback set to True makes asyncio to manually read and send
the file when the platform does not support the sendfile syscall
(e.g. Windows or SSL socket on Unix).
Raise SendfileNotAvailableError if the system does not support
sendfile syscall and fallback is False.
zTransport is closingZ_sendfile_compatiblez(sendfile is not supported for transport NzHfallback is disabled and native sendfile is not supported for transport ) ri rm r r Z
_SendfileModeZ UNSUPPORTEDZ
TRY_NATIVE_sendfile_nativer r1 _sendfile_fallback)rf rn r3 r4 r5 r. rD rW r r r sendfile? s4 zBaseEventLoop.sendfilec s t dd S )Nz!sendfile syscall is not supportedr7 )rf rg r3 r4 r5 r r r ri n s z BaseEventLoop._sendfile_nativec
s |r| | |r t|dnd}t|}d}t|}z|rXt|| |}|dkrX|W bS t|d | } | d |j| I d H }
|
s|W 0S | I d H |
| d |
||
7 }q6W 5 |dkrt|dr| || | I d H X d S )Ni @ r r9 ) r9 r: r; r\ r# r{ r< r r= rk write) rf rg r3 r4 r5 r> r? r@ r? rA rB r r r rj r s*
z BaseEventLoop._sendfile_fallbackrg c
s t dkrtdt|t js*td|t|ddsFtd|d| }tj| ||||||dd}| |
| | |j |} | |j
}
z|I dH W n. tk
r | | |
Y nX |jS ) zzUpgrade transport to TLS.
Return a new transport that *protocol* should start using
immediately.
Nz"Python ssl module is not availablez@sslcontext is expected to be an instance of ssl.SSLContext, got Z_start_tls_compatibleFz
transport z is not supported by start_tls())r r )rQ rm r Z
SSLContextr5 r rd r Z SSLProtocolra rb r ro ry
BaseExceptionr rz Z_app_transport) rf rn r r r r r r Z ssl_protocolZ
conmade_cbZ resume_cbr r r start_tls sB
zBaseEventLoop.start_tls)r= r? r&
reuse_address
reuse_portallow_broadcastr* c s |
dk r|
j tjkr"td|
s>s>|s>|s>|s>|s>| r~t |||||| d} ddd | D } td| d|
d d}
n ss|d
krtd ||fd ff}nttd
r|tj kr fD ] }|dk rt
|t st dqڈ rx d
dkrxz"t
t
jr.t W nF tk
rF Y n2 tk
rv } ztd | W 5 d}~X Y nX ||f fff}ni }d
fdffD ]\}}|dk r| j||tj||| dI dH }|std|D ]:\}}}}}||f}||krddg||< ||| |< qq fdd| D }|sHtdg }|tk rv|rftdntjdtdd |D ]\\}}\}}d}
d}
zxtj|tj|d}
|rt|
| r|
tj tj d |
d r|
| r| s| |
|I dH |}
W n^ tk
rJ } z |
dk r0|
! |"| W 5 d} ~ X Y n& |
dk rb|
! Y nX q|qz|d
| } | # } | $|
| |
| } | j%r̈ rt&d | | nt'd | | z| I dH W n | ! Y nX | | fS ) zCreate datagram connection.Nz A UDP Socket was expected, got )rR remote_addrr= r? r& ro rp rq r" c s s$ | ] \}}|r| d | V qdS )=Nr )rC kvr r r rE s z9BaseEventLoop.create_datagram_endpoint..zKsocket modifier keyword arguments can not be used when sock is specified. ()Fr zunexpected address family)NNAF_UNIXzstring is expected)r z2Unable to check or remove stale UNIX socket %r: %rr rW rX c s8 g | ]0\}} r |d dksr,|d dks||fqS )r Nr r )rC keyZ addr_pairrR rr r r r s z:BaseEventLoop.create_datagram_endpoint..z can not get address informationz~Passing `reuse_address=True` is no longer supported, as the usage of SO_REUSEPORT in UDP poses a significant security concern.zdThe *reuse_address* parameter has been deprecated as of 3.5.10 and is scheduled for removal in 3.11.r )
stacklevelrF z@Datagram endpoint local_addr=%r remote_addr=%r created: (%r, %r)z2Datagram endpoint remote_addr=%r created: (%r, %r))(r> r$ r2 r% dictr# itemsrH r# rw r r r5 statS_ISSOCKosst_moderemoveFileNotFoundErrorr( r errorra _unsetr r r r+ r& r' Z SO_BROADCASTrI rN r r9 rd r r r% r ) rf r rR rr r= r? r& ro rp rq r* ZoptsZproblemsZr_addrZaddr_pairs_inforO errZ
addr_infosidxre ZfamrO Zpror ry r Z
local_addressZremote_addressrW r r rn r rz r create_datagram_endpoint s$
z&BaseEventLoop.create_datagram_endpointc
s\ |d d \}}t |||||f|dd } | d k r<| gS |j||||||dI d H S d S )Nr r, )rA r$ )
rf r r= r> r? r& r r; r< r% r r r ra L s z BaseEventLoop._ensure_resolvedc s8 | j ||f|tj|| dI d H }|s4td|d|S )N)r= r> r& r z getaddrinfo(z) returned empty list)ra r$ r1 r( )rf r; r< r= r& re r r r _create_server_getaddrinfoX s z(BaseEventLoop._create_server_getaddrinfor ) r= r& r* r rQ ro rp r r c s t |trtd| dk r*|dkr*td|dk s<dk r"|dk rLtd| dkrhtjdkoftjdk} g }
|dkr|dg}n$t |tst |t j
j s|g}n|} fdd |D }t j
|d
iI dH }ttj|}d }z |D ]}|\}}}}}zt|||}W n8 tjk
rH jr@tjd |||d
d Y qY nX |
| | rl|tjtjd
|
rzt | t r|tj krt tdr|tj tj!d
z|"| W q t#k
r } z t#|j$d||j%& f dW 5 d}~X Y qX qd
}W 5 |s |
D ]}| qX n4|dkr4td|j'tj(krPtd||g}
|
D ]}|)d qZt*|
|||| }| r|+ t j,ddI dH jrt-d| |S )a1 Create a TCP server.
The host parameter can be a string, in that case the TCP server is
bound to host and port.
The host parameter can also be a sequence of strings and in that case
the TCP server is bound to all hosts of the sequence. If a host
appears multiple times (possibly indirectly e.g. when hostnames
resolve to the same IP address), the server is only bound once to that
host.
Return a Server object which can be used to stop the service.
This method is a coroutine.
z*ssl argument must be an SSLContext or NoneNrU rV posixcygwinr. c s g | ]}j | d qS ))r= r& )r )rC r; r= r& r< rf r r r s
z/BaseEventLoop.create_server..r Fz:create_server() failed to create socket.socket(%r, %r, %r)Texc_info IPPROTO_IPV6z0error while attempting to bind on address %r: %sz)Neither host/port nor sock were specifiedr` r r z
%r is serving).r rh r5 r% r r r platformr rF abcIterabler r setrK rL rM r r$ r r r warningr9 r& r' Z SO_REUSEADDRr+ r8 r r# r Z IPV6_V6ONLYrI r( rL rJ rK r> r1 rH r r r r% )rf r r; r< r= r& r* r rQ ro rp r r r ZhostsZfsre Z completedresr@ Zsocktyper? Z canonnameZsar r r r r
create_server` s
zBaseEventLoop.create_server)rQ r c sv |j tjkrtd||dk r.|s.td| j|||dd|dI dH \}}| jrn|d}td||| ||fS ) a Handle an accepted connection.
This is used by servers that accept connections outside of
asyncio but that use asyncio to handle connections.
This method is a coroutine. When completed, the coroutine
returns a (transport, protocol) pair.
r` NrU r. T)r r r$ z%r handled: (%r, %r)) r> r$ r1 r% rc r rd r r )rf r r* rQ r rn r r r r connect_accepted_socket s$
z%BaseEventLoop.connect_accepted_socketc sd | }| }| |||}z|I d H W n | Y nX | jr\td| || ||fS )Nz Read pipe %r connected: (%r, %r))rd r r r r r filenorf r r r r rn r r r connect_read_pipe s z BaseEventLoop.connect_read_pipec sd | }| }| |||}z|I d H W n | Y nX | jr\td| || ||fS )Nz!Write pipe %r connected: (%r, %r))rd r r r r r r r r r r connect_write_pipe s z BaseEventLoop.connect_write_pipec C s |g}|d k r"| dt| |d k rJ|tjkrJ| dt| n8|d k rf| dt| |d k r| dt| td| d S )Nzstdin=zstdout=stderr=zstdout=zstderr= )r9 r! r r r r r# )rf r' r r r r% r r r _log_subprocess s z BaseEventLoop._log_subprocess) r r r universal_newlinesr r encodingerrorstextc s t |ttfstd|r"td|s.td|dkr>td| rJtd| d k rZtd|
d k rjtd| }
d }| jrd | }| |||| | j|
|d
||||f| I d H }| jr|d k rtd || ||
fS ) Nzcmd must be a string universal_newlines must be Falsezshell must be Truer bufsize must be 0text must be Falseencoding must be Noneerrors must be Nonezrun shell command %rT%s: %r) r r3 r r% r r r r r% )rf r cmdr r r r r r r r r r r debug_logrn r r r subprocess_shell sB
z BaseEventLoop.subprocess_shellc s |r t d|rt d|dkr(t d| r4t d| d k rDt d|
d k rTt d|f| }| }d }| jrd|}| |||| | j||d ||||f|
I d H }| jr|d k rtd
|| ||fS ) Nr zshell must be Falser r r r r zexecute program Fr )r% r r r r r% )rf r Zprogramr r r r r r r r r r r Z
popen_argsr r rn r r r subprocess_execC s@
z BaseEventLoop.subprocess_execc C s | j S )zKReturn an exception handler, or None if the default one is in use.
)r rq r r r get_exception_handlere s z#BaseEventLoop.get_exception_handlerc C s( |dk r t |s td||| _dS )a Set handler as the new event loop exception handler.
If handler is None, the default exception handler will
be set.
If handler is a callable object, it should have a
signature matching '(loop, context)', where 'loop'
will be a reference to the active event loop, 'context'
will be a dict object (see `call_exception_handler()`
documentation for details about context).
Nz+A callable object or None is expected, got )r r5 r )rf Zhandlerr r r set_exception_handlerj s z#BaseEventLoop.set_exception_handlerc C s | d}|sd}| d}|dk r6t|||jf}nd}d|kr`| jdk r`| jjr`| jj|d< |g}t|D ]}|dkr|qn|| }|dkrd t|}d
}|| 7 }n2|dkrd t|}d }|| 7 }nt
|}| | d | qnt j
d
||d dS )aE Default exception handler.
This is called when an exception occurs and no exception
handler is set, and can be called by a custom exception
handler that wants to defer to the default behavior.
This default handler logs the error message and other
context-dependent information. In debug mode, a truncated
stack trace is also appended showing where the given object
(e.g. a handle or future or task) was created, if any.
The context parameter has the same meaning as in
`call_exception_handler()`.
r z!Unhandled exception in event looprR NFZsource_tracebackZhandle_traceback> rR r r. z+Object created at (most recent call last):
z+Handle created at (most recent call last):
rG
r )getr>
__traceback__r r sortedr# traceback format_listrstripr r9 r r ) rf r r rR r Z log_linesry valuetbr r r default_exception_handler{ s<
z'BaseEventLoop.default_exception_handlerc C s | j dkrVz| | W q ttfk
r2 Y q tk
rR tjddd Y qX nz| | | W n ttfk
r Y nt tk
r } zVz| d||d W n: ttfk
r Y n" tk
r tjddd Y nX W 5 d}~X Y nX dS )aD Call the current event loop's exception handler.
The context argument is a dict containing the following keys:
- 'message': Error message;
- 'exception' (optional): Exception object;
- 'future' (optional): Future instance;
- 'task' (optional): Task instance;
- 'handle' (optional): Handle instance;
- 'protocol' (optional): Protocol instance;
- 'transport' (optional): Transport instance;
- 'socket' (optional): Socket instance;
- 'asyncgen' (optional): Asynchronous generator that caused
the exception.
New keys maybe introduced in the future.
Note: do not overload this method in an event loop subclass.
For custom exception handling, use the
`set_exception_handler()` method.
Nz&Exception in default exception handlerTr z$Unhandled error in exception handler)r rR r zeException in default exception handler while handling an unexpected error in custom exception handler)r r rS rT rm r r )rf r rW r r r r s4
z$BaseEventLoop.call_exception_handlerc C s |j r
dS | j| dS )z3Add a Handle to _scheduled (TimerHandle) or _ready.N)
_cancelledr r9 rf r r r r
_add_callback s zBaseEventLoop._add_callbackc C s | | | dS )z6Like _add_callback() but called from a signal handler.N)r r r r r r _add_callback_signalsafe s
z&BaseEventLoop._add_callback_signalsafec C s |j r| jd7 _dS )z3Notification that a TimerHandle has been cancelled.r N)r r r r r r _timer_handle_cancelled s z%BaseEventLoop._timer_handle_cancelledc C s t | j}|tkr`| j| tkr`g }| jD ] }|jr sd
;
DoPK ! XFY
% __pycache__/exceptions.cpython-38.pycnu [ U
ifa @ sl d Z dZG dd deZG dd deZG dd deZG dd d eZG d
d d e Z
G d d
d
eZ dS )zasyncio exceptions.)CancelledErrorInvalidStateError TimeoutErrorIncompleteReadErrorLimitOverrunErrorSendfileNotAvailableErrorc @ s e Zd ZdZdS )r z!The Future or Task was cancelled.N__name__
__module__ __qualname____doc__ r r 7/opt/alt/python38/lib64/python3.8/asyncio/exceptions.pyr s r c @ s e Zd ZdZdS )r z*The operation exceeded the given deadline.Nr r r r r
r
s r c @ s e Zd ZdZdS )r z+The operation is not allowed in this state.Nr r r r r
r s r c @ s e Zd ZdZdS )r z~Sendfile syscall is not available.
Raised if OS does not support sendfile syscall for given socket or
file type.
Nr r r r r
r s r c s( e Zd ZdZ fddZdd Z ZS )r z
Incomplete read error. Attributes:
- partial: read bytes string before the end of stream was reached
- expected: total number of expected bytes (or None if unknown)
c s@ |d kr dnt |}t t| d| d || _|| _d S )NZ undefinedz bytes read on a total of z expected bytes)reprsuper__init__lenpartialexpected)selfr r Z
r_expected __class__r r
r $ s z IncompleteReadError.__init__c C s t | | j| jffS N)typer r r r r r
__reduce__+ s z IncompleteReadError.__reduce__r r r
r r r
__classcell__r r r r
r s r c s( e Zd ZdZ fddZdd Z ZS )r zReached the buffer limit while looking for a separator.
Attributes:
- consumed: total number of to be consumed bytes.
c s t | || _d S r )r r consumed)r messager r r r
r 5 s zLimitOverrunError.__init__c C s t | | jd | jffS )N )r argsr r r r r
r 9 s z LimitOverrunError.__reduce__r r r r r
r / s r N) r __all__
BaseExceptionr Exceptionr r RuntimeErrorr EOFErrorr r r r r r
s PK ! kނx x * __pycache__/staggered.cpython-38.opt-1.pycnu [ U
ifh
@ s d Z dZddlZddlZddlmZ ddlmZ ddlmZ ddlm Z dd ej
ej g ej f ej
e ejejejej
e ejej
e f d
d d ZdS )
zFSupport for running coroutines in parallel with staggered start times.)staggered_race N )events)
exceptions)locks)tasks)loop)coro_fnsdelayr returnc s p
t t| ddg g tjtj dd fdd d}| z.run_one_coror )
r Zget_running_loopr typingOptionalr r r r r lenr r )r r
r Z
first_taskr Z
done_countZdone_r# r! r$ r s( =
0
r )__doc____all__r
r% r r r r r IterableCallable Awaitabler& floatZAbstractEventLoopZTupleZAnyintZList Exceptionr r# r# r# r$ s& PK ! ? ( __pycache__/runners.cpython-38.opt-1.pycnu [ U
if @ sB d Z ddlmZ ddlmZ ddlmZ ddddZd d
ZdS ) )run )
coroutines)events)tasksN)debugc C s t dk rtdt| s,td| t }z*t | |dk rR|
| | | W S zt
| | | W 5 t d | X X dS )a Execute the coroutine and return the result.
This function runs the passed coroutine, taking care of
managing the asyncio event loop and finalizing asynchronous
generators.
This function cannot be called when another asyncio event loop is
running in the same thread.
If debug is True, the event loop will be run in debug mode.
This function always creates a new event loop and closes it at the end.
It should be used as a main entry point for asyncio programs, and should
ideally only be called once.
Example:
async def main():
await asyncio.sleep(1)
print('hello')
asyncio.run(main())
Nz8asyncio.run() cannot be called from a running event loopz"a coroutine was expected, got {!r})r Z_get_running_loop RuntimeErrorr Z iscoroutine
ValueErrorformatZnew_event_loopZset_event_loopclose_cancel_all_tasksrun_until_completeZshutdown_asyncgensZ set_debug)mainr loop r 4/opt/alt/python38/lib64/python3.8/asyncio/runners.pyr s"
r c C sv t | }|sd S |D ] }| q| t j|| dd |D ]0}| rNq@| d k r@| d| |d q@d S )NT)r Zreturn_exceptionsz1unhandled exception during asyncio.run() shutdown)message exceptiontask)r Z all_tasksZcancelr ZgatherZ cancelledr Zcall_exception_handler)r Z to_cancelr r r r r 6 s"
r )__all__ r r r r r r r r r s
.PK ! fm fm 0 __pycache__/selector_events.cpython-38.opt-2.pycnu [ U
ifT @ s* d Z ddlZddlZddlZddlZddlZddlZddlZz ddlZW n e k
r` dZY nX ddl
m Z ddl
m Z ddl
m
Z
ddl
mZ ddl
mZ dd l
mZ dd
l
mZ dd l
mZ dd lmZ d
d Zdd ZG dd de jZG dd dejejZG dd deZ G dd deZ dS ))BaseSelectorEventLoop N ) base_events) constants)events)futures) protocols)sslproto)
transports)trsock)loggerc C s8 z| |}W n tk
r$ Y dS X t|j|@ S d S NF)get_keyKeyErrorboolr )selectorfdZeventkey r d? Z!d@dA Z"dBdC Z#dDdE Z$dFdG Z%dHdI Z&dJdK Z'dLdM Z(dNdO Z)dPdQ Z* Z+S )Vr Nc sF t |d krt }td|jj || _| t
| _ d S )NzUsing selector: %s)
super__init__ selectorsZDefaultSelectorr debug __class____name__ _selector_make_self_pipeweakrefZWeakValueDictionary _transports)selfr r r r r 6 s
z BaseSelectorEventLoop.__init__extraserverc C s t | |||||S N)_SelectorSocketTransport)r& r protocolwaiterr) r* r r r _make_socket_transport@ s
z,BaseSelectorEventLoop._make_socket_transportF) server_sideserver_hostnamer) r* ssl_handshake_timeoutc C s0 t j| |||||| d}
t| ||
||d |
jS )N)r2 r( )r Z SSLProtocolr, Z_app_transport) r& Zrawsockr-
sslcontextr. r0 r1 r) r* r2 Z ssl_protocolr r r _make_ssl_transportE s z)BaseSelectorEventLoop._make_ssl_transportc C s t | |||||S r+ )_SelectorDatagramTransport)r& r r- addressr. r) r r r _make_datagram_transportR s
z.BaseSelectorEventLoop._make_datagram_transportc sL | rtd| r d S | t | jd k rH| j d | _d S )Nz!Cannot close a running event loop)Z
is_running RuntimeError is_closed_close_self_piper closer" r& r' r r r; W s
zBaseSelectorEventLoop.closec C sB | | j | j d | _| j d | _| jd8 _d S )Nr )_remove_reader_ssockfilenor; _csock
_internal_fdsr< r r r r: b s
z&BaseSelectorEventLoop._close_self_pipec C sN t \| _| _| jd | jd | jd7 _| | j | j d S )NFr ) socketZ
socketpairr> r@ setblockingrA _add_readerr? _read_from_selfr< r r r r# j s
z%BaseSelectorEventLoop._make_self_pipec C s d S r+ r r& datar r r _process_self_datar s z(BaseSelectorEventLoop._process_self_datac C sX z"| j d}|sW qT| | W q tk
r: Y q Y q tk
rP Y qTY q X q d S )Ni )r> recvrH InterruptedErrorBlockingIOErrorrF r r r rE u s z%BaseSelectorEventLoop._read_from_selfc C sN | j }|d krd S z|d W n( tk
rH | jrDtjddd Y nX d S )N z3Fail to write a null byte into the self-pipe socketTexc_info)r@ sendOSError_debugr r )r& Zcsockr r r _write_to_self s z$BaseSelectorEventLoop._write_to_selfd c
C s" | | | j|||||| d S r+ )rD r? _accept_connection)r& protocol_factoryr r3 r* backlogr2 r r r _start_serving s z$BaseSelectorEventLoop._start_servingc
C s t |D ]}z0| \}} | jr0td|| | |d W n tttfk
rZ Y d S t k
r }
zd|
j
t
j t
j t
j
t
jfkr| d|
t|d | | | tj| j|||||| n W 5 d }
~
X Y qX d| i} | ||| |||} | | qd S )Nz#%r got a new connection from %r: %rFz&socket.accept() out of system resource)message exceptionrB peername)rangeacceptrQ r r rC rK rJ ConnectionAbortedErrorrP errnoZEMFILEZENFILEZENOBUFSZENOMEMcall_exception_handlerr TransportSocketr= r? Z
call_laterr ZACCEPT_RETRY_DELAYrW _accept_connection2Z create_task)
r& rU r r3 r* rV r2 _connaddrexcr) r\ r r r rT sV z(BaseSelectorEventLoop._accept_connectionc
s d }d }zt| }| } |r8| j|||| d|||d}n| j||| ||d}z| I d H W n tk
rx | Y nX W nt ttfk
r Y n\ tk
r }
z>| jrd|
d} |d k r|| d< |d k r|| d< | | W 5 d }
~
X Y nX d S )NT)r. r0 r) r* r2 )r. r) r* z3Error on transport creation for incoming connection)rX rY r- transport)
create_futurer4 r/
BaseExceptionr;
SystemExitKeyboardInterruptrQ r_ ) r& rU rc r) r3 r* r2 r- rf r. re contextr r r ra sP z)BaseSelectorEventLoop._accept_connection2c
C s |}t |tsJzt| }W n* tttfk
rH td|d Y nX z| j| }W n tk
rl Y n X | st d|d|d S )NzInvalid file object: zFile descriptor z is used by transport )
r intr? AttributeErrorr
ValueErrorr% r
is_closingr8 )r& r r? rf r r r _ensure_fd_no_transport s
z-BaseSelectorEventLoop._ensure_fd_no_transportc G s | t||| d }z| j|}W n* tk
rR | j|tj|d f Y n>X |j|j }\}}| j
||tjB ||f |d k r| d S r+ )
_check_closedr Handler" r r registerr
EVENT_READrG modifycancel r& r callbackargsZhandler maskreaderwriterr r r rD s
z!BaseSelectorEventLoop._add_readerc C s | r dS z| j|}W n tk
r2 Y dS X |j|j }\}}|tj M }|sd| j| n| j ||d |f |d k r|
dS dS d S NFT) r9 r" r r r rG r rt
unregisterru rv r& r r rz r{ r| r r r r= s z$BaseSelectorEventLoop._remove_readerc G s | t||| d }z| j|}W n* tk
rR | j|tjd |f Y n>X |j|j }\}}| j
||tjB ||f |d k r| d S r+ ) rq r rr r" r r rs r EVENT_WRITErG ru rv rw r r r _add_writer% s
z!BaseSelectorEventLoop._add_writerc C s | r dS z| j|}W n tk
r2 Y dS X |j|j }\}}|tj M }|sd| j| n| j |||d f |d k r|
dS dS d S r} ) r9 r" r r r rG r r r~ ru rv r r r r _remove_writer4 s z$BaseSelectorEventLoop._remove_writerc G s | | | j||f| S r+ )rp rD r& r rx ry r r r
add_readerK s
z BaseSelectorEventLoop.add_readerc C s | | | |S r+ )rp r= r& r r r r
remove_readerP s
z#BaseSelectorEventLoop.remove_readerc G s | | | j||f| S r+ )rp r r r r r
add_writerU s
z BaseSelectorEventLoop.add_writerc C s | | | |S r+ )rp r r r r r
remove_writerZ s
z#BaseSelectorEventLoop.remove_writerc s t | | jr"| dkr"tdz ||W S ttfk
rF Y nX | }| }| || j
||| | t
| j| |I d H S Nr the socket must be non-blocking)r rQ
gettimeoutrn rI rK rJ rg r? r
_sock_recvadd_done_callback functoolspartial_sock_read_done)r& r nfutr r r r sock_recv_ s z BaseSelectorEventLoop.sock_recvc C s | | d S r+ )r r& r r r r r r t s z%BaseSelectorEventLoop._sock_read_donec
C s | r d S z||}W n\ ttfk
r4 Y d S ttfk
rL Y n6 tk
rv } z|| W 5 d }~X Y n X || d S r+ ) donerI rK rJ ri rj rh
set_exception
set_result)r& r r r rG re r r r r w s z BaseSelectorEventLoop._sock_recvc s t | | jr"| dkr"tdz ||W S ttfk
rF Y nX | }| }| || j
||| | t
| j| |I d H S r )r rQ r rn recv_intorK rJ rg r? r _sock_recv_intor r r r )r& r bufr r r r r sock_recv_into s z$BaseSelectorEventLoop.sock_recv_intoc
C s | r d S z||}W n\ ttfk
r4 Y d S ttfk
rL Y n6 tk
rv } z|| W 5 d }~X Y n X || d S r+ ) r r rK rJ ri rj rh r r )r& r r r nbytesre r r r r s z%BaseSelectorEventLoop._sock_recv_intoc s t | | jr"| dkr"tdz||}W n ttfk
rL d}Y nX |t|kr^d S | }| }|
t | j
| | || j||t||g |I d H S r )r rQ r rn rO rK rJ lenrg r? r r r _sock_write_doner
_sock_sendall
memoryview)r& r rG r r r r r r sock_sendall s&
z"BaseSelectorEventLoop.sock_sendallc
C s | r d S |d }z|||d }W nb ttfk
rD Y d S ttfk
r\ Y n2 tk
r } z|| W Y d S d }~X Y nX ||7 }|t|kr| d n||d< d S )Nr )
r rO rK rJ ri rj rh r r r )r& r r Zviewposstartr re r r r r s
z#BaseSelectorEventLoop._sock_sendallc s t | | jr"| dkr"tdttdr8|jtjkrf| j||j|j | dI d H }|d \}}}}}|
}| ||| |I d H S )Nr r AF_UNIX)familyprotoloop) r rQ r rn hasattrrB r r Z_ensure_resolvedr rg
_sock_connect)r& r r6 Zresolvedrb r r r r sock_connect s z"BaseSelectorEventLoop.sock_connectc
C s | }z|| W n ttfk
rV |t| j| | || j ||| Y nN t
t fk
rn Y n6 t k
r } z|
| W 5 d }~X Y n X |d d S r+ )r? ZconnectrK rJ r r r r r _sock_connect_cbri rj rh r r )r& r r r6 r re r r r r s z#BaseSelectorEventLoop._sock_connectc C s | | d S r+ )r r r r r r s z&BaseSelectorEventLoop._sock_write_donec
C s | r d S z,|tjtj}|dkr6t|d| W nZ ttfk
rP Y nN tt fk
rh Y n6 t
k
r } z| | W 5 d }~X Y n X | d d S )Nr zConnect call failed )
r Z
getsockoptrB Z
SOL_SOCKETZSO_ERRORrP rK rJ ri rj rh r r )r& r r r6 errre r r r r s z&BaseSelectorEventLoop._sock_connect_cbc sB t | | jr"| dkr"td| }| |d| |I d H S )Nr r F)r rQ r rn rg _sock_accept)r& r r r r r sock_accept s z!BaseSelectorEventLoop.sock_acceptc
C s | }|r| | | r"d S z| \}}|d W nn ttfk
rh | || j|d| Y nR t t
fk
r Y n: t k
r } z| | W 5 d }~X Y nX |
||f d S r} )r? r r r\ rC rK rJ r r ri rj rh r r )r& r Z
registeredr r rc r6 re r r r r * s
z"BaseSelectorEventLoop._sock_acceptc sp | j |j= | }| | I d H z | j|j|||ddI d H W S | |r^| || j |j< X d S )NF)Zfallback) r% _sock_fd
is_reading
pause_reading_make_empty_waiter_reset_empty_waiterresume_readingZ
sock_sendfile_sock)r& Ztranspfileoffsetcountr r r r _sendfile_native< s
z&BaseSelectorEventLoop._sendfile_nativec C s |D ]v\}}|j |j }\}}|tj@ rL|d k rL|jrB| | n
| | |tj@ r|d k r|jrp| | q| | qd S r+ ) fileobjrG r rt Z
_cancelledr= Z
_add_callbackr r )r& Z
event_listr rz r r{ r| r r r _process_eventsJ s
z%BaseSelectorEventLoop._process_eventsc C s | | | d S r+ )r= r? r; )r& r r r r
_stop_servingX s z#BaseSelectorEventLoop._stop_serving)N)N)N)NNN),r!
__module__ __qualname__r r/ r ZSSL_HANDSHAKE_TIMEOUTr4 r7 r; r: r# rH rE rR rW rT ra rp rD r= r r r r r r r r r r r r r r r r r r r r r r
__classcell__r r r' r r 0 s|
.
) r c s e Zd ZdZeZdZd fdd Zdd Zdd Z d d
Z
d d Z d
d Z dd Z
ejfddZd ddZdd Zdd Zdd Zd d Z ZS ) _SelectorTransporti Nc s t || t|| jd< z| | jd< W n tk
rN d | jd< Y nX d| jkrz| | jd< W n tj k
r d | jd< Y nX || _
| | _ d| _
| | || _| | _d| _d| _| jd k r| j | |j| j < d S )NrB ZsocknamerZ Fr )r r r r` _extraZ getsocknamerP Z getpeernamerB errorr r? r _protocol_connected set_protocol_server_buffer_factory_buffer
_conn_lost_closingZ_attachr% )r& r r r- r) r* r' r r r i s,
z_SelectorTransport.__init__c C s | j jg}| jd kr |d n| jr0|d |d| j | jd k r| j st| jj | jt
j }|rz|d n
|d t| jj | jt
j }|rd}nd}|
}|d| d | d
d d |S )
Nclosedclosingzfd=z read=pollingz read=idlepollingZidlezwrite=z<{}> )r r! r appendr r _loopr9 r r" r rt r get_write_buffer_sizeformatjoin)r& infor statebufsizer r r __repr__ s0
z_SelectorTransport.__repr__c C s | d d S r+ ) _force_closer< r r r abort s z_SelectorTransport.abortc C s || _ d| _d S NT) _protocolr r& r- r r r r s z _SelectorTransport.set_protocolc C s | j S r+ )r r< r r r get_protocol s z _SelectorTransport.get_protocolc C s | j S r+ )r r< r r r ro s z _SelectorTransport.is_closingc C sT | j r
d S d| _ | j| j | jsP| jd7 _| j| j | j| jd d S NTr ) r r r= r r r r call_soon_call_connection_lostr< r r r r; s z_SelectorTransport.closec C s, | j d k r(|d| t| d | j d S )Nzunclosed transport )source)r ResourceWarningr; )r& Z_warnr r r __del__ s
z_SelectorTransport.__del__Fatal error on transportc C sN t |tr(| j r@tjd| |dd n| j||| | jd | | d S )Nz%r: %sTrM )rX rY rf r- ) r rP r get_debugr r r_ r r )r& re rX r r r _fatal_error s
z _SelectorTransport._fatal_errorc C sd | j r
d S | jr(| j | j| j | jsBd| _| j| j | j d7 _ | j| j | d S r )
r r clearr r r r r= r r r& re r r r r s
z _SelectorTransport._force_closec C sV z| jr| j| W 5 | j d | _ d | _d | _| j}|d k rP| d | _X d S r+ )r r; r r r Z_detachr Zconnection_lost)r& re r* r r r r s
z(_SelectorTransport._call_connection_lostc C s
t | jS r+ )r r r< r r r r s z(_SelectorTransport.get_write_buffer_sizec G s" | j r
d S | jj||f| d S r+ )r r rD r r r r rD s z _SelectorTransport._add_reader)NN)r )r! r r max_size bytearrayr r r r r r r ro r; warningswarnr r r r r rD r r r r' r r ] s
r c s e Zd ZdZejjZd# fdd Z fddZ dd Z
d d
Z d d Z d
d Z
dd Zdd Zdd Zdd Zdd Zdd Zdd Z fd d Zd d Zd!d" Z ZS )$r, TNc s~ d | _ t ||||| d| _d| _d | _t| j | j
| j j | | j
| j
| j| j |d k rz| j
tj|d d S r
)_read_ready_cbr r _eof_paused
_empty_waiterr Z _set_nodelayr r r r connection_maderD r _read_readyr _set_result_unless_cancelled)r& r r r- r. r) r* r' r r r s
z!_SelectorSocketTransport.__init__c s. t |tjr| j| _n| j| _t | d S r+ )r r ZBufferedProtocol_read_ready__get_bufferr _read_ready__data_receivedr r r r' r r r s
z%_SelectorSocketTransport.set_protocolc C s | j o| j S r+ )r r r< r r r r s z#_SelectorSocketTransport.is_readingc C s> | j s | jrd S d| _| j| j | j r:td| d S )NTz%r pauses reading)r r r r= r r r r r< r r r r s
z&_SelectorSocketTransport.pause_readingc C s@ | j s | jsd S d| _| | j| j | j r Y n4 tk
rp } z| |d W Y d S d }~X Y nX |r| j
| j n| d S )Nz%r received EOFz1Fatal error: protocol.eof_received() call failed.)
r r r r r Z eof_receivedri rj rh r r= r r; )r& Z keep_openre r r r r e s
z,_SelectorSocketTransport._read_ready__on_eofc
C s6 t |tttfs$tdt|j| jr2td| j d k rDtd|sLd S | j
rz| j
t j krht
d | j
d7 _
d S | js z| j|}W nb ttfk
r Y nb ttfk
r Y nJ tk
r } z| |d W Y d S d }~X Y nX ||d }|s d S | j| j| j | j | | d S )N/data argument must be a bytes-like object, not z%Cannot call write() after write_eof()z(unable to write; sendfile is in progress socket.send() raised exception.r %Fatal write error on socket transport) r bytesr r r typer! r r8 r r r !LOG_THRESHOLD_FOR_CONNLOST_WRITESr warningr r rO rK rJ ri rj rh r r r r _write_readyextend_maybe_pause_protocol)r& rG r re r r r writez s:
z _SelectorSocketTransport.writec
C s | j r
d S z| j| j}W n ttfk
r4 Y n ttfk
rL Y n tk
r } z>| j
| j | j |
|d | jd k r| j| W 5 d }~X Y nnX |r| jd |= | | js| j
| j | jd k r| jd | jr| d n| jr| jtj d S )Nr )r r rO r rK rJ ri rj rh r r r r r r r _maybe_resume_protocolr r r r shutdownrB SHUT_WR)r& r re r r r r s2
z%_SelectorSocketTransport._write_readyc C s. | j s | jrd S d| _| js*| jtj d S r )r r r r r rB r r< r r r write_eof s
z"_SelectorSocketTransport.write_eofc C s dS r r r< r r r
can_write_eof s z&_SelectorSocketTransport.can_write_eofc s* t | | jd k r&| jtd d S )Nz Connection is closed by peer)r r r r ConnectionErrorr r' r r r s
z._SelectorSocketTransport._call_connection_lostc C s6 | j d k rtd| j | _ | js0| j d | j S )NzEmpty waiter is already set)r r8 r rg r r r< r r r r s
z+_SelectorSocketTransport._make_empty_waiterc C s
d | _ d S r+ )r r< r r r r s z,_SelectorSocketTransport._reset_empty_waiter)NNN)r! r r Z_start_tls_compatibler Z
_SendfileModeZ
TRY_NATIVEZ_sendfile_compatibler r r r r r r r r r r r r r r r r r r r' r r, s* %' r, c sF e Zd ZejZd fdd Zdd Zdd Zd
dd Z d
d Z
Z S )r5 Nc s^ t |||| || _| j| jj| | j| j| j| j |d k rZ| jt
j |d d S r+ ) r r _addressr r r r rD r r r r )r& r r r- r6 r. r) r' r r r s
z#_SelectorDatagramTransport.__init__c C s t dd | jD S )Nc s s | ]\}}t |V qd S r+ )r ).0rG rb r r r s zC_SelectorDatagramTransport.get_write_buffer_size..)sumr r< r r r r s z0_SelectorDatagramTransport.get_write_buffer_sizec
C s | j r
d S z| j| j\}}W n ttfk
r8 Y n tk
rd } z| j| W 5 d }~X Y nT t t
fk
r| Y n< t k
r } z| |d W 5 d }~X Y nX | j
|| d S )Nz&Fatal read error on datagram transport)r r Zrecvfromr rK rJ rP r error_receivedri rj rh r Zdatagram_receivedr& rG rd re r r r r s z&_SelectorDatagramTransport._read_readyc
C s t |tttfs$tdt|j|s,d S | jrV|d | jfkrPtd| j | j}| j r| jr| j t
j krxt
d | j d7 _ d S | jslz,| jd r| j| n| j|| W d S ttfk
r | j| j| j Y n tk
r } z| j| W Y d S d }~X Y nP t t fk
r6 Y n6 t k
rj } z| |d W Y d S d }~X Y nX | j t||f | ! d S )Nr z!Invalid address: must be None or r r rZ 'Fatal write error on datagram transport)"r r r r r r r! r
rn r r r r r r r r rO sendtorK rJ r r r
_sendto_readyrP r r ri rj rh r r r r r r r r sH
z!_SelectorDatagramTransport.sendtoc
C s | j r| j \}}z*| jd r.| j| n| j|| W q ttfk
rj | j ||f Y qY q t k
r } z| j
| W Y d S d }~X Y q t t
fk
r Y q tk
r } z| |d W Y d S d }~X Y q X q | | j s| j| j | jr| d d S )NrZ r )r popleftr r rO r rK rJ
appendleftrP r r ri rj rh r r r r r r r r r r r r * s2
z(_SelectorDatagramTransport._sendto_ready)NNN)N) r! r r collectionsdequer r r r r r r r r r' r r5 s
+r5 ) __all__r r^ r r rB r r$ r ImportError r r r r r r r
r logr r r Z
BaseEventLoopr Z_FlowControlMixinZ Transportr r, r5 r r r r sD
1 oPK ! ,P P " __pycache__/streams.cpython-38.pycnu [ U
if h @ s& d Z ddlZddlZddlZddlZeedr6e d7 Z ddlmZ ddlmZ ddlm Z dd lm
Z
dd
lm Z dd l m
Z
dd lmZ d
Zd dedddZd dedddZeedrd!dedddZd"dedddZG dd de jZG dd dee jZG dd d ZG d d d ZdS )#) StreamReader StreamWriterStreamReaderProtocolopen_connection start_server NZAF_UNIX)open_unix_connectionstart_unix_server )
coroutines)events)
exceptions)format_helpers) protocols)logger)sleepi )looplimitc st |dkrt }ntjdtdd t||d}t||d |j fdd| |f|I dH \}}t| ||}||fS ) a A wrapper for create_connection() returning a (reader, writer) pair.
The reader returned is a StreamReader instance; the writer is a
StreamWriter instance.
The arguments are all the usual arguments to create_connection()
except protocol_factory; most common are positional host and port,
with various optional keyword arguments following.
Additional optional keyword arguments are loop (to set the event loop
instance to use) and limit (to set the buffer limit passed to the
StreamReader).
(If you want to customize the StreamReader and/or
StreamReaderProtocol classes, just copy the code -- there's
really nothing special here except some convenience.)
N[The loop argument is deprecated since Python 3.8, and scheduled for removal in Python 3.10.
stacklevelr r r c s S N r protocolr 4/opt/alt/python38/lib64/python3.8/asyncio/streams.py5 z!open_connection..) r get_event_loopwarningswarnDeprecationWarningr r Zcreate_connectionr ) hostportr r kwdsreader transport_writerr r r r s"
r c sJ dkrt ntjdtdd fdd}j|||f|I dH S )a Start a socket server, call back for each client connected.
The first parameter, `client_connected_cb`, takes two parameters:
client_reader, client_writer. client_reader is a StreamReader
object, while client_writer is a StreamWriter object. This
parameter can either be a plain callback function or a coroutine;
if it is a coroutine, it will be automatically converted into a
Task.
The rest of the arguments are all the usual arguments to
loop.create_server() except protocol_factory; most common are
positional host and port, with various optional keyword arguments
following. The return value is the same as loop.create_server().
Additional optional keyword arguments are loop (to set the event loop
instance to use) and limit (to set the buffer limit passed to the
StreamReader).
The return value is the same as loop.create_server(), i.e. a
Server object which can be used to stop the service.
Nr r r c s t d} t| d}|S Nr r r r r' r client_connected_cbr r r r factoryX s
z start_server..factory)r r r! r" r# Z
create_server)r/ r$ r% r r r& r0 r r. r r : s
r c sr |dkrt }ntjdtdd t||d}t||d |j fdd| f|I dH \}}t| ||}||fS ) z@Similar to `open_connection` but works with UNIX Domain Sockets.Nr r r r r c s S r r r r r r r p r z&open_unix_connection..) r r r! r" r# r r Zcreate_unix_connectionr )pathr r r& r' r( r) r* r r r r d s
r c sH dkrt ntjdtdd fdd}j||f|I dH S )z=Similar to `start_server` but works with UNIX Domain Sockets.Nr r r c s t d} t| d}|S r+ r, r- r. r r r0 ~ s
z"start_unix_server..factory)r r r! r" r# Zcreate_unix_server)r/ r1 r r r& r0 r r. r r t s
r c @ sB e Zd ZdZdddZdd Zdd Zd d
Zd d Zd
d Z dS )FlowControlMixina) Reusable flow control logic for StreamWriter.drain().
This implements the protocol methods pause_writing(),
resume_writing() and connection_lost(). If the subclass overrides
these it must call the super methods.
StreamWriter.drain() must wait for _drain_helper() coroutine.
Nc C s0 |d krt | _n|| _d| _d | _d| _d S NF)r r _loop_paused
_drain_waiter_connection_lost)selfr r r r __init__ s zFlowControlMixin.__init__c C s* | j r
td| _ | j r&td| d S )NTz%r pauses writing)r5 AssertionErrorr4 get_debugr debugr8 r r r
pause_writing s
z FlowControlMixin.pause_writingc C sP | j s
td| _ | j r&td| | j}|d k rLd | _| sL|d d S )NFz%r resumes writing) r5 r: r4 r; r r< r6 done
set_resultr8 waiterr r r resume_writing s
z FlowControlMixin.resume_writingc C sV d| _ | jsd S | j}|d kr"d S d | _| r4d S |d krH|d n
|| d S NT)r7 r5 r6 r? r@
set_exceptionr8 excrB r r r connection_lost s z FlowControlMixin.connection_lostc sP | j rtd| jsd S | j}|d ks2| s2t| j }|| _|I d H d S )NzConnection lost)r7 ConnectionResetErrorr5 r6 cancelledr: r4
create_futurerA r r r
_drain_helper s
z FlowControlMixin._drain_helperc C s t d S r )NotImplementedErrorr8 streamr r r _get_close_waiter s z"FlowControlMixin._get_close_waiter)N)
__name__
__module__ __qualname____doc__r9 r> rC rH rL rP r r r r r2 s
r2 c sf e Zd ZdZdZd fdd Zedd Zdd Z fd d
Z d d Z
d
d Z dd Z dd Z
ZS )r a= Helper class to adapt between Protocol and StreamReader.
(This is a helper class instead of making StreamReader itself a
Protocol subclass, because the StreamReader has other potential
uses, and to prevent the user of the StreamReader to accidentally
call inappropriate methods of the protocol.)
Nc sn t j|d |d k r,t|| _|j| _nd | _|d k r@|| _d| _d | _d | _ || _
d| _ | j
| _d S )Nr F)superr9 weakrefref_stream_reader_wr_source_traceback_strong_reader_reject_connection_stream_writer
_transport_client_connected_cb _over_sslr4 rK _closed)r8 Z
stream_readerr/ r __class__r r r9 s
z StreamReaderProtocol.__init__c C s | j d krd S | S r )rX r= r r r _stream_reader s
z#StreamReaderProtocol._stream_readerc C s | j r6ddi}| jr | j|d< | j| | d S || _| j}|d k rT|| |dd k | _ | j
d k rt || || j| _ |
|| j }t
|r| j| d | _d S )NmessagezpAn open stream was garbage collected prior to establishing network connection; call "stream.close()" explicitly.Zsource_tracebackZ
sslcontext)r[ rY r4 Zcall_exception_handlerabortr] rc
set_transportget_extra_infor_ r^ r r\ r
Z iscoroutineZ create_taskrZ )r8 r( contextr' resr r r connection_made s2
z$StreamReaderProtocol.connection_madec sx | j }|d k r*|d kr | n
|| | j sV|d krJ| jd n | j| t | d | _d | _ d | _
d S r ) rc feed_eofrE r` r? r@ rU rH rX r\ r] )r8 rG r' ra r r rH
s
z$StreamReaderProtocol.connection_lostc C s | j }|d k r|| d S r )rc feed_data)r8 datar' r r r
data_received s z"StreamReaderProtocol.data_receivedc C s$ | j }|d k r| | jr dS dS )NFT)rc rk r_ )r8 r' r r r eof_received s z!StreamReaderProtocol.eof_receivedc C s | j S r )r` rN r r r rP + s z&StreamReaderProtocol._get_close_waiterc C s" | j }| r | s | d S r )r` r? rJ exception)r8 closedr r r __del__. s z StreamReaderProtocol.__del__)NN)rQ rR rS rT rY r9 propertyrc rj rH rn ro rP rr
__classcell__r r ra r r s
r c @ sv e Zd ZdZdd Zdd Zedd Zdd Zd
d Z d d
Z
dd Z dd Z dd Z
dd ZdddZdd ZdS ) r a' Wraps a Transport.
This exposes write(), writelines(), [can_]write_eof(),
get_extra_info() and close(). It adds drain() which returns an
optional Future on which you can wait for flow control. It also
adds a transport property which references the Transport
directly.
c C sJ || _ || _|d ks"t|ts"t|| _|| _| j | _| j d d S r )
r] _protocol
isinstancer r: _readerr4 rK Z
_complete_futr@ )r8 r( r r' r r r r r9 @ s zStreamWriter.__init__c C s@ | j jd| jg}| jd k r0|d| j dd|S )N
transport=zreader=<{}> )rb rQ r] rw appendformatjoinr8 infor r r __repr__J s
zStreamWriter.__repr__c C s | j S r )r] r= r r r r( P s zStreamWriter.transportc C s | j | d S r )r] writer8 rm r r r r T s zStreamWriter.writec C s | j | d S r )r]
writelinesr r r r r W s zStreamWriter.writelinesc C s
| j S r )r] write_eofr= r r r r Z s zStreamWriter.write_eofc C s
| j S r )r]
can_write_eofr= r r r r ] s zStreamWriter.can_write_eofc C s
| j S r )r] closer= r r r r ` s zStreamWriter.closec C s
| j S r )r]
is_closingr= r r r r c s zStreamWriter.is_closingc s | j | I d H d S r )ru rP r= r r r wait_closedf s zStreamWriter.wait_closedNc C s | j ||S r )r] rg )r8 namedefaultr r r rg i s zStreamWriter.get_extra_infoc sL | j dk r | j }|dk r || j r8tdI dH | j I dH dS )zyFlush the write buffer.
The intended use is to write
w.write(data)
await w.drain()
Nr )rw rp r] r r ru rL )r8 rG r r r drainl s
zStreamWriter.drain)N)rQ rR rS rT r9 r rs r( r r r r r r r rg r r r r r r 6 s
r c @ s e Zd ZdZedfddZdd Zdd Zdd Zd
d Z d d
Z
dd Z dd Z dd Z
dd Zdd Zdd Zd&dd Zd'd d Zd d! Zd"d# Zd$d% ZdS )(r Nc C sv |dkrt d|| _|d kr*t | _n|| _t | _d| _d | _d | _ d | _
d| _ | j rrt
td| _d S )Nr zLimit cannot be <= 0Fr )
ValueError_limitr r r4 bytearray_buffer_eof_waiter
_exceptionr] r5 r; r
extract_stacksys _getframerY )r8 r r r r r r9 s
zStreamReader.__init__c C s dg}| j r"|t| j d | jr2|d | jtkrN|d| j | jrf|d| j | jr~|d| j | jr|d| j | j r|d d
d
|S ) Nr z byteseofzlimit=zwaiter=z
exception=rx Zpausedry rz ) r r{ lenr r _DEFAULT_LIMITr r r] r5 r| r} r~ r r r r s
zStreamReader.__repr__c C s | j S r )r r= r r r rp s zStreamReader.exceptionc C s0 || _ | j}|d k r,d | _| s,|| d S r )r r rJ rE rF r r r rE s zStreamReader.set_exceptionc C s* | j }|dk r&d| _ | s&|d dS )z1Wakeup read*() functions waiting for data or EOF.N)r rJ r@ rA r r r _wakeup_waiter s
zStreamReader._wakeup_waiterc C s | j d kstd|| _ d S )NzTransport already set)r] r: )r8 r( r r r rf s zStreamReader.set_transportc C s* | j r&t| j| jkr&d| _ | j d S r3 )r5 r r r r] resume_readingr= r r r _maybe_resume_transport s z$StreamReader._maybe_resume_transportc C s d| _ | d S rD )r r r= r r r rk s zStreamReader.feed_eofc C s | j o | j S )z=Return True if the buffer is empty and 'feed_eof' was called.)r r r= r r r at_eof s zStreamReader.at_eofc C s | j rtd|sd S | j| | | jd k r~| js~t| jd| j kr~z| j W n t
k
rv d | _Y nX d| _d S )Nzfeed_data after feed_eofr T) r r: r extendr r] r5 r r Z
pause_readingrM r r r r rl s
zStreamReader.feed_datac sf | j dk rt| d| jr&td| jr
zStreamReader.readuntilr c s | j dk r| j |dkr dS |dk rVg }| | jI dH }|s@qL|| q(d|S | jsr| jsr| dI dH t| jd| }| jd|= | |S )a Read up to `n` bytes from the stream.
If n is not provided, or set to -1, read until EOF and return all read
bytes. If the EOF was received and the internal buffer is empty, return
an empty bytes object.
If n is zero, return empty bytes object immediately.
If n is positive, this function try to read `n` bytes, and may return
less or equal bytes than requested, but at least one byte. If EOF was
received before any byte is read, this function returns empty byte
object.
Returned value is not limited with limit, configured at stream
creation.
If stream was paused, this function will automatically resume it if
needed.
Nr r read)
r r r r{ r} r r r r r )r8 nZblocksblockrm r r r r s"
zStreamReader.readc s |dk rt d| jdk r | j|dkr,dS t| j|k rr| jr`t| j}| j t||| dI dH q,t| j|krt| j}| j n t| jd| }| jd|= |
|S )a Read exactly `n` bytes.
Raise an IncompleteReadError if EOF is reached before `n` bytes can be
read. The IncompleteReadError.partial attribute of the exception will
contain the partial read bytes.
if n is zero, return empty bytes object.
Returned value is not limited with limit, configured at stream
creation.
If stream was paused, this function will automatically resume it if
needed.
r z*readexactly size can not be less than zeroNr readexactly) r r r r r r r r r r r )r8 r Z
incompleterm r r r r s&
zStreamReader.readexactlyc C s | S r r r= r r r __aiter__ s zStreamReader.__aiter__c s | I d H }|dkrt|S )Nr )r StopAsyncIteration)r8 valr r r __anext__ s zStreamReader.__anext__)r )r )rQ rR rS rY r r9 r rp rE r rf r rk r rl r r r r r r r r r r r r s$
[
2)r )NN)NN)N)N)__all__Zsocketr r! rV hasattr r
r r r
r logr Ztasksr r r r r r ZProtocolr2 r r r r r r r sF
! '
DkPPK ! ֬ $ __pycache__/log.cpython-38.opt-2.pycnu [ U
if| @ s d dl Z e eZdS ) N)ZloggingZ getLogger __package__Zlogger r r 0/opt/alt/python38/lib64/python3.8/asyncio/log.py s PK ! J] J] 0 __pycache__/proactor_events.cpython-38.opt-1.pycnu [ U
if<} @ sT d Z dZddlZddlZddlZddlZddlZddlZddlZddl m
Z
ddl m Z ddl m Z ddl m
Z
dd l mZ dd
l mZ dd l mZ dd l mZ dd
lmZ dd ZG dd dejejZG dd deejZG dd deejZG dd deZ G dd deZ G dd deeej Z G d d d eeej Z G d d d e
j!Z"dS ) zEvent loop using a proactor and related classes.
A proactor is a "notify-on-completion" multiplexer. Currently a
proactor is only implemented on Windows with IOCP.
)BaseProactorEventLoop N ) base_events) constants)futures)
exceptions) protocols)sslproto)
transports)trsock)loggerc C s t || jd< z| | jd< W n0 tjk
rR | j rNtj d|dd Y nX d| jkrz|
| jd< W n tjk
r d | jd< Y nX d S )NsocketZsocknamezgetsockname() failed on %rTexc_infopeername) r TransportSocket_extraZ getsocknamer
error_loop get_debugr warningZ getpeername) transportsock r )
r4 __name__r appendr( filenor$ r% r# lenr) formatjoin)r- infor r r __repr__H s
z#_ProactorBasePipeTransport.__repr__c C s || j d< d S )Npipe)r r- r r r r r Z s z%_ProactorBasePipeTransport._set_extrac C s
|| _ d S Nr+ )r- r/ r r r r! ] s z'_ProactorBasePipeTransport.set_protocolc C s | j S rB rC r- r r r get_protocol` s z'_ProactorBasePipeTransport.get_protocolc C s | j S rB )r( rD r r r
is_closingc s z%_ProactorBasePipeTransport.is_closingc C s\ | j r
d S d| _ | jd7 _| js>| jd kr>| j| jd | jd k rX| j d | _d S )NTr ) r( r' r# r% r r* _call_connection_lostr$ cancelrD r r r closef s
z _ProactorBasePipeTransport.closec C s* | j d k r&|d| t| d | d S )Nzunclosed transport )source)r ResourceWarningrI )r- Z_warnr r r __del__q s
z"_ProactorBasePipeTransport.__del__ Fatal error on pipe transportc C sV zDt|tr*| j rBtjd| |dd n| j||| | jd W 5 | | X d S )Nz%r: %sTr )message exceptionr r/ ) _force_close
isinstanceOSErrorr r r debugcall_exception_handlerr+ )r- excrN r r r _fatal_errorv s
z'_ProactorBasePipeTransport._fatal_errorc C s | j d k r6| j s6|d kr*| j d n | j | | jr@d S d| _| jd7 _| jrj| j d | _| jr| j d | _d| _ d | _
| j | j
| d S )NTr r )
_empty_waiterdone
set_resultZ
set_exceptionr( r' r% rH r$ r& r# r r* rG )r- rU r r r rP s"
z'_ProactorBasePipeTransport._force_closec C s^ z| j | W 5 t | jdr,| jtj | j d | _| j}|d k rX| d | _X d S )Nshutdown)
hasattrr rZ r
Z SHUT_RDWRrI r" Z_detachr+ Zconnection_lost)r- rU r2 r r r rG s
z0_ProactorBasePipeTransport._call_connection_lostc C s" | j }| jd k r |t| j7 }|S rB )r& r# r; )r- sizer r r get_write_buffer_size s
z0_ProactorBasePipeTransport.get_write_buffer_size)NNN)rM )r8
__module__ __qualname____doc__r r? r r! rE rF rI warningswarnrL rV rP rG r]
__classcell__r r r3 r r . s
r c sT e Zd ZdZd fdd Zdd Zdd Zd d
Zd d Zd
d Z dddZ
Z S )_ProactorReadPipeTransportzTransport for read pipes.Nc s: d | _ d| _t |||||| | j| j d| _d S )NTF)
_pending_data_pausedr r r r*
_loop_readingr, r3 r r r s
z#_ProactorReadPipeTransport.__init__c C s | j o| j S rB )rf r( rD r r r
is_reading s z%_ProactorReadPipeTransport.is_readingc C s0 | j s | jrd S d| _| j r,td| d S )NTz%r pauses reading)r( rf r r r rS rD r r r
pause_reading s
z(_ProactorReadPipeTransport.pause_readingc C sn | j s | jsd S d| _| jd kr0| j| jd | j}d | _|d k rT| j| j| | j rjt
d| d S )NFz%r resumes reading) r( rf r$ r r* rg re _data_receivedr r rS r- datar r r resume_reading s
z)_ProactorReadPipeTransport.resume_readingc
C s | j rtd| z| j }W nL ttfk
r> Y n4 tk
rp } z| |d W Y d S d }~X Y nX |s~|
d S )Nz%r received EOFz1Fatal error: protocol.eof_received() call failed.) r r r rS r+ Z eof_received
SystemExitKeyboardInterrupt
BaseExceptionrV rI )r- Z keep_openrU r r r
_eof_received s
z(_ProactorReadPipeTransport._eof_receivedc
C s | j r|| _d S |s | d S t| jtjrzt| j| W q tt fk
rZ Y q t
k
r } z| |d W Y d S d }~X Y qX n | j | d S )Nz3Fatal error: protocol.buffer_updated() call failed.)
rf re rq rQ r+ r ZBufferedProtocolZ _feed_data_to_buffered_protorn ro rp rV Z
data_received)r- rl rU r r r rj s" z)_ProactorReadPipeTransport._data_receivedc
C st d }zRzp|d k r2d | _| r*| }n| | jrHd }W W d S |dkr\W W d S | jsv| jj | j
d| _W n t k
r } z0| js| |d n| j
rtjddd W 5 d }~X Y n tk
r } z| | W 5 d }~X Y nf tk
r } z| |d W 5 d }~X Y n8 tjk
r> | js: Y nX | jsV| j| j W 5 |d k rn| | X d S )N i z"Fatal read error on pipe transportz*Read error on pipe transport while closingTr )rj r$ rX resultrH r( rf r _proactorrecvr ConnectionAbortedErrorrV r r rS ConnectionResetErrorrP rR r CancelledErroradd_done_callbackrg )r- futrl rU r r r rg s@
z(_ProactorReadPipeTransport._loop_reading)NNN)N) r8 r^ r_ r` r rh ri rm rq rj rg rc r r r3 r rd s rd c s^ e Zd ZdZdZ fddZdd Zddd Zd
d Zd d
Z dd Z
dd Z dd Z Z
S ) _ProactorBaseWritePipeTransportzTransport for write pipes.Tc s t j|| d | _d S rB )r r rW r- argskwr3 r r r G s z(_ProactorBaseWritePipeTransport.__init__c C s t |tttfs$tdt|j | jr2td| j d k rDtd|sLd S | j
rz| j
t j krht
d | j
d7 _
d S | jd kr| jt|d n.| jst|| _| n| j| | d S )Nz/data argument must be a bytes-like object, not zwrite_eof() already calledz(unable to write; sendfile is in progressz socket.send() raised exception.r )rl )rQ bytes bytearray
memoryview TypeErrortyper8 r) RuntimeErrorrW r' r !LOG_THRESHOLD_FOR_CONNLOST_WRITESr r r%
_loop_writingr# _maybe_pause_protocolextendrk r r r writeK s,
z%_ProactorBaseWritePipeTransport.writeNc
C sV z|d k r | j d kr | jr W d S d | _ d| _|r8| |d krL| j}d | _|s| jrf| j| jd | jrz| j
t j |
nN| jj| j || _ | j st|| _| j | j | n| j | j | jd k r| j d kr| jd W n\ tk
r" } z| | W 5 d }~X Y n0 tk
rP } z| |d W 5 d }~X Y nX d S )Nr z#Fatal write error on pipe transport)r% r( r& rs r# r r* rG r) r rZ r
SHUT_WR_maybe_resume_protocolrt sendrX r; ry r r rW rY rw rP rR rV )r- frl rU r r r r q s8
z-_ProactorBaseWritePipeTransport._loop_writingc C s dS NTr rD r r r
can_write_eof s z-_ProactorBaseWritePipeTransport.can_write_eofc C s | d S rB )rI rD r r r write_eof s z)_ProactorBaseWritePipeTransport.write_eofc C s | d d S rB rP rD r r r abort s z%_ProactorBaseWritePipeTransport.abortc C s: | j d k rtd| j | _ | jd kr4| j d | j S )NzEmpty waiter is already set)rW r r Z
create_futurer% rY rD r r r _make_empty_waiter s
z2_ProactorBaseWritePipeTransport._make_empty_waiterc C s
d | _ d S rB )rW rD r r r _reset_empty_waiter s z3_ProactorBaseWritePipeTransport._reset_empty_waiter)NN)r8 r^ r_ r` Z_start_tls_compatibler r r r r r r r rc r r r3 r r{ A s &
)r{ c s$ e Zd Z fddZdd Z ZS )_ProactorWritePipeTransportc s4 t j|| | jj| jd| _| j| j d S )N ) r r r rt ru r r$ ry _pipe_closedr| r3 r r r s z$_ProactorWritePipeTransport.__init__c C s@ | r d S | jrd S d | _| jd k r4| t n| d S rB )Z cancelledr( r$ r% rP BrokenPipeErrorrI )r- rz r r r r s
z(_ProactorWritePipeTransport._pipe_closed)r8 r^ r_ r r rc r r r3 r r s r c sX e Zd ZdZd fdd Zdd Zdd Zd d
Zdd d Zdd
dZ dddZ
Z S )_ProactorDatagramTransporti Nc s> || _ d | _t j|||||d t | _| j| j d S )N)r0 r1 )
_addressrW r r collectionsdequer# r r* rg )r- r. r r/ addressr0 r1 r3 r r r s
z#_ProactorDatagramTransport.__init__c C s t | | d S rB r rA r r r r s z%_ProactorDatagramTransport._set_extrac C s t dd | jD S )Nc s s | ]\}}t |V qd S rB )r; ).0rl _r r r s zC_ProactorDatagramTransport.get_write_buffer_size..)sumr# rD r r r r] s z0_ProactorDatagramTransport.get_write_buffer_sizec C s | d d S rB r rD r r r r s z _ProactorDatagramTransport.abortc C s t |tttfs tdt||s&d S | jd k rN|d | jfkrNtd| j | jr| jr| jt j
krpt d | jd7 _d S | j
t||f | jd kr| | d S )Nz,data argument must be bytes-like object (%r)z!Invalid address: must be None or z!socket.sendto() raised exception.r )rQ r r r r r r
ValueErrorr' r r r r r# r9 r% r r )r- rl addrr r r sendto s&
z!_ProactorDatagramTransport.sendtoc
C s z| j rW d S d | _|r | | jr2| j rN| jrN| jrH| j| jd W d S | j \}}| jd k r|| jj
| j || _n| jj
j
| j ||d| _W nZ tk
r } z| j| W 5 d }~X Y nD tk
r } z| |d W 5 d }~X Y nX | j| j | d S )N)r z'Fatal write error on datagram transport)r' r% rs r# r r( r r* rG popleftrt r r r rR r+ error_received ExceptionrV ry r r )r- rz rl r rU r r r r s2
z(_ProactorDatagramTransport._loop_writingc
C s4 d }zz| jr W W d S d | _|d k rf| }| jrFd }W W d S | jd k r^|| j }}n|\}}| jrvW W d S | jd k r| jj | j
| j | _n| jj | j
| j | _W nJ t
k
r } z| j | W 5 d }~X Y n8 tjk
r | js Y n X | jd k r| j| j W 5 |r.| j || X d S rB )r+ Zdatagram_receivedr' r$ rs r( r r rt ru r max_sizeZrecvfromrR r r rx ry rg )r- rz rl r resrU r r r rg s>
z(_ProactorDatagramTransport._loop_reading)NNN)N)N)N) r8 r^ r_ r r r r] r r r rg rc r r r3 r r s
!r c @ s e Zd ZdZdd Zdd ZdS ) _ProactorDuplexPipeTransportzTransport for duplex pipes.c C s dS )NFr rD r r r r J s z*_ProactorDuplexPipeTransport.can_write_eofc C s t d S rB )NotImplementedErrorrD r r r r M s z&_ProactorDuplexPipeTransport.write_eofN)r8 r^ r_ r` r r r r r r r E s r c sB e Zd ZdZejjZd fdd Zdd Z dd Z
d d
Z Z S ) _ProactorSocketTransportz Transport for connected sockets.Nc s$ t |||||| t| d S rB )r r r Z _set_nodelayr, r3 r r r X s z!_ProactorSocketTransport.__init__c C s t | | d S rB r rA r r r r ] s z#_ProactorSocketTransport._set_extrac C s dS r r rD r r r r ` s z&_ProactorSocketTransport.can_write_eofc C s2 | j s | jrd S d| _| jd kr.| jtj d S r )r( r) r% r rZ r
r rD r r r r c s
z"_ProactorSocketTransport.write_eof)NNN)
r8 r^ r_ r` r Z
_SendfileModeZ
TRY_NATIVEZ_sendfile_compatibler r r r rc r r r3 r r Q s r c s e Zd Z fddZd3ddZd4dddddddd Zd5d
d Zd6d d
Zd7ddZd8ddZ fddZ
dd Z dd Z dd Z
dd Zd d Zd d Zd d! Zd"d# Zd$d% Zd9d&d'Zd(d) Zd:d+d,Zd-d. Zd/d0 Zd1d2 Z ZS );r c sh t td|jj || _|| _d | _i | _ |
| | t
t krdt| j d S )NzUsing proactor: %s)r r r rS r4 r8 rt _selector_self_reading_future_accept_futuresZset_loop_make_self_pipe threadingcurrent_thread main_threadsignal
set_wakeup_fd_csockr: )r- Zproactorr3 r r r m s
z BaseProactorEventLoop.__init__Nc C s t | |||||S rB )r )r- r r/ r0 r1 r2 r r r _make_socket_transportz s
z,BaseProactorEventLoop._make_socket_transportF) server_sideserver_hostnamer1 r2 ssl_handshake_timeoutc C s0 t j| |||||| d}
t| ||
||d |
jS )N)r r1 r2 )r Z SSLProtocolr Z_app_transport) r- Zrawsockr/
sslcontextr0 r r r1 r2 r Z ssl_protocolr r r _make_ssl_transport s z)BaseProactorEventLoop._make_ssl_transportc C s t | |||||S rB )r )r- r r/ r r0 r1 r r r _make_datagram_transport s
z.BaseProactorEventLoop._make_datagram_transportc C s t | ||||S rB )r r- r r/ r0 r1 r r r _make_duplex_pipe_transport s z1BaseProactorEventLoop._make_duplex_pipe_transportc C s t | ||||S rB )rd r r r r _make_read_pipe_transport s z/BaseProactorEventLoop._make_read_pipe_transportc C s t | ||||S rB )r r r r r _make_write_pipe_transport s z0BaseProactorEventLoop._make_write_pipe_transportc sj | rtd| r d S t t kr6td | | | j
d | _
d | _ t
d S )Nz!Cannot close a running event loop)Z
is_runningr is_closedr r r r r _stop_accept_futures_close_self_pipert rI r r rD r3 r r rI s
zBaseProactorEventLoop.closec s | j ||I d H S rB )rt ru )r- r nr r r sock_recv s z BaseProactorEventLoop.sock_recvc s | j ||I d H S rB )rt Z recv_into)r- r Zbufr r r sock_recv_into s z$BaseProactorEventLoop.sock_recv_intoc s | j ||I d H S rB )rt r )r- r rl r r r sock_sendall s z"BaseProactorEventLoop.sock_sendallc s | j ||I d H S rB )rt Zconnect)r- r r r r r sock_connect s z"BaseProactorEventLoop.sock_connectc s | j |I d H S rB )rt acceptrA r r r sock_accept s z!BaseProactorEventLoop.sock_acceptc
s( z | }W n2 ttjfk
r> } ztdW 5 d }~X Y nX zt|j}W n, t k
r| } ztdW 5 d }~X Y nX |r|n|}|sdS t
|d}|rt
|| |n|} t
||}d}
zLt
| | |}|dkr|
W 0S | j
||||I d H ||7 }|
|7 }
qW 5 |
dkr"| | X d S )Nznot a regular filer l )r: AttributeErrorioUnsupportedOperationr ZSendfileNotAvailableErrorosfstatst_sizerR minseekrt sendfile) r- r fileoffsetcountr: errZfsizeZ blocksizeZend_posZ
total_sentr r r _sock_sendfile_native s0
z+BaseProactorEventLoop._sock_sendfile_nativec sZ | }| | I d H z | j|j|||ddI d H W S | |rT| X d S )NF)Zfallback)rh ri r r rm Z
sock_sendfiler )r- Ztranspr r r rm r r r _sendfile_native s z&BaseProactorEventLoop._sendfile_nativec C sL | j d k r| j d | _ | j d | _| j d | _| jd8 _d S )Nr )r rH _ssockrI r
_internal_fdsrD r r r r s
z&BaseProactorEventLoop._close_self_pipec C s: t \| _| _| jd | jd | jd7 _d S )NFr )r
Z
socketpairr r Z setblockingr rD r r r r s z%BaseProactorEventLoop._make_self_pipec
C s z4|d k r| | j|k r"W d S | j| jd}W nb tjk
rL Y d S ttfk
rd Y nF t k
r } z|
d|| d W 5 d }~X Y nX || _| | j d S )Ni z.Error on reading from the event loop self pipe)rN rO r. )
rs r rt ru r r rx rn ro rp rT ry _loop_self_reading)r- r rU r r r r s$
z(BaseProactorEventLoop._loop_self_readingc C sN | j }|d krd S z|d W n( tk
rH | jrDtjddd Y nX d S )N z3Fail to write a null byte into the self-pipe socketTr )r r rR _debugr rS )r- Zcsockr r r _write_to_self s z$BaseProactorEventLoop._write_to_selfd c s( d fdd d S )Nc
s, z| d k rn| \}}jr,td|| }d k rXj||dd|id nj||d|id r|W d S j} W n t k
r } zH
dkrʈ d|t
d njrtjd dd
W 5 d }~X Y n8 tjk
r Y nX | j
< | d S ) Nz#%r got a new connection from %r: %rTr )r r1 r2 r r r zAccept failed on a socket)rN rO r
zAccept failed on socket %rr )rs r r rS r r r rt r rR r: rT r r rI r rx r ry )r Zconnr r/ rU r. protocol_factoryr- r2 r r r r r r. / s\
z2BaseProactorEventLoop._start_serving..loop)N)r* )r- r r r r2 Zbacklogr r r r _start_serving+ s %z$BaseProactorEventLoop._start_servingc C s d S rB r )r- Z
event_listr r r _process_eventsV s z%BaseProactorEventLoop._process_eventsc C s& | j D ] }| q
| j d S rB )r valuesrH clear)r- futurer r r r Z s
z*BaseProactorEventLoop._stop_accept_futuresc C s6 | j | d }|r | | j| | d S rB )r popr: rH rt
_stop_servingrI )r- r r r r r r _ s
z#BaseProactorEventLoop._stop_serving)NNN)N)NNN)NN)NN)NN)N)NNr N)r8 r^ r_ r r r r r r r rI r r r r r r r r r r r r r r r rc r r r3 r r k s\
+r )#r` __all__r r r
ra r r r r r r r r r r
r logr r Z_FlowControlMixinZ
BaseTransportr Z
ReadTransportrd ZWriteTransportr{ r r Z Transportr r Z
BaseEventLoopr r r r r sR n PK !
/ / % __pycache__/transports.cpython-38.pycnu [ U
if( @ s| d Z dZG dd dZG dd deZG dd deZG dd d eeZG d
d d eZG d d
d
eZG dd deZdS )zAbstract Transport class.)
BaseTransport
ReadTransportWriteTransport TransportDatagramTransportSubprocessTransportc @ sH e Zd ZdZdZdddZdddZdd Zd
d Zd d
Z dd Z
dS )r zBase class for transports._extraNc C s |d kr i }|| _ d S Nr )selfextra r 7/opt/alt/python38/lib64/python3.8/asyncio/transports.py__init__ s zBaseTransport.__init__c C s | j ||S )z#Get optional transport information.)r get)r
namedefaultr r r
get_extra_info s z BaseTransport.get_extra_infoc C s t dS )z2Return True if the transport is closing or closed.NNotImplementedErrorr
r r r
is_closing s zBaseTransport.is_closingc C s t dS )a Close the transport.
Buffered data will be flushed asynchronously. No more data
will be received. After all buffered data is flushed, the
protocol's connection_lost() method will (eventually) be
called with None as its argument.
Nr r r r r
close s zBaseTransport.closec C s t dS )zSet a new protocol.Nr )r
protocolr r r
set_protocol% s zBaseTransport.set_protocolc C s t dS )z Return the current protocol.Nr r r r r
get_protocol) s zBaseTransport.get_protocol)N)N) __name__
__module__ __qualname____doc__ __slots__r r r r r r r r r r
r s
r c @ s, e Zd ZdZdZdd Zdd Zdd Zd S )
r z#Interface for read-only transports.r c C s t dS )z*Return True if the transport is receiving.Nr r r r r
is_reading3 s zReadTransport.is_readingc C s t dS )zPause the receiving end.
No data will be passed to the protocol's data_received()
method until resume_reading() is called.
Nr r r r r
pause_reading7 s zReadTransport.pause_readingc C s t dS )zResume the receiving end.
Data received will once again be passed to the protocol's
data_received() method.
Nr r r r r
resume_reading? s z ReadTransport.resume_readingN)r r r r r r r! r" r r r r
r . s
r c @ sN e Zd ZdZdZdddZdd Zdd Zd
d Zd d
Z dd Z
dd Z dS )r z$Interface for write-only transports.r Nc C s t dS )a Set the high- and low-water limits for write flow control.
These two values control when to call the protocol's
pause_writing() and resume_writing() methods. If specified,
the low-water limit must be less than or equal to the
high-water limit. Neither value can be negative.
The defaults are implementation-specific. If only the
high-water limit is given, the low-water limit defaults to an
implementation-specific value less than or equal to the
high-water limit. Setting high to zero forces low to zero as
well, and causes pause_writing() to be called whenever the
buffer becomes non-empty. Setting low to zero causes
resume_writing() to be called only once the buffer is empty.
Use of zero for either limit is generally sub-optimal as it
reduces opportunities for doing I/O and computation
concurrently.
Nr r
highlowr r r
set_write_buffer_limitsM s z&WriteTransport.set_write_buffer_limitsc C s t dS )z,Return the current size of the write buffer.Nr r r r r
get_write_buffer_sizeb s z$WriteTransport.get_write_buffer_sizec C s t dS )zWrite some data bytes to the transport.
This does not block; it buffers the data and arranges for it
to be sent out asynchronously.
Nr )r
datar r r
writef s zWriteTransport.writec C s d |}| | dS )zWrite a list (or any iterable) of data bytes to the transport.
The default implementation concatenates the arguments and
calls write() on the result.
N)joinr) )r
Z list_of_datar( r r r
writelinesn s
zWriteTransport.writelinesc C s t dS )zClose the write end after flushing buffered data.
(This is like typing ^D into a UNIX program reading from stdin.)
Data may still be received.
Nr r r r r
write_eofw s zWriteTransport.write_eofc C s t dS )zAReturn True if this transport supports write_eof(), False if not.Nr r r r r
can_write_eof s z WriteTransport.can_write_eofc C s t dS zClose the transport immediately.
Buffered data will be lost. No more data will be received.
The protocol's connection_lost() method will (eventually) be
called with None as its argument.
Nr r r r r
abort s zWriteTransport.abort)NN) r r r r r r& r' r) r, r- r. r0 r r r r
r H s
r c @ s e Zd ZdZdZdS )r aS Interface representing a bidirectional transport.
There may be several implementations, but typically, the user does
not implement new transports; rather, the platform provides some
useful transports that are implemented using the platform's best
practices.
The user never instantiates a transport directly; they call a
utility function, passing it a protocol factory and other
information necessary to create the transport and protocol. (E.g.
EventLoop.create_connection() or EventLoop.create_server().)
The utility function will asynchronously create a transport and a
protocol and hook them up by calling the protocol's
connection_made() method, passing it the transport.
The implementation here raises NotImplemented for every method
except writelines(), which calls write() in a loop.
r N)r r r r r r r r r
r s r c @ s& e Zd ZdZdZdddZdd ZdS ) r z(Interface for datagram (UDP) transports.r Nc C s t dS )a Send data to the transport.
This does not block; it buffers the data and arranges for it
to be sent out asynchronously.
addr is target socket address.
If addr is None use target address pointed on transport creation.
Nr )r
r( Zaddrr r r
sendto s zDatagramTransport.sendtoc C s t dS r/ r r r r r
r0 s zDatagramTransport.abort)N)r r r r r r1 r0 r r r r
r s
r c @ s@ e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dS )r r c C s t dS )zGet subprocess id.Nr r r r r
get_pid s zSubprocessTransport.get_pidc C s t dS )zGet subprocess returncode.
See also
http://docs.python.org/3/library/subprocess#subprocess.Popen.returncode
Nr r r r r
get_returncode s z"SubprocessTransport.get_returncodec C s t dS )z&Get transport for pipe with number fd.Nr )r
fdr r r
get_pipe_transport s z&SubprocessTransport.get_pipe_transportc C s t dS )zSend signal to subprocess.
See also:
docs.python.org/3/library/subprocess#subprocess.Popen.send_signal
Nr )r
signalr r r
send_signal s z SubprocessTransport.send_signalc C s t dS )aL Stop the subprocess.
Alias for close() method.
On Posix OSs the method sends SIGTERM to the subprocess.
On Windows the Win32 API function TerminateProcess()
is called to stop the subprocess.
See also:
http://docs.python.org/3/library/subprocess#subprocess.Popen.terminate
Nr r r r r
terminate s z SubprocessTransport.terminatec C s t dS )zKill the subprocess.
On Posix OSs the function sends SIGKILL to the subprocess.
On Windows kill() is an alias for terminate().
See also:
http://docs.python.org/3/library/subprocess#subprocess.Popen.kill
Nr r r r r
kill s zSubprocessTransport.killN)
r r r r r2 r3 r5 r7 r8 r9 r r r r
r s r c sZ e Zd ZdZdZd fdd Zdd Zdd Zd
d Zdd d
Z dddZ
dd Z Z S )_FlowControlMixinav All the logic for (write) flow control in a mix-in base class.
The subclass must implement get_write_buffer_size(). It must call
_maybe_pause_protocol() whenever the write buffer size increases,
and _maybe_resume_protocol() whenever it decreases. It may also
override set_write_buffer_limits() (e.g. to specify different
defaults).
The subclass constructor must call super().__init__(extra). This
will call set_write_buffer_limits().
The user may call set_write_buffer_limits() and
get_write_buffer_size(), and their protocol's pause_writing() and
resume_writing() may be called.
)_loop_protocol_paused _high_water
_low_waterNc s0 t | |d k st|| _d| _| d S )NF)superr AssertionErrorr; r< _set_write_buffer_limits)r
r Zloop __class__r r
r s
z_FlowControlMixin.__init__c
C s | }|| jkrd S | jsd| _z| j W nR ttfk
rJ Y n: tk
r } z | j d|| | jd W 5 d }~X Y nX d S )NTz protocol.pause_writing() failedmessageZ exceptionZ transportr )
r' r= r< _protocolZ
pause_writing
SystemExitKeyboardInterrupt
BaseExceptionr; call_exception_handler)r
sizeexcr r r
_maybe_pause_protocol s
z'_FlowControlMixin._maybe_pause_protocolc
C s | j r|| | jkr|d| _ z| j W nR ttfk
rB Y n: tk
rz } z | j d|| | jd W 5 d }~X Y nX d S )NFz protocol.resume_writing() failedrD )
r< r' r> rF Zresume_writingrG rH rI r; rJ )r
rL r r r
_maybe_resume_protocol! s z(_FlowControlMixin._maybe_resume_protocolc C s | j | jfS r )r> r= r r r r
get_write_buffer_limits1 s z)_FlowControlMixin.get_write_buffer_limitsc C sj |d kr |d krd}nd| }|d kr.|d }|| krBdksZn t d|d|d|| _|| _d S )Ni zhigh (z) must be >= low (z) must be >= 0)
ValueErrorr= r> r# r r r
rA 4 s z*_FlowControlMixin._set_write_buffer_limitsc C s | j ||d | d S )N)r$ r% )rA rM r# r r r
r& D s z)_FlowControlMixin.set_write_buffer_limitsc C s t d S r r r r r r
r' H s z'_FlowControlMixin.get_write_buffer_size)NN)NN)NN)
r r r r r r rM rN rO rA r& r'
__classcell__r r rB r
r: s
r: N) r __all__r r r r r r r: r r r r
s %F6PK ! E2! 2! ' __pycache__/trsock.cpython-38.opt-1.pycnu [ U
if @ s" d dl Z d dlZG dd dZdS ) Nc @ s e Zd ZdZdZejdddZdd Zedd Z ed
d Z
ed d
Z dd Z dd Z
dd Zdd Zdd Zdd Zdd Zd d Zd d Zd d! Zd"d# Zd$d% Zd&d' Zd(d) Zd*d+ Zd,d- Zd.d/ Z d0d1 Z d2d3 Z d4d5 Z d6d7 Z d8d9 Z!d:d; Z"dd? Z$d@dA Z%dBdC Z&dDdE Z'dFdG Z(dHdI Z)dJdK Z*dLdM Z+dNdO Z,dPdQ Z-dRdS Z.dTdU Z/dVdW Z0dXdY Z1dZd[ Z2d\S )]TransportSocketzA socket-like wrapper for exposing real transport sockets.
These objects can be safely returned by APIs like
`transport.get_extra_info('socket')`. All potentially disruptive
operations (like "socket.close()") are banned.
_sock)sockc C s
|| _ d S Nr )selfr r 3/opt/alt/python38/lib64/python3.8/asyncio/trsock.py__init__ s zTransportSocket.__init__c C s t jd| dt| d d S )NzUsing z on sockets returned from get_extra_info('socket') will be prohibited in asyncio 3.9. Please report your use case to bugs.python.org.)source)warningswarnDeprecationWarning)r Zwhatr r r _na s
zTransportSocket._nac C s | j jS r )r familyr r r r r s zTransportSocket.familyc C s | j jS r )r typer r r r r s zTransportSocket.typec C s | j jS r )r protor r r r r " s zTransportSocket.protoc C s d| d| jd| jd| j }| dkrz | }|rN| d| }W n tjk
rf Y nX z | }|r| d| }W n tjk
r Y nX | dS ) Nz )filenor r r getsocknamesocketerror getpeername)r sZladdrZraddrr r r __repr__& s $ zTransportSocket.__repr__c C s t dd S )Nz/Cannot serialize asyncio.TransportSocket object) TypeErrorr r r r __getstate__= s z TransportSocket.__getstate__c C s
| j S r )r r r r r r r @ s zTransportSocket.filenoc C s
| j S r )r dupr r r r r C s zTransportSocket.dupc C s
| j S r )r get_inheritabler r r r r F s z TransportSocket.get_inheritablec C s | j | d S r )r shutdown)r Zhowr r r r! I s zTransportSocket.shutdownc O s | j j||S r )r
getsockoptr argskwargsr r r r" N s zTransportSocket.getsockoptc O s | j j|| d S r )r
setsockoptr# r r r r& Q s zTransportSocket.setsockoptc C s
| j S r )r r r r r r r T s zTransportSocket.getpeernamec C s
| j S r )r r r r r r r W s zTransportSocket.getsocknamec C s
| j S r )r
getsockbynamer r r r r' Z s z TransportSocket.getsockbynamec C s | d | j S )Nzaccept() method)r r acceptr r r r r( ] s
zTransportSocket.acceptc O s | d | jj||S )Nzconnect() method)r r connectr# r r r r) a s
zTransportSocket.connectc O s | d | jj||S )Nzconnect_ex() method)r r
connect_exr# r r r r* e s
zTransportSocket.connect_exc O s | d | jj||S )Nz
bind() method)r r bindr# r r r r+ i s
zTransportSocket.bindc O s | d | jj||S )Nzioctl() method)r r ioctlr# r r r r, m s
zTransportSocket.ioctlc O s | d | jj||S )Nzlisten() method)r r listenr# r r r r- q s
zTransportSocket.listenc C s | d | j S )Nzmakefile() method)r r makefiler r r r r. u s
zTransportSocket.makefilec O s | d | jj||S )Nzsendfile() method)r r sendfiler# r r r r/ y s
zTransportSocket.sendfilec C s | d | j S )Nzclose() method)r r closer r r r r0 } s
zTransportSocket.closec C s | d | j S )Nzdetach() method)r r detachr r r r r1 s
zTransportSocket.detachc O s | d | jj||S )Nzsendmsg_afalg() method)r r
sendmsg_afalgr# r r r r2 s
z TransportSocket.sendmsg_afalgc O s | d | jj||S )Nzsendmsg() method)r r sendmsgr# r r r r3 s
zTransportSocket.sendmsgc O s | d | jj||S )Nzsendto() method)r r sendtor# r r r r4 s
zTransportSocket.sendtoc O s | d | jj||S )Nz
send() method)r r sendr# r r r r5 s
zTransportSocket.sendc O s | d | jj||S )Nzsendall() method)r r sendallr# r r r r6 s
zTransportSocket.sendallc O s | d | jj||S )Nzset_inheritable() method)r r set_inheritabler# r r r r7 s
z TransportSocket.set_inheritablec C s | d | j|S )Nzshare() method)r r share)r Z
process_idr r r r8 s
zTransportSocket.sharec O s | d | jj||S )Nzrecv_into() method)r r recv_intor# r r r r9 s
zTransportSocket.recv_intoc O s | d | jj||S )Nzrecvfrom_into() method)r r
recvfrom_intor# r r r r: s
z TransportSocket.recvfrom_intoc O s | d | jj||S )Nzrecvmsg_into() method)r r recvmsg_intor# r r r r; s
z TransportSocket.recvmsg_intoc O s | d | jj||S )Nzrecvmsg() method)r r recvmsgr# r r r r< s
zTransportSocket.recvmsgc O s | d | jj||S )Nzrecvfrom() method)r r recvfromr# r r r r= s
zTransportSocket.recvfromc O s | d | jj||S )Nz
recv() method)r r recvr# r r r r> s
zTransportSocket.recvc C s |dkr d S t dd S )Nr z rB rC rE rG rH r r r r r sb
r )r r r r r r r s PK ! %i )r r2 formatjoin)r! r0 r& r& r' __repr__; s
zHandle.__repr__c C s0 | j s,d| _ | j r t| | _d | _d | _d S NT)r r r reprr r r r! r& r& r' cancelA s
z
Handle.cancelc C s | j S N)r r9 r& r& r' r) L s zHandle.cancelledc
C s z| j j| jf| j W n| ttfk
r4 Y nd tk
r } zFt| j| j}d| }||| d}| j rz| j |d< | j
| W 5 d }~X Y nX d } d S )NzException in callback )messageZ exceptionhandleZsource_traceback) r runr r
SystemExitKeyboardInterrupt
BaseExceptionr r/ r r call_exception_handler)r! exccbmsgr% r& r& r' _runO s$
z Handle._run)N) r-
__module__ __qualname____doc__ __slots__r( r2 r6 r: r) rF r& r& r& r' r s
r c s e Zd ZdZddgZd fdd Z fddZd d
Zd d Zd
d Z dd Z
dd Z dd Z dd Z
fddZdd Z ZS ) r z7Object returned by timed callback registration methods.
_scheduled_whenNc s0 t |||| | jr | jd= || _d| _d S )Nr* F)superr( r rL rK )r! whenr" r# r$ r% r, r& r' r( h s
zTimerHandle.__init__c s0 t }| jrdnd}||d| j |S )N r zwhen=)rM r2 r insertrL )r! r0 posrO r& r' r2 p s
zTimerHandle._repr_infoc C s
t | jS r; )hashrL r9 r& r& r' __hash__v s zTimerHandle.__hash__c C s | j |j k S r; rL r! otherr& r& r' __lt__y s zTimerHandle.__lt__c C s | j |j k rdS | |S r7 rL __eq__rV r& r& r' __le__| s zTimerHandle.__le__c C s | j |j kS r; rU rV r& r& r' __gt__ s zTimerHandle.__gt__c C s | j |j krdS | |S r7 rY rV r& r& r' __ge__ s zTimerHandle.__ge__c C s> t |tr:| j|jko8| j|jko8| j|jko8| j|jkS tS r; )
isinstancer rL r r r NotImplementedrV r& r& r' rZ s
zTimerHandle.__eq__c C s | |}|tkrtS | S r; )rZ r_ )r! rW Zequalr& r& r' __ne__ s
zTimerHandle.__ne__c s | j s| j| t d S r; )r r _timer_handle_cancelledrM r: r9 rO r& r' r: s zTimerHandle.cancelc C s | j S )zReturn a scheduled callback time.
The time is an absolute timestamp, using the same time
reference as loop.time().
rU r9 r& r& r' rN s zTimerHandle.when)N)r- rG rH rI rJ r( r2 rT rX r[ r\ r] rZ r` r: rN
__classcell__r& r& rO r' r c s r c @ sP e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
dd Z dS )r z,Abstract server returned by create_server().c C s t dS )z5Stop serving. This leaves existing connections open.NNotImplementedErrorr9 r& r& r' close s zAbstractServer.closec C s t dS )z4Get the event loop the Server object is attached to.Nrc r9 r& r& r' get_loop s zAbstractServer.get_loopc C s t dS )z3Return True if the server is accepting connections.Nrc r9 r& r& r'
is_serving s zAbstractServer.is_servingc s t dS )zStart accepting connections.
This method is idempotent, so it can be called when
the server is already being serving.
Nrc r9 r& r& r'
start_serving s z AbstractServer.start_servingc s t dS )zStart accepting connections until the coroutine is cancelled.
The server is closed when the coroutine is cancelled.
Nrc r9 r& r& r'
serve_forever s z AbstractServer.serve_foreverc s t dS )z*Coroutine to wait until service is closed.Nrc r9 r& r& r' wait_closed s zAbstractServer.wait_closedc s | S r; r& r9 r& r& r'
__aenter__ s zAbstractServer.__aenter__c s | | I d H d S r; )re rj )r! rC r& r& r' __aexit__ s zAbstractServer.__aexit__N) r- rG rH rI re rf rg rh ri rj rk rl r& r& r& r' r s r c @ sV e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
dd Z dd Z dd Z
dd Zdd Zdd Zd d d d Zd d! Zd"d# Zd$d% Zd&d&d&d&d'd(d)Zdud*d+Zdvd d&d&d&d d d d d d d,
d-d.Zdwejejd d/d d d d d0d1 d2d3Zdxd0d4d5d6Z d7d d d8d9d:Z dyd d d d d;dd?d@Z d{d&d&d&d d d d dAdBdCZ dDdE Z!dFdG Z"e#j$e#j$e#j$dHdIdJZ%e#j$e#j$e#j$dHdKdLZ&dMdN Z'dOdP Z(dQdR Z)dSdT Z*dUdV Z+dWdX Z,dYdZ Z-d[d\ Z.d]d^ Z/d|d d4d_d`Z0dadb Z1dcdd Z2dedf Z3dgdh Z4didj Z5dkdl Z6dmdn Z7dodp Z8dqdr Z9dsdt Z:d S )}r zAbstract event loop.c C s t dS )z*Run the event loop until stop() is called.Nrc r9 r& r& r' run_forever s z AbstractEventLoop.run_foreverc C s t dS )zpRun the event loop until a Future is done.
Return the Future's result, or raise its exception.
Nrc )r! Zfuturer& r& r' run_until_complete s z$AbstractEventLoop.run_until_completec C s t dS )zStop the event loop as soon as reasonable.
Exactly how soon that is may depend on the implementation, but
no more I/O callbacks should be scheduled.
Nrc r9 r& r& r' stop s zAbstractEventLoop.stopc C s t dS )z3Return whether the event loop is currently running.Nrc r9 r& r& r'
is_running s z AbstractEventLoop.is_runningc C s t dS )z*Returns True if the event loop was closed.Nrc r9 r& r& r' is_closed s zAbstractEventLoop.is_closedc C s t dS )zClose the loop.
The loop should not be running.
This is idempotent and irreversible.
No other methods should be called after this one.
Nrc r9 r& r& r' re s zAbstractEventLoop.closec s t dS )z,Shutdown all active asynchronous generators.Nrc r9 r& r& r' shutdown_asyncgens s z$AbstractEventLoop.shutdown_asyncgensc C s t dS )z3Notification that a TimerHandle has been cancelled.Nrc )r! r= r& r& r' ra s z)AbstractEventLoop._timer_handle_cancelledc G s | j d|f| S )Nr )
call_laterr! r" r# r& r& r' call_soon s zAbstractEventLoop.call_soonc G s t d S r; rc )r! Zdelayr" r# r& r& r' rs s z AbstractEventLoop.call_laterc G s t d S r; rc )r! rN r" r# r& r& r' call_at s zAbstractEventLoop.call_atc C s t d S r; rc r9 r& r& r' time s zAbstractEventLoop.timec C s t d S r; rc r9 r& r& r'
create_future s z AbstractEventLoop.create_futureN)namec C s t d S r; rc )r! corory r& r& r' create_task s z AbstractEventLoop.create_taskc G s t d S r; rc rt r& r& r' call_soon_threadsafe s z&AbstractEventLoop.call_soon_threadsafec G s t d S r; rc )r! executorfuncr# r& r& r' run_in_executor s z!AbstractEventLoop.run_in_executorc C s t d S r; rc )r! r} r& r& r' set_default_executor s z&AbstractEventLoop.set_default_executorr )familytypeprotoflagsc s t d S r; rc )r! hostportr r r r r& r& r' getaddrinfo# s z AbstractEventLoop.getaddrinfoc s t d S r; rc )r! Zsockaddrr r& r& r' getnameinfo' s z AbstractEventLoop.getnameinfo)
sslr r r sock
local_addrserver_hostnamessl_handshake_timeouthappy_eyeballs_delay
interleavec
s t d S r; rc )r! protocol_factoryr r r r r r r r r r r r r& r& r' create_connection* s z#AbstractEventLoop.create_connectiond T) r r r backlogr
reuse_address
reuse_portr rh c
s t dS )ad A coroutine which creates a TCP server bound to host and port.
The return value is a Server object which can be used to stop
the service.
If host is an empty string or None all interfaces are assumed
and a list of multiple sockets will be returned (most likely
one for IPv4 and another one for IPv6). The host parameter can also be
a sequence (e.g. list) of hosts to bind to.
family can be set to either AF_INET or AF_INET6 to force the
socket to use IPv4 or IPv6. If not set it will be determined
from host (defaults to AF_UNSPEC).
flags is a bitmask for getaddrinfo().
sock can optionally be specified in order to use a preexisting
socket object.
backlog is the maximum number of queued connections passed to
listen() (defaults to 100).
ssl can be set to an SSLContext to enable SSL over the
accepted connections.
reuse_address tells the kernel to reuse a local socket in
TIME_WAIT state, without waiting for its natural timeout to
expire. If not specified will automatically be set to True on
UNIX.
reuse_port tells the kernel to allow this endpoint to be bound to
the same port as other existing endpoints are bound to, so long as
they all set this flag when being created. This option is not
supported on Windows.
ssl_handshake_timeout is the time in seconds that an SSL server
will wait for completion of the SSL handshake before aborting the
connection. Default is 60s.
start_serving set to True (default) causes the created server
to start accepting connections immediately. When set to False,
the user should await Server.start_serving() or Server.serve_forever()
to make the server to start accepting connections.
Nrc )
r! r r r r r r r r r r r rh r& r& r'
create_server3 s 3z AbstractEventLoop.create_server)fallbackc s t dS )zRSend a file through a transport.
Return an amount of sent bytes.
Nrc )r! transportfileoffsetcountr r& r& r' sendfileh s zAbstractEventLoop.sendfileF) server_sider r c s t dS )z|Upgrade a transport to TLS.
Return a new transport that *protocol* should start using
immediately.
Nrc )r! r ZprotocolZ
sslcontextr r r r& r& r' start_tlsp s zAbstractEventLoop.start_tls)r r r r c s t d S r; rc )r! r pathr r r r r& r& r' create_unix_connection{ s z(AbstractEventLoop.create_unix_connection)r r r r rh c s t dS )a A coroutine which creates a UNIX Domain Socket server.
The return value is a Server object, which can be used to stop
the service.
path is a str, representing a file systsem path to bind the
server socket to.
sock can optionally be specified in order to use a preexisting
socket object.
backlog is the maximum number of queued connections passed to
listen() (defaults to 100).
ssl can be set to an SSLContext to enable SSL over the
accepted connections.
ssl_handshake_timeout is the time in seconds that an SSL server
will wait for the SSL handshake to complete (defaults to 60s).
start_serving set to True (default) causes the created server
to start accepting connections immediately. When set to False,
the user should await Server.start_serving() or Server.serve_forever()
to make the server to start accepting connections.
Nrc )r! r r r r r r rh r& r& r' create_unix_server s z$AbstractEventLoop.create_unix_server)r r r r r allow_broadcastr c s t dS )a A coroutine which creates a datagram endpoint.
This method will try to establish the endpoint in the background.
When successful, the coroutine returns a (transport, protocol) pair.
protocol_factory must be a callable returning a protocol instance.
socket family AF_INET, socket.AF_INET6 or socket.AF_UNIX depending on
host (or family if specified), socket type SOCK_DGRAM.
reuse_address tells the kernel to reuse a local socket in
TIME_WAIT state, without waiting for its natural timeout to
expire. If not specified it will automatically be set to True on
UNIX.
reuse_port tells the kernel to allow this endpoint to be bound to
the same port as other existing endpoints are bound to, so long as
they all set this flag when being created. This option is not
supported on Windows and some UNIX's. If the
:py:data:`~socket.SO_REUSEPORT` constant is not defined then this
capability is unsupported.
allow_broadcast tells the kernel to allow this endpoint to send
messages to the broadcast address.
sock can optionally be specified in order to use a preexisting
socket object.
Nrc ) r! r r Z remote_addrr r r r r r r r& r& r' create_datagram_endpoint s !z*AbstractEventLoop.create_datagram_endpointc s t dS )a Register read pipe in event loop. Set the pipe to non-blocking mode.
protocol_factory should instantiate object with Protocol interface.
pipe is a file-like object.
Return pair (transport, protocol), where transport supports the
ReadTransport interface.Nrc r! r piper& r& r' connect_read_pipe s z#AbstractEventLoop.connect_read_pipec s t dS )a Register write pipe in event loop.
protocol_factory should instantiate object with BaseProtocol interface.
Pipe is file-like object already switched to nonblocking.
Return pair (transport, protocol), where transport support
WriteTransport interface.Nrc r r& r& r' connect_write_pipe s z$AbstractEventLoop.connect_write_pipe)stdinstdoutstderrc s t d S r; rc )r! r cmdr r r kwargsr& r& r' subprocess_shell s z"AbstractEventLoop.subprocess_shellc s t d S r; rc )r! r r r r r# r r& r& r' subprocess_exec s z!AbstractEventLoop.subprocess_execc G s t d S r; rc r! fdr" r# r& r& r'
add_reader s z AbstractEventLoop.add_readerc C s t d S r; rc r! r r& r& r'
remove_reader s z AbstractEventLoop.remove_readerc G s t d S r; rc r r& r& r'
add_writer s z AbstractEventLoop.add_writerc C s t d S r; rc r r& r& r'
remove_writer s z AbstractEventLoop.remove_writerc s t d S r; rc )r! r nbytesr& r& r' sock_recv s zAbstractEventLoop.sock_recvc s t d S r; rc )r! r Zbufr& r& r' sock_recv_into s z AbstractEventLoop.sock_recv_intoc s t d S r; rc )r! r datar& r& r' sock_sendall s z AbstractEventLoop.sock_sendallc s t d S r; rc )r! r Zaddressr& r& r' sock_connect s z AbstractEventLoop.sock_connectc s t d S r; rc )r! r r& r& r' sock_accept s z AbstractEventLoop.sock_acceptc s t d S r; rc )r! r r r r r r& r& r'
sock_sendfile s z AbstractEventLoop.sock_sendfilec G s t d S r; rc )r! sigr" r# r& r& r' add_signal_handler s z$AbstractEventLoop.add_signal_handlerc C s t d S r; rc )r! r r& r& r' remove_signal_handler s z'AbstractEventLoop.remove_signal_handlerc C s t d S r; rc )r! factoryr& r& r' set_task_factory s z"AbstractEventLoop.set_task_factoryc C s t d S r; rc r9 r& r& r' get_task_factory" s z"AbstractEventLoop.get_task_factoryc C s t d S r; rc r9 r& r& r' get_exception_handler' s z'AbstractEventLoop.get_exception_handlerc C s t d S r; rc )r! Zhandlerr& r& r' set_exception_handler* s z'AbstractEventLoop.set_exception_handlerc C s t d S r; rc r! r% r& r& r' default_exception_handler- s z+AbstractEventLoop.default_exception_handlerc C s t d S r; rc r r& r& r' rB 0 s z(AbstractEventLoop.call_exception_handlerc C s t d S r; rc r9 r& r& r' r 5 s zAbstractEventLoop.get_debugc C s t d S r; rc )r! Zenabledr& r& r' set_debug8 s zAbstractEventLoop.set_debug)r )NN)NN)r N)N)N)NN)r N);r- rG rH rI rm rn ro rp rq re rr ra ru rs rv rw rx r{ r| r r r r r socketZ AF_UNSPECZ
AI_PASSIVEr r r r r r r r
subprocessPIPEr r r r r r r r r r r r r r r r r r r rB r r r& r& r& r' r s
5 ! %
r c @ s8 e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd S )
r z-Abstract policy for accessing the event loop.c C s t dS )a: Get the event loop for the current context.
Returns an event loop object implementing the BaseEventLoop interface,
or raises an exception in case no event loop has been set for the
current context and the current policy does not specify to create one.
It should never return None.Nrc r9 r& r& r' r ? s z&AbstractEventLoopPolicy.get_event_loopc C s t dS )z3Set the event loop for the current context to loop.Nrc r! r$ r& r& r' r I s z&AbstractEventLoopPolicy.set_event_loopc C s t dS )zCreate and return a new event loop object according to this
policy's rules. If there's need to set this loop as the event loop for
the current context, set_event_loop must be called explicitly.Nrc r9 r& r& r' r
M s z&AbstractEventLoopPolicy.new_event_loopc C s t dS )z$Get the watcher for child processes.Nrc r9 r& r& r' r U s z)AbstractEventLoopPolicy.get_child_watcherc C s t dS )z$Set the watcher for child processes.Nrc )r! watcherr& r& r' r Y s z)AbstractEventLoopPolicy.set_child_watcherN) r- rG rH rI r r r
r r r& r& r& r' r < s
r c @ sF e Zd ZdZdZG dd dejZdd Zdd Z d d
Z
d d Z dS )
BaseDefaultEventLoopPolicya Default policy implementation for accessing the event loop.
In this policy, each thread has its own event loop. However, we
only automatically create an event loop by default for the main
thread; other threads by default have no event loop.
Other policies may have different rules (e.g. a single global
event loop, or automatically creating an event loop per thread, or
using some other notion of context to which an event loop is
associated).
Nc @ s e Zd ZdZdZdS )z!BaseDefaultEventLoopPolicy._LocalNF)r- rG rH r _set_calledr& r& r& r' _Localm s r c C s | | _d S r; )r _localr9 r& r& r' r( q s z#BaseDefaultEventLoopPolicy.__init__c C sX | j jdkr2| j js2tt tjr2| | | j jdkrPt dt j
| j jS )zvGet the event loop for the current context.
Returns an instance of EventLoop or raises an exception.
Nz,There is no current event loop in thread %r.) r r r r^ threadingZcurrent_threadZ _MainThreadr r
RuntimeErrorry r9 r& r& r' r t s z)BaseDefaultEventLoopPolicy.get_event_loopc C s d| j _|| j _dS )zSet the event loop.TN)r r r r r& r& r' r s z)BaseDefaultEventLoopPolicy.set_event_loopc C s | S )zvCreate a new event loop.
You must call set_event_loop() to make this the current event
loop.
)
_loop_factoryr9 r& r& r' r
s z)BaseDefaultEventLoopPolicy.new_event_loop) r- rG rH rI r r localr r( r r r
r& r& r& r' r ^ s r c @ s e Zd ZdZdS ) _RunningLoop)NNN)r- rG rH loop_pidr& r& r& r' r s r c C s t } | dkrtd| S )zrReturn the running event loop. Raise a RuntimeError if there is none.
This function is thread-specific.
Nzno running event loop)r r r$ r& r& r' r s r c C s& t j\} }| dk r"|t kr"| S dS )zReturn the running event loop or None.
This is a low-level function intended to be used by event loops.
This function is thread-specific.
N)
_running_loopr osgetpid)Z running_looppidr& r& r' r s
r c C s | t ft_dS )zSet the running event loop.
This is a low-level function intended to be used by event loops.
This function is thread-specific.
N)r r r r r r& r& r' r
s r
c C s. t td kr ddlm} | aW 5 Q R X d S )Nr DefaultEventLoopPolicy)_lock_event_loop_policy r r r& r& r' _init_event_loop_policy s r c C s t dkrt t S )z"Get the current event loop policy.N)r r r& r& r& r' r s r c C s | a dS )zZSet the current event loop policy.
If policy is None, the default policy is restored.N)r )Zpolicyr& r& r' r s r c C s t } | dk r| S t S )aG Return an asyncio event loop.
When called from a coroutine or a callback (e.g. scheduled with call_soon
or similar API), this function will always return the running event loop.
If there is no running event loop set, the function will return
the result of `get_event_loop_policy().get_event_loop()` call.
N)r r r )Z current_loopr& r& r' r s
r c C s t | dS )zCEquivalent to calling get_event_loop_policy().set_event_loop(loop).N)r r r r& r& r' r s r c C s
t S )z?Equivalent to calling get_event_loop_policy().new_event_loop().)r r
r& r& r& r' r
s r
c C s
t S )zBEquivalent to calling get_event_loop_policy().get_child_watcher().)r r r& r& r& r' r s r c C s t | S )zMEquivalent to calling
get_event_loop_policy().set_child_watcher(watcher).)r r )r r& r& r' r s r )r r
r r ),rI __all__r r r r r r r r r r r r r r r r ZLockr r r r r r r
r r r r r r
r r Z_py__get_running_loopZ_py__set_running_loopZ_py_get_running_loopZ_py_get_event_loopZ_asyncio ImportErrorZ_c__get_running_loopZ_c__set_running_loopZ_c_get_running_loopZ_c_get_event_loopr& r& r& r' sX J@* q"9
PK ! r\ % __pycache__/subprocess.cpython-38.pycnu [ U
if @ s d Z ddlZddlZddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ej
Z
ej Z ej Z G d d
d
ej
ejZG d d d Zddddejfd
dZddddejdddZdS ))create_subprocess_execcreate_subprocess_shell N )events) protocols)streams)tasks)loggerc sX e Zd ZdZ fddZdd Zdd Zdd Zd
d Zd d
Z dd Z
dd Z Z S )SubprocessStreamProtocolz0Like StreamReaderProtocol, but for a subprocess.c sH t j|d || _d | _ | _| _d | _d| _g | _| j
| _ d S )NloopF) super__init___limitstdinstdoutstderr
_transport_process_exited _pipe_fds_loopZ
create_future
_stdin_closed)selflimitr __class__ 7/opt/alt/python38/lib64/python3.8/asyncio/subprocess.pyr s z!SubprocessStreamProtocol.__init__c C sn | j jg}| jd k r&|d| j | jd k rB|d| j | jd k r^|d| j dd|S )Nzstdin=zstdout=zstderr=z<{}> )r __name__r appendr r formatjoin)r infor r r __repr__ s
z!SubprocessStreamProtocol.__repr__c C s || _ |d}|d k rDtj| j| jd| _| j| | j d |d}|d k rtj| j| jd| _
| j
| | j d |d}|d k rtj || d | jd| _ d S )Nr r r r )protocolreaderr )
r get_pipe_transportr StreamReaderr r r Z
set_transportr r r StreamWriterr )r transportZstdout_transportZstderr_transportZstdin_transportr r r connection_made) s,
z(SubprocessStreamProtocol.connection_madec C s: |dkr| j }n|dkr | j}nd }|d k r6|| d S )Nr r& )r r Z feed_data)r fddatar( r r r pipe_data_receivedA s z+SubprocessStreamProtocol.pipe_data_receivedc C s |dkrN| j }|d k r | | | |d kr>| jd n | j| d S |dkr^| j}n|dkrn| j}nd }|d k r|d kr| n
|| || j kr| j
| | d S )Nr r r& ) r closeZconnection_lostr Z
set_resultZ
set_exceptionr r Zfeed_eofr remove_maybe_close_transport)r r. excpiper( r r r pipe_connection_lostK s*
z-SubprocessStreamProtocol.pipe_connection_lostc C s d| _ | d S )NT)r r3 r r r r process_exitedf s z'SubprocessStreamProtocol.process_exitedc C s( t | jdkr$| jr$| j d | _d S )Nr )lenr r r r1 r7 r r r r3 j s
z/SubprocessStreamProtocol._maybe_close_transportc C s || j kr| jS d S N)r r )r streamr r r _get_close_waitero s
z*SubprocessStreamProtocol._get_close_waiter)
r
__module__ __qualname____doc__r r$ r- r0 r6 r8 r3 r<
__classcell__r r r r r
s
r
c @ sj e Zd Zdd Zdd Zedd Zdd Zd d
Zd d Z d
d Z
dd Z dd Z dd Z
dddZdS )Processc C s8 || _ || _|| _|j| _|j| _|j| _| | _d S r: )r Z _protocolr r r r Zget_pidpid)r r, r' r r r r r u s zProcess.__init__c C s d| j j d| j dS )N)r r rB r7 r r r r$ ~ s zProcess.__repr__c C s
| j S r: )r Zget_returncoder7 r r r
returncode s zProcess.returncodec s | j I dH S )z?Wait until the process exit and return the process return code.N)r Z_waitr7 r r r wait s z Process.waitc C s | j | d S r: )r send_signal)r signalr r r rG s zProcess.send_signalc C s | j d S r: )r terminater7 r r r rI s zProcess.terminatec C s | j d S r: )r killr7 r r r rJ s z Process.killc
s | j }| j| |r,td| t| z| j I d H W n8 tt fk
rx } z|rhtd| | W 5 d }~X Y nX |rtd| | j
d S )Nz%%r communicate: feed stdin (%s bytes)z %r communicate: stdin got %rz%r communicate: close stdin) r get_debugr writer debugr9 ZdrainBrokenPipeErrorConnectionResetErrorr1 )r inputrM r4 r r r _feed_stdin s
zProcess._feed_stdinc s d S r: r r7 r r r _noop s z
Process._noopc s | j |}|dkr | j}n|dks(t| j}| j rV|dkrDdnd}td| | | I d H }| j r|dkrzdnd}td| | |
|S )Nr& r r r z%r communicate: read %sz%r communicate: close %s) r r) r AssertionErrorr r rK r rM readr1 )r r. r, r; nameoutputr r r _read_stream s
zProcess._read_streamNc s |d k r| |}n| }| jd k r2| d}n| }| jd k rP| d}n| }tj|||| jdI d H \}}}| I d H ||fS )Nr r& r ) rQ rR r rW r r Zgatherr rF )r rP r r r r r r communicate s
zProcess.communicate)N)r r= r> r r$ propertyrE rF rG rI rJ rQ rR rW rX r r r r rA t s
rA c
sb d krt ntjdtdd fdd}j|| f|||d|I d H \}} t|| S )NZThe loop argument is deprecated since Python 3.8 and scheduled for removal in Python 3.10.r&
stacklevelc s t dS Nr% r
r r% r r s z)create_subprocess_shell..r r r )r get_event_loopwarningswarnDeprecationWarningZsubprocess_shellrA )
cmdr r r r r kwdsprotocol_factoryr, r' r r% r r s$
r )r r r r r c sf d krt ntjdtdd fdd}j|| f||||d|I d H \} }
t| |
S )NrZ r& r[ c s t dS r] r^ r r% r r r_ s z(create_subprocess_exec..r` )r ra rb rc rd Zsubprocess_execrA ) Zprogramr r r r r argsrf rg r, r' r r% r r s(
r )__all__
subprocessrb r r r r logr PIPEZSTDOUTZDEVNULLZFlowControlMixinZSubprocessProtocolr
rA Z_DEFAULT_LIMITr r r r r r s. bV
PK ! ^1 __pycache__/log.cpython-38.pycnu [ U
if| @ s d Z ddlZeeZdS )zLogging configuration. N)__doc__ZloggingZ getLogger __package__Zlogger r r 0/opt/alt/python38/lib64/python3.8/asyncio/log.py s PK !
# # * __pycache__/staggered.cpython-38.opt-2.pycnu [ U
ifh
@ s d Z ddlZddlZddlmZ ddlmZ ddlmZ ddlmZ ddej ej
g ej f ej e
ejejejej e ejej e f d d
d ZdS ) )staggered_race N )events)
exceptions)locks)tasks)loop)coro_fnsdelayr returnc s p
t t| d d g g tjtj d d fdd d }| z.run_one_coror )
r Zget_running_loopr typingOptionalr r r r r lenr r )r r
r Z
first_taskr Z
done_countZdone_r# r! r$ r s( =
0
r )__all__r
r% r r r r r IterableCallable Awaitabler& floatZAbstractEventLoopZTupleZAnyintZList Exceptionr r# r# r# r$ s$ PK ! VwF + __pycache__/exceptions.cpython-38.opt-2.pycnu [ U
ifa @ sh d Z G dd deZG dd deZG dd deZG dd deZG d d
d
eZ G d d d eZ
d
S ))CancelledErrorInvalidStateError TimeoutErrorIncompleteReadErrorLimitOverrunErrorSendfileNotAvailableErrorc @ s e Zd ZdS )r N__name__
__module__ __qualname__ r r 7/opt/alt/python38/lib64/python3.8/asyncio/exceptions.pyr s r c @ s e Zd ZdS )r Nr r r r r r
s r c @ s e Zd ZdS )r Nr r r r r r s r c @ s e Zd ZdS )r Nr r r r r r s r c s$ e Zd Z fddZdd Z ZS )r c s@ |d kr dnt |}t t| d| d || _|| _d S )NZ undefinedz bytes read on a total of z expected bytes)reprsuper__init__lenpartialexpected)selfr r Z
r_expected __class__r r r $ s z IncompleteReadError.__init__c C s t | | j| jffS N)typer r r r r r
__reduce__+ s z IncompleteReadError.__reduce__r r r
r r
__classcell__r r r r r s r c s$ e Zd Z fddZdd Z ZS )r c s t | || _d S r )r r consumed)r messager r r r r 5 s zLimitOverrunError.__init__c C s t | | jd | jffS )N )r argsr r r r r r 9 s z LimitOverrunError.__reduce__r r r r r r / s r N) __all__
BaseExceptionr Exceptionr r RuntimeErrorr EOFErrorr r r r r r s PK ! EX>f[ [ 0 __pycache__/proactor_events.cpython-38.opt-2.pycnu [ U
if<} @ sP d Z ddlZddlZddlZddlZddlZddlZddlZddlm Z ddlm
Z
ddlm Z ddlm Z ddlm
Z
dd lmZ dd
lmZ dd lmZ dd lmZ d
d ZG dd dejejZG dd deejZG dd deejZG dd deZG dd deZ G dd deeej Z G dd d eeej Z G d d d e j Z!dS ) )BaseProactorEventLoop N ) base_events) constants)futures)
exceptions) protocols)sslproto)
transports)trsock)loggerc C s t || jd< z| | jd< W n0 tjk
rR | j rNtj d|dd Y nX d| jkrz|
| jd< W n tjk
r d | jd< Y nX d S )NsocketZsocknamezgetsockname() failed on %rTexc_infopeername) r TransportSocket_extraZ getsocknamer
error_loop get_debugr warningZ getpeername) transportsock r )
r4 __name__r appendr( filenor$ r% r# lenr) formatjoin)r- infor r r __repr__H s
z#_ProactorBasePipeTransport.__repr__c C s || j d< d S )Npipe)r r- r r r r r Z s z%_ProactorBasePipeTransport._set_extrac C s
|| _ d S Nr+ )r- r/ r r r r! ] s z'_ProactorBasePipeTransport.set_protocolc C s | j S rB rC r- r r r get_protocol` s z'_ProactorBasePipeTransport.get_protocolc C s | j S rB )r( rD r r r
is_closingc s z%_ProactorBasePipeTransport.is_closingc C s\ | j r
d S d| _ | jd7 _| js>| jd kr>| j| jd | jd k rX| j d | _d S )NTr ) r( r' r# r% r r* _call_connection_lostr$ cancelrD r r r closef s
z _ProactorBasePipeTransport.closec C s* | j d k r&|d| t| d | d S )Nzunclosed transport )source)r ResourceWarningrI )r- Z_warnr r r __del__q s
z"_ProactorBasePipeTransport.__del__ Fatal error on pipe transportc C sV zDt|tr*| j rBtjd| |dd n| j||| | jd W 5 | | X d S )Nz%r: %sTr )message exceptionr r/ ) _force_close
isinstanceOSErrorr r r debugcall_exception_handlerr+ )r- excrN r r r _fatal_errorv s
z'_ProactorBasePipeTransport._fatal_errorc C s | j d k r6| j s6|d kr*| j d n | j | | jr@d S d| _| jd7 _| jrj| j d | _| jr| j d | _d| _ d | _
| j | j
| d S )NTr r )
_empty_waiterdone
set_resultZ
set_exceptionr( r' r% rH r$ r& r# r r* rG )r- rU r r r rP s"
z'_ProactorBasePipeTransport._force_closec C s^ z| j | W 5 t | jdr,| jtj | j d | _| j}|d k rX| d | _X d S )Nshutdown)
hasattrr rZ r
Z SHUT_RDWRrI r" Z_detachr+ Zconnection_lost)r- rU r2 r r r rG s
z0_ProactorBasePipeTransport._call_connection_lostc C s" | j }| jd k r |t| j7 }|S rB )r& r# r; )r- sizer r r get_write_buffer_size s
z0_ProactorBasePipeTransport.get_write_buffer_size)NNN)rM )r8
__module__ __qualname__r r? r r! rE rF rI warningswarnrL rV rP rG r]
__classcell__r r r3 r r . s
r c sP e Zd Zd fdd Zdd Zdd Zdd Zd
d Zd d
ZdddZ Z
S )_ProactorReadPipeTransportNc s: d | _ d| _t |||||| | j| j d| _d S )NTF)
_pending_data_pausedr r r r*
_loop_readingr, r3 r r r s
z#_ProactorReadPipeTransport.__init__c C s | j o| j S rB )re r( rD r r r
is_reading s z%_ProactorReadPipeTransport.is_readingc C s0 | j s | jrd S d| _| j r,td| d S )NTz%r pauses reading)r( re r r r rS rD r r r
pause_reading s
z(_ProactorReadPipeTransport.pause_readingc C sn | j s | jsd S d| _| jd kr0| j| jd | j}d | _|d k rT| j| j| | j rjt
d| d S )NFz%r resumes reading) r( re r$ r r* rf rd _data_receivedr r rS r- datar r r resume_reading s
z)_ProactorReadPipeTransport.resume_readingc
C s | j rtd| z| j }W nL ttfk
r> Y n4 tk
rp } z| |d W Y d S d }~X Y nX |s~|
d S )Nz%r received EOFz1Fatal error: protocol.eof_received() call failed.) r r r rS r+ Z eof_received
SystemExitKeyboardInterrupt
BaseExceptionrV rI )r- Z keep_openrU r r r
_eof_received s
z(_ProactorReadPipeTransport._eof_receivedc
C s | j r|| _d S |s | d S t| jtjrzt| j| W q tt fk
rZ Y q t
k
r } z| |d W Y d S d }~X Y qX n | j | d S )Nz3Fatal error: protocol.buffer_updated() call failed.)
re rd rp rQ r+ r ZBufferedProtocolZ _feed_data_to_buffered_protorm rn ro rV Z
data_received)r- rk rU r r r ri s" z)_ProactorReadPipeTransport._data_receivedc
C st d }zRzp|d k r2d | _| r*| }n| | jrHd }W W d S |dkr\W W d S | jsv| jj | j
d| _W n t k
r } z0| js| |d n| j
rtjddd W 5 d }~X Y n tk
r } z| | W 5 d }~X Y nf tk
r } z| |d W 5 d }~X Y n8 tjk
r> | js: Y nX | jsV| j| j W 5 |d k rn| | X d S )N i z"Fatal read error on pipe transportz*Read error on pipe transport while closingTr )ri r$ rX resultrH r( re r _proactorrecvr ConnectionAbortedErrorrV r r rS ConnectionResetErrorrP rR r CancelledErroradd_done_callbackrf )r- futrk rU r r r rf s@
z(_ProactorReadPipeTransport._loop_reading)NNN)N) r8 r^ r_ r rg rh rl rp ri rf rb r r r3 r rc s rc c sZ e Zd ZdZ fddZdd ZdddZd d
Zd d Zd
d Z dd Z
dd Z Z S ) _ProactorBaseWritePipeTransportTc s t j|| d | _d S rB )r r rW r- argskwr3 r r r G s z(_ProactorBaseWritePipeTransport.__init__c C s t |tttfs$tdt|j | jr2td| j d k rDtd|sLd S | j
rz| j
t j krht
d | j
d7 _
d S | jd kr| jt|d n.| jst|| _| n| j| | d S )Nz/data argument must be a bytes-like object, not zwrite_eof() already calledz(unable to write; sendfile is in progressz socket.send() raised exception.r )rk )rQ bytes bytearray
memoryview TypeErrortyper8 r) RuntimeErrorrW r' r !LOG_THRESHOLD_FOR_CONNLOST_WRITESr r r%
_loop_writingr# _maybe_pause_protocolextendrj r r r writeK s,
z%_ProactorBaseWritePipeTransport.writeNc
C sV z|d k r | j d kr | jr W d S d | _ d| _|r8| |d krL| j}d | _|s| jrf| j| jd | jrz| j
t j |
nN| jj| j || _ | j st|| _| j | j | n| j | j | jd k r| j d kr| jd W n\ tk
r" } z| | W 5 d }~X Y n0 tk
rP } z| |d W 5 d }~X Y nX d S )Nr z#Fatal write error on pipe transport)r% r( r& rr r# r r* rG r) r rZ r
SHUT_WR_maybe_resume_protocolrs sendrX r; rx r r rW rY rv rP rR rV )r- frk rU r r r r q s8
z-_ProactorBaseWritePipeTransport._loop_writingc C s dS NTr rD r r r
can_write_eof s z-_ProactorBaseWritePipeTransport.can_write_eofc C s | d S rB )rI rD r r r write_eof s z)_ProactorBaseWritePipeTransport.write_eofc C s | d d S rB rP rD r r r abort s z%_ProactorBaseWritePipeTransport.abortc C s: | j d k rtd| j | _ | jd kr4| j d | j S )NzEmpty waiter is already set)rW r r Z
create_futurer% rY rD r r r _make_empty_waiter s
z2_ProactorBaseWritePipeTransport._make_empty_waiterc C s
d | _ d S rB )rW rD r r r _reset_empty_waiter s z3_ProactorBaseWritePipeTransport._reset_empty_waiter)NN)
r8 r^ r_ Z_start_tls_compatibler r r r r r r r rb r r r3 r rz A s &
)rz c s$ e Zd Z fddZdd Z ZS )_ProactorWritePipeTransportc s4 t j|| | jj| jd| _| j| j d S )N ) r r r rs rt r r$ rx _pipe_closedr{ r3 r r r s z$_ProactorWritePipeTransport.__init__c C s@ | r d S | jrd S d | _| jd k r4| t n| d S rB )Z cancelledr( r$ r% rP BrokenPipeErrorrI )r- ry r r r r s
z(_ProactorWritePipeTransport._pipe_closed)r8 r^ r_ r r rb r r r3 r r s r c sX e Zd ZdZd fdd Zdd Zdd Zd d
Zdd d Zdd
dZ dddZ
Z S )_ProactorDatagramTransporti Nc s> || _ d | _t j|||||d t | _| j| j d S )N)r0 r1 )
_addressrW r r collectionsdequer# r r* rf )r- r. r r/ addressr0 r1 r3 r r r s
z#_ProactorDatagramTransport.__init__c C s t | | d S rB r rA r r r r s z%_ProactorDatagramTransport._set_extrac C s t dd | jD S )Nc s s | ]\}}t |V qd S rB )r; ).0rk _r r r s zC_ProactorDatagramTransport.get_write_buffer_size..)sumr# rD r r r r] s z0_ProactorDatagramTransport.get_write_buffer_sizec C s | d d S rB r rD r r r r s z _ProactorDatagramTransport.abortc C s t |tttfs tdt||s&d S | jd k rN|d | jfkrNtd| j | jr| jr| jt j
krpt d | jd7 _d S | j
t||f | jd kr| | d S )Nz,data argument must be bytes-like object (%r)z!Invalid address: must be None or z!socket.sendto() raised exception.r )rQ r~ r r r r r
ValueErrorr' r r r r r# r9 r% r r )r- rk addrr r r sendto s&
z!_ProactorDatagramTransport.sendtoc
C s z| j rW d S d | _|r | | jr2| j rN| jrN| jrH| j| jd W d S | j \}}| jd k r|| jj
| j || _n| jj
j
| j ||d| _W nZ tk
r } z| j| W 5 d }~X Y nD tk
r } z| |d W 5 d }~X Y nX | j| j | d S )N)r z'Fatal write error on datagram transport)r' r% rr r# r r( r r* rG popleftrs r r r rR r+ error_received ExceptionrV rx r r )r- ry rk r rU r r r r s2
z(_ProactorDatagramTransport._loop_writingc
C s4 d }zz| jr W W d S d | _|d k rf| }| jrFd }W W d S | jd k r^|| j }}n|\}}| jrvW W d S | jd k r| jj | j
| j | _n| jj | j
| j | _W nJ t
k
r } z| j | W 5 d }~X Y n8 tjk
r | js Y n X | jd k r| j| j W 5 |r.| j || X d S rB )r+ Zdatagram_receivedr' r$ rr r( r r rs rt r max_sizeZrecvfromrR r r rw rx rf )r- ry rk r resrU r r r rf s>
z(_ProactorDatagramTransport._loop_reading)NNN)N)N)N) r8 r^ r_ r r r r] r r r rf rb r r r3 r r s
!r c @ s e Zd Zdd Zdd ZdS ) _ProactorDuplexPipeTransportc C s dS )NFr rD r r r r J s z*_ProactorDuplexPipeTransport.can_write_eofc C s t d S rB )NotImplementedErrorrD r r r r M s z&_ProactorDuplexPipeTransport.write_eofN)r8 r^ r_ r r r r r r r E s r c s> e Zd ZejjZd
fdd Zdd Zdd Z dd Z
Z S ) _ProactorSocketTransportNc s$ t |||||| t| d S rB )r r r Z _set_nodelayr, r3 r r r X s z!_ProactorSocketTransport.__init__c C s t | | d S rB r rA r r r r ] s z#_ProactorSocketTransport._set_extrac C s dS r r rD r r r r ` s z&_ProactorSocketTransport.can_write_eofc C s2 | j s | jrd S d| _| jd kr.| jtj d S r )r( r) r% r rZ r
r rD r r r r c s
z"_ProactorSocketTransport.write_eof)NNN) r8 r^ r_ r Z
_SendfileModeZ
TRY_NATIVEZ_sendfile_compatibler r r r rb r r r3 r r Q s r c s e Zd Z fddZd3ddZd4dddddddd Zd5d
d Zd6d d
Zd7ddZd8ddZ fddZ
dd Z dd Z dd Z
dd Zd d Zd d Zd d! Zd"d# Zd$d% Zd9d&d'Zd(d) Zd:d+d,Zd-d. Zd/d0 Zd1d2 Z ZS );r c sh t td|jj || _|| _d | _i | _ |
| | t
t krdt| j d S )NzUsing proactor: %s)r r r rS r4 r8 rs _selector_self_reading_future_accept_futuresZset_loop_make_self_pipe threadingcurrent_thread main_threadsignal
set_wakeup_fd_csockr: )r- Zproactorr3 r r r m s
z BaseProactorEventLoop.__init__Nc C s t | |||||S rB )r )r- r r/ r0 r1 r2 r r r _make_socket_transportz s
z,BaseProactorEventLoop._make_socket_transportF) server_sideserver_hostnamer1 r2 ssl_handshake_timeoutc C s0 t j| |||||| d}
t| ||
||d |
jS )N)r r1 r2 )r Z SSLProtocolr Z_app_transport) r- Zrawsockr/
sslcontextr0 r r r1 r2 r Z ssl_protocolr r r _make_ssl_transport s z)BaseProactorEventLoop._make_ssl_transportc C s t | |||||S rB )r )r- r r/ r r0 r1 r r r _make_datagram_transport s
z.BaseProactorEventLoop._make_datagram_transportc C s t | ||||S rB )r r- r r/ r0 r1 r r r _make_duplex_pipe_transport s z1BaseProactorEventLoop._make_duplex_pipe_transportc C s t | ||||S rB )rc r r r r _make_read_pipe_transport s z/BaseProactorEventLoop._make_read_pipe_transportc C s t | ||||S rB )r r r r r _make_write_pipe_transport s z0BaseProactorEventLoop._make_write_pipe_transportc sj | rtd| r d S t t kr6td | | | j
d | _
d | _ t
d S )Nz!Cannot close a running event loop)Z
is_runningr is_closedr r r r r _stop_accept_futures_close_self_pipers rI r r rD r3 r r rI s
zBaseProactorEventLoop.closec s | j ||I d H S rB )rs rt )r- r nr r r sock_recv s z BaseProactorEventLoop.sock_recvc s | j ||I d H S rB )rs Z recv_into)r- r Zbufr r r sock_recv_into s z$BaseProactorEventLoop.sock_recv_intoc s | j ||I d H S rB )rs r )r- r rk r r r sock_sendall s z"BaseProactorEventLoop.sock_sendallc s | j ||I d H S rB )rs Zconnect)r- r r r r r sock_connect s z"BaseProactorEventLoop.sock_connectc s | j |I d H S rB )rs acceptrA r r r sock_accept s z!BaseProactorEventLoop.sock_acceptc
s( z | }W n2 ttjfk
r> } ztdW 5 d }~X Y nX zt|j}W n, t k
r| } ztdW 5 d }~X Y nX |r|n|}|sdS t
|d}|rt
|| |n|} t
||}d}
zLt
| | |}|dkr|
W 0S | j
||||I d H ||7 }|
|7 }
qW 5 |
dkr"| | X d S )Nznot a regular filer l )r: AttributeErrorioUnsupportedOperationr ZSendfileNotAvailableErrorosfstatst_sizerR minseekrs sendfile) r- r fileoffsetcountr: errZfsizeZ blocksizeZend_posZ
total_sentr r r _sock_sendfile_native s0
z+BaseProactorEventLoop._sock_sendfile_nativec sZ | }| | I d H z | j|j|||ddI d H W S | |rT| X d S )NF)Zfallback)rg rh r r rl Z
sock_sendfiler )r- Ztranspr r r rl r r r _sendfile_native s z&BaseProactorEventLoop._sendfile_nativec C sL | j d k r| j d | _ | j d | _| j d | _| jd8 _d S )Nr )r rH _ssockrI r
_internal_fdsrD r r r r s
z&BaseProactorEventLoop._close_self_pipec C s: t \| _| _| jd | jd | jd7 _d S )NFr )r
Z
socketpairr r Z setblockingr rD r r r r s z%BaseProactorEventLoop._make_self_pipec
C s z4|d k r| | j|k r"W d S | j| jd}W nb tjk
rL Y d S ttfk
rd Y nF t k
r } z|
d|| d W 5 d }~X Y nX || _| | j d S )Ni z.Error on reading from the event loop self pipe)rN rO r. )
rr r rs rt r r rw rm rn ro rT rx _loop_self_reading)r- r rU r r r r s$
z(BaseProactorEventLoop._loop_self_readingc C sN | j }|d krd S z|d W n( tk
rH | jrDtjddd Y nX d S )N z3Fail to write a null byte into the self-pipe socketTr )r r rR _debugr rS )r- Zcsockr r r _write_to_self s z$BaseProactorEventLoop._write_to_selfd c s( d fdd d S )Nc
s, z| d k rn| \}}jr,td|| }d k rXj||dd|id nj||d|id r|W d S j} W n t k
r } zH
dkrʈ d|t
d njrtjd dd
W 5 d }~X Y n8 tjk
r Y nX | j
< | d S ) Nz#%r got a new connection from %r: %rTr )r r1 r2 r r r zAccept failed on a socket)rN rO r
zAccept failed on socket %rr )rr r r rS r r r rs r rR r: rT r r rI r rw r rx )r Zconnr r/ rU r. protocol_factoryr- r2 r r r r r r. / s\
z2BaseProactorEventLoop._start_serving..loop)N)r* )r- r r r r2 Zbacklogr r r r _start_serving+ s %z$BaseProactorEventLoop._start_servingc C s d S rB r )r- Z
event_listr r r _process_eventsV s z%BaseProactorEventLoop._process_eventsc C s& | j D ] }| q
| j d S rB )r valuesrH clear)r- futurer r r r Z s
z*BaseProactorEventLoop._stop_accept_futuresc C s6 | j | d }|r | | j| | d S rB )r popr: rH rs
_stop_servingrI )r- r r r r r r _ s
z#BaseProactorEventLoop._stop_serving)NNN)N)NNN)NN)NN)NN)N)NNr N)r8 r^ r_ r r r r r r r rI r r r r r r r r r r r r r r r rb r r r3 r r k s\
+r )"__all__r r r
r` r r r r r r r r r r
r logr r Z_FlowControlMixinZ
BaseTransportr Z
ReadTransportrc ZWriteTransportrz r r Z Transportr r Z
BaseEventLoopr r r r r sP n PK ! /v/ / + __pycache__/transports.cpython-38.opt-1.pycnu [ U
if( @ s| d Z dZG dd dZG dd deZG dd deZG dd d eeZG d
d d eZG d d
d
eZG dd deZdS )zAbstract Transport class.)
BaseTransport
ReadTransportWriteTransport TransportDatagramTransportSubprocessTransportc @ sH e Zd ZdZdZdddZdddZdd Zd
d Zd d
Z dd Z
dS )r zBase class for transports._extraNc C s |d kr i }|| _ d S Nr )selfextra r 7/opt/alt/python38/lib64/python3.8/asyncio/transports.py__init__ s zBaseTransport.__init__c C s | j ||S )z#Get optional transport information.)r get)r
namedefaultr r r
get_extra_info s z BaseTransport.get_extra_infoc C s t dS )z2Return True if the transport is closing or closed.NNotImplementedErrorr
r r r
is_closing s zBaseTransport.is_closingc C s t dS )a Close the transport.
Buffered data will be flushed asynchronously. No more data
will be received. After all buffered data is flushed, the
protocol's connection_lost() method will (eventually) be
called with None as its argument.
Nr r r r r
close s zBaseTransport.closec C s t dS )zSet a new protocol.Nr )r
protocolr r r
set_protocol% s zBaseTransport.set_protocolc C s t dS )z Return the current protocol.Nr r r r r
get_protocol) s zBaseTransport.get_protocol)N)N) __name__
__module__ __qualname____doc__ __slots__r r r r r r r r r r
r s
r c @ s, e Zd ZdZdZdd Zdd Zdd Zd S )
r z#Interface for read-only transports.r c C s t dS )z*Return True if the transport is receiving.Nr r r r r
is_reading3 s zReadTransport.is_readingc C s t dS )zPause the receiving end.
No data will be passed to the protocol's data_received()
method until resume_reading() is called.
Nr r r r r
pause_reading7 s zReadTransport.pause_readingc C s t dS )zResume the receiving end.
Data received will once again be passed to the protocol's
data_received() method.
Nr r r r r
resume_reading? s z ReadTransport.resume_readingN)r r r r r r r! r" r r r r
r . s
r c @ sN e Zd ZdZdZdddZdd Zdd Zd
d Zd d
Z dd Z
dd Z dS )r z$Interface for write-only transports.r Nc C s t dS )a Set the high- and low-water limits for write flow control.
These two values control when to call the protocol's
pause_writing() and resume_writing() methods. If specified,
the low-water limit must be less than or equal to the
high-water limit. Neither value can be negative.
The defaults are implementation-specific. If only the
high-water limit is given, the low-water limit defaults to an
implementation-specific value less than or equal to the
high-water limit. Setting high to zero forces low to zero as
well, and causes pause_writing() to be called whenever the
buffer becomes non-empty. Setting low to zero causes
resume_writing() to be called only once the buffer is empty.
Use of zero for either limit is generally sub-optimal as it
reduces opportunities for doing I/O and computation
concurrently.
Nr r
highlowr r r
set_write_buffer_limitsM s z&WriteTransport.set_write_buffer_limitsc C s t dS )z,Return the current size of the write buffer.Nr r r r r
get_write_buffer_sizeb s z$WriteTransport.get_write_buffer_sizec C s t dS )zWrite some data bytes to the transport.
This does not block; it buffers the data and arranges for it
to be sent out asynchronously.
Nr )r
datar r r
writef s zWriteTransport.writec C s d |}| | dS )zWrite a list (or any iterable) of data bytes to the transport.
The default implementation concatenates the arguments and
calls write() on the result.
N)joinr) )r
Z list_of_datar( r r r
writelinesn s
zWriteTransport.writelinesc C s t dS )zClose the write end after flushing buffered data.
(This is like typing ^D into a UNIX program reading from stdin.)
Data may still be received.
Nr r r r r
write_eofw s zWriteTransport.write_eofc C s t dS )zAReturn True if this transport supports write_eof(), False if not.Nr r r r r
can_write_eof s z WriteTransport.can_write_eofc C s t dS zClose the transport immediately.
Buffered data will be lost. No more data will be received.
The protocol's connection_lost() method will (eventually) be
called with None as its argument.
Nr r r r r
abort s zWriteTransport.abort)NN) r r r r r r& r' r) r, r- r. r0 r r r r
r H s
r c @ s e Zd ZdZdZdS )r aS Interface representing a bidirectional transport.
There may be several implementations, but typically, the user does
not implement new transports; rather, the platform provides some
useful transports that are implemented using the platform's best
practices.
The user never instantiates a transport directly; they call a
utility function, passing it a protocol factory and other
information necessary to create the transport and protocol. (E.g.
EventLoop.create_connection() or EventLoop.create_server().)
The utility function will asynchronously create a transport and a
protocol and hook them up by calling the protocol's
connection_made() method, passing it the transport.
The implementation here raises NotImplemented for every method
except writelines(), which calls write() in a loop.
r N)r r r r r r r r r
r s r c @ s& e Zd ZdZdZdddZdd ZdS ) r z(Interface for datagram (UDP) transports.r Nc C s t dS )a Send data to the transport.
This does not block; it buffers the data and arranges for it
to be sent out asynchronously.
addr is target socket address.
If addr is None use target address pointed on transport creation.
Nr )r
r( Zaddrr r r
sendto s zDatagramTransport.sendtoc C s t dS r/ r r r r r
r0 s zDatagramTransport.abort)N)r r r r r r1 r0 r r r r
r s
r c @ s@ e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dS )r r c C s t dS )zGet subprocess id.Nr r r r r
get_pid s zSubprocessTransport.get_pidc C s t dS )zGet subprocess returncode.
See also
http://docs.python.org/3/library/subprocess#subprocess.Popen.returncode
Nr r r r r
get_returncode s z"SubprocessTransport.get_returncodec C s t dS )z&Get transport for pipe with number fd.Nr )r
fdr r r
get_pipe_transport s z&SubprocessTransport.get_pipe_transportc C s t dS )zSend signal to subprocess.
See also:
docs.python.org/3/library/subprocess#subprocess.Popen.send_signal
Nr )r
signalr r r
send_signal s z SubprocessTransport.send_signalc C s t dS )aL Stop the subprocess.
Alias for close() method.
On Posix OSs the method sends SIGTERM to the subprocess.
On Windows the Win32 API function TerminateProcess()
is called to stop the subprocess.
See also:
http://docs.python.org/3/library/subprocess#subprocess.Popen.terminate
Nr r r r r
terminate s z SubprocessTransport.terminatec C s t dS )zKill the subprocess.
On Posix OSs the function sends SIGKILL to the subprocess.
On Windows kill() is an alias for terminate().
See also:
http://docs.python.org/3/library/subprocess#subprocess.Popen.kill
Nr r r r r
kill s zSubprocessTransport.killN)
r r r r r2 r3 r5 r7 r8 r9 r r r r
r s r c sZ e Zd ZdZdZd fdd Zdd Zdd Zd
d Zdd d
Z dddZ
dd Z Z S )_FlowControlMixinav All the logic for (write) flow control in a mix-in base class.
The subclass must implement get_write_buffer_size(). It must call
_maybe_pause_protocol() whenever the write buffer size increases,
and _maybe_resume_protocol() whenever it decreases. It may also
override set_write_buffer_limits() (e.g. to specify different
defaults).
The subclass constructor must call super().__init__(extra). This
will call set_write_buffer_limits().
The user may call set_write_buffer_limits() and
get_write_buffer_size(), and their protocol's pause_writing() and
resume_writing() may be called.
)_loop_protocol_paused _high_water
_low_waterNc s$ t | || _d| _| d S )NF)superr r; r< _set_write_buffer_limits)r
r Zloop __class__r r
r s z_FlowControlMixin.__init__c
C s | }|| jkrd S | jsd| _z| j W nR ttfk
rJ Y n: tk
r } z | j d|| | jd W 5 d }~X Y nX d S )NTz protocol.pause_writing() failedmessageZ exceptionZ transportr )
r' r= r< _protocolZ
pause_writing
SystemExitKeyboardInterrupt
BaseExceptionr; call_exception_handler)r
sizeexcr r r
_maybe_pause_protocol s
z'_FlowControlMixin._maybe_pause_protocolc
C s | j r|| | jkr|d| _ z| j W nR ttfk
rB Y n: tk
rz } z | j d|| | jd W 5 d }~X Y nX d S )NFz protocol.resume_writing() failedrC )
r< r' r> rE Zresume_writingrF rG rH r; rI )r
rK r r r
_maybe_resume_protocol! s z(_FlowControlMixin._maybe_resume_protocolc C s | j | jfS r )r> r= r r r r
get_write_buffer_limits1 s z)_FlowControlMixin.get_write_buffer_limitsc C sj |d kr |d krd}nd| }|d kr.|d }|| krBdksZn t d|d|d|| _|| _d S )Ni zhigh (z) must be >= low (z) must be >= 0)
ValueErrorr= r> r# r r r
r@ 4 s z*_FlowControlMixin._set_write_buffer_limitsc C s | j ||d | d S )N)r$ r% )r@ rL r# r r r
r& D s z)_FlowControlMixin.set_write_buffer_limitsc C s t d S r r r r r r
r' H s z'_FlowControlMixin.get_write_buffer_size)NN)NN)NN)
r r r r r r rL rM rN r@ r& r'
__classcell__r r rA r
r: s
r: N) r __all__r r r r r r r: r r r r
s %F6PK ! r s s 0 __pycache__/selector_events.cpython-38.opt-1.pycnu [ U
ifT @ s. d Z dZddlZddlZddlZddlZddlZddlZddlZz ddl Z W n e
k
rd dZ Y nX ddl m Z ddl m
Z
ddl mZ ddl mZ dd l mZ dd
l mZ dd l mZ dd l mZ dd
lmZ dd Zdd ZG dd de jZG dd dejejZ G dd de Z G dd de Z dS )zEvent loop using a selector and related classes.
A selector is a "notify-when-ready" multiplexer. For a subclass which
also includes support for signal handling, see the unix_events sub-module.
)BaseSelectorEventLoop N ) base_events) constants)events)futures) protocols)sslproto)
transports)trsock)loggerc C s8 z| |}W n tk
r$ Y dS X t|j|@ S d S NF)get_keyKeyErrorboolr )selectorfdZeventkey r Z!d?d@ Z"dAdB Z#dCdD Z$dEdF Z%dGdH Z&dIdJ Z'dKdL Z(dMdN Z)dOdP Z*dQdR Z+ Z,S )Wr zJSelector event loop.
See events.EventLoop for API specification.
Nc sF t |d krt }td|jj || _| t
| _ d S )NzUsing selector: %s)
super__init__ selectorsZDefaultSelectorr debug __class____name__ _selector_make_self_pipeweakrefZWeakValueDictionary _transports)selfr r r r r 6 s
z BaseSelectorEventLoop.__init__extraserverc C s t | |||||S N)_SelectorSocketTransport)r& r protocolwaiterr) r* r r r _make_socket_transport@ s
z,BaseSelectorEventLoop._make_socket_transportF) server_sideserver_hostnamer) r* ssl_handshake_timeoutc C s0 t j| |||||| d}
t| ||
||d |
jS )N)r2 r( )r Z SSLProtocolr, Z_app_transport) r& Zrawsockr-
sslcontextr. r0 r1 r) r* r2 Z ssl_protocolr r r _make_ssl_transportE s z)BaseSelectorEventLoop._make_ssl_transportc C s t | |||||S r+ )_SelectorDatagramTransport)r& r r- addressr. r) r r r _make_datagram_transportR s
z.BaseSelectorEventLoop._make_datagram_transportc sL | rtd| r d S | t | jd k rH| j d | _d S )Nz!Cannot close a running event loop)Z
is_running RuntimeError is_closed_close_self_piper closer" r& r' r r r; W s
zBaseSelectorEventLoop.closec C sB | | j | j d | _| j d | _| jd8 _d S )Nr )_remove_reader_ssockfilenor; _csock
_internal_fdsr< r r r r: b s
z&BaseSelectorEventLoop._close_self_pipec C sN t \| _| _| jd | jd | jd7 _| | j | j d S )NFr ) socketZ
socketpairr> r@ setblockingrA _add_readerr? _read_from_selfr< r r r r# j s
z%BaseSelectorEventLoop._make_self_pipec C s d S r+ r r& datar r r _process_self_datar s z(BaseSelectorEventLoop._process_self_datac C sX z"| j d}|sW qT| | W q tk
r: Y q Y q tk
rP Y qTY q X q d S )Ni )r> recvrH InterruptedErrorBlockingIOErrorrF r r r rE u s z%BaseSelectorEventLoop._read_from_selfc C sN | j }|d krd S z|d W n( tk
rH | jrDtjddd Y nX d S )N z3Fail to write a null byte into the self-pipe socketTexc_info)r@ sendOSError_debugr r )r& Zcsockr r r _write_to_self s z$BaseSelectorEventLoop._write_to_selfd c
C s" | | | j|||||| d S r+ )rD r? _accept_connection)r& protocol_factoryr r3 r* backlogr2 r r r _start_serving s z$BaseSelectorEventLoop._start_servingc
C s t |D ]}z0| \}} | jr0td|| | |d W n tttfk
rZ Y d S t k
r }
zd|
j
t
j t
j t
j
t
jfkr| d|
t|d | | | tj| j|||||| n W 5 d }
~
X Y qX d| i} | ||| |||} | | qd S )Nz#%r got a new connection from %r: %rFz&socket.accept() out of system resource)message exceptionrB peername)rangeacceptrQ r r rC rK rJ ConnectionAbortedErrorrP errnoZEMFILEZENFILEZENOBUFSZENOMEMcall_exception_handlerr TransportSocketr= r? Z
call_laterr ZACCEPT_RETRY_DELAYrW _accept_connection2Z create_task)
r& rU r r3 r* rV r2 _connaddrexcr) r\ r r r rT sV z(BaseSelectorEventLoop._accept_connectionc
s d }d }zt| }| } |r8| j|||| d|||d}n| j||| ||d}z| I d H W n tk
rx | Y nX W nt ttfk
r Y n\ tk
r }
z>| jrd|
d} |d k r|| d< |d k r|| d< | | W 5 d }
~
X Y nX d S )NT)r. r0 r) r* r2 )r. r) r* z3Error on transport creation for incoming connection)rX rY r- transport)
create_futurer4 r/
BaseExceptionr;
SystemExitKeyboardInterruptrQ r_ ) r& rU rc r) r3 r* r2 r- rf r. re contextr r r ra sP z)BaseSelectorEventLoop._accept_connection2c
C s |}t |tsJzt| }W n* tttfk
rH td|d Y nX z| j| }W n tk
rl Y n X | st d|d|d S )NzInvalid file object: zFile descriptor z is used by transport )
r intr? AttributeErrorr
ValueErrorr% r
is_closingr8 )r& r r? rf r r r _ensure_fd_no_transport s
z-BaseSelectorEventLoop._ensure_fd_no_transportc G s | t||| d }z| j|}W n* tk
rR | j|tj|d f Y n>X |j|j }\}}| j
||tjB ||f |d k r| d S r+ )
_check_closedr Handler" r r registerr
EVENT_READrG modifycancel r& r callbackargsZhandler maskreaderwriterr r r rD s
z!BaseSelectorEventLoop._add_readerc C s | r dS z| j|}W n tk
r2 Y dS X |j|j }\}}|tj M }|sd| j| n| j ||d |f |d k r|
dS dS d S NFT) r9 r" r r r rG r rt
unregisterru rv r& r r rz r{ r| r r r r= s z$BaseSelectorEventLoop._remove_readerc G s | t||| d }z| j|}W n* tk
rR | j|tjd |f Y n>X |j|j }\}}| j
||tjB ||f |d k r| d S r+ ) rq r rr r" r r rs r EVENT_WRITErG ru rv rw r r r _add_writer% s
z!BaseSelectorEventLoop._add_writerc C s | r dS z| j|}W n tk
r2 Y dS X |j|j }\}}|tj M }|sd| j| n| j |||df |dk r|
dS dS dS )Remove a writer callback.FNT) r9 r" r r r rG r r r~ ru rv r r r r _remove_writer4 s z$BaseSelectorEventLoop._remove_writerc G s | | | j||f| S )zAdd a reader callback.)rp rD r& r rx ry r r r
add_readerK s
z BaseSelectorEventLoop.add_readerc C s | | | |S )zRemove a reader callback.)rp r= r& r r r r
remove_readerP s
z#BaseSelectorEventLoop.remove_readerc G s | | | j||f| S )zAdd a writer callback..)rp r r r r r
add_writerU s
z BaseSelectorEventLoop.add_writerc C s | | | |S )r )rp r r r r r
remove_writerZ s
z#BaseSelectorEventLoop.remove_writerc s t | | jr"| dkr"tdz ||W S ttfk
rF Y nX | }| }| || j
||| | t
| j| |I dH S )zReceive data from the socket.
The return value is a bytes object representing the data received.
The maximum amount of data to be received at once is specified by
nbytes.
r the socket must be non-blockingN)r rQ
gettimeoutrn rI rK rJ rg r? r
_sock_recvadd_done_callback functoolspartial_sock_read_done)r& r nfutr r r r sock_recv_ s z BaseSelectorEventLoop.sock_recvc C s | | d S r+ )r r& r r r r r r t s z%BaseSelectorEventLoop._sock_read_donec
C s | r d S z||}W n\ ttfk
r4 Y d S ttfk
rL Y n6 tk
rv } z|| W 5 d }~X Y n X || d S r+ ) donerI rK rJ ri rj rh
set_exception
set_result)r& r r r rG re r r r r w s z BaseSelectorEventLoop._sock_recvc s t | | jr"| dkr"tdz ||W S ttfk
rF Y nX | }| }| || j
||| | t
| j| |I dH S )zReceive data from the socket.
The received data is written into *buf* (a writable buffer).
The return value is the number of bytes written.
r r N)r rQ r rn recv_intorK rJ rg r? r _sock_recv_intor r r r )r& r bufr r r r r sock_recv_into s z$BaseSelectorEventLoop.sock_recv_intoc
C s | r d S z||}W n\ ttfk
r4 Y d S ttfk
rL Y n6 tk
rv } z|| W 5 d }~X Y n X || d S r+ ) r r rK rJ ri rj rh r r )r& r r r nbytesre r r r r s z%BaseSelectorEventLoop._sock_recv_intoc s t | | jr"| dkr"tdz||}W n ttfk
rL d}Y nX |t|kr^dS | }| }|
t | j
| | || j||t||g |I dH S )a Send data to the socket.
The socket must be connected to a remote socket. This method continues
to send data from data until either all data has been sent or an
error occurs. None is returned on success. On error, an exception is
raised, and there is no way to determine how much data, if any, was
successfully processed by the receiving end of the connection.
r r N)r rQ r rn rO rK rJ lenrg r? r r r _sock_write_doner
_sock_sendall
memoryview)r& r rG r r r r r r sock_sendall s&
z"BaseSelectorEventLoop.sock_sendallc
C s | r d S |d }z|||d }W nb ttfk
rD Y d S ttfk
r\ Y n2 tk
r } z|| W Y d S d }~X Y nX ||7 }|t|kr| d n||d< d S )Nr )
r rO rK rJ ri rj rh r r r )r& r r Zviewposstartr re r r r r s
z#BaseSelectorEventLoop._sock_sendallc s t | | jr"| dkr"tdttdr8|jtjkrf| j||j|j | dI dH }|d \}}}}}|
}| ||| |I dH S )zTConnect to a remote socket at address.
This method is a coroutine.
r r AF_UNIX)familyprotoloopN) r rQ r rn hasattrrB r r Z_ensure_resolvedr rg
_sock_connect)r& r r6 Zresolvedrb r r r r sock_connect s z"BaseSelectorEventLoop.sock_connectc
C s | }z|| W n ttfk
rV |t| j| | || j ||| Y nN t
t fk
rn Y n6 t k
r } z|
| W 5 d }~X Y n X |d d S r+ )r? ZconnectrK rJ r r r r r _sock_connect_cbri rj rh r r )r& r r r6 r re r r r r s z#BaseSelectorEventLoop._sock_connectc C s | | d S r+ )r r r r r r s z&BaseSelectorEventLoop._sock_write_donec
C s | r d S z,|tjtj}|dkr6t|d| W nZ ttfk
rP Y nN tt fk
rh Y n6 t
k
r } z| | W 5 d }~X Y n X | d d S )Nr zConnect call failed )
r Z
getsockoptrB Z
SOL_SOCKETZSO_ERRORrP rK rJ ri rj rh r r )r& r r r6 errre r r r r s z&BaseSelectorEventLoop._sock_connect_cbc sB t | | jr"| dkr"td| }| |d| |I dH S )aW Accept a connection.
The socket must be bound to an address and listening for connections.
The return value is a pair (conn, address) where conn is a new socket
object usable to send and receive data on the connection, and address
is the address bound to the socket on the other end of the connection.
r r FN)r rQ r rn rg _sock_accept)r& r r r r r sock_accept s z!BaseSelectorEventLoop.sock_acceptc
C s | }|r| | | r"d S z| \}}|d W nn ttfk
rh | || j|d| Y nR t t
fk
r Y n: t k
r } z| | W 5 d }~X Y nX |
||f d S r} )r? r r r\ rC rK rJ r r ri rj rh r r )r& r Z
registeredr r rc r6 re r r r r * s
z"BaseSelectorEventLoop._sock_acceptc sp | j |j= | }| | I d H z | j|j|||ddI d H W S | |r^| || j |j< X d S )NF)Zfallback) r% _sock_fd
is_reading
pause_reading_make_empty_waiter_reset_empty_waiterresume_readingZ
sock_sendfile_sock)r& Ztranspfileoffsetcountr r r r _sendfile_native< s
z&BaseSelectorEventLoop._sendfile_nativec C s |D ]v\}}|j |j }\}}|tj@ rL|d k rL|jrB| | n
| | |tj@ r|d k r|jrp| | q| | qd S r+ ) fileobjrG r rt Z
_cancelledr= Z
_add_callbackr r )r& Z
event_listr rz r r{ r| r r r _process_eventsJ s
z%BaseSelectorEventLoop._process_eventsc C s | | | d S r+ )r= r? r; )r& r r r r
_stop_servingX s z#BaseSelectorEventLoop._stop_serving)N)N)N)NNN)-r!
__module__ __qualname____doc__r r/ r ZSSL_HANDSHAKE_TIMEOUTr4 r7 r; r: r# rH rE rR rW rT ra rp rD r= r r r r r r r r r r r r r r r r r r r r r r
__classcell__r r r' r r 0 s~
.
) r c s e Zd ZdZeZdZd fdd Zdd Zdd Z d d
Z
d d Z d
d Z dd Z
ejfddZd ddZdd Zdd Zdd Zd d Z ZS ) _SelectorTransporti Nc s t || t|| jd< z| | jd< W n tk
rN d | jd< Y nX d| jkrz| | jd< W n tj k
r d | jd< Y nX || _
| | _ d| _
| | || _| | _d| _d| _| jd k r| j | |j| j < d S )NrB ZsocknamerZ Fr )r r r r` _extraZ getsocknamerP Z getpeernamerB errorr r? r _protocol_connected set_protocol_server_buffer_factory_buffer
_conn_lost_closingZ_attachr% )r& r r r- r) r* r' r r r i s,
z_SelectorTransport.__init__c C s | j jg}| jd kr |d n| jr0|d |d| j | jd k r| j st| jj | jt
j }|rz|d n
|d t| jj | jt
j }|rd}nd}|
}|d| d | d
d d |S )
Nclosedclosingzfd=z read=pollingz read=idlepollingZidlezwrite=z<{}> )r r! r appendr r _loopr9 r r" r rt r get_write_buffer_sizeformatjoin)r& infor statebufsizer r r __repr__ s0
z_SelectorTransport.__repr__c C s | d d S r+ ) _force_closer< r r r abort s z_SelectorTransport.abortc C s || _ d| _d S NT) _protocolr r& r- r r r r s z _SelectorTransport.set_protocolc C s | j S r+ )r r< r r r get_protocol s z _SelectorTransport.get_protocolc C s | j S r+ )r r< r r r ro s z _SelectorTransport.is_closingc C sT | j r
d S d| _ | j| j | jsP| jd7 _| j| j | j| jd d S NTr ) r r r= r r r r call_soon_call_connection_lostr< r r r r; s z_SelectorTransport.closec C s, | j d k r(|d| t| d | j d S )Nzunclosed transport )source)r ResourceWarningr; )r& Z_warnr r r __del__ s
z_SelectorTransport.__del__Fatal error on transportc C sN t |tr(| j r@tjd| |dd n| j||| | jd | | d S )Nz%r: %sTrM )rX rY rf r- ) r rP r get_debugr r r_ r r )r& re rX r r r _fatal_error s
z _SelectorTransport._fatal_errorc C sd | j r
d S | jr(| j | j| j | jsBd| _| j| j | j d7 _ | j| j | d S r )
r r clearr r r r r= r r r& re r r r r s
z _SelectorTransport._force_closec C sV z| jr| j| W 5 | j d | _ d | _d | _| j}|d k rP| d | _X d S r+ )r r; r r r Z_detachr Zconnection_lost)r& re r* r r r r s
z(_SelectorTransport._call_connection_lostc C s
t | jS r+ )r r r< r r r r s z(_SelectorTransport.get_write_buffer_sizec G s" | j r
d S | jj||f| d S r+ )r r rD r r r r rD s z _SelectorTransport._add_reader)NN)r )r! r r max_size bytearrayr r r r r r r ro r; warningswarnr r r r r rD r r r r' r r ] s
r c s e Zd ZdZejjZd# fdd Z fddZ dd Z
d d
Z d d Z d
d Z
dd Zdd Zdd Zdd Zdd Zdd Zdd Z fd d Zd d Zd!d" Z ZS )$r, TNc s~ d | _ t ||||| d| _d| _d | _t| j | j
| j j | | j
| j
| j| j |d k rz| j
tj|d d S r
)_read_ready_cbr r _eof_paused
_empty_waiterr Z _set_nodelayr r r r connection_maderD r _read_readyr _set_result_unless_cancelled)r& r r r- r. r) r* r' r r r s
z!_SelectorSocketTransport.__init__c s. t |tjr| j| _n| j| _t | d S r+ )r r ZBufferedProtocol_read_ready__get_bufferr _read_ready__data_receivedr r r r' r r r s
z%_SelectorSocketTransport.set_protocolc C s | j o| j S r+ )r r r< r r r r s z#_SelectorSocketTransport.is_readingc C s> | j s | jrd S d| _| j| j | j r:td| d S )NTz%r pauses reading)r r r r= r r r r r< r r r r s
z&_SelectorSocketTransport.pause_readingc C s@ | j s | jsd S d| _| | j| j | j r Y n4 tk
rp } z| |d W Y d S d }~X Y nX |r| j
| j n| d S )Nz%r received EOFz1Fatal error: protocol.eof_received() call failed.)
r r r r r Z eof_receivedri rj rh r r= r r; )r& Z keep_openre r r r r e s
z,_SelectorSocketTransport._read_ready__on_eofc
C s6 t |tttfs$tdt|j| jr2td| j d k rDtd|sLd S | j
rz| j
t j krht
d | j
d7 _
d S | js z| j|}W nb ttfk
r Y nb ttfk
r Y nJ tk
r } z| |d W Y d S d }~X Y nX ||d }|s d S | j| j| j | j | | d S )N/data argument must be a bytes-like object, not z%Cannot call write() after write_eof()z(unable to write; sendfile is in progress socket.send() raised exception.r %Fatal write error on socket transport) r bytesr r r typer! r r8 r r r !LOG_THRESHOLD_FOR_CONNLOST_WRITESr warningr r rO rK rJ ri rj rh r r r r _write_readyextend_maybe_pause_protocol)r& rG r re r r r writez s:
z _SelectorSocketTransport.writec
C s | j r
d S z| j| j}W n ttfk
r4 Y n ttfk
rL Y n tk
r } z>| j
| j | j |
|d | jd k r| j| W 5 d }~X Y nnX |r| jd |= | | js| j
| j | jd k r| jd | jr| d n| jr| jtj d S )Nr )r r rO r rK rJ ri rj rh r r r r r r r _maybe_resume_protocolr r r r shutdownrB SHUT_WR)r& r re r r r r s2
z%_SelectorSocketTransport._write_readyc C s. | j s | jrd S d| _| js*| jtj d S r )r r r r r rB r r< r r r write_eof s
z"_SelectorSocketTransport.write_eofc C s dS r r r< r r r
can_write_eof s z&_SelectorSocketTransport.can_write_eofc s* t | | jd k r&| jtd d S )Nz Connection is closed by peer)r r r r ConnectionErrorr r' r r r s
z._SelectorSocketTransport._call_connection_lostc C s6 | j d k rtd| j | _ | js0| j d | j S )NzEmpty waiter is already set)r r8 r rg r r r< r r r r s
z+_SelectorSocketTransport._make_empty_waiterc C s
d | _ d S r+ )r r< r r r r s z,_SelectorSocketTransport._reset_empty_waiter)NNN)r! r r Z_start_tls_compatibler Z
_SendfileModeZ
TRY_NATIVEZ_sendfile_compatibler r r r r r r r r r r r r r r r r r r r' r r, s* %' r, c sF e Zd ZejZd fdd Zdd Zdd Zd
dd Z d
d Z
Z S )r5 Nc s^ t |||| || _| j| jj| | j| j| j| j |d k rZ| jt
j |d d S r+ ) r r _addressr r r r rD r r r r )r& r r r- r6 r. r) r' r r r s
z#_SelectorDatagramTransport.__init__c C s t dd | jD S )Nc s s | ]\}}t |V qd S r+ )r ).0rG rb r r r s zC_SelectorDatagramTransport.get_write_buffer_size..)sumr r< r r r r s z0_SelectorDatagramTransport.get_write_buffer_sizec
C s | j r
d S z| j| j\}}W n ttfk
r8 Y n tk
rd } z| j| W 5 d }~X Y nT t t
fk
r| Y n< t k
r } z| |d W 5 d }~X Y nX | j
|| d S )Nz&Fatal read error on datagram transport)r r Zrecvfromr rK rJ rP r error_receivedri rj rh r Zdatagram_receivedr& rG rd re r r r r s z&_SelectorDatagramTransport._read_readyc
C s t |tttfs$tdt|j|s,d S | jrV|d | jfkrPtd| j | j}| j r| jr| j t
j krxt
d | j d7 _ d S | jslz,| jd r| j| n| j|| W d S ttfk
r | j| j| j Y n tk
r } z| j| W Y d S d }~X Y nP t t fk
r6 Y n6 t k
rj } z| |d W Y d S d }~X Y nX | j t||f | ! d S )Nr z!Invalid address: must be None or r r rZ 'Fatal write error on datagram transport)"r r r r r r r! r rn r r r r r r r r rO sendtorK rJ r r r
_sendto_readyrP r r ri rj rh r r r r r r r r sH
z!_SelectorDatagramTransport.sendtoc
C s | j r| j \}}z*| jd r.| j| n| j|| W q ttfk
rj | j ||f Y qY q t k
r } z| j
| W Y d S d }~X Y q t t
fk
r Y q tk
r } z| |d W Y d S d }~X Y q X q | | j s| j| j | jr| d d S )NrZ r )r popleftr r rO r rK rJ
appendleftrP r r ri rj rh r r r r r r r r r r r r * s2
z(_SelectorDatagramTransport._sendto_ready)NNN)N) r! r r collectionsdequer r r r r r r r r r' r r5 s
+r5 ) r __all__r r^ r r rB r r$ r ImportError r r r r r r r
r logr r r Z
BaseEventLoopr Z_FlowControlMixinZ Transportr r, r5 r r r r sF
1 oPK ! d5y y - __pycache__/base_futures.cpython-38.opt-1.pycnu [ U
if
@ sR d Z ddlZddlmZ ddlmZ dZdZdZd d
Z d d Z
e Z d
d Z
dS ) N) get_ident )format_helpersZPENDINGZ CANCELLEDZFINISHEDc C s t | jdo| jdk S )zCheck 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)hasattr __class__r )objr r 9/opt/alt/python38/lib64/python3.8/asyncio/base_futures.pyisfuture s r c C s t | }|sd} dd }|dkr2|| d d } n`|dkr`d|| d d || d d } n2|dkrd|| d d |d || d d } d
| d S ) #helper function for Future.__repr__ c S s t | dS )Nr )r Z_format_callback_source)callbackr r r
format_cb s z$_format_callbacks..format_cbr r z{}, {}z{}, <{} more>, {}zcb=[])lenformat)cbsizer r r r
_format_callbacks s &r c C s | j g}| j tkr| jdk r4|d| j nTt| t f}|tkrPd}n(t| zt
| j }W 5 t | X |d| | j
r|t| j
| jr| jd }|d|d d|d |S )
r Nz
exception=z...zresult=r z created at r :r )Z_statelower _FINISHEDZ
_exceptionappendidr
_repr_runningadddiscardreprlibreprZ_resultZ
_callbacksr Z_source_traceback)Zfutureinfokeyresultframer r r
_future_repr_info7 s$
r& )__all__r _threadr r
r Z_PENDINGZ
_CANCELLEDr r r setr r& r r r r
s PK ! مT T $ __pycache__/constants.cpython-38.pycnu [ U
ifx @ s2 d dl Z dZdZdZdZdZG dd de jZdS ) N
g N@i c @ s$ e Zd Ze Ze Ze ZdS )
_SendfileModeN)__name__
__module__ __qualname__enumautoZ UNSUPPORTEDZ
TRY_NATIVEZFALLBACK r r 6/opt/alt/python38/lib64/python3.8/asyncio/constants.pyr s r )r Z!LOG_THRESHOLD_FOR_CONNLOST_WRITESZACCEPT_RETRY_DELAYZDEBUG_STACK_DEPTHZSSL_HANDSHAKE_TIMEOUTZ!SENDFILE_FALLBACK_READBUFFER_SIZEEnumr r r r r s PK ! ^1 $ __pycache__/log.cpython-38.opt-1.pycnu [ U
if| @ s d Z ddlZeeZdS )zLogging configuration. N)__doc__ZloggingZ getLogger __package__Zlogger r r 0/opt/alt/python38/lib64/python3.8/asyncio/log.py s PK ! cnd d , __pycache__/base_events.cpython-38.opt-2.pycnu [ U
if @ s d dl Z d dlZ d dlZd dlZd dlZd dlZd dlZd dlZd dl Z d dl
Z
d dl Z d dl Z d dl
Z
d dlZd dlZd dlZz d dlZW n ek
r dZY nX ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ dd lmZ dd
lmZ dd lm Z dd lm Z dd
lm Z ddl m Z dZ!dZ"dZ#e$edZ%dZ&e' Z(dd Z)dd Z*dd Z+d*ddZ,d+d d Z-d d Z.e$ed rd!d" Z/nd#d" Z/G d$d% d%ej0Z1G d&d' d'ej2Z3G d(d) d)ej4Z5dS ), N ) constants)
coroutines)events)
exceptions)futures) protocols)sslproto) staggered)tasks)
transports)trsock)logger)
BaseEventLoopd g ?AF_INET6iQ c C s0 | j }tt|dd tjr$t|jS t| S d S )N__self__)Z _callback
isinstancegetattrr Taskreprr str)handlecb r 8/opt/alt/python38/lib64/python3.8/asyncio/base_events.py_format_handleJ s
r c C s( | t jkrdS | t jkr dS t| S d S )Nzz)
subprocessPIPESTDOUTr )fdr r r _format_pipeS s
r! c C sL t tdstdn4z| tjtjd W n tk
rF tdY nX d S )N SO_REUSEPORTz)reuse_port not supported by socket moduler zTreuse_port not supported by socket module, SO_REUSEPORT defined but not implemented.)hasattrsocket
ValueError
setsockopt
SOL_SOCKETr" OSErrorsockr r r _set_reuseport\ s
r+ c C s t tdsd S |dtjtjhks(| d kr,d S |tjkr>tj}n|tjkrPtj}nd S |d krbd}nXt|trz|dkrzd}n@t|tr|dkrd}n(z t |}W n t
t fk
r Y d S X |tj krtj
g}tr|tj n|g}t| tr| d} d| krd S |D ]t}zVt|| trJ|tjkrJ|||d| |||ffW S |||d| |ffW S W n tk
rz Y nX q
d S )N inet_ptonr Zidna%)r# r$ IPPROTO_TCPZ IPPROTO_UDP SOCK_STREAM
SOCK_DGRAMr bytesr int TypeErrorr% AF_UNSPECAF_INET _HAS_IPv6appendr decoder, r( ) hostportfamilytypeprotoZflowinfoZscopeidZafsafr r r _ipaddr_infog sN
rA c C s t }| D ]*}|d }||kr(g ||< || | q t| }g }|dkr|||d d |d |d d |d = |dd tjtj | D |S )Nr r c s s | ]}|d k r|V qd S Nr ).0ar r r s z(_interleave_addrinfos..)
collections OrderedDictr9 listvaluesextend itertoolschain
from_iterable zip_longest)Z addrinfosZfirst_address_family_countZaddrinfos_by_familyaddrr= Zaddrinfos_listsZ reorderedr r r _interleave_addrinfos s"
rP c C s4 | s"| }t|ttfr"d S t| d S rB ) cancelled exceptionr
SystemExitKeyboardInterruptr Z _get_loopstop)futexcr r r _run_until_complete_cb s
rX TCP_NODELAYc C s@ | j tjtjhkr<| jtjkr<| jtjkr<| tjtj d d S Nr )
r= r$ r7 r r> r1 r? r0 r& rY r) r r r _set_nodelay s
r[ c C s d S rB r r) r r r r[ s c @ sT e Zd Zdd Zdd Zdd Zdd Zd d
Zd d Zd
d Z dd Z
dd Z dS )_SendfileFallbackProtocolc C sh t |tjstd|| _| | _| | _|j | _
| | | | j
r^| jj
| _nd | _d S )Nz.transport should be _FlowControlMixin instance)r r Z_FlowControlMixinr5
_transportZ get_protocol_protoZ
is_reading_should_resume_readingZ_protocol_paused_should_resume_writing
pause_reading set_protocol_loop
create_future_write_ready_fut)selftranspr r r __init__ s
z"_SendfileFallbackProtocol.__init__c s2 | j rtd| j}|d kr$d S |I d H d S )NzConnection closed by peer)r]
is_closingConnectionErrorre )rf rV r r r drain s
z _SendfileFallbackProtocol.drainc C s t dd S )Nz?Invalid state: connection should have been established already. RuntimeError)rf transportr r r connection_made s z)_SendfileFallbackProtocol.connection_madec C s@ | j d k r0|d kr$| j td n | j | | j| d S )Nz Connection is closed by peer)re Z
set_exceptionrj r^ connection_lost)rf rW r r r rp s
z)_SendfileFallbackProtocol.connection_lostc C s | j d k rd S | jj | _ d S rB )re r] rc rd rf r r r
pause_writing s
z'_SendfileFallbackProtocol.pause_writingc C s$ | j d krd S | j d d | _ d S )NF)re
set_resultrq r r r resume_writing s
z(_SendfileFallbackProtocol.resume_writingc C s t dd S Nz'Invalid state: reading should be pausedrl )rf datar r r
data_received s z'_SendfileFallbackProtocol.data_receivedc C s t dd S ru rl rq r r r eof_received s z&_SendfileFallbackProtocol.eof_receivedc sF | j | j | jr | j | jd k r2| j | jrB| j d S rB ) r] rb r^ r_ resume_readingre cancelr` rt rq r r r restore s
z!_SendfileFallbackProtocol.restoreN) __name__
__module__ __qualname__rh rk ro rp rr rt rw rx r{ r r r r r\ s r\ c @ sx e Zd Zdd Zdd Zdd Zdd Zd d
Zd d Zd
d Z dd Z
e dd Z dd Z
dd Zdd Zdd ZdS ) Serverc C s@ || _ || _d| _g | _|| _|| _|| _|| _d| _d | _ d S )Nr F)
rc _sockets
_active_count_waiters_protocol_factory_backlog _ssl_context_ssl_handshake_timeout_serving_serving_forever_fut)rf loopsocketsprotocol_factoryZ ssl_contextbacklogssl_handshake_timeoutr r r rh s zServer.__init__c C s d| j j d| jdS )N) __class__r| r rq r r r __repr__ s zServer.__repr__c C s | j d7 _ d S rZ )r rq r r r _attach# s zServer._attachc C s. | j d8 _ | j dkr*| jd kr*| d S )Nr r )r r _wakeuprq r r r _detach' s zServer._detachc C s, | j }d | _ |D ]}| s|| qd S rB )r doners )rf waiterswaiterr r r r - s
zServer._wakeupc C sJ | j r
d S d| _ | jD ].}|| j | j| j|| j| | j| j qd S NT) r r Zlistenr rc _start_servingr r r )rf r* r r r r 4 s
zServer._start_servingc C s | j S rB )rc rq r r r get_loop> s zServer.get_loopc C s | j S rB )r rq r r r
is_servingA s zServer.is_servingc C s" | j d krdS tdd | j D S )Nr c s s | ]}t |V qd S rB )r
ZTransportSocket)rC sr r r rE H s z!Server.sockets..)r tuplerq r r r r D s
zServer.socketsc C sn | j }|d krd S d | _ |D ]}| j| q d| _| jd k rX| j sX| j d | _| jdkrj| d S )NFr ) r rc Z
_stop_servingr r r rz r r )rf r r* r r r closeJ s
z Server.closec s" | tjd| jdI d H d S )Nr r )r r sleeprc rq r r r
start_serving] s zServer.start_servingc s | j d k rtd| d| jd kr4td| d| | j | _ zLz| j I d H W n6 tjk
r z| | I d H W 5 X Y nX W 5 d | _ X d S )Nzserver z, is already being awaited on serve_forever()z
is closed)
r rm r r rc rd r ZCancelledErrorr wait_closedrq r r r
serve_foreverc s
zServer.serve_foreverc s< | j d ks| jd krd S | j }| j| |I d H d S rB )r r rc rd r9 )rf r r r r r x s
zServer.wait_closedN)r| r} r~ rh r r r r r r r propertyr r r r r r r r r r s
r c @ sP e Zd Zdd Zdd Zdd Zddd d
Zd d Zd
d ZddddddZ ddddddddddZ
dddZ dddZ ddd Z
dd d Zd d Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Zd+d, Zd-d. Zd/d0 Zd1d2 Zd3d4 Zd5d6 Zej fd7d8Z d9d: Z d;d< Z dd=d>d?Z dd=d@dAZ!dd=dBdCZ"dDdE Z#dFdG Z$dHdI Z%dd=dJdKZ&dLdM Z'dNdO Z(dPdQ Z)dRdRdRdRdSdTdUZ*ddVdWZ+dddXdYdZZ,d[d\ Z-d]d^ Z.d_d` Z/ddadbZ0dddRdRdRdddddddc
dddeZ1ddfdgZ2dddXdhdiZ3djdk Z4dldm Z5ddddndodpZ6ddRdRdRe7ddddqdrdsZ8dRe9j:dRdRdSdtduZ;dvdw Zddxddddddy dzd{Z?ddd|d}d~Z@dd ZAdd ZBdd ZCeDjEeDjEeDjEdddRdddd ddZFeDjEeDjEeDjEdddRdddd ddZGdd ZHdd ZIdd ZJdd ZKdd ZLdd ZMdd ZNdd ZOdd ZPdd ZQdd ZRdS )r c C s d| _ d| _d| _t | _g | _d | _d| _d | _ t
dj | _
d | _| t d| _d | _d | _d| _d | _t | _d| _d S )Nr F monotonicg?)_timer_cancelled_count_closed _stoppingrF deque_ready
_scheduled_default_executorZ
_internal_fds
_thread_idtimeget_clock_infoZ
resolution_clock_resolution_exception_handler set_debugr Z_is_debug_modeslow_callback_duration_current_handle
_task_factory"_coroutine_origin_tracking_enabled&_coroutine_origin_tracking_saved_depthweakrefZWeakSet
_asyncgens_asyncgens_shutdown_calledrq r r r rh s$
zBaseEventLoop.__init__c C s. d| j j d| d| d| d S )Nr z running=z closed=z debug=r )r r|
is_running is_closed get_debugrq r r r r s ,zBaseEventLoop.__repr__c C s t j| dS )Nr )r ZFuturerq r r r rd s zBaseEventLoop.create_futureN)namec C sN | | jd kr2tj|| |d}|jrJ|jd= n| | |}t|| |S )N)r r )
_check_closedr r r _source_tracebackZ_set_task_name)rf coror Ztaskr r r create_task s
zBaseEventLoop.create_taskc C s" |d k rt |std|| _d S )Nz'task factory must be a callable or None)callabler5 r )rf factoryr r r set_task_factory s
z BaseEventLoop.set_task_factoryc C s | j S rB )r rq r r r get_task_factory s z BaseEventLoop.get_task_factory)extraserverc C s t d S rB NotImplementedError)rf r* protocolr r r r r r _make_socket_transport s z$BaseEventLoop._make_socket_transportFT) server_sideserver_hostnamer r r call_connection_madec C s t d S rB r ) rf Zrawsockr
sslcontextr r r r r r r r r r _make_ssl_transport s z!BaseEventLoop._make_ssl_transportc C s t d S rB r )rf r* r addressr r r r r _make_datagram_transport s z&BaseEventLoop._make_datagram_transportc C s t d S rB r rf piper r r r r r _make_read_pipe_transport s z'BaseEventLoop._make_read_pipe_transportc C s t d S rB r r r r r _make_write_pipe_transport s z(BaseEventLoop._make_write_pipe_transportc
s t d S rB r )
rf r argsshellstdinstdoutstderrbufsizer kwargsr r r _make_subprocess_transport s z(BaseEventLoop._make_subprocess_transportc C s t d S rB r rq r r r _write_to_self s z BaseEventLoop._write_to_selfc C s t d S rB r )rf
event_listr r r _process_events s z BaseEventLoop._process_eventsc C s | j rtdd S )NzEvent loop is closed)r rm rq r r r r s zBaseEventLoop._check_closedc C s* | j | | s&| | j| d S rB )r discardr call_soon_threadsafer acloserf agenr r r _asyncgen_finalizer_hook s z&BaseEventLoop._asyncgen_finalizer_hookc C s. | j r tjd|dt| d | j| d S )Nzasynchronous generator z3 was scheduled after loop.shutdown_asyncgens() callsource)r warningswarnResourceWarningr addr r r r _asyncgen_firstiter_hook s
z&BaseEventLoop._asyncgen_firstiter_hookc s d| _ t| jsd S t| j}| j tjdd |D d| dI d H }t||D ]*\}}t|t rT|
d|||d qTd S )NTc S s g | ] }| qS r )r )rC Zagr r r
s z4BaseEventLoop.shutdown_asyncgens..)Zreturn_exceptionsr z;an error occurred during closing of asynchronous generator )messagerR Zasyncgen) r lenr rH clearr gatherzipr Exceptioncall_exception_handler)rf Z
closing_agensZresultsresultr r r r shutdown_asyncgens s"
z BaseEventLoop.shutdown_asyncgensc C s( | rtdt d k r$tdd S )Nz"This event loop is already runningz7Cannot run the event loop while another loop is running)r rm r Z_get_running_looprq r r r _check_running& s z BaseEventLoop._check_runningc C s | | | | j t | _t }tj | j
| j d z t
| | | j rLq^qLW 5 d| _ d | _t
d | d tj | X d S )N) firstiter finalizerF)r r _set_coroutine_origin_tracking_debug threading get_identr sysget_asyncgen_hooksset_asyncgen_hooksr r r r Z_set_running_loop _run_once)rf Zold_agen_hooksr r r run_forever- s$
zBaseEventLoop.run_foreverc C s | | t| }tj|| d}|r4d|_|t z|jd= |S )N call_soonr )r r r r
_call_soonr rf r r
r r r r r r s
zBaseEventLoop.call_soonc C sD t |st |r$td| dt|s@td| d|d S )Nz coroutines cannot be used with z()z"a callable object was expected by z(), got )r Z iscoroutineZiscoroutinefunctionr5 r )rf r methodr r r r s
z BaseEventLoop._check_callbackc C s. t ||| |}|jr |jd= | j| |S )Nr )r ZHandler r r9 )rf r r r
r r r r r s
zBaseEventLoop._call_soonc C s, | j d krd S t }|| j kr(tdd S )NzMNon-thread-safe operation invoked on an event loop other than the current one)r r r rm )rf Z thread_idr r r r s
zBaseEventLoop._check_threadc G sB | | jr| |d | |||}|jr6|jd= | |S )Nr r )r r r r r r r r r r r s z"BaseEventLoop.call_soon_threadsafec G sZ | | jr| |d |d kr@| j}|d kr@tj }|| _tj|j|f| | dS )Nrun_in_executorr ) r r r r
concurrentr ThreadPoolExecutorZ wrap_futureZsubmit)rf r funcr r r r r s
z BaseEventLoop.run_in_executorc C s& t |tjjs tdtd || _d S )Nz{Using the default executor that is not an instance of ThreadPoolExecutor is deprecated and will be prohibited in Python 3.9 )r r r r r r DeprecationWarningr r
r r r set_default_executor s z"BaseEventLoop.set_default_executorc C s | d|g}|r$| d| |r8| d| |rL| d| |r`| d| d|}td| | }t||||||} | | }
d| d |
d
d d | }|
| jkrt| n
t| | S )
N:zfamily=ztype=zproto=zflags=, zGet address info %szGetting address info z took g @@z.3fzms: ) r9 joinr r r r$ getaddrinfor info) rf r; r< r= r> r? flagsmsgt0addrinfodtr r r _getaddrinfo_debug s&
z BaseEventLoop._getaddrinfo_debugr r= r> r? r' c
s2 | j r| j}ntj}| d |||||||I d H S rB )r r, r$ r% r )rf r; r< r= r> r? r' Z getaddr_funcr r r r% 2 s zBaseEventLoop.getaddrinfoc s | d tj||I d H S rB )r r$ getnameinfo)rf Zsockaddrr' r r r r. < s zBaseEventLoop.getnameinfo)fallbackc
s | j r| dkrtd| |||| z| ||||I d H W S tjk
rl } z
|s\ W 5 d }~X Y nX | ||||I d H S )Nr z the socket must be non-blocking)r Z
gettimeoutr% _check_sendfile_params_sock_sendfile_nativer SendfileNotAvailableError_sock_sendfile_fallback)rf r* fileoffsetcountr/ rW r r r
sock_sendfile@ s zBaseEventLoop.sock_sendfilec s t d|dd S )Nz-syscall sendfile is not available for socket z and file {file!r} combinationr r2 rf r* r4 r5 r6 r r r r1 N s
z#BaseEventLoop._sock_sendfile_nativec
s |r| | |r t|tjntj}t|}d}zt|rNt|| |}|dkrNqt|d | }| d |j|I d H } | szq| ||d | I d H || 7 }q2|W S |dkrt|dr| || X d S )Nr seek)
r: minr Z!SENDFILE_FALLBACK_READBUFFER_SIZE bytearrayr#
memoryviewr readintoZ sock_sendall)
rf r* r4 r5 r6 blocksizebuf
total_sentviewreadr r r r3 U s,
z%BaseEventLoop._sock_sendfile_fallbackc C s dt |ddkrtd|jtjks,td|d k rbt|tsLtd||dkrbtd|t|tsztd||dk rtd|d S )Nbmodez$file should be opened in binary modez+only SOCK_STREAM type sockets are supportedz+count must be a positive integer (got {!r})r z0offset must be a non-negative integer (got {!r})) r r% r> r$ r1 r r4 r5 formatr9 r r r r0 o s2
z$BaseEventLoop._check_sendfile_paramsc s@ g }| | |\}}}}} d }
ztj|||d}
|
d |d k r|D ]r\}}}}} z|
| W qW qH tk
r } z0d| d| j }
t| j|
} | | W 5 d } ~ X Y qHX qH| | |
| I d H |
W S tk
r } z"| | |
d k r
|
W 5 d } ~ X Y n |
d k r4|
Y nX d S )Nr= r> r? Fz*error while attempting to bind on address : ) r9 r$ setblockingbindr( strerrorlowererrnopop sock_connectr )rf r Z addr_infoZlocal_addr_infosZ
my_exceptionsr= Ztype_r? _r r* ZladdrrW r( r r r
_connect_sock s:
zBaseEventLoop._connect_sock)
sslr= r? r' r*
local_addrr r happy_eyeballs_delay
interleavec
sl |
d k r|st d|
d kr0|r0|s,t d|}
| d k rD|sDt d| d k rX|
d krXd}
|d k sj|d k r|d k rzt dj||f|tj||dI d H }|std| d k r܈j| |tj||dI d H stdnd |
rt||
}g | d krH|D ]D}z |I d H }W qvW n tk
r@ Y q Y nX q n.tj fdd |D | d
I d H \}}}|d kr d d D t dkr d
nJt
d
t fdd D r҈ d
td d
dd D n.|d krt d|jtjkr t d|j||||
| dI d H \}}jrd|d}td||||| ||fS )Nz+server_hostname is only meaningful with sslz:You must set server_hostname when using ssl without a host1ssl_handshake_timeout is only meaningful with sslr 8host/port and sock can not be specified at the same timer= r> r? r' r !getaddrinfo() returned empty listc 3 s | ]}t j |V qd S rB ) functoolspartialrQ )rC r* )r laddr_infosrf r r rE s z2BaseEventLoop.create_connection..r c S s g | ]}|D ]}|q qS r r )rC subrW r r r r s z3BaseEventLoop.create_connection..r c 3 s | ]}t | kV qd S rB r rC rW )modelr r rE s zMultiple exceptions: {}r# c s s | ]}t |V qd S rB r^ r_ r r r rE
s z5host and port was not specified and no sock specified"A Stream Socket was expected, got )r r$ z %r connected to %s:%r: (%r, %r))r% _ensure_resolvedr$ r1 r( rP rQ r
Zstaggered_racer r allrF r$ r> _create_connection_transportr get_extra_infor r )rf r r; r< rR r= r? r' r* rS r r rT rU infosr* rP rn r r )r r\ r` rf r create_connection s
z BaseEventLoop.create_connectionc s | d | }| }|rHt|tr*d n|} | j||| ||||d}
n| |||}
z|I d H W n |
Y nX |
|fS )NFr r r )rI rd r boolr r r ) rf r* r rR r r r r r r rn r r r rd % s*
z*BaseEventLoop._create_connection_transportc
s | rtdt|dtjj}|tjjkr:td||tjjkrz| ||||I d H W S tj k
r } z
|sx W 5 d }~X Y nX |std||
||||I d H S )NzTransport is closingZ_sendfile_compatiblez(sendfile is not supported for transport zHfallback is disabled and native sendfile is not supported for transport ) ri rm r r Z
_SendfileModeZ UNSUPPORTEDZ
TRY_NATIVE_sendfile_nativer r2 _sendfile_fallback)rf rn r4 r5 r6 r/ rE rW r r r sendfile? s4 zBaseEventLoop.sendfilec s t dd S )Nz!sendfile syscall is not supportedr8 )rf rg r4 r5 r6 r r r rj n s z BaseEventLoop._sendfile_nativec
s |r| | |r t|dnd}t|}d}t|}z|rXt|| |}|dkrX|W bS t|d | } | d |j| I d H }
|
s|W 0S | I d H |
| d |
||
7 }q6W 5 |dkrt|dr| || | I d H X d S )Ni @ r r: ) r: r; r< r\ r# r{ r= r r> rk write) rf rg r4 r5 r6 r? r@ rA r? rB rC r r r rk r s*
z BaseEventLoop._sendfile_fallbackrh c
s t d krtdt|t js*td|t|ddsFtd|d| }tj| ||||||dd}| |
| | |j |} | |j
}
z|I d H W n. tk
r | | |
Y nX |jS )Nz"Python ssl module is not availablez@sslcontext is expected to be an instance of ssl.SSLContext, got Z_start_tls_compatibleFz
transport z is not supported by start_tls())r r )rR rm r Z
SSLContextr5 r rd r Z SSLProtocolra rb r ro ry
BaseExceptionr rz Z_app_transport) rf rn r r r r r r Z ssl_protocolZ
conmade_cbZ resume_cbr r r start_tls sB
zBaseEventLoop.start_tls)r= r? r'
reuse_address
reuse_portallow_broadcastr* c s |
d k r|
j tjkr"td|
s>s>|s>|s>|s>|s>| r~t |||||| d} ddd | D } td| d|
d d }
n ss|d krtd
||fd ff}nttd r|tj kr fD ] }|d k rt
|t st d
qڈ rx d dkrxz"t
t
jr.t W nF tk
rF Y n2 tk
rv } ztd | W 5 d }~X Y nX ||f fff}ni }d fdffD ]\}}|d k r| j||tj||| dI d H }|std|D ]:\}}}}}||f}||krd d g||< ||| |< qq fdd| D }|sHtdg }|tk rv|rftdntjdtdd |D ]\\}}\}}d }
d }
zxtj|tj|d}
|rt|
| r|
tj tj d |
d r|
| r| s| |
|I d H |}
W n^ tk
rJ } z |
d k r0|
! |"| W 5 d } ~ X Y n& |
d k rb|
! Y nX q|qz|d | } | # } | $|
| |
| } | j%r̈ rt&d | | nt'd | | z| I d H W n | ! Y nX | | fS ) Nz A UDP Socket was expected, got )rS remote_addrr= r? r' rp rq rr r# c s s$ | ] \}}|r| d | V qdS )=Nr )rC kvr r r rE s z9BaseEventLoop.create_datagram_endpoint..zKsocket modifier keyword arguments can not be used when sock is specified. ()Fr zunexpected address family)NNAF_UNIXzstring is expected)r z2Unable to check or remove stale UNIX socket %r: %rr rX rY c s8 g | ]0\}} r |d dksr,|d dks||fqS )r Nr r )rC keyZ addr_pairrS rs r r r s z:BaseEventLoop.create_datagram_endpoint..z can not get address informationz~Passing `reuse_address=True` is no longer supported, as the usage of SO_REUSEPORT in UDP poses a significant security concern.zdThe *reuse_address* parameter has been deprecated as of 3.5.10 and is scheduled for removal in 3.11.r )
stacklevelrG z@Datagram endpoint local_addr=%r remote_addr=%r created: (%r, %r)z2Datagram endpoint remote_addr=%r created: (%r, %r))(r> r$ r2 r% dictr$ itemsrI r# rx r r r5 statS_ISSOCKosst_moderemoveFileNotFoundErrorr( r errorrb _unsetr r r r+ r& r' Z SO_BROADCASTrJ rO r r9 rd r r r& r ) rf r rS rs r= r? r' rp rq rr r* ZoptsZproblemsZr_addrZaddr_pairs_inforO errZ
addr_infosidxrf ZfamrP Zpror rz r Z
local_addressZremote_addressrW r r rn r r{ r create_datagram_endpoint s$
z&BaseEventLoop.create_datagram_endpointc
s\ |d d \}}t |||||f|dd } | d k r<| gS |j||||||dI d H S d S )Nr r- )rA r% )
rf r r= r> r? r' r r; r< r& r r r rb L s z BaseEventLoop._ensure_resolvedc s8 | j ||f|tj|| dI d H }|s4td|d|S )N)r= r> r' r z getaddrinfo(z) returned empty list)rb r$ r1 r( )rf r; r< r= r' rf r r r _create_server_getaddrinfoX s z(BaseEventLoop._create_server_getaddrinfor ) r= r' r* r rR rp rq r r c s t |trtd| d k r*|d kr*td|d k s<d k r"|d k rLtd| d krhtjdkoftjdk} g }
|dkr|d g}n$t |tst |t j
j s|g}n|} fdd|D }t j
|d iI d H }ttj|}d
}z |D ]}|\}}}}}zt|||}W n8 tjk
rH jr@tjd |||d d
Y qY nX |
| | rl|tjtjd |
rzt | t r|tj krt tdr|tj tj!d z|"| W q t#k
r } z t#|j$d||j%& f d W 5 d }~X Y qX qd }W 5 |s |
D ]}| qX n4|d kr4td|j'tj(krPtd||g}
|
D ]}|)d
qZt*|
|||| }| r|+ t j,ddI d H jrt-d| |S )Nz*ssl argument must be an SSLContext or NonerV rW posixcygwinr. c s g | ]}j | d qS ))r= r' )r )rC r; r= r' r< rf r r r s
z/BaseEventLoop.create_server..r Fz:create_server() failed to create socket.socket(%r, %r, %r)Texc_info IPPROTO_IPV6z0error while attempting to bind on address %r: %sz)Neither host/port nor sock were specifiedra r r z
%r is serving).r ri r5 r% r r r platformr rF abcIterabler r setrK rL rM r r$ r r r warningr9 r& r' Z SO_REUSEADDRr+ r8 r r# r Z IPV6_V6ONLYrJ r( rM rK rL r> r1 rI r r r r& )rf r r; r< r= r' r* r rR rp rq r r r ZhostsZfsrf Z completedresr@ Zsocktyper? Z canonnameZsar r r r r
create_server` s
zBaseEventLoop.create_server)rR r c sv |j tjkrtd||d k r.|s.td| j|||dd|dI d H \}}| jrn|d}td||| ||fS )Nra rV r. T)r r r$ z%r handled: (%r, %r)) r> r$ r1 r% rd r re r r )rf r r* rR r rn r r r r connect_accepted_socket s$
z%BaseEventLoop.connect_accepted_socketc sd | }| }| |||}z|I d H W n | Y nX | jr\td| || ||fS )Nz Read pipe %r connected: (%r, %r))rd r r r r r filenorf r r r r rn r r r connect_read_pipe s z BaseEventLoop.connect_read_pipec sd | }| }| |||}z|I d H W n | Y nX | jr\td| || ||fS )Nz!Write pipe %r connected: (%r, %r))rd r r r r r r r r r r connect_write_pipe s z BaseEventLoop.connect_write_pipec C s |g}|d k r"| dt| |d k rJ|tjkrJ| dt| n8|d k rf| dt| |d k r| dt| td| d S )Nzstdin=zstdout=stderr=zstdout=zstderr= )r9 r! r r r r r$ )rf r( r r r r& r r r _log_subprocess s z BaseEventLoop._log_subprocess) r r r universal_newlinesr r encodingerrorstextc s t |ttfstd|r"td|s.td|dkr>td| rJtd| d k rZtd|
d k rjtd| }
d }| jrd | }| |||| | j|
|d
||||f| I d H }| jr|d k rtd || ||
fS ) Nzcmd must be a string universal_newlines must be Falsezshell must be Truer bufsize must be 0text must be Falseencoding must be Noneerrors must be Nonezrun shell command %rT%s: %r) r r3 r r% r r r r r& )rf r cmdr r r r r r r r r r r debug_logrn r r r subprocess_shell sB
z BaseEventLoop.subprocess_shellc s |r t d|rt d|dkr(t d| r4t d| d k rDt d|
d k rTt d|f| }| }d }| jrd|}| |||| | j||d ||||f|
I d H }| jr|d k rtd
|| ||fS ) Nr zshell must be Falser r r r r zexecute program Fr )r% r r r r r& )rf r Zprogramr r r r r r r r r r r Z
popen_argsr r rn r r r subprocess_execC s@
z BaseEventLoop.subprocess_execc C s | j S rB )r rq r r r get_exception_handlere s z#BaseEventLoop.get_exception_handlerc C s( |d k r t |s td||| _d S )Nz+A callable object or None is expected, got )r r5 r )rf Zhandlerr r r set_exception_handlerj s z#BaseEventLoop.set_exception_handlerc C s | d}|sd}| d}|d k r6t|||jf}nd}d|kr`| jd k r`| jjr`| jj|d< |g}t|D ]}|dkr|qn|| }|dkrdt|}d }|| 7 }n2|dkrdt|}d
}|| 7 }nt
|}| | d | qnt j
d ||d
d S )Nr z!Unhandled exception in event looprR FZsource_tracebackZhandle_traceback> rR r r. z+Object created at (most recent call last):
z+Handle created at (most recent call last):
rH
r )getr>
__traceback__r r sortedr$ traceback format_listrstripr r9 r r ) rf r
r rR r Z log_linesrz valuetbr r r default_exception_handler{ s<
z'BaseEventLoop.default_exception_handlerc C s | j d krVz| | W q ttfk
r2 Y q tk
rR tjddd Y qX nz| | | W n ttfk
r Y nt tk
r } zVz| d||d W n: ttfk
r Y n" tk
r tjddd Y nX W 5 d }~X Y nX d S )Nz&Exception in default exception handlerTr z$Unhandled error in exception handler)r rR r
zeException in default exception handler while handling an unexpected error in custom exception handler)r r rS rT rn r r )rf r
rW r r r r s4
z$BaseEventLoop.call_exception_handlerc C s |j r
d S | j| d S rB )
_cancelledr r9 rf r r r r
_add_callback s zBaseEventLoop._add_callbackc C s | | | d S rB )r r r r r r _add_callback_signalsafe s
z&BaseEventLoop._add_callback_signalsafec C s |j r| jd7 _d S rZ )r r r r r r _timer_handle_cancelled s z%BaseEventLoop._timer_handle_cancelledc C s t | j}|tkr`| j| tkr`g }| jD ] }|jr sb
;
DoPK ! _P + __pycache__/base_tasks.cpython-38.opt-2.pycnu [ U
if @ sD d dl Z d dlZddlmZ ddlmZ dd Zdd Zd d
ZdS ) N ) base_futures)
coroutinesc C sn t | }| jrd|d< |dd| t| j}|dd| d | jd k rj|dd | j |S )
NZ
cancellingr r zname=%r zcoro=<> z wait_for=) r Z_future_repr_infoZ _must_cancelinsertZget_namer Z_format_coroutine_coroZ _fut_waiter)taskinfocoro r
7/opt/alt/python38/lib64/python3.8/asyncio/base_tasks.py_task_repr_info s
r c C s g }t | jdr| jj}n0t | jdr0| jj}nt | jdrF| jj}nd }|d k r|d k r|d k rt|dkrlq|d8 }|| |j}qR| nH| jd k r| jj }|d k r|d k r|dkrq|d8 }||j
|j }q|S )Ncr_framegi_frameag_framer r ) hasattrr r r r appendf_backreverse
_exception
__traceback__tb_frametb_next)r
limitZframesftbr
r
r _task_get_stack s6
r c C s g }t }| j|dD ]Z}|j}|j}|j}|j} ||krN|| t| t |||j
}
| ||| |
f q| j } |st
d| |d n2| d k rt
d| d|d nt
d| d|d tj||d | d k rt| j| D ]}
t
|
|dd qd S ) N)r z
No stack for )filezTraceback for z (most recent call last):z
Stack for )r end)setZ get_stackf_linenof_code co_filenameco_nameadd linecache
checkcachegetline f_globalsr r print traceback
print_listformat_exception_only __class__) r
r r extracted_listcheckedr linenocofilenamenamelineexcr
r
r _task_print_stack< s,
r9 )r( r- r r r r r r9 r
r
r
r s #PK ! mmt t * __pycache__/selector_events.cpython-38.pycnu [ U
ifT @ s. d Z dZddlZddlZddlZddlZddlZddlZddlZz ddl Z W n e
k
rd dZ Y nX ddl m Z ddl m
Z
ddl mZ ddl mZ dd l mZ dd
l mZ dd l mZ dd l mZ dd
lmZ dd Zdd ZG dd de jZG dd dejejZ G dd de Z G dd de Z dS )zEvent loop using a selector and related classes.
A selector is a "notify-when-ready" multiplexer. For a subclass which
also includes support for signal handling, see the unix_events sub-module.
)BaseSelectorEventLoop N ) base_events) constants)events)futures) protocols)sslproto)
transports)trsock)loggerc C s8 z| |}W n tk
r$ Y dS X t|j|@ S d S NF)get_keyKeyErrorboolr )selectorfdZeventkey r Z!d?d@ Z"dAdB Z#dCdD Z$dEdF Z%dGdH Z&dIdJ Z'dKdL Z(dMdN Z)dOdP Z*dQdR Z+ Z,S )Wr zJSelector event loop.
See events.EventLoop for API specification.
Nc sF t |d krt }td|jj || _| t
| _ d S )NzUsing selector: %s)
super__init__ selectorsZDefaultSelectorr debug __class____name__ _selector_make_self_pipeweakrefZWeakValueDictionary _transports)selfr r r r r 6 s
z BaseSelectorEventLoop.__init__extraserverc C s t | |||||S N)_SelectorSocketTransport)r& r protocolwaiterr) r* r r r _make_socket_transport@ s
z,BaseSelectorEventLoop._make_socket_transportF) server_sideserver_hostnamer) r* ssl_handshake_timeoutc C s0 t j| |||||| d}
t| ||
||d |
jS )N)r2 r( )r Z SSLProtocolr, Z_app_transport) r& Zrawsockr-
sslcontextr. r0 r1 r) r* r2 Z ssl_protocolr r r _make_ssl_transportE s z)BaseSelectorEventLoop._make_ssl_transportc C s t | |||||S r+ )_SelectorDatagramTransport)r& r r- addressr. r) r r r _make_datagram_transportR s
z.BaseSelectorEventLoop._make_datagram_transportc sL | rtd| r d S | t | jd k rH| j d | _d S )Nz!Cannot close a running event loop)Z
is_running RuntimeError is_closed_close_self_piper closer" r& r' r r r; W s
zBaseSelectorEventLoop.closec C sB | | j | j d | _| j d | _| jd8 _d S )Nr )_remove_reader_ssockfilenor; _csock
_internal_fdsr< r r r r: b s
z&BaseSelectorEventLoop._close_self_pipec C sN t \| _| _| jd | jd | jd7 _| | j | j d S )NFr ) socketZ
socketpairr> r@ setblockingrA _add_readerr? _read_from_selfr< r r r r# j s
z%BaseSelectorEventLoop._make_self_pipec C s d S r+ r r& datar r r _process_self_datar s z(BaseSelectorEventLoop._process_self_datac C sX z"| j d}|sW qT| | W q tk
r: Y q Y q tk
rP Y qTY q X q d S )Ni )r> recvrH InterruptedErrorBlockingIOErrorrF r r r rE u s z%BaseSelectorEventLoop._read_from_selfc C sN | j }|d krd S z|d W n( tk
rH | jrDtjddd Y nX d S )N z3Fail to write a null byte into the self-pipe socketTexc_info)r@ sendOSError_debugr r )r& Zcsockr r r _write_to_self s z$BaseSelectorEventLoop._write_to_selfd c
C s" | | | j|||||| d S r+ )rD r? _accept_connection)r& protocol_factoryr r3 r* backlogr2 r r r _start_serving s z$BaseSelectorEventLoop._start_servingc
C s t |D ]}z0| \}} | jr0td|| | |d W n tttfk
rZ Y d S t k
r }
zd|
j
t
j t
j t
j
t
jfkr| d|
t|d | | | tj| j|||||| n W 5 d }
~
X Y qX d| i} | ||| |||} | | qd S )Nz#%r got a new connection from %r: %rFz&socket.accept() out of system resource)message exceptionrB peername)rangeacceptrQ r r rC rK rJ ConnectionAbortedErrorrP errnoZEMFILEZENFILEZENOBUFSZENOMEMcall_exception_handlerr TransportSocketr= r? Z
call_laterr ZACCEPT_RETRY_DELAYrW _accept_connection2Z create_task)
r& rU r r3 r* rV r2 _connaddrexcr) r\ r r r rT sV z(BaseSelectorEventLoop._accept_connectionc
s d }d }zt| }| } |r8| j|||| d|||d}n| j||| ||d}z| I d H W n tk
rx | Y nX W nt ttfk
r Y n\ tk
r }
z>| jrd|
d} |d k r|| d< |d k r|| d< | | W 5 d }
~
X Y nX d S )NT)r. r0 r) r* r2 )r. r) r* z3Error on transport creation for incoming connection)rX rY r- transport)
create_futurer4 r/
BaseExceptionr;
SystemExitKeyboardInterruptrQ r_ ) r& rU rc r) r3 r* r2 r- rf r. re contextr r r ra sP z)BaseSelectorEventLoop._accept_connection2c
C s |}t |tsJzt| }W n* tttfk
rH td|d Y nX z| j| }W n tk
rl Y n X | st d|d|d S )NzInvalid file object: zFile descriptor z is used by transport )
r intr? AttributeErrorr
ValueErrorr% r
is_closingr8 )r& r r? rf r r r _ensure_fd_no_transport s
z-BaseSelectorEventLoop._ensure_fd_no_transportc G s | t||| d }z| j|}W n* tk
rR | j|tj|d f Y n>X |j|j }\}}| j
||tjB ||f |d k r| d S r+ )
_check_closedr Handler" r r registerr
EVENT_READrG modifycancel r& r callbackargsZhandler maskreaderwriterr r r rD s
z!BaseSelectorEventLoop._add_readerc C s | r dS z| j|}W n tk
r2 Y dS X |j|j }\}}|tj M }|sd| j| n| j ||d |f |d k r|
dS dS d S NFT) r9 r" r r r rG r rt
unregisterru rv r& r r rz r{ r| r r r r= s z$BaseSelectorEventLoop._remove_readerc G s | t||| d }z| j|}W n* tk
rR | j|tjd |f Y n>X |j|j }\}}| j
||tjB ||f |d k r| d S r+ ) rq r rr r" r r rs r EVENT_WRITErG ru rv rw r r r _add_writer% s
z!BaseSelectorEventLoop._add_writerc C s | r dS z| j|}W n tk
r2 Y dS X |j|j }\}}|tj M }|sd| j| n| j |||df |dk r|
dS dS dS )Remove a writer callback.FNT) r9 r" r r r rG r r r~ ru rv r r r r _remove_writer4 s z$BaseSelectorEventLoop._remove_writerc G s | | | j||f| S )zAdd a reader callback.)rp rD r& r rx ry r r r
add_readerK s
z BaseSelectorEventLoop.add_readerc C s | | | |S )zRemove a reader callback.)rp r= r& r r r r
remove_readerP s
z#BaseSelectorEventLoop.remove_readerc G s | | | j||f| S )zAdd a writer callback..)rp r r r r r
add_writerU s
z BaseSelectorEventLoop.add_writerc C s | | | |S )r )rp r r r r r
remove_writerZ s
z#BaseSelectorEventLoop.remove_writerc s t | | jr"| dkr"tdz ||W S ttfk
rF Y nX | }| }| || j
||| | t
| j| |I dH S )zReceive data from the socket.
The return value is a bytes object representing the data received.
The maximum amount of data to be received at once is specified by
nbytes.
r the socket must be non-blockingN)r rQ
gettimeoutrn rI rK rJ rg r? r
_sock_recvadd_done_callback functoolspartial_sock_read_done)r& r nfutr r r r sock_recv_ s z BaseSelectorEventLoop.sock_recvc C s | | d S r+ )r r& r r r r r r t s z%BaseSelectorEventLoop._sock_read_donec
C s | r d S z||}W n\ ttfk
r4 Y d S ttfk
rL Y n6 tk
rv } z|| W 5 d }~X Y n X || d S r+ ) donerI rK rJ ri rj rh
set_exception
set_result)r& r r r rG re r r r r w s z BaseSelectorEventLoop._sock_recvc s t | | jr"| dkr"tdz ||W S ttfk
rF Y nX | }| }| || j
||| | t
| j| |I dH S )zReceive data from the socket.
The received data is written into *buf* (a writable buffer).
The return value is the number of bytes written.
r r N)r rQ r rn recv_intorK rJ rg r? r _sock_recv_intor r r r )r& r bufr r r r r sock_recv_into s z$BaseSelectorEventLoop.sock_recv_intoc
C s | r d S z||}W n\ ttfk
r4 Y d S ttfk
rL Y n6 tk
rv } z|| W 5 d }~X Y n X || d S r+ ) r r rK rJ ri rj rh r r )r& r r r nbytesre r r r r s z%BaseSelectorEventLoop._sock_recv_intoc s t | | jr"| dkr"tdz||}W n ttfk
rL d}Y nX |t|kr^dS | }| }|
t | j
| | || j||t||g |I dH S )a Send data to the socket.
The socket must be connected to a remote socket. This method continues
to send data from data until either all data has been sent or an
error occurs. None is returned on success. On error, an exception is
raised, and there is no way to determine how much data, if any, was
successfully processed by the receiving end of the connection.
r r N)r rQ r rn rO rK rJ lenrg r? r r r _sock_write_doner
_sock_sendall
memoryview)r& r rG r r r r r r sock_sendall s&
z"BaseSelectorEventLoop.sock_sendallc
C s | r d S |d }z|||d }W nb ttfk
rD Y d S ttfk
r\ Y n2 tk
r } z|| W Y d S d }~X Y nX ||7 }|t|kr| d n||d< d S )Nr )
r rO rK rJ ri rj rh r r r )r& r r Zviewposstartr re r r r r s
z#BaseSelectorEventLoop._sock_sendallc s t | | jr"| dkr"tdttdr8|jtjkrf| j||j|j | dI dH }|d \}}}}}|
}| ||| |I dH S )zTConnect to a remote socket at address.
This method is a coroutine.
r r AF_UNIX)familyprotoloopN) r rQ r rn hasattrrB r r Z_ensure_resolvedr rg
_sock_connect)r& r r6 Zresolvedrb r r r r sock_connect s z"BaseSelectorEventLoop.sock_connectc
C s | }z|| W n ttfk
rV |t| j| | || j ||| Y nN t
t fk
rn Y n6 t k
r } z|
| W 5 d }~X Y n X |d d S r+ )r? ZconnectrK rJ r r r r r _sock_connect_cbri rj rh r r )r& r r r6 r re r r r r s z#BaseSelectorEventLoop._sock_connectc C s | | d S r+ )r r r r r r s z&BaseSelectorEventLoop._sock_write_donec
C s | r d S z,|tjtj}|dkr6t|d| W nZ ttfk
rP Y nN tt fk
rh Y n6 t
k
r } z| | W 5 d }~X Y n X | d d S )Nr zConnect call failed )
r Z
getsockoptrB Z
SOL_SOCKETZSO_ERRORrP rK rJ ri rj rh r r )r& r r r6 errre r r r r s z&BaseSelectorEventLoop._sock_connect_cbc sB t | | jr"| dkr"td| }| |d| |I dH S )aW Accept a connection.
The socket must be bound to an address and listening for connections.
The return value is a pair (conn, address) where conn is a new socket
object usable to send and receive data on the connection, and address
is the address bound to the socket on the other end of the connection.
r r FN)r rQ r rn rg _sock_accept)r& r r r r r sock_accept s z!BaseSelectorEventLoop.sock_acceptc
C s | }|r| | | r"d S z| \}}|d W nn ttfk
rh | || j|d| Y nR t t
fk
r Y n: t k
r } z| | W 5 d }~X Y nX |
||f d S r} )r? r r r\ rC rK rJ r r ri rj rh r r )r& r Z
registeredr r rc r6 re r r r r * s
z"BaseSelectorEventLoop._sock_acceptc sp | j |j= | }| | I d H z | j|j|||ddI d H W S | |r^| || j |j< X d S )NF)Zfallback) r% _sock_fd
is_reading
pause_reading_make_empty_waiter_reset_empty_waiterresume_readingZ
sock_sendfile_sock)r& Ztranspfileoffsetcountr r r r _sendfile_native< s
z&BaseSelectorEventLoop._sendfile_nativec C s |D ]v\}}|j |j }\}}|tj@ rL|d k rL|jrB| | n
| | |tj@ r|d k r|jrp| | q| | qd S r+ ) fileobjrG r rt Z
_cancelledr= Z
_add_callbackr r )r& Z
event_listr rz r r{ r| r r r _process_eventsJ s
z%BaseSelectorEventLoop._process_eventsc C s | | | d S r+ )r= r? r; )r& r r r r
_stop_servingX s z#BaseSelectorEventLoop._stop_serving)N)N)N)NNN)-r!
__module__ __qualname____doc__r r/ r ZSSL_HANDSHAKE_TIMEOUTr4 r7 r; r: r# rH rE rR rW rT ra rp rD r= r r r r r r r r r r r r r r r r r r r r r r
__classcell__r r r' r r 0 s~
.
) r c s e Zd ZdZeZdZd fdd Zdd Zdd Z d d
Z
d d Z d
d Z dd Z
ejfddZd ddZdd Zdd Zdd Zd d Z ZS ) _SelectorTransporti Nc s t || t|| jd< z| | jd< W n tk
rN d | jd< Y nX d| jkrz| | jd< W n tj k
r d | jd< Y nX || _
| | _ d| _
| | || _| | _d| _d| _| jd k r| j | |j| j < d S )NrB ZsocknamerZ Fr )r r r r` _extraZ getsocknamerP Z getpeernamerB errorr r? r _protocol_connected set_protocol_server_buffer_factory_buffer
_conn_lost_closingZ_attachr% )r& r r r- r) r* r' r r r i s,
z_SelectorTransport.__init__c C s | j jg}| jd kr |d n| jr0|d |d| j | jd k r| j st| jj | jt
j }|rz|d n
|d t| jj | jt
j }|rd}nd}|
}|d| d | d
d d |S )
Nclosedclosingzfd=z read=pollingz read=idlepollingZidlezwrite=z<{}> )r r! r appendr r _loopr9 r r" r rt r get_write_buffer_sizeformatjoin)r& infor statebufsizer r r __repr__ s0
z_SelectorTransport.__repr__c C s | d d S r+ ) _force_closer< r r r abort s z_SelectorTransport.abortc C s || _ d| _d S NT) _protocolr r& r- r r r r s z _SelectorTransport.set_protocolc C s | j S r+ )r r< r r r get_protocol s z _SelectorTransport.get_protocolc C s | j S r+ )r r< r r r ro s z _SelectorTransport.is_closingc C sT | j r
d S d| _ | j| j | jsP| jd7 _| j| j | j| jd d S NTr ) r r r= r r r r call_soon_call_connection_lostr< r r r r; s z_SelectorTransport.closec C s, | j d k r(|d| t| d | j d S )Nzunclosed transport )source)r ResourceWarningr; )r& Z_warnr r r __del__ s
z_SelectorTransport.__del__Fatal error on transportc C sN t |tr(| j r@tjd| |dd n| j||| | jd | | d S )Nz%r: %sTrM )rX rY rf r- ) r rP r get_debugr r r_ r r )r& re rX r r r _fatal_error s
z _SelectorTransport._fatal_errorc C sd | j r
d S | jr(| j | j| j | jsBd| _| j| j | j d7 _ | j| j | d S r )
r r clearr r r r r= r r r& re r r r r s
z _SelectorTransport._force_closec C sV z| jr| j| W 5 | j d | _ d | _d | _| j}|d k rP| d | _X d S r+ )r r; r r r Z_detachr Zconnection_lost)r& re r* r r r r s
z(_SelectorTransport._call_connection_lostc C s
t | jS r+ )r r r< r r r r s z(_SelectorTransport.get_write_buffer_sizec G s" | j r
d S | jj||f| d S r+ )r r rD r r r r rD s z _SelectorTransport._add_reader)NN)r )r! r r max_size bytearrayr r r r r r r ro r; warningswarnr r r r r rD r r r r' r r ] s
r c s e Zd ZdZejjZd# fdd Z fddZ dd Z
d d
Z d d Z d
d Z
dd Zdd Zdd Zdd Zdd Zdd Zdd Z fd d Zd d Zd!d" Z ZS )$r, TNc s~ d | _ t ||||| d| _d| _d | _t| j | j
| j j | | j
| j
| j| j |d k rz| j
tj|d d S r
)_read_ready_cbr r _eof_paused
_empty_waiterr Z _set_nodelayr r r r connection_maderD r _read_readyr _set_result_unless_cancelled)r& r r r- r. r) r* r' r r r s
z!_SelectorSocketTransport.__init__c s. t |tjr| j| _n| j| _t | d S r+ )r r ZBufferedProtocol_read_ready__get_bufferr _read_ready__data_receivedr r r r' r r r s
z%_SelectorSocketTransport.set_protocolc C s | j o| j S r+ )r r r< r r r r s z#_SelectorSocketTransport.is_readingc C s> | j s | jrd S d| _| j| j | j r:td| d S )NTz%r pauses reading)r r r r= r r r r r< r r r r s
z&_SelectorSocketTransport.pause_readingc C s@ | j s | jsd S d| _| | j| j | j r Y n4 tk
rp } z| |d W Y d S d }~X Y nX |r| j
| j n| d S )Nz%r received EOFz1Fatal error: protocol.eof_received() call failed.)
r r r r r Z eof_receivedri rj rh r r= r r; )r& Z keep_openre r r r r e s
z,_SelectorSocketTransport._read_ready__on_eofc
C s6 t |tttfs$tdt|j| jr2td| j d k rDtd|sLd S | j
rz| j
t j krht
d | j
d7 _
d S | js z| j|}W nb ttfk
r Y nb ttfk
r Y nJ tk
r } z| |d W Y d S d }~X Y nX ||d }|s d S | j| j| j | j | | d S )N/data argument must be a bytes-like object, not z%Cannot call write() after write_eof()z(unable to write; sendfile is in progress socket.send() raised exception.r %Fatal write error on socket transport) r bytesr r r typer! r r8 r r r !LOG_THRESHOLD_FOR_CONNLOST_WRITESr warningr r rO rK rJ ri rj rh r r r r _write_readyextend_maybe_pause_protocol)r& rG r re r r r writez s:
z _SelectorSocketTransport.writec
C s( | j std| jrd S z| j| j }W n ttfk
rB Y n ttfk
rZ Y n t k
r } z>| j
| j | j
| |d | jd k r| j| W 5 d }~X Y npX |r| j d |= | | j s$| j
| j | jd k r| jd | jr| d n| jr$| jtj d S )NzData should not be emptyr )r AssertionErrorr r rO rK rJ ri rj rh r r r r r r r _maybe_resume_protocolr r r r shutdownrB SHUT_WR)r& r re r r r r s4
z%_SelectorSocketTransport._write_readyc C s. | j s | jrd S d| _| js*| jtj d S r )r r r r r rB r r< r r r write_eof s
z"_SelectorSocketTransport.write_eofc C s dS r r r< r r r
can_write_eof s z&_SelectorSocketTransport.can_write_eofc s* t | | jd k r&| jtd d S )Nz Connection is closed by peer)r r r r ConnectionErrorr r' r r r s
z._SelectorSocketTransport._call_connection_lostc C s6 | j d k rtd| j | _ | js0| j d | j S )NzEmpty waiter is already set)r r8 r rg r r r< r r r r s
z+_SelectorSocketTransport._make_empty_waiterc C s
d | _ d S r+ )r r< r r r r s z,_SelectorSocketTransport._reset_empty_waiter)NNN)r! r r Z_start_tls_compatibler Z
_SendfileModeZ
TRY_NATIVEZ_sendfile_compatibler r r r r r r r r r r r r
r r r r r r r' r r, s* %' r, c sF e Zd ZejZd fdd Zdd Zdd Zd
dd Z d
d Z
Z S )r5 Nc s^ t |||| || _| j| jj| | j| j| j| j |d k rZ| jt
j |d d S r+ ) r r _addressr r r r rD r r r r )r& r r r- r6 r. r) r' r r r s
z#_SelectorDatagramTransport.__init__c C s t dd | jD S )Nc s s | ]\}}t |V qd S r+ )r ).0rG rb r r r s zC_SelectorDatagramTransport.get_write_buffer_size..)sumr r< r r r r s z0_SelectorDatagramTransport.get_write_buffer_sizec
C s | j r
d S z| j| j\}}W n ttfk
r8 Y n tk
rd } z| j| W 5 d }~X Y nT t t
fk
r| Y n< t k
r } z| |d W 5 d }~X Y nX | j
|| d S )Nz&Fatal read error on datagram transport)r r Zrecvfromr rK rJ rP r error_receivedri rj rh r Zdatagram_receivedr& rG rd re r r r r s z&_SelectorDatagramTransport._read_readyc
C s t |tttfs$tdt|j|s,d S | jrV|d | jfkrPtd| j | j}| j r| jr| j t
j krxt
d | j d7 _ d S | jslz,| jd r| j| n| j|| W d S ttfk
r | j| j| j Y n tk
r } z| j| W Y d S d }~X Y nP t t fk
r6 Y n6 t k
rj } z| |d W Y d S d }~X Y nX | j t||f | ! d S )Nr z!Invalid address: must be None or r r rZ 'Fatal write error on datagram transport)"r r r r r r r! r rn r r r r r r r r rO sendtorK rJ r r r
_sendto_readyrP r r ri rj rh r r r r r r r r sH
z!_SelectorDatagramTransport.sendtoc
C s | j r| j \}}z*| jd r.| j| n| j|| W q ttfk
rj | j ||f Y qY q t k
r } z| j
| W Y d S d }~X Y q t t
fk
r Y q tk
r } z| |d W Y d S d }~X Y q X q | | j s| j| j | jr| d d S )NrZ r )r popleftr r rO r rK rJ
appendleftrP r r ri rj rh r r r r r r r r r r r r * s2
z(_SelectorDatagramTransport._sendto_ready)NNN)N) r! r r collectionsdequer r r r r r r r r r' r r5 s
+r5 ) r __all__r r^ r r rB r r$ r ImportError r r r r r r r
r logr r r Z
BaseEventLoopr Z_FlowControlMixinZ Transportr r, r5 r r r r sF
1 oPK ! M!` !` ) __pycache__/windows_events.cpython-38.pycnu [ U
if @ s d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
m Z ddl
m Z ddl
m
Z
ddl
mZ ddl
mZ dd l
mZ dd
l
mZ dd l
mZ dd lmZ d
ZdZdZdZdZdZdZG dd de
j Z G dd de
j Z G dd de Z G dd de Z G dd d e!Z"G d d d ej#Z$G d d d ej%Z&G d!d" d"Z'G d#d$ d$e j(Z)e$Z*G d%d& d&e j+Z,G d'd( d(e j+Z-e-Z.dS ))z.Selector and proactor event loops for Windows. N )events)base_subprocess)futures)
exceptions)proactor_events)selector_events)tasks)
windows_utils)logger)SelectorEventLoopProactorEventLoop IocpProactorDefaultEventLoopPolicy WindowsSelectorEventLoopPolicy WindowsProactorEventLoopPolicy i i gMbP?g?c s^ e Zd ZdZdd fdd
Z fddZdd Z fd
d Z fd d
Z fddZ Z
S )_OverlappedFuturezSubclass of Future which represents an overlapped operation.
Cancelling it will immediately cancel the overlapped operation.
Nloopc s& t j|d | jr | jd= || _d S Nr )super__init___source_traceback_ov)selfovr __class__ ;/opt/alt/python38/lib64/python3.8/asyncio/windows_events.pyr 1 s z_OverlappedFuture.__init__c sH t }| jd k rD| jjr dnd}|dd| d| jjdd |S )NpendingZ completedr z overlapped=)r
_repr_infor r" insertaddressr infostater r r! r% 7 s
z _OverlappedFuture._repr_infoc
C sr | j d krd S z| j W nJ tk
rf } z,d|| d}| jrJ| j|d< | j| W 5 d }~X Y nX d | _ d S )Nz&Cancelling an overlapped future failedmessage exceptionfuturesource_traceback)r cancelOSErrorr _loopcall_exception_handler)r exccontextr r r! _cancel_overlapped> s
z$_OverlappedFuture._cancel_overlappedc s | t S N)r6 r r0 r r r r! r0 N s z_OverlappedFuture.cancelc s t | | d S r7 )r
set_exceptionr6 r r- r r r! r9 R s z _OverlappedFuture.set_exceptionc s t | d | _d S r7 )r
set_resultr r resultr r r! r; V s z _OverlappedFuture.set_result) __name__
__module__ __qualname____doc__r r% r6 r0 r9 r;
__classcell__r r r r! r + s r c sn e Zd ZdZdd fdd
Zdd Z fdd Zd
d Zd d
Z fddZ fddZ
fddZ Z S )_BaseWaitHandleFuturez2Subclass of Future which represents a wait handle.Nr c s8 t j|d | jr | jd= || _|| _|| _d| _d S )Nr r T)r r r r _handle _wait_handle _registered)r r handle wait_handler r r r! r ^ s z _BaseWaitHandleFuture.__init__c C s t | jdt jkS Nr )_winapiZWaitForSingleObjectrD Z
WAIT_OBJECT_0r8 r r r! _polll s z_BaseWaitHandleFuture._pollc sd t }|d| jd | jd k rB| r4dnd}|| | jd k r`|d| jd |S )Nzhandle=r# ZsignaledZwaitingz wait_handle=)r r% appendrD rK rE r( r r r! r% q s
z _BaseWaitHandleFuture._repr_infoc C s
d | _ d S r7 )r r futr r r! _unregister_wait_cb{ s z)_BaseWaitHandleFuture._unregister_wait_cbc
C s | j s
d S d| _ | j}d | _zt| W n` tk
r } zB|jtjkrzd|| d}| jrd| j|d< | j | W Y d S W 5 d }~X Y nX |
d d S NFz$Failed to unregister the wait handler+ r/ ) rF rE _overlappedZUnregisterWaitr1 winerrorERROR_IO_PENDINGr r2 r3 rO r rH r4 r5 r r r! _unregister_wait s$
z&_BaseWaitHandleFuture._unregister_waitc s | t S r7 )rU r r0 r8 r r r! r0 s z _BaseWaitHandleFuture.cancelc s | t | d S r7 )rU r r9 r: r r r! r9 s z#_BaseWaitHandleFuture.set_exceptionc s | t | d S r7 )rU r r; r< r r r! r; s z _BaseWaitHandleFuture.set_result)
r> r? r@ rA r rK r% rO rU r0 r9 r; rB r r r r! rC [ s
rC c sF e Zd ZdZdd fdd
Zdd Z fdd Z fd
d Z ZS ) _WaitCancelFuturezoSubclass of Future which represents a wait for the cancellation of a
_WaitHandleFuture using an event.
Nr c s t j||||d d | _d S )Nr )r r _done_callback)r r eventrH r r r r! r s z_WaitCancelFuture.__init__c C s t dd S )Nz'_WaitCancelFuture must not be cancelled) RuntimeErrorr8 r r r! r0 s z_WaitCancelFuture.cancelc s$ t | | jd k r | | d S r7 )r r; rW r< r r r! r; s
z _WaitCancelFuture.set_resultc s$ t | | jd k r | | d S r7 )r r9 rW r: r r r! r9 s
z _WaitCancelFuture.set_exception) r> r? r@ rA r r0 r; r9 rB r r r r! rV s
rV c s6 e Zd Zdd fdd
Z fddZdd Z ZS ) _WaitHandleFutureNr c s< t j||||d || _d| _td ddd | _d | _d S )Nr TF)r r _proactorZ_unregister_proactorrQ Z CreateEvent_event
_event_fut)r r rG rH proactorr r r r! r s
z_WaitHandleFuture.__init__c sF | j d k r"t| j d | _ d | _| j| j d | _t | d S r7 ) r\ rJ CloseHandler] r[ _unregisterr r rO rM r r r! rO s
z%_WaitHandleFuture._unregister_wait_cbc
C s | j s
d S d| _ | j}d | _zt|| j W n` tk
r } zB|jtjkr~d|| d}| jrh| j|d< | j
| W Y d S W 5 d }~X Y nX | j | j| j
| _d S rP )rF rE rQ ZUnregisterWaitExr\ r1 rR rS r r2 r3 r[ _wait_cancelrO r] rT r r r! rU s(
z"_WaitHandleFuture._unregister_wait)r> r? r@ r rO rU rB r r r r! rZ s rZ c @ s< e Zd ZdZdd Zdd Zdd Zdd Zd
d ZeZ d S )
PipeServerzXClass representing a pipe server.
This is much like a bound, listening socket.
c C s, || _ t | _d | _d | _| d| _d S NT)_addressweakrefWeakSet_free_instances_pipe_accept_pipe_future_server_pipe_handle)r r' r r r! r s
zPipeServer.__init__c C s | j | d }| _ |S )NF)rh rj )r tmpr r r! _get_unconnected_pipe s z PipeServer._get_unconnected_pipec
C sr | r d S tjtjB }|r&|tjO }t| j|tjtjB tj B tj
t j t j tj
tj}t |}| j| |S r7 )closedrJ ZPIPE_ACCESS_DUPLEXZFILE_FLAG_OVERLAPPEDZ FILE_FLAG_FIRST_PIPE_INSTANCEZCreateNamedPiperd ZPIPE_TYPE_MESSAGEZPIPE_READMODE_MESSAGEZ PIPE_WAITZPIPE_UNLIMITED_INSTANCESr
ZBUFSIZEZNMPWAIT_WAIT_FOREVERNULL
PipeHandlerg add)r firstflagshpiper r r! rj s(
z PipeServer._server_pipe_handlec C s
| j d kS r7 )rd r8 r r r! rm s zPipeServer.closedc C sR | j d k r| j d | _ | jd k rN| jD ] }| q*d | _d | _| j d S r7 )ri r0 rd rg closerh clear)r rt r r r! ru s
zPipeServer.closeN)
r> r? r@ rA r rl rj rm ru __del__r r r r! rb s
rb c @ s e Zd ZdZdS )_WindowsSelectorEventLoopz'Windows version of selector event loop.N)r> r? r@ rA r r r r! rx , s rx c sH e Zd ZdZd
fdd Z fddZdd Zd d
Zdd d Z Z S )r
z2Windows version of proactor event loop using IOCP.Nc s |d krt }t | d S r7 )r r r )r r^ r r r! r 3 s zProactorEventLoop.__init__c sl z(| j d kst| | j t
W 5 | j d k rf| j j}| j |d k r`|js`| j| d | _ X d S r7 ) Z_self_reading_futurer r0 r" r[ r` AssertionError call_soonZ_loop_self_readingr run_foreverr r r r r! r{ 8 s
z ProactorEventLoop.run_foreverc s8 | j |}|I d H }| }| j||d|id}||fS )Naddrextra)r[ connect_pipe_make_duplex_pipe_transport)r protocol_factoryr' frt protocoltransr r r! create_pipe_connectionK s
z(ProactorEventLoop.create_pipe_connectionc s. t d fdd gS )Nc
s d }zn| rN| }j| r4| W d S }j||d id }|d krdW d S j|} W n t k
r } zF|r|
dkr d||d | nj rt
jd|dd W 5 d }~X Y n2 tjk
r |r| Y nX | _| d S ) Nr} r~ r zPipe accept failed)r, r- rt z Accept pipe failed on pipe %rT)exc_info)r= rg discardrm ru r rl r[ accept_piper1 filenor3 Z_debugr Zwarningr CancelledErrorri add_done_callback)r rt r r4 r' loop_accept_piper r Zserverr r! r V sH
z>ProactorEventLoop.start_serving_pipe..loop_accept_pipe)N)rb rz )r r r' r r r! start_serving_pipeS s (
z$ProactorEventLoop.start_serving_pipec s | }
t| |||||||f|
|d| } z|
I d H W nD ttfk
rT Y n, tk
r~ | | I d H Y nX | S )N)waiterr )
create_future_WindowsSubprocessTransport
SystemExitKeyboardInterrupt
BaseExceptionru Z_wait) r r argsshellstdinstdoutstderrbufsizer kwargsr Ztranspr r r! _make_subprocess_transport s*
z,ProactorEventLoop._make_subprocess_transport)N)N)
r> r? r@ rA r r{ r r r rB r r r r! r
0 s 0 r
c @ s e Zd ZdZd;ddZdd Zdd Zd d
ZdddZ d?ddZ d@ddZ
dAddZdd Zd d Zd d Zd!d" Zd#d$ ZdBd%d&Zd'd( Zd)d* Zd+d, Zd-d. Zd/d0 Zd1d2 ZdCd3d4Zd5d6 Z d7d8 Z d9d: Z d S )Dr z#Proactor implementation using IOCP.r c C sD d | _ g | _ttjtd|| _i | _t | _
g | _ t | _ d S rI )
r2 _resultsrQ CreateIoCompletionPortINVALID_HANDLE_VALUErn _iocp_cachere rf rF
_unregistered_stopped_serving)r Z concurrencyr r r! r s
zIocpProactor.__init__c C s | j d krtdd S )NzIocpProactor is closed)r rY r8 r r r!
_check_closed s
zIocpProactor._check_closedc C sF dt | j dt | j g}| jd kr0|d d| jjd|f S )Nzoverlapped#=%sz
result#=%srm z<%s %s> )lenr r r rL r r> join)r r) r r r! __repr__ s
zIocpProactor.__repr__c C s
|| _ d S r7 )r2 )r r r r r! set_loop s zIocpProactor.set_loopNc C s | j s| | | j }g | _ |S r7 )r rK )r timeoutrk r r r! select s
zIocpProactor.selectc C s | j }|| |S r7 )r2 r r; )r valuerN r r r! _result s
zIocpProactor._resultr c C s~ | | tt}z4t|tjr6|| || n|| | W n t k
rf |
d Y S X dd }| |||S )N c
S sR z
| W S tk
rL } z$|jtjtjfkr:t|j n W 5 d }~X Y nX d S r7 getresultr1 rR rQ ZERROR_NETNAME_DELETEDZERROR_OPERATION_ABORTEDConnectionResetErrorr r keyr r4 r r r! finish_recv s
z&IocpProactor.recv..finish_recv) _register_with_iocprQ
Overlappedrn
isinstancesocketZWSARecvr ZReadFileBrokenPipeErrorr _registerr connnbytesrr r r r r r! recv s
zIocpProactor.recvc C s~ | | tt}z4t|tjr6|| || n|| | W n t k
rf |
d Y S X dd }| |||S )Nr c
S sR z
| W S tk
rL } z$|jtjtjfkr:t|j n W 5 d }~X Y nX d S r7 r r r r r! r s
z+IocpProactor.recv_into..finish_recv) r rQ r rn r r Z WSARecvIntor Z ReadFileIntor r r )r r bufrr r r r r r! recv_into s
zIocpProactor.recv_intoc C s` | | tt}z|| || W n tk
rH | d Y S X dd }| |||S )N)r Nc
S sR z
| W S tk
rL } z$|jtjtjfkr:t|j n W 5 d }~X Y nX d S r7 r r r r r! r s
z*IocpProactor.recvfrom..finish_recv) r rQ r rn Z WSARecvFromr r r r r r r r! recvfrom s
zIocpProactor.recvfromc C s> | | tt}|| ||| dd }| |||S )Nc
S sR z
| W S tk
rL } z$|jtjtjfkr:t|j n W 5 d }~X Y nX d S r7 r r r r r! finish_send s
z(IocpProactor.sendto..finish_send)r rQ r rn Z WSASendTor r )r r r rr r} r r r r r! sendto s
zIocpProactor.sendtoc C sZ | | tt}t|tjr4|| || n|| | dd }| |||S )Nc
S sR z
| W S tk
rL } z$|jtjtjfkr:t|j n W 5 d }~X Y nX d S r7 r r r r r! r s
z&IocpProactor.send..finish_send)
r rQ r rn r r ZWSASendr Z WriteFiler )r r r rr r r r r r! send s
zIocpProactor.sendc sv | | j tt}| fdd}dd }| ||}|| }t j
|| j d |S )Nc sD | td } tjtj|
fS )Nz@P) r structZpackr
setsockoptr
SOL_SOCKETrQ ZSO_UPDATE_ACCEPT_CONTEXT
settimeoutZ
gettimeoutZ getpeername)r r r r r listenerr r!
finish_accept* s z*IocpProactor.accept..finish_acceptc s4 z| I d H W n t jk
r. | Y nX d S r7 )r r ru )r. r r r r! accept_coro3 s
z(IocpProactor.accept..accept_coror ) r _get_accept_socketfamilyrQ r rn ZAcceptExr r r Z
ensure_futurer2 )r r r r r r. coror r r! accept$ s
zIocpProactor.acceptc
s j tjkr4t | | j }|d |S | zt
j W nB t k
r } z$|j
tjkrt d dkr W 5 d }~X Y nX tt}| | fdd}| | |S )Nr r c s | tjtjd S rI )r r r r rQ ZSO_UPDATE_CONNECT_CONTEXTr r r r r r! finish_connectV s z,IocpProactor.connect..finish_connect)typer Z
SOCK_DGRAMrQ Z
WSAConnectr r2 r r; r Z BindLocalr r1 rR errnoZ WSAEINVALZ getsocknamer rn Z ConnectExr )r r r' rN er r r r r! connect@ s"
zIocpProactor.connectc C sb | | tt}|d@ }|d? d@ }|| t| |||dd dd }| |||S )Nr r c
S sR z
| W S tk
rL } z$|jtjtjfkr:t|j n W 5 d }~X Y nX d S r7 r r r r r! finish_sendfilei s
z.IocpProactor.sendfile..finish_sendfile) r rQ r rn Z TransmitFiler msvcrtZ
get_osfhandler ) r Zsockfileoffsetcountr Z
offset_lowZ offset_highr r r r! sendfile_ s
zIocpProactor.sendfilec sJ | tt}| }|r0| S fdd}| | |S )Nc s | S r7 )r r rt r r! finish_accept_pipe s z4IocpProactor.accept_pipe..finish_accept_pipe)r rQ r rn ZConnectNamedPiper r r )r rt r Z connectedr r r r! r t s
zIocpProactor.accept_pipec
sr t }zt|}W qhW n0 tk
rF } z|jtjkr6 W 5 d }~X Y nX t|d t}t |I d H qt
|S )N ) CONNECT_PIPE_INIT_DELAYrQ Z ConnectPiper1 rR ZERROR_PIPE_BUSYminCONNECT_PIPE_MAX_DELAYr sleepr
ro )r r' ZdelayrG r4 r r r! r s
zIocpProactor.connect_pipec C s | ||dS )zWait for a handle.
Return a Future object. The result of the future is True if the wait
completed, or False if the wait did not complete (on timeout).
F)_wait_for_handle)r rG r r r r! wait_for_handle s z IocpProactor.wait_for_handlec C s | |d d}||_|S rc )r rW )r rX Z
done_callbackrN r r r! ra s zIocpProactor._wait_cancelc s | |d krtj}nt|d }tt}t|| j |j
|}|r\t |||| j d nt
|||| | j d jr~ jd= fdd} |d|f| j|j
< S )N @@r r c s S r7 )rK r r r r! finish_wait_for_handle s z=IocpProactor._wait_for_handle..finish_wait_for_handler )r rJ INFINITEmathceilrQ r rn ZRegisterWaitWithQueuer r' rV r2 rZ r r )r rG r Z
_is_cancelmsr rH r r r r! r s*
z IocpProactor._wait_for_handlec C s0 || j kr,| j | t| | jdd d S rI )rF rp rQ r r r r objr r r! r s
z IocpProactor._register_with_iocpc
C s | t|| jd}|jr$|jd= |jsrz|d d |}W n, tk
rf } z|| W 5 d }~X Y n X || ||||f| j|j < |S r )
r r r2 r r" r1 r9 r; r r' )r r r callbackr r r r r r! r s
zIocpProactor._registerc C s | | j| dS )a
Unregister an overlapped object.
Call this method when its future has been cancelled. The event can
already be signalled (pending in the proactor event queue). It is also
safe if the event is never signalled (because it was cancelled).
N)r r rL r| r r r! r` s zIocpProactor._unregisterc C s t |}|d |S rI )r r )r r sr r r! r s
z IocpProactor._get_accept_socketc C s |d krt }n0|dk r tdn t|d }|t kr>tdt| j|}|d krXqZd}|\}}}}z| j|\}} }
} W nX t k
r | j
r| j
dd||||f d |dtj
fkrt| Y q>Y nX |
| jkr| q>| s>z| ||| } W n: tk
r@ }
z||
| j| W 5 d }
~
X Y q>X || | j| q>| jD ]} | j| jd q`| j d S )Nr znegative timeoutr ztimeout too bigz8GetQueuedCompletionStatus() returned an unexpected eventz)err=%s transferred=%s key=%#x address=%#x)r, status)r
ValueErrorr r rQ ZGetQueuedCompletionStatusr r popKeyErrorr2 Z get_debugr3 r rJ r_ r r0 Zdoner1 r9 r rL r; r r' rv )r r r r errZ transferredr r' r r r r r r r r r! rK sL
zIocpProactor._pollc C s | j | d S r7 )r rp r r r r!
_stop_serving9 s zIocpProactor._stop_servingc C s | j d krd S t| j D ]\}\}}}}| r6q t|trBq z | W q tk
r } z6| j d k rd||d}|j
r|j
|d< | j | W 5 d }~X Y q X q d}t
} | | }
| jr|
t
krtd| t
| t
| }
| | qg | _t| j d | _ d S )NzCancelling a future failedr+ r/ g ?z,%r is running after closing for %.1f seconds)r listr itemsZ cancelledr rV r0 r1 r2 r r3 time monotonicr debugrK r rJ r_ ) r r' rN r r r r4 r5 Z
msg_updateZ
start_timeZnext_msgr r r! ru ? s@
zIocpProactor.closec C s | d S r7 )ru r8 r r r! rw n s zIocpProactor.__del__)r )N)r )r )r )r N)r )N)N) r> r? r@ rA r r r r r r r r r r r r r r r r r ra r r r r` r rK r ru rw r r r r! r s8
"
7/r c @ s e Zd Zdd ZdS )r c
sP t j|f|||||d| _ fdd} jjt jj} | | d S )N)r r r r r c s j } | d S r7 )_procZpollZ_process_exited)r
returncoder8 r r! r y s
z4_WindowsSubprocessTransport._start..callback) r
Popenr r2 r[ r intrD r )
r r r r r r r r r r r r8 r! _startt s z"_WindowsSubprocessTransport._startN)r> r? r@ r r r r r! r r s r c @ s e Zd ZeZdS )r N)r> r? r@ r
_loop_factoryr r r r! r s r c @ s e Zd ZeZdS )r N)r> r? r@ r
r r r r r! r s r )/rA rQ rJ r r r r r r re r r r r r r r r
logr __all__rn r ZERROR_CONNECTION_REFUSEDZERROR_CONNECTION_ABORTEDr r ZFuturer rC rV rZ objectrb ZBaseSelectorEventLooprx ZBaseProactorEventLoopr
r ZBaseSubprocessTransportr r ZBaseDefaultEventLoopPolicyr r r r r r r! sR 0J4;e `PK ! - + __pycache__/transports.cpython-38.opt-2.pycnu [ U
if( @ sx d Z G dd dZG dd deZG dd deZG dd deeZG d d
d
eZG d d d eZG d
d deZdS ))
BaseTransport
ReadTransportWriteTransport TransportDatagramTransportSubprocessTransportc @ sD e Zd ZdZdddZdddZdd Zd d
Zd d Zd
d Z dS )r _extraNc C s |d kr i }|| _ d S Nr )selfextra r 7/opt/alt/python38/lib64/python3.8/asyncio/transports.py__init__ s zBaseTransport.__init__c C s | j ||S r )r get)r
namedefaultr r r
get_extra_info s z BaseTransport.get_extra_infoc C s t d S r NotImplementedErrorr
r r r
is_closing s zBaseTransport.is_closingc C s t d S r r r r r r
close s zBaseTransport.closec C s t d S r r )r
protocolr r r
set_protocol% s zBaseTransport.set_protocolc C s t d S r r r r r r
get_protocol) s zBaseTransport.get_protocol)N)N)
__name__
__module__ __qualname__ __slots__r r r r r r r r r r
r s
r c @ s( e Zd ZdZdd Zdd Zdd ZdS ) r r c C s t d S r r r r r r
is_reading3 s zReadTransport.is_readingc C s t d S r r r r r r
pause_reading7 s zReadTransport.pause_readingc C s t d S r r r r r r
resume_reading? s z ReadTransport.resume_readingN)r r r r r r r! r r r r
r . s r c @ sJ e Zd ZdZdddZdd Zdd Zd d
Zd d Zd
d Z dd Z
dS )r r Nc C s t d S r r r
highlowr r r
set_write_buffer_limitsM s z&WriteTransport.set_write_buffer_limitsc C s t d S r r r r r r
get_write_buffer_sizeb s z$WriteTransport.get_write_buffer_sizec C s t d S r r )r
datar r r
writef s zWriteTransport.writec C s d |}| | d S )N )joinr( )r
Z list_of_datar' r r r
writelinesn s
zWriteTransport.writelinesc C s t d S r r r r r r
write_eofw s zWriteTransport.write_eofc C s t d S r r r r r r
can_write_eof s z WriteTransport.can_write_eofc C s t d S r r r r r r
abort s zWriteTransport.abort)NN) r r r r r% r& r( r+ r, r- r. r r r r
r H s
r c @ s e Zd ZdZdS )r r N)r r r r r r r r
r s r c @ s" e Zd ZdZdddZdd ZdS )r r Nc C s t d S r r )r
r' Zaddrr r r
sendto s zDatagramTransport.sendtoc C s t d S r r r r r r
r. s zDatagramTransport.abort)N)r r r r r/ r. r r r r
r s
r c @ s@ e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dS )r r c C s t d S r r r r r r
get_pid s zSubprocessTransport.get_pidc C s t d S r r r r r r
get_returncode s z"SubprocessTransport.get_returncodec C s t d S r r )r
fdr r r
get_pipe_transport s z&SubprocessTransport.get_pipe_transportc C s t d S r r )r
signalr r r
send_signal s z SubprocessTransport.send_signalc C s t d S r r r r r r
terminate s z SubprocessTransport.terminatec C s t d S r r r r r r
kill s zSubprocessTransport.killN)
r r r r r0 r1 r3 r5 r6 r7 r r r r
r s r c sV e Zd ZdZd fdd Zdd Zdd Zd d
Zdd d Zdd
dZ dd Z
Z S )_FlowControlMixin)_loop_protocol_paused _high_water
_low_waterNc s$ t | || _d| _| d S )NF)superr r9 r: _set_write_buffer_limits)r
r Zloop __class__r r
r s z_FlowControlMixin.__init__c
C s | }|| jkrd S | jsd| _z| j W nR ttfk
rJ Y n: tk
r } z | j d|| | jd W 5 d }~X Y nX d S )NTz protocol.pause_writing() failedmessageZ exceptionZ transportr )
r& r; r: _protocolZ
pause_writing
SystemExitKeyboardInterrupt
BaseExceptionr9 call_exception_handler)r
sizeexcr r r
_maybe_pause_protocol s
z'_FlowControlMixin._maybe_pause_protocolc
C s | j r|| | jkr|d| _ z| j W nR ttfk
rB Y n: tk
rz } z | j d|| | jd W 5 d }~X Y nX d S )NFz protocol.resume_writing() failedrA )
r: r& r< rC Zresume_writingrD rE rF r9 rG )r
rI r r r
_maybe_resume_protocol! s z(_FlowControlMixin._maybe_resume_protocolc C s | j | jfS r )r< r; r r r r
get_write_buffer_limits1 s z)_FlowControlMixin.get_write_buffer_limitsc C sj |d kr |d krd}nd| }|d kr.|d }|| krBdksZn t d|d|d|| _|| _d S )Ni zhigh (z) must be >= low (z) must be >= 0)
ValueErrorr; r< r" r r r
r> 4 s z*_FlowControlMixin._set_write_buffer_limitsc C s | j ||d | d S )N)r# r$ )r> rJ r" r r r
r% D s z)_FlowControlMixin.set_write_buffer_limitsc C s t d S r r r r r r
r& H s z'_FlowControlMixin.get_write_buffer_size)NN)NN)NN) r r r r r rJ rK rL r> r% r&
__classcell__r r r? r
r8 s
r8 N)__all__r r r r r r r8 r r r r
s %F6PK ! Zy y # __pycache__/__main__.cpython-38.pycnu [ U
if3
@ sX d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl Z ddl
m Z G dd dej Z
G dd dejZedkrTed e Zee d
eiZd D ]Ze e ee< qe
eeZdad az d dlZW n e k
r Y nX e Z d
e _ e z e W n8 e!k
rJ tr@t" s@t# d
aY qY nX qTqdS ) N )futuresc s$ e Zd Z fddZdd Z ZS )AsyncIOInteractiveConsolec s* t | | jj jtjO _|| _d S )N)super__init__compileZcompilerflagsastZPyCF_ALLOW_TOP_LEVEL_AWAITloop)selflocalsr
__class__ 5/opt/alt/python38/lib64/python3.8/asyncio/__main__.pyr s z"AsyncIOInteractiveConsole.__init__c st t j fdd}t| z
W S tk
rD Y n, tk
rn trb d n
Y nX d S )Nc
s d a dat j} z
| }W nz tk
r6 Y nf tk
rj } zda| W Y d S d }~X Y n2 tk
r } z| W Y d S d }~X Y nX t
|s | d S z j
|a tt W n. tk
r } z| W 5 d }~X Y nX d S )NFT) repl_futurerepl_future_interruptedtypes FunctionTyper
SystemExitKeyboardInterruptZ
set_exception
BaseExceptioninspectZ iscoroutineZ
set_resultr
Z create_taskr Z
_chain_future)funccoroZexexccodeZfuturer r r callback s,
z3AsyncIOInteractiveConsole.runcode..callbackz
KeyboardInterrupt
)
concurrentr ZFuturer
call_soon_threadsaferesultr r r writeZ
showtraceback)r r r r r r runcode s
z!AsyncIOInteractiveConsole.runcode)__name__
__module__ __qualname__r r#
__classcell__r r r
r r s r c @ s e Zd Zdd ZdS )
REPLThreadc C sZ z6dtj dtj dt tdd d }t
j |d
d W 5 t jddtd ttj X d S ) Nignorez ^coroutine .* was never awaited$)messagecategoryz
asyncio REPL z on zy
Use "await" directly instead of "asyncio.run()".
Type "help", "copyright", "credits" or "license" for more information.
Zps1z>>> zimport asynciozexiting asyncio REPL...)bannerZexitmsg) warningsfilterwarningsRuntimeWarningr
r stopsysversionplatformgetattrconsoleZinteract)r r, r r r runF s "
zREPLThread.runN)r$ r% r& r6 r r r r r( D s r( __main__zcpython.run_stdinasyncio> r$ __file__ __package__ __builtins__
__loader____spec__FT)$r r8 r Zconcurrent.futuresr r r1 Z threadingr r- r ZInteractiveConsoler ZThreadr( r$ auditZnew_event_loopr
Zset_event_loopZ repl_localskeyr r5 r r readline ImportErrorZ repl_threadZdaemonstartZ run_foreverr ZdoneZcancelr r r r sH 6
PK ! 2 2 ' __pycache__/trsock.cpython-38.opt-2.pycnu [ U
if @ s" d dl Z d dlZG dd dZdS ) Nc @ s e Zd ZdZejdddZdd Zedd Zed d
Z ed d Z
d
d Z dd Z dd Z
dd Zdd Zdd Zdd Zdd Zd d Zd d Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Zd+d, Zd-d. Zd/d0 Z d1d2 Z d3d4 Z d5d6 Z d7d8 Z d9d: Z!d;d< Z"d=d> Z#d?d@ Z$dAdB Z%dCdD Z&dEdF Z'dGdH Z(dIdJ Z)dKdL Z*dMdN Z+dOdP Z,dQdR Z-dSdT Z.dUdV Z/dWdX Z0dYdZ Z1d[S )\TransportSocket_sock)sockc C s
|| _ d S Nr )selfr r 3/opt/alt/python38/lib64/python3.8/asyncio/trsock.py__init__ s zTransportSocket.__init__c C s t jd| dt| d d S )NzUsing z on sockets returned from get_extra_info('socket') will be prohibited in asyncio 3.9. Please report your use case to bugs.python.org.)source)warningswarnDeprecationWarning)r Zwhatr r r _na s
zTransportSocket._nac C s | j jS r )r familyr r r r r s zTransportSocket.familyc C s | j jS r )r typer r r r r s zTransportSocket.typec C s | j jS r )r protor r r r r " s zTransportSocket.protoc C s d| d| jd| jd| j }| dkrz | }|rN| d| }W n tjk
rf Y nX z | }|r| d| }W n tjk
r Y nX | dS ) Nz )filenor r r getsocknamesocketerror getpeername)r sZladdrZraddrr r r __repr__& s $ zTransportSocket.__repr__c C s t dd S )Nz/Cannot serialize asyncio.TransportSocket object) TypeErrorr r r r __getstate__= s z TransportSocket.__getstate__c C s
| j S r )r r r r r r r @ s zTransportSocket.filenoc C s
| j S r )r dupr r r r r C s zTransportSocket.dupc C s
| j S r )r get_inheritabler r r r r F s z TransportSocket.get_inheritablec C s | j | d S r )r shutdown)r Zhowr r r r! I s zTransportSocket.shutdownc O s | j j||S r )r
getsockoptr argskwargsr r r r" N s zTransportSocket.getsockoptc O s | j j|| d S r )r
setsockoptr# r r r r& Q s zTransportSocket.setsockoptc C s
| j S r )r r r r r r r T s zTransportSocket.getpeernamec C s
| j S r )r r r r r r r W s zTransportSocket.getsocknamec C s
| j S r )r
getsockbynamer r r r r' Z s z TransportSocket.getsockbynamec C s | d | j S )Nzaccept() method)r r acceptr r r r r( ] s
zTransportSocket.acceptc O s | d | jj||S )Nzconnect() method)r r connectr# r r r r) a s
zTransportSocket.connectc O s | d | jj||S )Nzconnect_ex() method)r r
connect_exr# r r r r* e s
zTransportSocket.connect_exc O s | d | jj||S )Nz
bind() method)r r bindr# r r r r+ i s
zTransportSocket.bindc O s | d | jj||S )Nzioctl() method)r r ioctlr# r r r r, m s
zTransportSocket.ioctlc O s | d | jj||S )Nzlisten() method)r r listenr# r r r r- q s
zTransportSocket.listenc C s | d | j S )Nzmakefile() method)r r makefiler r r r r. u s
zTransportSocket.makefilec O s | d | jj||S )Nzsendfile() method)r r sendfiler# r r r r/ y s
zTransportSocket.sendfilec C s | d | j S )Nzclose() method)r r closer r r r r0 } s
zTransportSocket.closec C s | d | j S )Nzdetach() method)r r detachr r r r r1 s
zTransportSocket.detachc O s | d | jj||S )Nzsendmsg_afalg() method)r r
sendmsg_afalgr# r r r r2 s
z TransportSocket.sendmsg_afalgc O s | d | jj||S )Nzsendmsg() method)r r sendmsgr# r r r r3 s
zTransportSocket.sendmsgc O s | d | jj||S )Nzsendto() method)r r sendtor# r r r r4 s
zTransportSocket.sendtoc O s | d | jj||S )Nz
send() method)r r sendr# r r r r5 s
zTransportSocket.sendc O s | d | jj||S )Nzsendall() method)r r sendallr# r r r r6 s
zTransportSocket.sendallc O s | d | jj||S )Nzset_inheritable() method)r r set_inheritabler# r r r r7 s
z TransportSocket.set_inheritablec C s | d | j|S )Nzshare() method)r r share)r Z
process_idr r r r8 s
zTransportSocket.sharec O s | d | jj||S )Nzrecv_into() method)r r recv_intor# r r r r9 s
zTransportSocket.recv_intoc O s | d | jj||S )Nzrecvfrom_into() method)r r
recvfrom_intor# r r r r: s
z TransportSocket.recvfrom_intoc O s | d | jj||S )Nzrecvmsg_into() method)r r recvmsg_intor# r r r r; s
z TransportSocket.recvmsg_intoc O s | d | jj||S )Nzrecvmsg() method)r r recvmsgr# r r r r< s
zTransportSocket.recvmsgc O s | d | jj||S )Nzrecvfrom() method)r r recvfromr# r r r r= s
zTransportSocket.recvfromc O s | d | jj||S )Nz
recv() method)r r recvr# r r r r> s
zTransportSocket.recvc C s |dkr d S t dd S )Nr z rB rC rE rG rH r r r r r s`
r )r r r r r r r s PK ! f
Vq ( __pycache__/windows_utils.cpython-38.pycnu [ U
if @ s d Z ddlZejdkr edddlZddlZddlZddlZddlZddl Z ddl
Z
dZ dZ ej
Z
ejZe Zdde d d
d ZG d d
d
ZG dd dejZdS )z)Various Windows specific bits and pieces. NZwin32z
win32 only)pipePopenPIPE
PipeHandlei F)TT)duplex
overlappedbufsizec
C s$ t jdt ttd}| r>tj}tj tj
B }|| }}ntj }tj
}d| }}|tj O }|d rp|tj
O }|d rtj
}nd}d } }
z\t||tjd||tjtj} t||dtjtj|tj}
tj| dd} | d | |
fW S | dk rt| |
dk rt|
Y nX dS )zELike os.pipe() but with overlapped support and using handles not fds.z \\.\pipe\python-pipe-{:d}-{:d}-)prefixr NTr )tempfileZmktempformatosgetpidnext
_mmap_counter_winapiZPIPE_ACCESS_DUPLEXZ GENERIC_READZ
GENERIC_WRITEZPIPE_ACCESS_INBOUNDZ FILE_FLAG_FIRST_PIPE_INSTANCEZFILE_FLAG_OVERLAPPEDZCreateNamedPipeZ PIPE_WAITZNMPWAIT_WAIT_FOREVERZNULLZ
CreateFileZ
OPEN_EXISTINGZConnectNamedPipeZGetOverlappedResult CloseHandle) r r r ZaddressZopenmodeaccessZobsizeZibsizeZflags_and_attribsZh1Zh2Zov r :/opt/alt/python38/lib64/python3.8/asyncio/windows_utils.pyr sb
r c @ sb e Zd ZdZdd Zdd Zedd Zdd Ze j
d
d d Z e j
fd
dZdd Zdd ZdS )r zWrapper for an overlapped pipe handle which is vaguely file-object like.
The IOCP event loop can use these instead of socket objects.
c C s
|| _ d S N_handleselfhandler r r __init__V s zPipeHandle.__init__c C s2 | j d k rd| j }nd}d| jj d| dS )Nzhandle=closed< >)r __class____name__r r r r __repr__Y s
zPipeHandle.__repr__c C s | j S r r r r r r r ` s zPipeHandle.handlec C s | j d krtd| j S )Nz I/O operation on closed pipe)r
ValueErrorr% r r r filenod s
zPipeHandle.fileno)r c C s | j d k r|| j d | _ d S r r )r r r r r closei s
zPipeHandle.closec C s* | j d k r&|d| t| d | d S )Nz unclosed )source)r ResourceWarningr( )r Z_warnr r r __del__n s
zPipeHandle.__del__c C s | S r r r% r r r __enter__s s zPipeHandle.__enter__c C s | d S r )r( )r tvtbr r r __exit__v s zPipeHandle.__exit__N)r#
__module__ __qualname____doc__r r$ propertyr r' r r r( warningswarnr+ r, r0 r r r r r Q s
r c s" e Zd ZdZd fdd Z ZS )r zReplacement for subprocess.Popen using overlapped pipe handles.
The stdin, stdout, stderr are None or instances of PipeHandle.
Nc s | drt| dddks"td } }}d } }
} |tkrbtddd\} } t| tj}n|}|tkrtdd\}
}
t|
d}n|}|tkrtdd\} }t|d}n|tkr|}n|}zz t
j |f|||d | W n0 | |
| fD ]}|d k rt
| q Y n>X | d k r,t| | _|
d k r@t|
| _| d k rTt| | _W 5 |tkrlt | |tkrt | |tkrt | X d S )
NZuniversal_newlinesr r )FTT)r r )TFr )stdinstdoutstderr)getAssertionErrorr r msvcrtZopen_osfhandler O_RDONLYSTDOUTr( superr r r r r7 r8 r9 )r argsr7 r8 r9 kwdsZ stdin_rfdZ
stdout_wfdZ
stderr_wfdZstdin_whZ stdout_rhZ stderr_rhZstdin_rhZ stdout_whZ stderr_whhr" r r r sR
zPopen.__init__)NNN)r# r1 r2 r3 r
__classcell__r r rC r r } s r )r3 sysplatform ImportErrorr itertoolsr< r
subprocessr r5 __all__ZBUFSIZEr r> countr r r r r r r r s$
1,PK ! b5? ? __pycache__/locks.cpython-38.pycnu [ U
if|C @ s d Z dZddlZddlZddlZddlmZ ddlmZ ddlmZ ddlm Z G d d
d
Z
G d d d Z G d
d de Z G dd dZ
G dd de ZG dd de ZG dd deZdS )zSynchronization primitives.)LockEvent Condition SemaphoreBoundedSemaphore N )events)futures)
exceptions)
coroutinesc @ s( e Zd ZdZdd Zdd Zdd ZdS ) _ContextManagera\ Context manager.
This enables the following idiom for acquiring and releasing a
lock around a block:
with (yield from lock):
while failing loudly when accidentally using:
with lock:
Deprecated, use 'async with' statement:
async with lock:
c C s
|| _ d S N)_lock)selflock r 2/opt/alt/python38/lib64/python3.8/asyncio/locks.py__init__" s z_ContextManager.__init__c C s d S r
r r r r r __enter__% s z_ContextManager.__enter__c G s z| j W 5 d | _ X d S r
)r releaser argsr r r __exit__* s z_ContextManager.__exit__N)__name__
__module__ __qualname____doc__r r r r r r r r s r c @ sR e Zd Zdd Zdd Zejdd Zej e_ dd Z
d d
Z d d Z d
d Z
dS )_ContextManagerMixinc C s t dd S )Nz9"yield from" should be used as context manager expression) RuntimeErrorr r r r r 2 s z _ContextManagerMixin.__enter__c G s d S r
r r r r r r 6 s z _ContextManagerMixin.__exit__c c s& t jdtdd | E d H t| S )NzD'with (yield from lock)' is deprecated use 'async with lock' instead
stacklevel)warningswarnDeprecationWarningacquirer r r r r __iter__; s z _ContextManagerMixin.__iter__c s | I d H t| S r
)r& r r r r r Z
__acquire_ctxU s z"_ContextManagerMixin.__acquire_ctxc C s t jdtdd | S )Nz='with await lock' is deprecated use 'async with lock' insteadr r! )r# r$ r% !_ContextManagerMixin__acquire_ctx __await__r r r r r) Y s
z _ContextManagerMixin.__await__c s | I d H d S r
)r& r r r r
__aenter__` s z _ContextManagerMixin.__aenter__c s | d S r
)r )r exc_typeexctbr r r __aexit__f s z _ContextManagerMixin.__aexit__N)r r r r r types coroutiner' r Z
_is_coroutiner( r) r* r. r r r r r 1 s
r c sN e Zd ZdZddddZ fddZdd Zd
d Zd d
Zdd Z Z
S )r a Primitive lock objects.
A primitive lock is a synchronization primitive that is not owned
by a particular coroutine when locked. A primitive lock is in one
of two states, 'locked' or 'unlocked'.
It is created in the unlocked state. It has two basic methods,
acquire() and release(). When the state is unlocked, acquire()
changes the state to locked and returns immediately. When the
state is locked, acquire() blocks until a call to release() in
another coroutine changes it to unlocked, then the acquire() call
resets it to locked and returns. The release() method should only
be called in the locked state; it changes the state to unlocked
and returns immediately. If an attempt is made to release an
unlocked lock, a RuntimeError will be raised.
When more than one coroutine is blocked in acquire() waiting for
the state to turn to unlocked, only one coroutine proceeds when a
release() call resets the state to unlocked; first coroutine which
is blocked in acquire() is being processed.
acquire() is a coroutine and should be called with 'await'.
Locks also support the asynchronous context management protocol.
'async with lock' statement should be used.
Usage:
lock = Lock()
...
await lock.acquire()
try:
...
finally:
lock.release()
Context manager usage:
lock = Lock()
...
async with lock:
...
Lock objects can be tested for locking state:
if not lock.locked():
await lock.acquire()
else:
# lock is acquired
...
Nloopc C s: d | _ d| _|d kr t | _n|| _tjdtdd d S NF[The loop argument is deprecated since Python 3.8, and scheduled for removal in Python 3.10.r r! )_waiters_lockedr get_event_loop_loopr# r$ r% r r2 r r r r s z
Lock.__init__c sL t }| jrdnd}| jr2| dt| j }d|dd d| dS NlockedZunlocked
, waiters:)super__repr__r6 r5 lenr resZextra __class__r r rB s
z
Lock.__repr__c C s | j S )z Return True if lock is acquired.)r6 r r r r r; s z Lock.lockedc s | j s.| jdks$tdd | jD r.d| _ dS | jdkrBt | _| j }| j| z"z|I dH W 5 | j| X W n& t j
k
r | j s| Y nX d| _ dS )zAcquire a lock.
This method blocks until the lock is unlocked, then sets it to
locked and returns True.
Nc s s | ]}| V qd S r
) cancelled).0wr r r s z Lock.acquire..T) r6 r5 all collectionsdequer8
create_futureappendremover
CancelledError_wake_up_firstr futr r r r& s&
z Lock.acquirec C s" | j rd| _ | ntddS )aG Release a lock.
When the lock is locked, reset it to unlocked, and return.
If any other coroutines are blocked waiting for the lock to become
unlocked, allow exactly one of them to proceed.
When invoked on an unlocked lock, a RuntimeError is raised.
There is no return value.
FzLock is not acquired.N)r6 rS r r r r r r s
z Lock.releasec C sJ | j s
dS ztt| j }W n tk
r2 Y dS X | sF|d dS )z*Wake up the first waiter if it isn't done.NT)r5 nextiter
StopIterationdone
set_resultrT r r r rS s zLock._wake_up_first) r r r r r rB r; r& r rS
__classcell__r r rF r r j s 5 r c sN e Zd ZdZddddZ fddZdd Zd
d Zd d
Zdd Z Z
S )r a# Asynchronous equivalent to threading.Event.
Class implementing event objects. An event manages a flag that can be set
to true with the set() method and reset to false with the clear() method.
The wait() method blocks until the flag is true. The flag is initially
false.
Nr1 c C s> t | _d| _|d kr$t | _n|| _tjdt dd d S r3 )
rM rN r5 _valuer r7 r8 r# r$ r% r9 r r r r s
zEvent.__init__c sL t }| jrdnd}| jr2| dt| j }d|dd d| dS ) NsetZunsetr< r= r r> r? r@ )rA rB r\ r5 rC rD rF r r rB s
zEvent.__repr__c C s | j S )z5Return True if and only if the internal flag is true.r\ r r r r is_set s z Event.is_setc C s. | j s*d| _ | jD ]}| s|d qdS )zSet the internal flag to true. All coroutines waiting for it to
become true are awakened. Coroutine that call wait() once the flag is
true will not block at all.
TN)r\ r5 rY rZ rT r r r r] s
z Event.setc C s
d| _ dS )zReset the internal flag to false. Subsequently, coroutines calling
wait() will block until set() is called to set the internal flag
to true again.FNr^ r r r r clear" s z Event.clearc sF | j r
dS | j }| j| z|I dH W dS | j| X dS )zBlock until the internal flag is true.
If the internal flag is true on entry, return True
immediately. Otherwise, block until another coroutine calls
set() to set the flag to true, then return True.
TN)r\ r8 rO r5 rP rQ rT r r r wait( s
z
Event.wait) r r r r r rB r_ r] r` ra r[ r r rF r r s r c sR e Zd ZdZdddddZ fddZdd Zd
d Zdd
dZdd Z Z
S )r a Asynchronous equivalent to threading.Condition.
This class implements condition variable objects. A condition variable
allows one or more coroutines to wait until they are notified by another
coroutine.
A new Lock object is created and used as the underlying lock.
Nr1 c C s~ |d krt | _n|| _tjdtdd |d kr>t|d}n|j| jk rRtd|| _|j | _ |j
| _
|j | _ t
| _d S )Nr4 r r! r1 z"loop argument must agree with lock)r r7 r8 r# r$ r% r
ValueErrorr r; r& r rM rN r5 )r r r2 r r r r E s zCondition.__init__c sN t }| rdnd}| jr4| dt| j }d|dd d| dS r: )rA rB r; r5 rC rD rF r r rB [ s
zCondition.__repr__c s | std| z@| j }| j | z|I dH W W dS | j
| X W 5 d}z| I dH W qW q^ tjk
r d}Y q^X q^|rtjX dS )a Wait until notified.
If the calling coroutine has not acquired the lock when this
method is called, a RuntimeError is raised.
This method releases the underlying lock, and then blocks
until it is awakened by a notify() or notify_all() call for
the same condition variable in another coroutine. Once
awakened, it re-acquires the lock and returns True.
z cannot wait on un-acquired lockFNT) r; r r r& r
rR r8 rO r5 rP rQ )r rH rU r r r ra b s$
zCondition.waitc s$ | }|s | I dH | }q|S )zWait until a predicate becomes true.
The predicate should be a callable which result will be
interpreted as a boolean value. The final predicate value is
the return value.
N)ra )r Z predicateresultr r r wait_for s
zCondition.wait_forr c C sJ | stdd}| jD ]*}||kr* qF| s|d7 }|d qdS )a By default, wake up one coroutine waiting on this condition, if any.
If the calling coroutine has not acquired the lock when this method
is called, a RuntimeError is raised.
This method wakes up at most n of the coroutines waiting for the
condition variable; it is a no-op if no coroutines are waiting.
Note: an awakened coroutine does not actually return from its
wait() call until it can reacquire the lock. Since notify() does
not release the lock, its caller should.
z!cannot notify on un-acquired lockr r FN)r; r r5 rY rZ )r nidxrU r r r notify s
zCondition.notifyc C s | t| j dS )a Wake up all threads waiting on this condition. This method acts
like notify(), but wakes up all waiting threads instead of one. If the
calling thread has not acquired the lock when this method is called,
a RuntimeError is raised.
N)rg rC r5 r r r r
notify_all s zCondition.notify_all)N)r ) r r r r r rB ra rd rg rh r[ r r rF r r ; s %
r c sP e Zd ZdZdddddZ fddZd d
Zd d Zd
d Zdd Z Z
S )r a A Semaphore implementation.
A semaphore manages an internal counter which is decremented by each
acquire() call and incremented by each release() call. The counter
can never go below zero; when acquire() finds that it is zero, it blocks,
waiting until some other thread calls release().
Semaphores also support the context management protocol.
The optional argument gives the initial value for the internal
counter; it defaults to 1. If the value given is less than 0,
ValueError is raised.
r Nr1 c C sN |dk rt d|| _t | _|d kr4t | _n|| _tj dt
dd d S )Nr z$Semaphore initial value must be >= 0r4 r r! ) rb r\ rM rN r5 r r7 r8 r# r$ r% r valuer2 r r r r s
zSemaphore.__init__c sV t }| rdn
d| j }| jr<| dt| j }d|dd d| dS ) Nr; zunlocked, value:r< r= r r> r? r@ )rA rB r; r\ r5 rC rD rF r r rB s
zSemaphore.__repr__c C s, | j r(| j }| s |d d S q d S r
)r5 popleftrY rZ )r Zwaiterr r r
_wake_up_next s
zSemaphore._wake_up_nextc C s
| j dkS )z:Returns True if semaphore can not be acquired immediately.r r^ r r r r r; s zSemaphore.lockedc st | j dkrb| j }| j| z|I dH W q | | j dkrX| sX| Y q X q | j d8 _ dS )a5 Acquire a semaphore.
If the internal counter is larger than zero on entry,
decrement it by one and return True immediately. If it is
zero on entry, block, waiting until some other coroutine has
called release() to make it larger than 0, and then return
True.
r Nr T)r\ r8 rO r5 rP ZcancelrH rl rT r r r r& s
zSemaphore.acquirec C s | j d7 _ | dS )zRelease a semaphore, incrementing the internal counter by one.
When it was zero on entry and another coroutine is waiting for it to
become larger than zero again, wake up that coroutine.
r N)r\ rl r r r r r s zSemaphore.release)r ) r r r r r rB rl r; r& r r[ r r rF r r s
r c s4 e Zd ZdZd dd fdd Z fddZ ZS )
r zA bounded semaphore implementation.
This raises ValueError in release() if it would increase the value
above the initial value.
r Nr1 c s. |rt jdtdd || _t j||d d S )Nr4 r r! r1 )r# r$ r% _bound_valuerA r ri rF r r r
s zBoundedSemaphore.__init__c s" | j | jkrtdt d S )Nz(BoundedSemaphore released too many times)r\ rm rb rA r r rF r r r s zBoundedSemaphore.release)r )r r r r r r r[ r r rF r r s r )r __all__rM r/ r# r r r
r r r r r r r r r r r r s "9 DzNPK ! . __pycache__/windows_utils.cpython-38.opt-2.pycnu [ U
if @ s d dl Z e jdkredd dlZd dlZd dlZd dlZd dlZd dlZd dl Z dZ
dZ ej Z ej
Z
e Zdde dd d
ZG d d d ZG d
d dejZdS ) NZwin32z
win32 only)pipePopenPIPE
PipeHandlei F)TT)duplex
overlappedbufsizec
C s$ t jdt ttd}| r>tj}tj tj
B }|| }}ntj }tj
}d| }}|tj O }|d rp|tj
O }|d rtj
}nd}d } }
z\t||tjd||tjtj} t||dtjtj|tj}
tj| dd} | d | |
fW S | d k rt| |
d k rt|
Y nX d S )Nz \\.\pipe\python-pipe-{:d}-{:d}-)prefixr Tr )tempfileZmktempformatosgetpidnext
_mmap_counter_winapiZPIPE_ACCESS_DUPLEXZ GENERIC_READZ
GENERIC_WRITEZPIPE_ACCESS_INBOUNDZ FILE_FLAG_FIRST_PIPE_INSTANCEZFILE_FLAG_OVERLAPPEDZCreateNamedPipeZ PIPE_WAITZNMPWAIT_WAIT_FOREVERZNULLZ
CreateFileZ
OPEN_EXISTINGZConnectNamedPipeZGetOverlappedResult CloseHandle) r r r ZaddressZopenmodeaccessZobsizeZibsizeZflags_and_attribsZh1Zh2Zov r :/opt/alt/python38/lib64/python3.8/asyncio/windows_utils.pyr sb
r c @ s^ e Zd Zdd Zdd Zedd Zdd Zej d d
d Z
e j fd d
Z
dd Zdd ZdS )r c C s
|| _ d S N_handleselfhandler r r __init__V s zPipeHandle.__init__c C s2 | j d k rd| j }nd}d| jj d| dS )Nzhandle=closed< >)r __class____name__r r r r __repr__Y s
zPipeHandle.__repr__c C s | j S r r r r r r r ` s zPipeHandle.handlec C s | j d krtd| j S )Nz I/O operation on closed pipe)r
ValueErrorr% r r r filenod s
zPipeHandle.fileno)r c C s | j d k r|| j d | _ d S r r )r r r r r closei s
zPipeHandle.closec C s* | j d k r&|d| t| d | d S )Nz unclosed )source)r ResourceWarningr( )r Z_warnr r r __del__n s
zPipeHandle.__del__c C s | S r r r% r r r __enter__s s zPipeHandle.__enter__c C s | d S r )r( )r tvtbr r r __exit__v s zPipeHandle.__exit__N)r#
__module__ __qualname__r r$ propertyr r' r r r( warningswarnr+ r, r0 r r r r r Q s
r c s e Zd Zd fdd Z ZS )r Nc sx d } }}d } }
} |t kr@tddd\} } t| tj}n|}|t krhtdd\}
}
t|
d}n|}|t krtdd\} }t|d}n|tkr|}n|}zz t j |f|||d| W n0 | |
| fD ]}|d k rt
| qւ Y n>X | d k r
t | | _
|
d k r t |
| _| d k r2t | | _W 5 |t krJt| |t kr^t| |t krrt| X d S )N)FTT)r r )TFr r )stdinstdoutstderr)r r msvcrtZopen_osfhandler O_RDONLYSTDOUTr( superr r r r r6 r7 r8 )r argsr6 r7 r8 kwdsZ stdin_rfdZ
stdout_wfdZ
stderr_wfdZstdin_whZ stdout_rhZ stderr_rhZstdin_rhZ stdout_whZ stderr_whhr" r r r sN
zPopen.__init__)NNN)r# r1 r2 r
__classcell__r r r@ r r } s r )sysplatform ImportErrorr itertoolsr9 r
subprocessr r4 __all__ZBUFSIZEr r; countr r r r r r r r s"
1,PK ! ~ ( __pycache__/runners.cpython-38.opt-2.pycnu [ U
if @ sB d Z ddlmZ ddlmZ ddlmZ ddddZd d
ZdS ) )run )
coroutines)events)tasksN)debugc C s t d k rtdt| s,td| t }z*t | |d k rR|
| | | W S zt
| | | W 5 t d | X X d S )Nz8asyncio.run() cannot be called from a running event loopz"a coroutine was expected, got {!r})r Z_get_running_loop RuntimeErrorr Z iscoroutine
ValueErrorformatZnew_event_loopZset_event_loopclose_cancel_all_tasksrun_until_completeZshutdown_asyncgensZ set_debug)mainr loop r 4/opt/alt/python38/lib64/python3.8/asyncio/runners.pyr s"
r c C sv t | }|sd S |D ] }| q| t j|| dd |D ]0}| rNq@| d k r@| d| |d q@d S )NT)r Zreturn_exceptionsz1unhandled exception during asyncio.run() shutdown)message exceptiontask)r Z all_tasksZcancelr ZgatherZ cancelledr Zcall_exception_handler)r Z to_cancelr r r r r 6 s"
r )__all__ r r r r r r r r r s
.PK ! ) __pycache__/__init__.cpython-38.opt-1.pycnu [ U
if @ s d Z ddlZddlT ddlT ddlT ddlT ddlT ddlT ddlT ddl T ddl
T ddl T ddl T ddl
T ddlT ddl
mZ ejej ej ej ej ej ej e j e
j e j e j e
j ej ZejdkrddlT eej7 ZnddlT eej7 ZdS )z'The asyncio package, tracking PEP 3156. N )*)_all_tasks_compatZwin32)__doc__sysZ base_eventsZ
coroutinesZevents
exceptionsZfuturesZlocksZ protocolsZrunnersZqueuesZstreams
subprocessZtasksZ
transportsr __all__platformZwindows_eventsZ unix_events r r 5/opt/alt/python38/lib64/python3.8/asyncio/__init__.py sZ
PK ! 6l[P+ + " __pycache__/futures.cpython-38.pycnu [ U
ifb3 @ s d Z dZddlZddlZddlZddlZddlmZ ddlm Z ddlm
Z
ddlm Z ej Z ej
Z
ejZejZejd ZG d d
d
ZeZd d Zd
d Zdd Zdd Zdd Zdd ZddddZz ddlZW n e k
r Y n X ej ZZ dS )z.A Future class similar to the one in PEP 3148.)Future wrap_futureisfuture N ) base_futures)events)
exceptions)format_helpersc @ s e Zd ZdZeZdZdZdZdZ dZ
dZ ddddZ e
jZdd Zd d
Zed d Zejd
d Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zdd d d Z d d Z d!d" Z d#d$ Z d%d& Z 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.)
NFloopc C s@ |dkrt | _n|| _g | _| j r )format __class____name__join
_repr_infor r r r __repr__V s
zFuture.__repr__c C sF | j s
d S | j}| jj d|| d}| jr6| j|d< | j| d S )Nz exception was never retrieved)message exceptionfutureZsource_traceback)_Future__log_traceback
_exceptionr r r r
Zcall_exception_handler)r exccontextr r r __del__Z s
zFuture.__del__c C s | j S N)r# r r r r _log_tracebackj s zFuture._log_tracebackc C s t |rtdd| _d S )Nz'_log_traceback can only be set to FalseF)bool
ValueErrorr# )r valr r r r) n s c C s | j }|dkrtd|S )z-Return the event loop the Future is bound to.Nz!Future object is not initialized.)r
RuntimeErrorr r r r get_loopt s zFuture.get_loopc C s& d| _ | jtkrdS t| _| dS )zCancel 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)r# _state_PENDING
_CANCELLED_Future__schedule_callbacksr r r r cancel{ s
z
Future.cancelc C sH | j dd }|sdS g | j dd< |D ]\}}| jj|| |d q(dS )zInternal: Ask the event loop to call all callbacks.
The callbacks are scheduled to be called as soon as possible. Also
clears the callback list.
Nr& )r r
call_soon)r Z callbackscallbackctxr r r Z__schedule_callbacks s zFuture.__schedule_callbacksc C s
| j tkS )z(Return True if the future was cancelled.)r/ r1 r r r r cancelled s zFuture.cancelledc C s
| j tkS )zReturn True if the future is done.
Done means either that a result / exception are available, or that the
future was cancelled.
)r/ r0 r r r r done s z Future.donec C s@ | j tkrtj| j tkr$tdd| _| jdk r:| 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) r/ r1 r CancelledError _FINISHEDInvalidStateErrorr# r$ _resultr r r r result s
z
Future.resultc C s0 | j tkrtj| j tkr$tdd| _| 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)r/ r1 r r: r; r< r# r$ r r r r r! s
zFuture.exceptionr4 c C sB | j tkr | jj|| |d n |dkr.t }| j||f dS )zAdd 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.
r4 N)r/ r0 r
r5 contextvarsZ copy_contextr append)r fnr& r 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||fqS r r ).0fr7 rA r r
s z/Future.remove_done_callback..N)r len)r rA Zfiltered_callbacksZ
removed_countr rE r remove_done_callback s
zFuture.remove_done_callbackc C s8 | j tkr t| j d| || _t| _ | dS )zMark the future done and set its result.
If the future is already done when this method is called, raises
InvalidStateError.
: N)r/ r0 r r< r= r; r2 )r r> r r r
set_result s
zFuture.set_resultc C sb | j tkr t| j d| t|tr0| }t|tkrDtd|| _t | _ |
d| _ dS )zMark the future done and set an exception.
If the future is already done when this method is called, raises
InvalidStateError.
rI zPStopIteration interacts badly with generators and cannot be raised into a FutureTN) r/ r0 r r<
isinstancetype
StopIteration TypeErrorr$ r; r2 r# )r r! r r r
set_exception s
zFuture.set_exceptionc c s, | sd| _| V | s$td| S )NTz await wasn't used with future)r9 _asyncio_future_blockingr- r> r r r r __await__ s zFuture.__await__)"r
__module__ __qualname____doc__r0 r/ r= r$ r
r rP r# r r Z_future_repr_infor r r' propertyr) setterr. r3 r2 r8 r9 r> r! rB rH rJ rO rQ __iter__r r r r r s:
r c C s, z
| j }W n tk
r Y nX | S | jS r( )r. AttributeErrorr
)futr. r r r _get_loop s
rZ c C s | r dS | | dS )z?Helper setting the result only if the future was not cancelled.N)r8 rJ )rY r> r r r _set_result_unless_cancelled s r[ c C sX t | }|tjjkr tj| j S |tjjkr8tj| j S |tjjkrPtj| j S | S d S r( )rL
concurrentfuturesr: r args TimeoutErrorr< )r% Z exc_classr r r _convert_future_exc# s r` c C s^ | s t| r | | s(dS | }|dk rH| t| n| }| | dS )z8Copy state from a future to a concurrent.futures.Future.N)
r9 AssertionErrorr8 r3 Z set_running_or_notify_cancelr! rO r` r> rJ )r\ sourcer! r> r r r _set_concurrent_future_state/ s rc c C sl | s t| rdS | r$t| r6| n2| }|dk rV|t| n| }|| dS )zqInternal helper to copy state from another Future.
The other Future may be a concurrent.futures.Future.
N) r9 ra r8 r3 r! rO r` r> rJ )rb destr! r> r r r _copy_future_state> s
re c s t s ttjjs tdt s._set_statec s2 | r.d ks kr" n j d S r( )r8 r3 call_soon_threadsafe) destination) dest_looprb source_loopr r _call_check_cancelh s
z)_chain_future.._call_check_cancelc sJ r d k r r d S d ks,kr8 | n | d S r( )r8 Z is_closedrh )rb )rg rj ri rk r r _call_set_stateo s z&_chain_future.._call_set_state)r rK r\ r] r rN rZ rB )rb ri rl rm r )rg rj ri rb rk r
_chain_futureR s
rn r
c C sN t | r | S t| tjjs(td| |dkr8t }| }t | | |S )z&Wrap concurrent.futures.Future object.z+concurrent.futures.Future is expected, got N)
r rK r\ r] r ra r r Z
create_futurern )r" r Z
new_futurer r r r | s
r ) rT __all__Zconcurrent.futuresr\ r? Zloggingr r r r r r r0 r1 r; DEBUGZ STACK_DEBUGr Z _PyFuturerZ r[ r` rc re rn r Z_asyncio ImportErrorZ_CFuturer r r r s:
q *
PK ! EK{ { - __pycache__/base_futures.cpython-38.opt-2.pycnu [ U
if
@ sR d Z ddlZddlmZ ddlmZ dZdZdZd d
Z d d Z
e Z d
d Z
dS ) N) get_ident )format_helpersZPENDINGZ CANCELLEDZFINISHEDc C s t | jdo| jd k S )N_asyncio_future_blocking)hasattr __class__r )objr r 9/opt/alt/python38/lib64/python3.8/asyncio/base_futures.pyisfuture s r c C s t | }|sd} dd }|dkr2|| d d } n`|dkr`d|| d d || d d } n2|dkrd|| d d |d || d d } d
| d S ) N c S s t | dS )Nr )r Z_format_callback_source)callbackr r r
format_cb s z$_format_callbacks..format_cbr r z{}, {}z{}, <{} more>, {}zcb=[])lenformat)cbsizer r r r
_format_callbacks s &r c C s | j g}| j tkr| jd k r4|d| j nTt| t f}|tkrPd}n(t| zt
| j }W 5 t | X |d| | j
r|t| j
| jr| jd }|d|d d|d |S ) Nz
exception=z...zresult=r z created at r :r )Z_statelower _FINISHEDZ
_exceptionappendidr
_repr_runningadddiscardreprlibreprZ_resultZ
_callbacksr Z_source_traceback)Zfutureinfokeyresultframer r r
_future_repr_info7 s$
r% )__all__r _threadr r r Z_PENDINGZ
_CANCELLEDr r r setr r% r r r r
s PK ! ոlU U ' __pycache__/queues.cpython-38.opt-2.pycnu [ U
if @ s d Z ddlZddlZddlZddlmZ ddlmZ G dd deZG dd d eZ G d
d d Z
G d d
d
e
Z G dd de
Z dS ))Queue
PriorityQueue LifoQueue QueueFull
QueueEmpty N )events)locksc @ s e Zd ZdS )r N__name__
__module__ __qualname__ r r 3/opt/alt/python38/lib64/python3.8/asyncio/queues.pyr s r c @ s e Zd ZdS )r Nr
r r r r r s r c @ s e Zd Zd(ddddZdd Zdd Zd
d Zd d
Zdd Zdd Z dd Z
dd Z e dd Z
dd Zdd Zd d Zd d Zd d! Zd"d# Zd$d% Zd&d' ZdS ))r r Nloopc C sp |d krt | _n|| _tjdtdd || _t | _ t | _
d| _ t j
|d| _| j | | d S )Nz[The loop argument is deprecated since Python 3.8, and scheduled for removal in Python 3.10. )
stacklevelr r )r Zget_event_loop_loopwarningswarnDeprecationWarning_maxsize collectionsdeque_getters_putters_unfinished_tasksr ZEvent _finishedset_init)selfmaxsizer r r r __init__! s
zQueue.__init__c C s t | _d S N)r r _queuer! r" r r r r 6 s z Queue._initc C s
| j S r$ )r% popleftr! r r r _get9 s z
Queue._getc C s | j | d S r$ r% appendr! itemr r r _put< s z
Queue._putc C s& |r"| }| s |d q"q d S r$ )r' ZdoneZ
set_result)r! waitersZwaiterr r r _wakeup_nextA s
zQueue._wakeup_nextc C s( dt | j dt| dd| dS )N)typer id_formatr( r r r __repr__I s zQueue.__repr__c C s dt | j d| dS )Nr1 r2 r3 )r4 r r6 r( r r r __str__L s z
Queue.__str__c C s~ d| j }t| dd r,|dt| j7 }| jrH|dt| j d7 }| jrd|dt| j d7 }| jrz|d| j 7 }|S )Nzmaxsize=r% z _queue=z
_getters[]z
_putters[z tasks=)r getattrlistr% r lenr r )r! resultr r r r6 O s z
Queue._formatc C s
t | jS r$ )r< r% r( r r r qsize[ s z Queue.qsizec C s | j S r$ )r r( r r r r" _ s z
Queue.maxsizec C s | j S r$ r% r( r r r emptyd s z Queue.emptyc C s | j dkrdS | | j kS d S )Nr F)r r> r( r r r fullh s
z
Queue.fullc s | r| j }| j| z|I d H W q | z| j| W n tk
r` Y nX | s~| s~| | j Y q X q |
|S r$ ) rA r
create_futurer r+ cancelremove
ValueError cancelledr0
put_nowait)r! r- Zputterr r r puts s
z Queue.putc C s> | r t| | | jd7 _| j | | j d S )Nr )rA r r. r r clearr0 r r, r r r rG s
zQueue.put_nowaitc s | r| j }| j| z|I d H W q | z| j| W n tk
r` Y nX | s~| s~| | j Y q X q |
S r$ ) r@ r rB r r+ rC rD rE rF r0
get_nowait)r! getterr r r get s
z Queue.getc C s$ | r t| }| | j |S r$ )r@ r r) r0 r r, r r r rJ s
zQueue.get_nowaitc C s8 | j dkrtd| j d8 _ | j dkr4| j d S )Nr z!task_done() called too many timesr )r rE r r r( r r r task_done s
zQueue.task_donec s | j dkr| j I d H d S )Nr )r r waitr( r r r join s
z
Queue.join)r )r r r
r# r r) r. r0 r7 r8 r6 r> propertyr" r@ rA rH rG rL rJ rM rO r r r r r s&
r c @ s0 e Zd Zdd ZejfddZejfddZdS )r c C s
g | _ d S r$ r? r& r r r r s zPriorityQueue._initc C s || j | d S r$ r? )r! r- heappushr r r r. s zPriorityQueue._putc C s
|| j S r$ r? )r! heappopr r r r) s zPriorityQueue._getN) r r r
r heapqrQ r. rR r) r r r r r s r c @ s$ e Zd Zdd Zdd Zdd ZdS )r c C s
g | _ d S r$ r? r& r r r r s zLifoQueue._initc C s | j | d S r$ r* r, r r r r. s zLifoQueue._putc C s
| j S r$ )r% popr( r r r r) s zLifoQueue._getN)r r r
r r. r) r r r r r s r )
__all__r rS r r r Exceptionr r r r r r r r r s KPK ! b5? ? & __pycache__/locks.cpython-38.opt-1.pycnu [ U
if|C @ s d Z dZddlZddlZddlZddlmZ ddlmZ ddlmZ ddlm Z G d d
d
Z
G d d d Z G d
d de Z G dd dZ
G dd de ZG dd de ZG dd deZdS )zSynchronization primitives.)LockEvent Condition SemaphoreBoundedSemaphore N )events)futures)
exceptions)
coroutinesc @ s( e Zd ZdZdd Zdd Zdd ZdS ) _ContextManagera\ Context manager.
This enables the following idiom for acquiring and releasing a
lock around a block:
with (yield from lock):
while failing loudly when accidentally using:
with lock:
Deprecated, use 'async with' statement:
async with lock:
c C s
|| _ d S N)_lock)selflock r 2/opt/alt/python38/lib64/python3.8/asyncio/locks.py__init__" s z_ContextManager.__init__c C s d S r
r r r r r __enter__% s z_ContextManager.__enter__c G s z| j W 5 d | _ X d S r
)r releaser argsr r r __exit__* s z_ContextManager.__exit__N)__name__
__module__ __qualname____doc__r r r r r r r r s r c @ sR e Zd Zdd Zdd Zejdd Zej e_ dd Z
d d
Z d d Z d
d Z
dS )_ContextManagerMixinc C s t dd S )Nz9"yield from" should be used as context manager expression) RuntimeErrorr r r r r 2 s z _ContextManagerMixin.__enter__c G s d S r
r r r r r r 6 s z _ContextManagerMixin.__exit__c c s& t jdtdd | E d H t| S )NzD'with (yield from lock)' is deprecated use 'async with lock' instead
stacklevel)warningswarnDeprecationWarningacquirer r r r r __iter__; s z _ContextManagerMixin.__iter__c s | I d H t| S r
)r& r r r r r Z
__acquire_ctxU s z"_ContextManagerMixin.__acquire_ctxc C s t jdtdd | S )Nz='with await lock' is deprecated use 'async with lock' insteadr r! )r# r$ r% !_ContextManagerMixin__acquire_ctx __await__r r r r r) Y s
z _ContextManagerMixin.__await__c s | I d H d S r
)r& r r r r
__aenter__` s z _ContextManagerMixin.__aenter__c s | d S r
)r )r exc_typeexctbr r r __aexit__f s z _ContextManagerMixin.__aexit__N)r r r r r types coroutiner' r Z
_is_coroutiner( r) r* r. r r r r r 1 s
r c sN e Zd ZdZddddZ fddZdd Zd
d Zd d
Zdd Z Z
S )r a Primitive lock objects.
A primitive lock is a synchronization primitive that is not owned
by a particular coroutine when locked. A primitive lock is in one
of two states, 'locked' or 'unlocked'.
It is created in the unlocked state. It has two basic methods,
acquire() and release(). When the state is unlocked, acquire()
changes the state to locked and returns immediately. When the
state is locked, acquire() blocks until a call to release() in
another coroutine changes it to unlocked, then the acquire() call
resets it to locked and returns. The release() method should only
be called in the locked state; it changes the state to unlocked
and returns immediately. If an attempt is made to release an
unlocked lock, a RuntimeError will be raised.
When more than one coroutine is blocked in acquire() waiting for
the state to turn to unlocked, only one coroutine proceeds when a
release() call resets the state to unlocked; first coroutine which
is blocked in acquire() is being processed.
acquire() is a coroutine and should be called with 'await'.
Locks also support the asynchronous context management protocol.
'async with lock' statement should be used.
Usage:
lock = Lock()
...
await lock.acquire()
try:
...
finally:
lock.release()
Context manager usage:
lock = Lock()
...
async with lock:
...
Lock objects can be tested for locking state:
if not lock.locked():
await lock.acquire()
else:
# lock is acquired
...
Nloopc C s: d | _ d| _|d kr t | _n|| _tjdtdd d S NF[The loop argument is deprecated since Python 3.8, and scheduled for removal in Python 3.10.r r! )_waiters_lockedr get_event_loop_loopr# r$ r% r r2 r r r r s z
Lock.__init__c sL t }| jrdnd}| jr2| dt| j }d|dd d| dS NlockedZunlocked
, waiters:)super__repr__r6 r5 lenr resZextra __class__r r rB s
z
Lock.__repr__c C s | j S )z Return True if lock is acquired.)r6 r r r r r; s z Lock.lockedc s | j s.| jdks$tdd | jD r.d| _ dS | jdkrBt | _| j }| j| z"z|I dH W 5 | j| X W n& t j
k
r | j s| Y nX d| _ dS )zAcquire a lock.
This method blocks until the lock is unlocked, then sets it to
locked and returns True.
Nc s s | ]}| V qd S r
) cancelled).0wr r r s z Lock.acquire..T) r6 r5 all collectionsdequer8
create_futureappendremover
CancelledError_wake_up_firstr futr r r r& s&
z Lock.acquirec C s" | j rd| _ | ntddS )aG Release a lock.
When the lock is locked, reset it to unlocked, and return.
If any other coroutines are blocked waiting for the lock to become
unlocked, allow exactly one of them to proceed.
When invoked on an unlocked lock, a RuntimeError is raised.
There is no return value.
FzLock is not acquired.N)r6 rS r r r r r r s
z Lock.releasec C sJ | j s
dS ztt| j }W n tk
r2 Y dS X | sF|d dS )z*Wake up the first waiter if it isn't done.NT)r5 nextiter
StopIterationdone
set_resultrT r r r rS s zLock._wake_up_first) r r r r r rB r; r& r rS
__classcell__r r rF r r j s 5 r c sN e Zd ZdZddddZ fddZdd Zd
d Zd d
Zdd Z Z
S )r a# Asynchronous equivalent to threading.Event.
Class implementing event objects. An event manages a flag that can be set
to true with the set() method and reset to false with the clear() method.
The wait() method blocks until the flag is true. The flag is initially
false.
Nr1 c C s> t | _d| _|d kr$t | _n|| _tjdt dd d S r3 )
rM rN r5 _valuer r7 r8 r# r$ r% r9 r r r r s
zEvent.__init__c sL t }| jrdnd}| jr2| dt| j }d|dd d| dS ) NsetZunsetr< r= r r> r? r@ )rA rB r\ r5 rC rD rF r r rB s
zEvent.__repr__c C s | j S )z5Return True if and only if the internal flag is true.r\ r r r r is_set s z Event.is_setc C s. | j s*d| _ | jD ]}| s|d qdS )zSet the internal flag to true. All coroutines waiting for it to
become true are awakened. Coroutine that call wait() once the flag is
true will not block at all.
TN)r\ r5 rY rZ rT r r r r] s
z Event.setc C s
d| _ dS )zReset the internal flag to false. Subsequently, coroutines calling
wait() will block until set() is called to set the internal flag
to true again.FNr^ r r r r clear" s z Event.clearc sF | j r
dS | j }| j| z|I dH W dS | j| X dS )zBlock until the internal flag is true.
If the internal flag is true on entry, return True
immediately. Otherwise, block until another coroutine calls
set() to set the flag to true, then return True.
TN)r\ r8 rO r5 rP rQ rT r r r wait( s
z
Event.wait) r r r r r rB r_ r] r` ra r[ r r rF r r s r c sR e Zd ZdZdddddZ fddZdd Zd
d Zdd
dZdd Z Z
S )r a Asynchronous equivalent to threading.Condition.
This class implements condition variable objects. A condition variable
allows one or more coroutines to wait until they are notified by another
coroutine.
A new Lock object is created and used as the underlying lock.
Nr1 c C s~ |d krt | _n|| _tjdtdd |d kr>t|d}n|j| jk rRtd|| _|j | _ |j
| _
|j | _ t
| _d S )Nr4 r r! r1 z"loop argument must agree with lock)r r7 r8 r# r$ r% r
ValueErrorr r; r& r rM rN r5 )r r r2 r r r r E s zCondition.__init__c sN t }| rdnd}| jr4| dt| j }d|dd d| dS r: )rA rB r; r5 rC rD rF r r rB [ s
zCondition.__repr__c s | std| z@| j }| j | z|I dH W W dS | j
| X W 5 d}z| I dH W qW q^ tjk
r d}Y q^X q^|rtjX dS )a Wait until notified.
If the calling coroutine has not acquired the lock when this
method is called, a RuntimeError is raised.
This method releases the underlying lock, and then blocks
until it is awakened by a notify() or notify_all() call for
the same condition variable in another coroutine. Once
awakened, it re-acquires the lock and returns True.
z cannot wait on un-acquired lockFNT) r; r r r& r
rR r8 rO r5 rP rQ )r rH rU r r r ra b s$
zCondition.waitc s$ | }|s | I dH | }q|S )zWait until a predicate becomes true.
The predicate should be a callable which result will be
interpreted as a boolean value. The final predicate value is
the return value.
N)ra )r Z predicateresultr r r wait_for s
zCondition.wait_forr c C sJ | stdd}| jD ]*}||kr* qF| s|d7 }|d qdS )a By default, wake up one coroutine waiting on this condition, if any.
If the calling coroutine has not acquired the lock when this method
is called, a RuntimeError is raised.
This method wakes up at most n of the coroutines waiting for the
condition variable; it is a no-op if no coroutines are waiting.
Note: an awakened coroutine does not actually return from its
wait() call until it can reacquire the lock. Since notify() does
not release the lock, its caller should.
z!cannot notify on un-acquired lockr r FN)r; r r5 rY rZ )r nidxrU r r r notify s
zCondition.notifyc C s | t| j dS )a Wake up all threads waiting on this condition. This method acts
like notify(), but wakes up all waiting threads instead of one. If the
calling thread has not acquired the lock when this method is called,
a RuntimeError is raised.
N)rg rC r5 r r r r
notify_all s zCondition.notify_all)N)r ) r r r r r rB ra rd rg rh r[ r r rF r r ; s %
r c sP e Zd ZdZdddddZ fddZd d
Zd d Zd
d Zdd Z Z
S )r a A Semaphore implementation.
A semaphore manages an internal counter which is decremented by each
acquire() call and incremented by each release() call. The counter
can never go below zero; when acquire() finds that it is zero, it blocks,
waiting until some other thread calls release().
Semaphores also support the context management protocol.
The optional argument gives the initial value for the internal
counter; it defaults to 1. If the value given is less than 0,
ValueError is raised.
r Nr1 c C sN |dk rt d|| _t | _|d kr4t | _n|| _tj dt
dd d S )Nr z$Semaphore initial value must be >= 0r4 r r! ) rb r\ rM rN r5 r r7 r8 r# r$ r% r valuer2 r r r r s
zSemaphore.__init__c sV t }| rdn
d| j }| jr<| dt| j }d|dd d| dS ) Nr; zunlocked, value:r< r= r r> r? r@ )rA rB r; r\ r5 rC rD rF r r rB s
zSemaphore.__repr__c C s, | j r(| j }| s |d d S q d S r
)r5 popleftrY rZ )r Zwaiterr r r
_wake_up_next s
zSemaphore._wake_up_nextc C s
| j dkS )z:Returns True if semaphore can not be acquired immediately.r r^ r r r r r; s zSemaphore.lockedc st | j dkrb| j }| j| z|I dH W q | | j dkrX| sX| Y q X q | j d8 _ dS )a5 Acquire a semaphore.
If the internal counter is larger than zero on entry,
decrement it by one and return True immediately. If it is
zero on entry, block, waiting until some other coroutine has
called release() to make it larger than 0, and then return
True.
r Nr T)r\ r8 rO r5 rP ZcancelrH rl rT r r r r& s
zSemaphore.acquirec C s | j d7 _ | dS )zRelease a semaphore, incrementing the internal counter by one.
When it was zero on entry and another coroutine is waiting for it to
become larger than zero again, wake up that coroutine.
r N)r\ rl r r r r r s zSemaphore.release)r ) r r r r r rB rl r; r& r r[ r r rF r r s
r c s4 e Zd ZdZd dd fdd Z fddZ ZS )
r zA bounded semaphore implementation.
This raises ValueError in release() if it would increase the value
above the initial value.
r Nr1 c s. |rt jdtdd || _t j||d d S )Nr4 r r! r1 )r# r$ r% _bound_valuerA r ri rF r r r
s zBoundedSemaphore.__init__c s" | j | jkrtdt d S )Nz(BoundedSemaphore released too many times)r\ rm rb rA r r rF r r r s zBoundedSemaphore.release)r )r r r r r r r[ r r rF r r s r )r __all__rM r/ r# r r r
r r r r r r r r r r r r s "9 DzNPK ! @[{ ) __pycache__/__init__.cpython-38.opt-2.pycnu [ U
if @ s d dl Z ddlT ddlT ddlT ddlT ddlT ddlT ddlT ddlT ddl T ddl
T ddl T ddl T ddl
T ddl mZ ejej ej ej ej ej ej ej e j e
j e j e j e
j Ze jdkrddlT eej7 ZnddlT eej7 ZdS ) N )*)_all_tasks_compatZwin32)sysZ base_eventsZ
coroutinesZevents
exceptionsZfuturesZlocksZ protocolsZrunnersZqueuesZstreams
subprocessZtasksZ
transportsr __all__platformZwindows_eventsZ unix_events r
r
5/opt/alt/python38/lib64/python3.8/asyncio/__init__.py sX
PK ! ")+ + ) __pycache__/format_helpers.cpython-38.pycnu [ U
ifd @ sd d dl Z d dlZd dlZd dlZd dlZddlmZ dd Zdd Zdd Z dd d Z
dd
dZ dS ) N ) constantsc C sV t | } t | r&| j}|j|jfS t| tjr& s z*_format_args_and_kwargs..c s s& | ] \}}| d t | V qdS )=Nr )r kvr r r r ( s z({})z, )extenditemsformatjoin)r kwargsr" r r r _format_args_and_kwargs s r& c C s t | tjr.t||| }t| j| j| j|S t| drF| j rF| j }n t| dr^| j
r^| j
}nt | }|t||7 }|r||7 }|S )N __qualname____name__) r r
r r& r r
r keywordshasattrr( r) r )r
r r% suffixr r r r r , s r c C sD | dkrt j} |dkr tj}tjjt| |dd}| |S )zlReplacement for traceback.extract_stack() that only does the
necessary work for asyncio debug mode.
NF)limit lookup_lines)
sys _getframef_backr ZDEBUG_STACK_DEPTH traceback StackSummaryextract
walk_stackreverse)fr- stackr r r
extract_stack> s
r9 )r' )NN) r
r r r/ r2 r' r r r r& r r9 r r r r s
PK ! x*0 & __pycache__/unix_events.cpython-38.pycnu [ U
ifۿ @ s d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl
mZ ddl
mZ ddl
mZ ddl
mZ ddl
mZ dd l
mZ dd
l
mZ dd l
mZ dd l
mZ dd
l
mZ ddlmZ dZe
jdkre ddd Z G dd dej Z G dd dej Z!G dd dej"ej#Z$G dd dej%Z&G d d d Z'd d Z(G d d! d!e'Z)G d"d# d#e)Z*G d$d% d%e)Z+G d&d' d'e'Z,G d(d) d)e'Z-G d*d+ d+ej.Z/e Z0e/Z1dS ),z2Selector event loop for Unix with signal handling. N ) base_events)base_subprocess) constants)
coroutines)events)
exceptions)futures)selector_events)tasks)
transports)logger)SelectorEventLoopAbstractChildWatcherSafeChildWatcherFastChildWatcherMultiLoopChildWatcherThreadedChildWatcherDefaultEventLoopPolicyZwin32z+Signals are not really supported on Windowsc C s dS )zDummy signal handler.N )signumframer r 8/opt/alt/python38/lib64/python3.8/asyncio/unix_events.py_sighandler_noop* s r c s e Zd ZdZd) fdd Z fddZdd Zd d
Zd d Zd
d Z dd Z
d*ddZ d+ddZ d,ddZ
dd Zd-dddddddZd.dd ddd d d d Zd!d" Zd#d$ Zd%d& Zd'd( Z ZS )/_UnixSelectorEventLoopzdUnix event loop.
Adds signal handling and UNIX Domain Socket support to SelectorEventLoop.
Nc s t | i | _d S N)super__init___signal_handlers)selfselector __class__r r r 5 s z _UnixSelectorEventLoop.__init__c sZ t t s.t| jD ]}| | q n(| jrVtjd| dt | d | j
d S )NzClosing the loop z@ on interpreter shutdown stage, skipping signal handlers removalsource) r closesys
is_finalizinglistr remove_signal_handlerwarningswarnResourceWarningclearr sigr! r r r% 9 s
z _UnixSelectorEventLoop.closec C s |D ]}|sq| | qd S r )_handle_signal)r datar r r r _process_self_dataG s z)_UnixSelectorEventLoop._process_self_datac
G sL t |st |r td| | | zt| j W n2 t
t fk
rt } zt t
|W 5 d}~X Y nX t||| d}|| j|< z t|t t|d W n t k
rF } zz| j|= | jsztd W n4 t
t fk
r } ztd| W 5 d}~X Y nX |jtjkr4t d| dn W 5 d}~X Y nX dS )zAdd a handler for a signal. UNIX only.
Raise ValueError if the signal number is invalid or uncatchable.
Raise RuntimeError if there is a problem setting up the handler.
z3coroutines cannot be used with add_signal_handler()NF set_wakeup_fd(-1) failed: %ssig cannot be caught)r Z iscoroutineZiscoroutinefunction TypeError
_check_signalZ
_check_closedsignal
set_wakeup_fdZ_csockfileno
ValueErrorOSError RuntimeErrorstrr ZHandler r siginterruptr
infoerrnoEINVAL)r r/ callbackargsexchandleZnexcr r r add_signal_handlerN s2
z)_UnixSelectorEventLoop.add_signal_handlerc C s8 | j |}|dkrdS |jr*| | n
| | dS )z2Internal helper that is the actual signal handler.N)r getZ
_cancelledr) Z_add_callback_signalsafe)r r/ rG r r r r0 { s z%_UnixSelectorEventLoop._handle_signalc
C s | | z | j|= W n tk
r, Y dS X |tjkr@tj}ntj}zt|| W nB tk
r } z$|jtj krt
d| dn W 5 d}~X Y nX | jszt d W n2 t tfk
r } zt
d| W 5 d}~X Y nX dS )zwRemove a handler for a signal. UNIX only.
Return True if a signal handler was removed, False if not.
Fr5 r6 Nr3 r4 T)r8 r KeyErrorr9 SIGINTdefault_int_handlerSIG_DFLr= rB rC r> r: r< r
rA )r r/ handlerrF r r r r) s(
z,_UnixSelectorEventLoop.remove_signal_handlerc C s6 t |tstd||t kr2td| dS )zInternal helper to validate a signal.
Raise ValueError if the signal number is invalid or uncatchable.
Raise RuntimeError if there is a problem setting up the handler.
zsig must be an int, not zinvalid signal number N)
isinstanceintr7 r9
valid_signalsr< r. r r r r8 s
z$_UnixSelectorEventLoop._check_signalc C s t | ||||S r )_UnixReadPipeTransportr pipeprotocolwaiterextrar r r _make_read_pipe_transport s z0_UnixSelectorEventLoop._make_read_pipe_transportc C s t | ||||S r )_UnixWritePipeTransportrS r r r _make_write_pipe_transport s z1_UnixSelectorEventLoop._make_write_pipe_transportc
s t }
|
std| } t| |||||||f| |d| } |
| | j| z| I d H W nD t t
fk
r Y n, t k
r | |
I d H Y nX W 5 Q R X | S )NzRasyncio.get_child_watcher() is not activated, subprocess support is not installed.)rV rW )r get_child_watcher is_activer>
create_future_UnixSubprocessTransportadd_child_handlerZget_pid_child_watcher_callback
SystemExitKeyboardInterrupt
BaseExceptionr% Z_wait)
r rU rE shellstdinstdoutstderrbufsizerW kwargswatcherrV transpr r r _make_subprocess_transport s8
z1_UnixSelectorEventLoop._make_subprocess_transportc C s | |j| d S r )call_soon_threadsafeZ_process_exited)r pid
returncoderk r r r r` s z._UnixSelectorEventLoop._child_watcher_callback)sslsockserver_hostnamessl_handshake_timeoutc s |d kst |tst|r,|d krLtdn |d k r.cb)Zadd_done_callback)r r rq r r r r r s z6_UnixSelectorEventLoop._sock_add_cancellation_callback)N)NN)NN)N)N)N)__name__
__module__ __qualname____doc__r r% r2 rH r0 r) r8 rX rZ rl r` r r r r r r
__classcell__r r r! r r / sH -
. CFr c s e Zd ZdZd fdd Zdd Zdd Zd d
Zd d Zd
d Z dd Z
dd Z dd Z e
jfddZd ddZdd Zd d Z ZS ) rR i Nc s t | || jd< || _|| _| | _|| _d| _d| _ t
| jj }t
|st
|st
|sd | _d | _d | _tdt
| jd | j| jj| | j| jj| j| j |d k r| jtj|d d S )NrT Fz)Pipe transport is for pipes/sockets only.)r r _extra_loop_piper; _fileno _protocol_closing_pausedrx r r r S_ISFIFOr S_ISCHRr< set_blocking call_soonconnection_made _add_reader _read_readyr _set_result_unless_cancelled)r r rT rU rV rW moder! r r r s:
z _UnixReadPipeTransport.__init__c C s | j jg}| jd kr |d n| jr0|d |d| j t| jdd }| jd k r|d k rt || jt
j }|r|d q|d n | jd k r|d n
|d d d
|S )
Nclosedclosingfd= _selectorpollingidleopen<{}> )r" r r appendr r getattrr r
_test_selector_event selectorsZ
EVENT_READformatjoin)r rA r r r r r __repr__ s(
z _UnixReadPipeTransport.__repr__c
C s zt | j| j}W nD ttfk
r, Y n tk
rX } z| |d W 5 d }~X Y n^X |rl| j | nJ| j
rt
d| d| _| j
| j | j
| jj | j
| jd d S )Nz"Fatal read error on pipe transport%r was closed by peerT)rx readr max_sizer r r= _fatal_errorr Z
data_receivedr get_debugr
rA r _remove_readerr Z eof_received_call_connection_lost)r r1 rF r r r r s
z"_UnixReadPipeTransport._read_readyc C s> | j s | jrd S d| _| j| j | j r:td| d S )NTz%r pauses reading)r r r r r r r
debugr r r r
pause_reading s
z$_UnixReadPipeTransport.pause_readingc C sB | j s | jsd S d| _| j| j| j | j r>td| d S )NFz%r resumes reading) r r r r r r r r
r r r r r resume_reading s
z%_UnixReadPipeTransport.resume_readingc C s
|| _ d S r r r rU r r r set_protocol
s z#_UnixReadPipeTransport.set_protocolc C s | j S r r r r r r get_protocol s z#_UnixReadPipeTransport.get_protocolc C s | j S r r r r r r
is_closing s z!_UnixReadPipeTransport.is_closingc C s | j s| d d S r )r _closer r r r r% s z _UnixReadPipeTransport.closec C s, | j d k r(|d| t| d | j d S Nzunclosed transport r# r r, r% r _warnr r r __del__ s
z _UnixReadPipeTransport.__del__ Fatal error on pipe transportc C sZ t |tr4|jtjkr4| j rLtjd| |dd n| j||| | j d |
| d S Nz%r: %sTexc_info)message exceptionr rU ) rO r= rB ZEIOr r r
r call_exception_handlerr r r rF r r r r r s
z#_UnixReadPipeTransport._fatal_errorc C s( d| _ | j| j | j| j| d S NT)r r r r r r r rF r r r r - s z _UnixReadPipeTransport._closec C s4 z| j| W 5 | j d | _ d | _d | _X d S r r r% r r Zconnection_lostr r r r r 2 s
z,_UnixReadPipeTransport._call_connection_lost)NN)r )r r r r r r r r r r r r r% r* r+ r r r r r r r r! r rR s
rR c s e Zd Zd% fdd Zdd Zdd Zdd Zd
d Zd d
Zdd Z dd Z
dd Z dd Z dd Z
dd ZejfddZd d Zd&d d Zd'd!d"Zd#d$ Z ZS )(rY Nc
s t || || jd< || _| | _|| _t | _d| _ d| _
t | jj
}t|}t|}t|} |s|s| sd | _d | _d | _tdt | jd | j| jj| | s|rtjds| j| jj| j| j |d k r| jt j |d d S )NrT r Fz?Pipe transport is only for pipes, sockets and character devicesZaix) r r r r r; r r bytearray_buffer
_conn_lostr rx r r r r r r r< r r r r r& platform
startswithr r r r )
r r rT rU rV rW r Zis_charZis_fifoZ is_socketr! r r r ? s:
z _UnixWritePipeTransport.__init__c C s | j jg}| jd kr |d n| jr0|d |d| j t| jdd }| jd k r|d k rt || jt
j }|r|d n
|d | }|d| n | jd k r|d n
|d d
d
|S ) Nr r r r r r zbufsize=r r r )r" r r r r r r r r
r r Z EVENT_WRITEget_write_buffer_sizer r )r rA r r rh r r r r d s,
z _UnixWritePipeTransport.__repr__c C s
t | jS r )lenr r r r r r | s z-_UnixWritePipeTransport.get_write_buffer_sizec C s6 | j rtd| | jr*| t n| d S )Nr )r r r
rA r r BrokenPipeErrorr r r r r s
z#_UnixWritePipeTransport._read_readyc
C sR t |tttfs tt|t |tr.t|}|s6d S | jsB| jrj| jtj krXt
d | jd7 _d S | j s8zt
| j|}W nt ttfk
r d}Y nZ ttfk
r Y nB tk
r } z$| jd7 _| |d W Y d S d }~X Y nX |t|kr d S |dkr&t||d }| j| j| j | j |7 _ | d S )Nz=pipe closed by peer or os.write(pipe, data) raised exception.r r #Fatal write error on pipe transport)rO bytesr
memoryviewrw reprr r r Z!LOG_THRESHOLD_FOR_CONNLOST_WRITESr
warningr rx writer r r ra rb rc r r r Z _add_writer _write_readyZ_maybe_pause_protocol)r r1 nrF r r r r s8
z _UnixWritePipeTransport.writec
C s | j stdzt| j| j }W n ttfk
r: Y n ttfk
rR Y n t k
r } z6| j
| j d7 _ | j
| j | |d W 5 d }~X Y nhX |t| j kr| j
| j
| j | | jr| j | j | d d S |dkr | j d |= d S )NzData should not be emptyr r r )r rw rx r r r r ra rb rc r- r r _remove_writerr r Z_maybe_resume_protocolr r r )r r rF r r r r s,
z$_UnixWritePipeTransport._write_readyc C s dS r r r r r r
can_write_eof s z%_UnixWritePipeTransport.can_write_eofc C sB | j r
d S | jstd| _ | js>| j| j | j| jd d S r ) r r rw r r r r r r r r r r write_eof s
z!_UnixWritePipeTransport.write_eofc C s
|| _ d S r r r r r r r s z$_UnixWritePipeTransport.set_protocolc C s | j S r r r r r r r s z$_UnixWritePipeTransport.get_protocolc C s | j S r r r r r r r s z"_UnixWritePipeTransport.is_closingc C s | j d k r| js| d S r )r r r r r r r r% s z _UnixWritePipeTransport.closec C s, | j d k r(|d| t| d | j d S r r r r r r r s
z _UnixWritePipeTransport.__del__c C s | d d S r )r r r r r abort s z _UnixWritePipeTransport.abortr c C sN t |tr(| j r@tjd| |dd n| j||| | jd | | d S r ) rO r= r r r
r r r r r r r r r s
z$_UnixWritePipeTransport._fatal_errorc C sF d| _ | jr| j| j | j | j| j | j| j| d S r ) r r r r r r- r r r r r r r r s
z _UnixWritePipeTransport._closec C s4 z| j| W 5 | j d | _ d | _d | _X d S r r r r r r r s
z-_UnixWritePipeTransport._call_connection_lost)NN)r )N)r r r r r r r r r r
r r r r r% r* r+ r r r r r r r r r! r rY < s" % #
rY c @ s e Zd Zdd ZdS )r^ c K s d }|t jkrt \}}zPt j|f||||d|d|| _|d k rh| t| d|d| j_ d }W 5 |d k r| | X d S )NF)rd re rf rg Zuniversal_newlinesrh wb) buffering)
subprocessPIPErz Z
socketpairr% Popen_procr detachre ) r rE rd re rf rg rh ri Zstdin_wr r r _start s.
z _UnixSubprocessTransport._startN)r r r r r r r r r^ s r^ c @ sH e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
dS )r aH Abstract base class for monitoring child processes.
Objects derived from this class monitor a collection of subprocesses and
report their termination or interruption by a signal.
New callbacks are registered with .add_child_handler(). Starting a new
process must be done within a 'with' block to allow the watcher to suspend
its activity until the new process if fully registered (this is needed to
prevent a race condition in some implementations).
Example:
with watcher:
proc = subprocess.Popen("sleep 1")
watcher.add_child_handler(proc.pid, callback)
Notes:
Implementations of this class must be thread-safe.
Since child watcher objects may catch the SIGCHLD signal and call
waitpid(-1), there should be only one active object per process.
c G s
t dS )a Register a new child handler.
Arrange for callback(pid, returncode, *args) to be called when
process 'pid' terminates. Specifying another callback for the same
process replaces the previous handler.
Note: callback() must be thread-safe.
NNotImplementedErrorr rn rD rE r r r r_ 9 s z&AbstractChildWatcher.add_child_handlerc C s
t dS )zRemoves the handler for process 'pid'.
The function returns True if the handler was successfully removed,
False if there was nothing to remove.Nr r rn r r r remove_child_handlerD s z)AbstractChildWatcher.remove_child_handlerc C s
t dS )zAttach the watcher to an event loop.
If the watcher was previously attached to an event loop, then it is
first detached before attaching to the new loop.
Note: loop may be None.
Nr r r r r r attach_loopL s z AbstractChildWatcher.attach_loopc C s
t dS )zlClose the watcher.
This must be called to make sure that any underlying resource is freed.
Nr r r r r r% V s zAbstractChildWatcher.closec C s
t dS )zReturn ``True`` if the watcher is active and is used by the event loop.
Return True if the watcher is installed and ready to handle process exit
notifications.
Nr r r r r r\ ] s z AbstractChildWatcher.is_activec C s
t dS )zdEnter the watcher's context and allow starting new processes
This function must return selfNr r r r r __enter__f s z AbstractChildWatcher.__enter__c C s
t dS )zExit the watcher's contextNr r abcr r r __exit__l s z AbstractChildWatcher.__exit__N) r r r r r_ r r r% r\ r r! r r r r r " s
r c C s2 t | rt | S t | r*t | S | S d S r )rx WIFSIGNALEDWTERMSIG WIFEXITED WEXITSTATUS)statusr r r _compute_returncodeq s
r' c @ sD e Zd Zdd Zdd Zdd Zdd Zd d
Zd d Zd
d Z dS )BaseChildWatcherc C s d | _ i | _d S r )r
_callbacksr r r r r s zBaseChildWatcher.__init__c C s | d d S r )r r r r r r% s zBaseChildWatcher.closec C s | j d k o| j S r )r Z
is_runningr r r r r\ s zBaseChildWatcher.is_activec C s
t d S r r )r expected_pidr r r _do_waitpid s z BaseChildWatcher._do_waitpidc C s
t d S r r r r r r _do_waitpid_all s z BaseChildWatcher._do_waitpid_allc C s~ |d kst |tjst| jd k r<|d kr<| jr r r% r r! r r r% s
zFastChildWatcher.closec
C s0 | j | jd7 _| W 5 Q R S Q R X d S )Nr )r= r? r r r r r s zFastChildWatcher.__enter__c C s^ | j B | jd8 _| js"| js0W 5 Q R d S t| j}| j W 5 Q R X td| d S )Nr z5Caught subprocesses termination from unknown pids: %s)r= r? r> r? r- r
r )r r r r Zcollateral_victimsr r r r! s
zFastChildWatcher.__exit__c G st | j std| jF z| j|}W n. tk
rT ||f| j|< Y W 5 Q R d S X W 5 Q R X |||f| d S )Nz Must use the context manager)r? rw r= r> r; rJ r) )r rn rD rE ro r r r r_ ' s z"FastChildWatcher.add_child_handlerc C s* z| j |= W dS tk
r$ Y dS X d S r1 r2 r r r r r 5 s
z%FastChildWatcher.remove_child_handlerc C s zt dt j\}}W n tk
r, Y d S X |dkr:d S t|}| j z| j|\}}W nN tk
r | j r|| j
|< | j rt
d|| Y W 5 Q R q d }Y nX | j rt
d|| W 5 Q R X |d krt
d|| q |||f| q d S )Nr3 r z,unknown process %s exited with returncode %sr6 z8Caught subprocess termination from unknown pid: %d -> %d)rx r8 r9 r: r' r= r) r; rJ r? r> r r r
r r )r rn r& ro rD rE r r r r, < s@
z FastChildWatcher._do_waitpid_all) r r r r r r% r r! r_ r r, r r r r! r r s r c @ sh e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
dd Z dd Z dd Z
dd ZdS )r a~ A watcher that doesn't require running loop in the main thread.
This implementation registers a SIGCHLD signal handler on
instantiation (which may conflict with other code that
install own handler for this signal).
The solution is safe but it has a significant overhead when
handling a big number of processes (*O(n)* each time a
SIGCHLD is received).
c C s i | _ d | _d S r )r) _saved_sighandlerr r r r r z s z MultiLoopChildWatcher.__init__c C s
| j d k S r )r@ r r r r r\ ~ s z MultiLoopChildWatcher.is_activec C sT | j | jd krd S ttj}|| jkr:td nttj| j d | _d S )Nz+SIGCHLD handler was changed by outside code) r) r- r@ r9 getsignalr. r/ r
r )r rN r r r r% s
zMultiLoopChildWatcher.closec C s | S r r r r r r r s z MultiLoopChildWatcher.__enter__c C s d S r r r exc_typeZexc_valZexc_tbr r r r! s z MultiLoopChildWatcher.__exit__c G s& t }|||f| j|< | | d S r )r get_running_loopr) r+ )r rn rD rE r r r r r_ s z'MultiLoopChildWatcher.add_child_handlerc C s* z| j |= W dS tk
r$ Y dS X d S r1 r2 r r r r r s
z*MultiLoopChildWatcher.remove_child_handlerc C sN | j d k rd S ttj| j| _ | j d kr s z6ThreadedChildWatcher._join_threads..N)r( rI valuesr )r threadsrO r r r rJ s z"ThreadedChildWatcher._join_threadsc C s | S r r r r r r r s z ThreadedChildWatcher.__enter__c C s d S r r rB r r r r! s z ThreadedChildWatcher.__exit__c C s6 dd t | j D }|r2|| j dt| d d S )Nc S s g | ]}| r|qS r )rK rM r r r rP s z0ThreadedChildWatcher.__del__..z0 has registered but not finished child processesr# )r( rI rQ r" r, )r r rR r r r r s z ThreadedChildWatcher.__del__c G sF t }tj| jdt| j ||||fdd}|| j|< | d S )Nzwaitpid-T)targetnamerE rL ) r rD r< ZThreadr+ nextrH rI start)r rn rD rE r rO r r r r_ s
z&ThreadedChildWatcher.add_child_handlerc C s dS r r r r r r r s z)ThreadedChildWatcher.remove_child_handlerc C s d S r r r r r r r s z ThreadedChildWatcher.attach_loopc C s |dks t zt|d\}}W n( tk
rH |}d}td| Y n X t|}| rhtd|| | rtd|| n|j
|||f| | j | d S )Nr r4 r5 r6 rE )
rw rx r8 r: r
r r' r r rF rm rI r; )r r r* rD rE rn r& ro r r r r+ " s(
z ThreadedChildWatcher._do_waitpidN)r r r r r r\ r% rJ r r! r* r+ r r_ r r r+ r r r r r s r c sH e Zd ZdZeZ fddZdd Z fddZdd Z d
d Z
Z S ) _UnixDefaultEventLoopPolicyz:UNIX event loop policy with a watcher for child processes.c s t d | _d S r )r r _watcherr r! r r r A s
z$_UnixDefaultEventLoopPolicy.__init__c C sH t j8 | jd kr:t | _tt tjr:| j| j j
W 5 Q R X d S r ) r r= rX r rO r< current_thread _MainThreadr _localr r r r r
_init_watcherE s
z)_UnixDefaultEventLoopPolicy._init_watcherc s6 t | | jdk r2tt tjr2| j| dS )zSet the event loop.
As a side effect, if a child watcher was set before, then calling
.set_event_loop() from the main thread will call .attach_loop(loop) on
the child watcher.
N)r set_event_looprX rO r< rY rZ r r r! r r r] M s
z*_UnixDefaultEventLoopPolicy.set_event_loopc C s | j dkr| | j S )z~Get the watcher for child processes.
If not yet set, a ThreadedChildWatcher object is automatically created.
N)rX r\ r r r r r[ [ s
z-_UnixDefaultEventLoopPolicy.get_child_watcherc C s4 |dkst |tst| jdk r*| j || _dS )z$Set the watcher for child processes.N)rO r rw rX r% )r rj r r r set_child_watchere s
z-_UnixDefaultEventLoopPolicy.set_child_watcher) r r r r r Z
_loop_factoryr r\ r] r[ r^ r r r r! r rW = s
rW )2r rB r rG rx r r9 rz r r r& r< r* r r r r r r r r
r r logr
__all__r ImportErrorr ZBaseSelectorEventLoopr Z
ReadTransportrR Z_FlowControlMixinZWriteTransportrY ZBaseSubprocessTransportr^ r r' r( r r r r ZBaseDefaultEventLoopPolicyrW r r r r r r s`
NO5Ji}Y3PK ! % % $ __pycache__/staggered.cpython-38.pycnu [ U
ifh
@ s d Z dZddlZddlZddlmZ ddlmZ ddlmZ ddlm Z dd ej
ej g ej f ej
e ejejejej
e ejej
e f d
d d ZdS )
zFSupport for running coroutines in parallel with staggered start times.)staggered_race N )events)
exceptions)locks)tasks)loop)coro_fnsdelayr returnc s p
t t| ddg g tjtj dd fdd d}| zfd}|t
krt I dH \}}t
|}|D ]$}|
r| s| r| qqlfW S D ] }| qX dS )a Run coroutines with staggered start times and take the first to finish.
This method takes an iterable of coroutine functions. The first one is
started immediately. From then on, whenever the immediately preceding one
fails (raises an exception), or when *delay* seconds has passed, the next
coroutine is started. This continues until one of the coroutines complete
successfully, in which case all others are cancelled, or until all
coroutines fail.
The coroutines provided should be well-behaved in the following way:
* They should only ``return`` if completed successfully.
* They should always raise an exception if they did not complete
successfully. In particular, if they handle cancellation, they should
probably reraise, like this::
try:
# do work
except asyncio.CancelledError:
# undo partially completed work
raise
Args:
coro_fns: an iterable of coroutine functions, i.e. callables that
return a coroutine object when called. Use ``functools.partial`` or
lambdas to pass arguments.
delay: amount of time, in seconds, between starting coroutines. If
``None``, the coroutines will run sequentially.
loop: the event loop to use.
Returns:
tuple *(winner_result, winner_index, exceptions)* where
- *winner_result*: the result of the winning coroutine, or ``None``
if no coroutines won.
- *winner_index*: the index of the winning coroutine in
``coro_fns``, or ``None`` if no coroutines won. If the winning
coroutine may return None on success, *winner_index* can be used
to definitively determine whether any coroutine won.
- *exceptions*: list of exceptions returned by the coroutines.
``len(exceptions)`` is equal to the number of coroutines actually
started, and the order is the same as in ``coro_fns``. The winning
coroutine's entry is ``None``.
N)previous_failedr c
sN | d k r6t tj t| I d H W 5 Q R X zt\}}W n tk
r\ Y d S X t
} |} | t
|d kst d t
|d kstz| I d H }W nL ttfk
r Y np tk
r } z||< | W 5 d }~X Y n>X d ks t||tD ] \}}||kr,| q,d S )N r )
contextlibsuppressexceptions_mod TimeoutErrorr Zwait_forwaitnext
StopIterationr Event create_taskappendlenAssertionError
SystemExitKeyboardInterrupt
BaseExceptionset enumeratecancel) r Z
this_indexZcoro_fnZ this_failedZ next_taskresulteitr
Z
enum_coro_fnsr r run_one_coroZ
running_tasksZ winner_indexZ
winner_result 6/opt/alt/python38/lib64/python3.8/asyncio/staggered.pyr% R s4
z$staggered_race..run_one_coror )r Zget_running_loopr typingOptionalr r r r r r r r doneZ cancelledZ exception) r r
r Z
first_taskr# Z
done_countr* _dr& r$ r' r s, =
0
r )__doc____all__r r( r r r r r IterableCallable Awaitabler) floatZAbstractEventLoopZTupleZAnyintZList Exceptionr r& r& r& r' s& PK ! !8 8 ( __pycache__/streams.cpython-38.opt-2.pycnu [ U
if h @ s& d Z ddlZddlZddlZddlZeedr6e d7 Z ddlmZ ddlmZ ddlm Z dd lm
Z
dd
lm Z dd l m
Z
dd lmZ d
Zd dedddZd dedddZeedrd!dedddZd"dedddZG dd de jZG dd dee jZG dd d ZG d d d ZdS )#) StreamReader StreamWriterStreamReaderProtocolopen_connection start_server NZAF_UNIX)open_unix_connectionstart_unix_server )
coroutines)events)
exceptions)format_helpers) protocols)logger)sleepi )looplimitc st |d krt }ntjdtdd t||d}t||d |j fdd| |f|I d H \}}t| ||}||fS )N[The loop argument is deprecated since Python 3.8, and scheduled for removal in Python 3.10.
stacklevelr r r c s S N r protocolr 4/opt/alt/python38/lib64/python3.8/asyncio/streams.py5 z!open_connection..) r get_event_loopwarningswarnDeprecationWarningr r Zcreate_connectionr ) hostportr r kwdsreader transport_writerr r r r s"
r c sJ d krt ntjdtdd fdd}j|||f|I d H S )Nr r r c s t d} t| d}|S Nr r r r r' r client_connected_cbr r r r factoryX s
z start_server..factory)r r r! r" r# Z
create_server)r/ r$ r% r r r& r0 r r. r r : s
r c sr |d krt }ntjdtdd t||d}t||d |j fdd| f|I d H \}}t| ||}||fS )Nr r r r r c s S r r r r r r r p r z&open_unix_connection..) r r r! r" r# r r Zcreate_unix_connectionr )pathr r r& r' r( r) r* r r r r d s
r c sH d krt ntjdtdd fdd}j||f|I d H S )Nr r r c s t d} t| d}|S r+ r, r- r. r r r0 ~ s
z"start_unix_server..factory)r r r! r" r# Zcreate_unix_server)r/ r1 r r r& r0 r r. r r t s
r c @ s> e Zd ZdddZdd Zdd Zdd Zd
d Zd d
ZdS )FlowControlMixinNc C s0 |d krt | _n|| _d| _d | _d| _d S NF)r r _loop_paused
_drain_waiter_connection_lost)selfr r r r __init__ s zFlowControlMixin.__init__c C s d| _ | j r td| d S )NTz%r pauses writing)r5 r4 get_debugr debugr8 r r r
pause_writing s
z FlowControlMixin.pause_writingc C sF d| _ | j r td| | j}|d k rBd | _| sB|d d S )NFz%r resumes writing)r5 r4 r: r r; r6 done
set_resultr8 waiterr r r resume_writing s
z FlowControlMixin.resume_writingc C sV d| _ | jsd S | j}|d kr"d S d | _| r4d S |d krH|d n
|| d S NT)r7 r5 r6 r> r?
set_exceptionr8 excrA r r r connection_lost s z FlowControlMixin.connection_lostc s< | j rtd| jsd S | j}| j }|| _|I d H d S )NzConnection lost)r7 ConnectionResetErrorr5 r6 r4
create_futurer@ r r r
_drain_helper s
z FlowControlMixin._drain_helperc C s t d S r )NotImplementedErrorr8 streamr r r _get_close_waiter s z"FlowControlMixin._get_close_waiter)N) __name__
__module__ __qualname__r9 r= rB rG rJ rN r r r r r2 s
r2 c sb e Zd ZdZd fdd Zedd Zdd Z fdd Zd
d Z d d
Z
dd Z dd Z Z
S )r Nc sn t j|d |d k r,t|| _|j| _nd | _|d k r@|| _d| _d | _d | _ || _
d| _ | j
| _d S )Nr F)superr9 weakrefref_stream_reader_wr_source_traceback_strong_reader_reject_connection_stream_writer
_transport_client_connected_cb _over_sslr4 rI _closed)r8 Z
stream_readerr/ r __class__r r r9 s
z StreamReaderProtocol.__init__c C s | j d krd S | S r )rU r< r r r _stream_reader s
z#StreamReaderProtocol._stream_readerc C s | j r6ddi}| jr | j|d< | j| | d S || _| j}|d k rT|| |dd k | _ | j
d k rt || || j| _ |
|| j }t
|r| j| d | _d S )NmessagezpAn open stream was garbage collected prior to establishing network connection; call "stream.close()" explicitly.Zsource_tracebackZ
sslcontext)rX rV r4 Zcall_exception_handlerabortrZ r`
set_transportget_extra_infor\ r[ r rY r
Z iscoroutineZ create_taskrW )r8 r( contextr' resr r r connection_made s2
z$StreamReaderProtocol.connection_madec sx | j }|d k r*|d kr | n
|| | j sV|d krJ| jd n | j| t | d | _d | _ d | _
d S r ) r` feed_eofrD r] r> r? rR rG rU rY rZ )r8 rF r' r^ r r rG
s
z$StreamReaderProtocol.connection_lostc C s | j }|d k r|| d S r )r` feed_data)r8 datar' r r r
data_received s z"StreamReaderProtocol.data_receivedc C s$ | j }|d k r| | jr dS dS )NFT)r` rh r\ )r8 r' r r r eof_received s z!StreamReaderProtocol.eof_receivedc C s | j S r )r] rL r r r rN + s z&StreamReaderProtocol._get_close_waiterc C s" | j }| r | s | d S r )r] r> cancelled exception)r8 closedr r r __del__. s z StreamReaderProtocol.__del__)NN)rO rP rQ rV r9 propertyr` rg rG rk rl rN rp
__classcell__r r r^ r r s
r c @ sr e Zd Zdd Zdd Zedd Zdd Zd d
Zd d Z d
d Z
dd Z dd Z dd Z
dddZdd ZdS )r c C s4 || _ || _|| _|| _| j | _| jd d S r )rZ _protocol_readerr4 rI Z
_complete_futr? )r8 r( r r' r r r r r9 @ s zStreamWriter.__init__c C s@ | j jd| jg}| jd k r0|d| j dd|S )N
transport=zreader=<{}> )r_ rO rZ rt appendformatjoinr8 infor r r __repr__J s
zStreamWriter.__repr__c C s | j S r rZ r< r r r r( P s zStreamWriter.transportc C s | j | d S r )rZ writer8 rj r r r r T s zStreamWriter.writec C s | j | d S r )rZ
writelinesr r r r r W s zStreamWriter.writelinesc C s
| j S r )rZ write_eofr< r r r r Z s zStreamWriter.write_eofc C s
| j S r )rZ
can_write_eofr< r r r r ] s zStreamWriter.can_write_eofc C s
| j S r )rZ closer< r r r r ` s zStreamWriter.closec C s
| j S r )rZ
is_closingr< r r r r c s zStreamWriter.is_closingc s | j | I d H d S r )rs rN r< r r r wait_closedf s zStreamWriter.wait_closedNc C s | j ||S r )rZ rd )r8 namedefaultr r r rd i s zStreamWriter.get_extra_infoc sL | j d k r | j }|d k r || j r8tdI d H | j I d H d S )Nr )rt rn rZ r r rs rJ )r8 rF r r r drainl s
zStreamWriter.drain)N)rO rP rQ r9 r} rq r( r r r r r r r rd r r r r r r 6 s
r c @ s e Zd ZdZedfddZdd Zdd Zdd Zd
d Z d d
Z
dd Z dd Z dd Z
dd Zdd Zdd Zd&dd Zd'd d Zd d! Zd"d# Zd$d% ZdS )(r Nc C sv |dkrt d|| _|d kr*t | _n|| _t | _d| _d | _d | _ d | _
d| _ | j rrt
td| _d S )Nr zLimit cannot be <= 0Fr )
ValueError_limitr r r4 bytearray_buffer_eof_waiter
_exceptionrZ r5 r: r
extract_stacksys _getframerV )r8 r r r r r r9 s
zStreamReader.__init__c C s dg}| j r"|t| j d | jr2|d | jtkrN|d| j | jrf|d| j | jr~|d| j | jr|d| j | j r|d d
d
|S ) Nr z byteseofzlimit=zwaiter=z
exception=ru Zpausedrv rw ) r rx lenr r _DEFAULT_LIMITr r rZ r5 ry rz r{ r r r r} s
zStreamReader.__repr__c C s | j S r )r r< r r r rn s zStreamReader.exceptionc C s0 || _ | j}|d k r,d | _| s,|| d S r )r r rm rD rE r r r rD s zStreamReader.set_exceptionc C s* | j }|d k r&d | _ | s&|d d S r )r rm r? r@ r r r _wakeup_waiter s
zStreamReader._wakeup_waiterc C s
|| _ d S r r~ )r8 r( r r r rc s zStreamReader.set_transportc C s* | j r&t| j| jkr&d| _ | j d S r3 )r5 r r r rZ resume_readingr< r r r _maybe_resume_transport s z$StreamReader._maybe_resume_transportc C s d| _ | d S rC )r r r< r r r rh s zStreamReader.feed_eofc C s | j o | j S r )r r r< r r r at_eof s zStreamReader.at_eofc C st |sd S | j | | | jd k rp| jspt| j d| j krpz| j W n tk
rh d | _Y nX d| _d S )Nr T) r extendr rZ r5 r r Z
pause_readingrK r r r r ri s
zStreamReader.feed_datac sX | j d k rt| d| jr.d| _| j | j | _ z| j I d H W 5 d | _ X d S )NzF() called while another coroutine is already waiting for incoming dataF)r RuntimeErrorr5 rZ r r4 rI )r8 Z func_namer r r _wait_for_data s
zStreamReader._wait_for_datac
s d}t |}z| |I d H }W n tjk
rN } z|j W Y S d }~X Y nh tjk
r } zH| j||jr| jd |j| = n
| j |
t |j d W 5 d }~X Y nX |S )N
r )
r readuntilr IncompleteReadErrorpartialLimitOverrunErrorr
startswithconsumedclearr r args)r8 sepseplenlineer r r readline s
zStreamReader.readliner c s t |}|dkrtd| jd k r(| jd}t | j}|| |kr|| j||}|dkrZq|d | }|| jkr|td|| jrt | j}| j
t |d | dI d H q,|| jkrtd|| jd || }| jd || = |
t |S )Nr z,Separator should be at least one-byte stringr z2Separator is not found, and chunk exceed the limitr z2Separator is found, but chunk is longer than limit)r r r r findr r r r bytesr r r r )r8 Z separatorr offsetZbuflenZisepchunkr r r r ( s>
zStreamReader.readuntilr c s | j d k r| j |dkr dS |dk rVg }| | jI d H }|s@qL|| q(d|S | jsr| jsr| dI d H t| jd | }| jd |= | |S )Nr r read)
r r r rx rz r r r r r )r8 nZblocksblockrj r r r r s"
zStreamReader.readc s |dk rt d| jd k r | j|dkr,dS t| j|k rr| jr`t| j}| j t||| dI d H q,t| j|krt| j}| j n t| jd | }| jd |= |
|S )Nr z*readexactly size can not be less than zeror readexactly) r r r r r r r r r r r )r8 r Z
incompleterj r r r r s&
zStreamReader.readexactlyc C s | S r r r< r r r __aiter__ s zStreamReader.__aiter__c s | I d H }|dkrt|S )Nr )r StopAsyncIteration)r8 valr r r __anext__ s zStreamReader.__anext__)r )r )rO rP rQ rV r r9 r} rn rD r rc r rh r ri r r r r r r r r r r r r s$
[
2)r )NN)NN)N)N)__all__Zsocketr r! rS hasattr r
r r r
r logr Ztasksr r r r r r ZProtocolr2 r r r r r r r sF
! '
DkPPK ! {`^ `^ * __pycache__/proactor_events.cpython-38.pycnu [ U
if<} @ sT d Z dZddlZddlZddlZddlZddlZddlZddlZddl m
Z
ddl m Z ddl m Z ddl m
Z
dd l mZ dd
l mZ dd l mZ dd l mZ dd
lmZ dd ZG dd dejejZG dd deejZG dd deejZG dd deZ G dd deZ G dd deeej Z G d d d eeej Z G d d d e
j!Z"dS ) zEvent loop using a proactor and related classes.
A proactor is a "notify-on-completion" multiplexer. Currently a
proactor is only implemented on Windows with IOCP.
)BaseProactorEventLoop N ) base_events) constants)futures)
exceptions) protocols)sslproto)
transports)trsock)loggerc C s t || jd< z| | jd< W n0 tjk
rR | j rNtj d|dd Y nX d| jkrz|
| jd< W n tjk
r d | jd< Y nX d S )NsocketZsocknamezgetsockname() failed on %rTexc_infopeername) r TransportSocket_extraZ getsocknamer
error_loop get_debugr warningZ getpeername) transportsock r )
r4 __name__r appendr( filenor$ r% r# lenr) formatjoin)r- infor r r __repr__H s
z#_ProactorBasePipeTransport.__repr__c C s || j d< d S )Npipe)r r- r r r r r Z s z%_ProactorBasePipeTransport._set_extrac C s
|| _ d S Nr+ )r- r/ r r r r! ] s z'_ProactorBasePipeTransport.set_protocolc C s | j S rB rC r- r r r get_protocol` s z'_ProactorBasePipeTransport.get_protocolc C s | j S rB )r( rD r r r
is_closingc s z%_ProactorBasePipeTransport.is_closingc C s\ | j r
d S d| _ | jd7 _| js>| jd kr>| j| jd | jd k rX| j d | _d S )NTr ) r( r' r# r% r r* _call_connection_lostr$ cancelrD r r r closef s
z _ProactorBasePipeTransport.closec C s* | j d k r&|d| t| d | d S )Nzunclosed transport )source)r ResourceWarningrI )r- Z_warnr r r __del__q s
z"_ProactorBasePipeTransport.__del__ Fatal error on pipe transportc C sV zDt|tr*| j rBtjd| |dd n| j||| | jd W 5 | | X d S )Nz%r: %sTr )message exceptionr r/ ) _force_close
isinstanceOSErrorr r r debugcall_exception_handlerr+ )r- excrN r r r _fatal_errorv s
z'_ProactorBasePipeTransport._fatal_errorc C s | j d k r6| j s6|d kr*| j d n | j | | jr@d S d| _| jd7 _| jrj| j d | _| jr| j d | _d| _ d | _
| j | j
| d S )NTr r )
_empty_waiterdone
set_resultZ
set_exceptionr( r' r% rH r$ r& r# r r* rG )r- rU r r r rP s"
z'_ProactorBasePipeTransport._force_closec C s^ z| j | W 5 t | jdr,| jtj | j d | _| j}|d k rX| d | _X d S )Nshutdown)
hasattrr rZ r
Z SHUT_RDWRrI r" Z_detachr+ Zconnection_lost)r- rU r2 r r r rG s
z0_ProactorBasePipeTransport._call_connection_lostc C s" | j }| jd k r |t| j7 }|S rB )r& r# r; )r- sizer r r get_write_buffer_size s
z0_ProactorBasePipeTransport.get_write_buffer_size)NNN)rM )r8
__module__ __qualname____doc__r r? r r! rE rF rI warningswarnrL rV rP rG r]
__classcell__r r r3 r r . s
r c sT e Zd ZdZd fdd Zdd Zdd Zd d
Zd d Zd
d Z dddZ
Z S )_ProactorReadPipeTransportzTransport for read pipes.Nc s: d | _ d| _t |||||| | j| j d| _d S )NTF)
_pending_data_pausedr r r r*
_loop_readingr, r3 r r r s
z#_ProactorReadPipeTransport.__init__c C s | j o| j S rB )rf r( rD r r r
is_reading s z%_ProactorReadPipeTransport.is_readingc C s0 | j s | jrd S d| _| j r,td| d S )NTz%r pauses reading)r( rf r r r rS rD r r r
pause_reading s
z(_ProactorReadPipeTransport.pause_readingc C sn | j s | jsd S d| _| jd kr0| j| jd | j}d | _|d k rT| j| j| | j rjt
d| d S )NFz%r resumes reading) r( rf r$ r r* rg re _data_receivedr r rS r- datar r r resume_reading s
z)_ProactorReadPipeTransport.resume_readingc
C s | j rtd| z| j }W nL ttfk
r> Y n4 tk
rp } z| |d W Y d S d }~X Y nX |s~|
d S )Nz%r received EOFz1Fatal error: protocol.eof_received() call failed.) r r r rS r+ Z eof_received
SystemExitKeyboardInterrupt
BaseExceptionrV rI )r- Z keep_openrU r r r
_eof_received s
z(_ProactorReadPipeTransport._eof_receivedc
C s | j r | jd kst|| _d S |s.| d S t| jtjrzt| j| W q t t
fk
rh Y q t k
r } z| |d W Y d S d }~X Y qX n | j
| d S )Nz3Fatal error: protocol.buffer_updated() call failed.)rf re AssertionErrorrq rQ r+ r ZBufferedProtocolZ _feed_data_to_buffered_protorn ro rp rV Z
data_received)r- rl rU r r r rj s$ z)_ProactorReadPipeTransport._data_receivedc
C s d }zrz|d k rP| j|ks0| jd kr,| js0td | _| rH| }n| | jrfd }W W d S |dkrzW W d S | js| jj
| j d| _W n t k
r } z0| js|
|d n| j rtjddd W 5 d }~X Y n tk
r } z| | W 5 d }~X Y nf tk
r> } z|
|d W 5 d }~X Y n8 tjk
r^ | jsZ Y nX | jsv| j| j W 5 |d k r| | X d S )N i z"Fatal read error on pipe transportz*Read error on pipe transport while closingTr )rj r$ r( rr rX resultrH rf r _proactorrecvr ConnectionAbortedErrorrV r r rS ConnectionResetErrorrP rR r CancelledErroradd_done_callbackrg )r- futrl rU r r r rg sF
z(_ProactorReadPipeTransport._loop_reading)NNN)N) r8 r^ r_ r` r rh ri rm rq rj rg rc r r r3 r rd s rd c s^ e Zd ZdZdZ fddZdd Zddd Zd
d Zd d
Z dd Z
dd Z dd Z Z
S ) _ProactorBaseWritePipeTransportzTransport for write pipes.Tc s t j|| d | _d S rB )r r rW r- argskwr3 r r r G s z(_ProactorBaseWritePipeTransport.__init__c C s t |tttfs$tdt|j | jr2td| j d k rDtd|sLd S | j
rz| j
t j krht
d | j
d7 _
d S | jd kr| jd kst| jt|d n.| jst|| _| n| j| | d S )Nz/data argument must be a bytes-like object, not zwrite_eof() already calledz(unable to write; sendfile is in progressz socket.send() raised exception.r )rl )rQ bytes bytearray
memoryview TypeErrortyper8 r) RuntimeErrorrW r' r !LOG_THRESHOLD_FOR_CONNLOST_WRITESr r r% r# rr
_loop_writing_maybe_pause_protocolextendrk r r r writeK s.
z%_ProactorBaseWritePipeTransport.writeNc
C sx z|d k r"| j d kr"| jr"W d S || j ks0td | _ d| _|rH| |d kr\| j}d | _|s| jrv| j| jd | j r| j
t j
| n\| jj| j
|| _ | j s| jdkstt|| _| j | j | n| j | j | jd k r| j d kr| jd W n\ tk
rD } z| | W 5 d }~X Y n0 tk
rr } z| |d W 5 d }~X Y nX d S )Nr z#Fatal write error on pipe transport) r% r( rr r& rt r# r r* rG r) r rZ r
SHUT_WR_maybe_resume_protocolru sendrX r; rz r r rW rY rx rP rR rV )r- frl rU r r r r q s<
z-_ProactorBaseWritePipeTransport._loop_writingc C s dS NTr rD r r r
can_write_eof s z-_ProactorBaseWritePipeTransport.can_write_eofc C s | d S rB )rI rD r r r write_eof s z)_ProactorBaseWritePipeTransport.write_eofc C s | d d S rB rP rD r r r abort s z%_ProactorBaseWritePipeTransport.abortc C s: | j d k rtd| j | _ | jd kr4| j d | j S )NzEmpty waiter is already set)rW r r Z
create_futurer% rY rD r r r _make_empty_waiter s
z2_ProactorBaseWritePipeTransport._make_empty_waiterc C s
d | _ d S rB )rW rD r r r _reset_empty_waiter s z3_ProactorBaseWritePipeTransport._reset_empty_waiter)NN)r8 r^ r_ r` Z_start_tls_compatibler r r r r r r r rc r r r3 r r| A s &
)r| c s$ e Zd Z fddZdd Z ZS )_ProactorWritePipeTransportc s4 t j|| | jj| jd| _| j| j d S )N ) r r r ru rv r r$ rz _pipe_closedr} r3 r r r s z$_ProactorWritePipeTransport.__init__c C sv | r d S | dks t| jr4| jd ks0td S || jksLt|| jfd | _| jd k rj| t n| d S )Nrs ) Z cancelledrt rr r( r$ r% rP BrokenPipeErrorrI )r- r{ r r r r s
z(_ProactorWritePipeTransport._pipe_closed)r8 r^ r_ r r rc r r r3 r r s r c sX e Zd ZdZd fdd Zdd Zdd Zd d
Zdd d Zdd
dZ dddZ
Z S )_ProactorDatagramTransporti Nc s> || _ d | _t j|||||d t | _| j| j d S )N)r0 r1 )
_addressrW r r collectionsdequer# r r* rg )r- r. r r/ addressr0 r1 r3 r r r s
z#_ProactorDatagramTransport.__init__c C s t | | d S rB r rA r r r r s z%_ProactorDatagramTransport._set_extrac C s t dd | jD S )Nc s s | ]\}}t |V qd S rB )r; ).0rl _r r r s zC_ProactorDatagramTransport.get_write_buffer_size..)sumr# rD r r r r] s z0_ProactorDatagramTransport.get_write_buffer_sizec C s | d d S rB r rD r r r r s z _ProactorDatagramTransport.abortc C s t |tttfs tdt||s&d S | jd k rN|d | jfkrNtd| j | jr| jr| jt j
krpt d | jd7 _d S | j
t||f | jd kr| | d S )Nz,data argument must be bytes-like object (%r)z!Invalid address: must be None or z!socket.sendto() raised exception.r )rQ r r r r r r
ValueErrorr' r r r r r# r9 r% r r )r- rl addrr r r sendto s&
z!_ProactorDatagramTransport.sendtoc
C s z| j rW d S || jks td | _|r.| | jr@| j r\| jr\| jrV| j| j d W d S | j
\}}| jd k r| jj | j
|| _n| jj j| j
||d| _W nZ tk
r } z| j| W 5 d }~X Y nD tk
r } z| |d W 5 d }~X Y nX | j| j | d S )N)r z'Fatal write error on datagram transport)r' r% rr rt r# r r( r r* rG popleftru r r r rR r+ error_received ExceptionrV rz r r )r- r{ rl r rU r r r r s4
z(_ProactorDatagramTransport._loop_writingc
C sV d }z4z| jr W W $d S | j|ks:| jd kr6| js:td | _|d k r| }| jrdd }W W d S | jd k r||| j }}n|\}}| jrW W d S | jd k r| jj
| j | j | _n| jj
| j | j | _W nN tk
r } z| j | W 5 d }~X Y n< tjk
r | js Y n X | jd k r8| j| j W 5 |rP| j || X d S rB )r+ Zdatagram_receivedr' r$ r( rr rt r r ru rv r max_sizeZrecvfromrR r r ry rz rg )r- r{ rl r resrU r r r rg sD
z(_ProactorDatagramTransport._loop_reading)NNN)N)N)N) r8 r^ r_ r r r r] r r r rg rc r r r3 r r s
!r c @ s e Zd ZdZdd Zdd ZdS ) _ProactorDuplexPipeTransportzTransport for duplex pipes.c C s dS )NFr rD r r r r J s z*_ProactorDuplexPipeTransport.can_write_eofc C s t d S rB )NotImplementedErrorrD r r r r M s z&_ProactorDuplexPipeTransport.write_eofN)r8 r^ r_ r` r r r r r r r E s r c sB e Zd ZdZejjZd fdd Zdd Z dd Z
d d
Z Z S ) _ProactorSocketTransportz Transport for connected sockets.Nc s$ t |||||| t| d S rB )r r r Z _set_nodelayr, r3 r r r X s z!_ProactorSocketTransport.__init__c C s t | | d S rB r rA r r r r ] s z#_ProactorSocketTransport._set_extrac C s dS r r rD r r r r ` s z&_ProactorSocketTransport.can_write_eofc C s2 | j s | jrd S d| _| jd kr.| jtj d S r )r( r) r% r rZ r
r rD r r r r c s
z"_ProactorSocketTransport.write_eof)NNN)
r8 r^ r_ r` r Z
_SendfileModeZ
TRY_NATIVEZ_sendfile_compatibler r r r rc r r r3 r r Q s r c s e Zd Z fddZd3ddZd4dddddddd Zd5d
d Zd6d d
Zd7ddZd8ddZ fddZ
dd Z dd Z dd Z
dd Zd d Zd d Zd d! Zd"d# Zd$d% Zd9d&d'Zd(d) Zd:d+d,Zd-d. Zd/d0 Zd1d2 Z ZS );r c sh t td|jj || _|| _d | _i | _ |
| | t
t krdt| j d S )NzUsing proactor: %s)r r r rS r4 r8 ru _selector_self_reading_future_accept_futuresZset_loop_make_self_pipe threadingcurrent_thread main_threadsignal
set_wakeup_fd_csockr: )r- Zproactorr3 r r r m s
z BaseProactorEventLoop.__init__Nc C s t | |||||S rB )r )r- r r/ r0 r1 r2 r r r _make_socket_transportz s
z,BaseProactorEventLoop._make_socket_transportF) server_sideserver_hostnamer1 r2 ssl_handshake_timeoutc C s0 t j| |||||| d}
t| ||
||d |
jS )N)r r1 r2 )r Z SSLProtocolr Z_app_transport) r- Zrawsockr/
sslcontextr0 r r r1 r2 r Z ssl_protocolr r r _make_ssl_transport s z)BaseProactorEventLoop._make_ssl_transportc C s t | |||||S rB )r )r- r r/ r r0 r1 r r r _make_datagram_transport s
z.BaseProactorEventLoop._make_datagram_transportc C s t | ||||S rB )r r- r r/ r0 r1 r r r _make_duplex_pipe_transport s z1BaseProactorEventLoop._make_duplex_pipe_transportc C s t | ||||S rB )rd r r r r _make_read_pipe_transport s z/BaseProactorEventLoop._make_read_pipe_transportc C s t | ||||S rB )r r r r r _make_write_pipe_transport s z0BaseProactorEventLoop._make_write_pipe_transportc sj | rtd| r d S t t kr6td | | | j
d | _
d | _ t
d S )Nz!Cannot close a running event loop)Z
is_runningr is_closedr r r r r _stop_accept_futures_close_self_piperu rI r r rD r3 r r rI s
zBaseProactorEventLoop.closec s | j ||I d H S rB )ru rv )r- r nr r r sock_recv s z BaseProactorEventLoop.sock_recvc s | j ||I d H S rB )ru Z recv_into)r- r Zbufr r r sock_recv_into s z$BaseProactorEventLoop.sock_recv_intoc s | j ||I d H S rB )ru r )r- r rl r r r sock_sendall s z"BaseProactorEventLoop.sock_sendallc s | j ||I d H S rB )ru Zconnect)r- r r r r r sock_connect s z"BaseProactorEventLoop.sock_connectc s | j |I d H S rB )ru acceptrA r r r sock_accept s z!BaseProactorEventLoop.sock_acceptc
s( z | }W n2 ttjfk
r> } ztdW 5 d }~X Y nX zt|j}W n, t k
r| } ztdW 5 d }~X Y nX |r|n|}|sdS t
|d}|rt
|| |n|} t
||}d}
zLt
| | |}|dkr|
W 0S | j
||||I d H ||7 }|
|7 }
qW 5 |
dkr"| | X d S )Nznot a regular filer l )r: AttributeErrorioUnsupportedOperationr ZSendfileNotAvailableErrorosfstatst_sizerR minseekru sendfile) r- r fileoffsetcountr: errZfsizeZ blocksizeZend_posZ
total_sentr r r _sock_sendfile_native s0
z+BaseProactorEventLoop._sock_sendfile_nativec sZ | }| | I d H z | j|j|||ddI d H W S | |rT| X d S )NF)Zfallback)rh ri r r rm Z
sock_sendfiler )r- Ztranspr r r rm r r r _sendfile_native s z&BaseProactorEventLoop._sendfile_nativec C sL | j d k r| j d | _ | j d | _| j d | _| jd8 _d S )Nr )r rH _ssockrI r
_internal_fdsrD r r r r s
z&BaseProactorEventLoop._close_self_pipec C s: t \| _| _| jd | jd | jd7 _d S )NFr )r
Z
socketpairr r Z setblockingr rD r r r r s z%BaseProactorEventLoop._make_self_pipec
C s z4|d k r| | j|k r"W d S | j| jd}W nb tjk
rL Y d S ttfk
rd Y nF t k
r } z|
d|| d W 5 d }~X Y nX || _| | j d S )Ni z.Error on reading from the event loop self pipe)rN rO r. )
rt r ru rv r r ry rn ro rp rT rz _loop_self_reading)r- r rU r r r r s$
z(BaseProactorEventLoop._loop_self_readingc C sN | j }|d krd S z|d W n( tk
rH | jrDtjddd Y nX d S )N z3Fail to write a null byte into the self-pipe socketTr )r r rR _debugr rS )r- Zcsockr r r _write_to_self s z$BaseProactorEventLoop._write_to_selfd c s( d fdd d S )Nc
s, z| d k rn| \}}jr,td|| }d k rXj||dd|id nj||d|id r|W d S j} W n t k
r } zH
dkrʈ d|t
d njrtjd dd
W 5 d }~X Y n8 tjk
r Y nX | j
< | d S ) Nz#%r got a new connection from %r: %rTr )r r1 r2 r r r zAccept failed on a socket)rN rO r
zAccept failed on socket %rr )rt r r rS r r r ru r rR r: rT r r rI r ry r rz )r Zconnr r/ rU r. protocol_factoryr- r2 r r r r r r. / s\
z2BaseProactorEventLoop._start_serving..loop)N)r* )r- r r r r2 Zbacklogr r r r _start_serving+ s %z$BaseProactorEventLoop._start_servingc C s d S rB r )r- Z
event_listr r r _process_eventsV s z%BaseProactorEventLoop._process_eventsc C s& | j D ] }| q
| j d S rB )r valuesrH clear)r- futurer r r r Z s
z*BaseProactorEventLoop._stop_accept_futuresc C s6 | j | d }|r | | j| | d S rB )r popr: rH ru
_stop_servingrI )r- r r r r r r _ s
z#BaseProactorEventLoop._stop_serving)NNN)N)NNN)NN)NN)NN)N)NNr N)r8 r^ r_ r r r r r r r rI r r r r r r r r r r r r r r r rc r r r3 r r k s\
+r )#r` __all__r r r
ra r r r r r r r r r r
r logr r Z_FlowControlMixinZ
BaseTransportr Z
ReadTransportrd ZWriteTransportr| r r Z Transportr r Z
BaseEventLoopr r r r r sR n PK ! {7 7 / __pycache__/format_helpers.cpython-38.opt-2.pycnu [ U
ifd @ sd d dl Z d dlZd dlZd dlZd dlZddlmZ dd Zdd Zdd Z dd d Z
dd
dZ dS ) N ) constantsc C sV t | } t | r&| j}|j|jfS t| tjr& s z*_format_args_and_kwargs..c s s& | ] \}}| d t | V qdS )=Nr )r kvr r r r ( s z({})z, )extenditemsformatjoin)r kwargsr" r r r _format_args_and_kwargs s r& c C s t | tjr.t||| }t| j| j| j|S t| drF| j rF| j }n t| dr^| j
r^| j
}nt | }|t||7 }|r||7 }|S )N __qualname____name__) r r
r r& r r
r keywordshasattrr( r) r )r
r r% suffixr r r r r , s r c C sD | d krt j} |d kr tj}tjjt| |dd}| |S )NF)limit lookup_lines)
sys _getframef_backr ZDEBUG_STACK_DEPTH traceback StackSummaryextract
walk_stackreverse)fr- stackr r r
extract_stack> s
r9 )r' )NN) r
r r r/ r2 r' r r r r& r r9 r r r r s
PK ! !S S ) __pycache__/sslproto.cpython-38.opt-1.pycnu [ U
ifJj @ s d dl Z d dlZz d dlZW n ek
r4 dZY nX ddlmZ ddlmZ ddlmZ ddlmZ ddl m
Z
dd Z d
Z d Z
d Zd
ZG dd deZG dd dejejZG dd dejZdS ) N ) base_events) constants) protocols)
transports)loggerc C s" | r t dt }|s d|_|S )Nz(Server side SSL needs a valid SSLContextF)
ValueErrorsslZcreate_default_contextZcheck_hostname) server_sideserver_hostname
sslcontext r
5/opt/alt/python38/lib64/python3.8/asyncio/sslproto.py_create_transport_context s r Z UNWRAPPEDZ DO_HANDSHAKEZWRAPPEDZSHUTDOWNc @ s~ e Zd ZdZdZdddZedd Zedd Zed
d Z ed d
Z
dddZ d ddZ dd Z
d ddZd ddZdS ) _SSLPipea An SSL "Pipe".
An SSL pipe allows you to communicate with an SSL/TLS protocol instance
through memory buffers. It can be used to implement a security layer for an
existing connection where you don't have access to the connection's file
descriptor, or for some reason you don't want to use it.
An SSL pipe can be in "wrapped" and "unwrapped" mode. In unwrapped mode,
data is passed through untransformed. In wrapped mode, application level
data is encrypted to SSL record level data and vice versa. The SSL record
level is the lowest level in the SSL protocol suite and is what travels
as-is over the wire.
An SslPipe initially is in "unwrapped" mode. To start SSL, call
do_handshake(). To shutdown SSL again, call unwrap().
i Nc C sH || _ || _|| _t| _t | _t | _d| _ d| _
d| _ d| _ dS )a
The *context* argument specifies the ssl.SSLContext to use.
The *server_side* argument indicates whether this is a server side or
client side transport.
The optional *server_hostname* argument can be used to specify the
hostname you are connecting to. You may only specify this parameter if
the _ssl module supports Server Name Indication (SNI).
NF)
_context _server_side_server_hostname
_UNWRAPPED_stater Z MemoryBIO _incoming _outgoing_sslobj
_need_ssldata
_handshake_cb _shutdown_cb)selfcontextr
r r
r
r __init__8 s
z_SSLPipe.__init__c C s | j S )z*The SSL context passed to the constructor.)r r r
r
r r N s z_SSLPipe.contextc C s | j S )z^The internal ssl.SSLObject instance.
Return None if the pipe is not wrapped.
)r r r
r
r
ssl_objectS s z_SSLPipe.ssl_objectc C s | j S )zgWhether more record level data is needed to complete a handshake
that is currently in progress.)r r r
r
r need_ssldata[ s z_SSLPipe.need_ssldatac C s
| j tkS )zj
Whether a security layer is currently in effect.
Return False during handshake.
)r _WRAPPEDr r
r
r wrappeda s z_SSLPipe.wrappedc C sR | j tkrtd| jj| j| j| j| jd| _ t
| _ || _ | j ddd\}}|S )aL Start the SSL handshake.
Return a list of ssldata. A ssldata element is a list of buffers
The optional *callback* argument can be used to install a callback that
will be called when the handshake is complete. The callback will be
called with None if successful, else an exception instance.
z"handshake in progress or completed)r
r T)only_handshake)
r r RuntimeErrorr Zwrap_bior r r r r
_DO_HANDSHAKEr feed_ssldatar callbackssldataappdatar
r
r do_handshakej s
z_SSLPipe.do_handshakec C sB | j tkrtd| j tkr$tdt| _ || _| d\}}|S )a1 Start the SSL shutdown sequence.
Return a list of ssldata. A ssldata element is a list of buffers
The optional *callback* argument can be used to install a callback that
will be called when the shutdown is complete. The callback will be
called without arguments.
zno security layer presentzshutdown in progressr$ )r r r& _SHUTDOWNr r( r) r
r
r shutdown s
z_SSLPipe.shutdownc C s | j | d\}}dS )zSend a potentially "ragged" EOF.
This method will raise an SSL_ERROR_EOF exception if the EOF is
unexpected.
r$ N)r Z write_eofr( )r r+ r, r
r
r feed_eof s
z_SSLPipe.feed_eofFc
C s | j tkr"|r|g}ng }g |fS d| _|r8| j| g }g }z| j tkrz| j t| _ | j rl| d |rz||fW S | j tkr| j
| j }| | |sqqnJ| j t
kr| j d| _t| _ | jr| n| j tkr| | j
W nz tjtjfk
rl } zRt|dd}|tjtjtjfkrP| j tkrN| j rN| | |tjk| _W 5 d}~X Y nX | jjr| | j
||fS )a Feed SSL record level data into the pipe.
The data must be a bytes instance. It is OK to send an empty bytes
instance. This can be used to get ssldata for a handshake initiated by
this endpoint.
Return a (ssldata, appdata) tuple. The ssldata element is a list of
buffers containing SSL data that needs to be sent to the remote SSL.
The appdata element is a list of buffers containing plaintext data that
needs to be forwarded to the application. The appdata list may contain
an empty buffer indicating an SSL "close_notify" alert. This alert must
be acknowledged by calling shutdown().
FNerrno)r r r r writer' r r- r" r readmax_sizeappendr. Zunwrapr r SSLErrorCertificateErrorgetattrSSL_ERROR_WANT_READSSL_ERROR_WANT_WRITESSL_ERROR_SYSCALLr pending)r datar% r, r+ chunkexc exc_errnor
r
r r( sZ
z_SSLPipe.feed_ssldatar c
C s | j tkr6|t|k r&||d g}ng }|t|fS g }t|}d| _z(|t|k rn|| j||d 7 }W nh tjk
r } zHt |dd}|j
dkrtj }|_ |tj tj
tjfkr |tj k| _W 5 d}~X Y nX | jjr|| j |t|ks | jrBq qB||fS )a Feed plaintext data into the pipe.
Return an (ssldata, offset) tuple. The ssldata element is a list of
buffers containing record level data that needs to be sent to the
remote SSL instance. The offset is the number of plaintext bytes that
were processed, which may be less than the length of data.
NOTE: In case of short writes, this call MUST be retried with the SAME
buffer passed into the *data* argument (i.e. the id() must be the
same). This is an OpenSSL requirement. A further particularity is that
a short write will always have offset == 0, because the _ssl module
does not enable partial writes. And even though the offset is zero,
there will still be encrypted data in ssldata.
NFr1 ZPROTOCOL_IS_SHUTDOWN)r r len
memoryviewr r r2 r r6 r8 reasonr9 r1 r: r; r r< r5 r3 )r r= offsetr+ Zviewr? r@ r
r
r feed_appdata s4
z_SSLPipe.feed_appdata)N)N)N)F)r )__name__
__module__ __qualname____doc__r4 r propertyr r r! r# r- r/ r0 r( rE r
r
r
r r $ s
Kr c @ s e Zd ZejjZdd Zd"ddZdd Z dd Z
d
d Z d d
Z e
jfddZdd Zdd Zdd Zd#ddZdd Zedd Zd d Zd d Zd d! ZdS )$_SSLProtocolTransportc C s || _ || _d| _d S )NF)_loop
_ssl_protocol_closed)r loopZ ssl_protocolr
r
r r ! s z _SSLProtocolTransport.__init__Nc C s | j ||S )z#Get optional transport information.)rM _get_extra_infor namedefaultr
r
r get_extra_info' s z$_SSLProtocolTransport.get_extra_infoc C s | j | d S N)rM _set_app_protocol)r protocolr
r
r set_protocol+ s z"_SSLProtocolTransport.set_protocolc C s | j jS rU )rM
_app_protocolr r
r
r get_protocol. s z"_SSLProtocolTransport.get_protocolc C s | j S rU )rN r r
r
r
is_closing1 s z _SSLProtocolTransport.is_closingc C s d| _ | j dS )a
Close the transport.
Buffered data will be flushed asynchronously. No more data
will be received. After all buffered data is flushed, the
protocol's connection_lost() method will (eventually) called
with None as its argument.
TN)rN rM _start_shutdownr r
r
r close4 s z_SSLProtocolTransport.closec C s& | j s"|d| t| d | d S )Nzunclosed transport )source)rN ResourceWarningr] )r Z_warnr
r
r __del__? s z _SSLProtocolTransport.__del__c C s | j j}|d krtd| S )Nz*SSL transport has not been initialized yet)rM
_transportr&
is_reading)r Ztrr
r
r rb D s z _SSLProtocolTransport.is_readingc C s | j j dS )zPause the receiving end.
No data will be passed to the protocol's data_received()
method until resume_reading() is called.
N)rM ra
pause_readingr r
r
r rc J s z#_SSLProtocolTransport.pause_readingc C s | j j dS )zResume the receiving end.
Data received will once again be passed to the protocol's
data_received() method.
N)rM ra resume_readingr r
r
r rd R s z$_SSLProtocolTransport.resume_readingc C s | j j|| dS )a Set the high- and low-water limits for write flow control.
These two values control when to call the protocol's
pause_writing() and resume_writing() methods. If specified,
the low-water limit must be less than or equal to the
high-water limit. Neither value can be negative.
The defaults are implementation-specific. If only the
high-water limit is given, the low-water limit defaults to an
implementation-specific value less than or equal to the
high-water limit. Setting high to zero forces low to zero as
well, and causes pause_writing() to be called whenever the
buffer becomes non-empty. Setting low to zero causes
resume_writing() to be called only once the buffer is empty.
Use of zero for either limit is generally sub-optimal as it
reduces opportunities for doing I/O and computation
concurrently.
N)rM ra set_write_buffer_limits)r ZhighZlowr
r
r re Z s z-_SSLProtocolTransport.set_write_buffer_limitsc C s | j j S )z,Return the current size of the write buffer.)rM ra get_write_buffer_sizer r
r
r rf o s z+_SSLProtocolTransport.get_write_buffer_sizec C s
| j jjS rU )rM ra _protocol_pausedr r
r
r rg s s z&_SSLProtocolTransport._protocol_pausedc C s< t |tttfs$tdt|j |s,dS | j| dS )zWrite some data bytes to the transport.
This does not block; it buffers the data and arranges for it
to be sent out asynchronously.
z+data: expecting a bytes-like instance, got N)
isinstancebytes bytearrayrB TypeErrortyperF rM _write_appdatar r= r
r
r r2 x s
z_SSLProtocolTransport.writec C s dS )zAReturn True if this transport supports write_eof(), False if not.Fr
r r
r
r
can_write_eof s z#_SSLProtocolTransport.can_write_eofc C s | j d| _dS )zClose the transport immediately.
Buffered data will be lost. No more data will be received.
The protocol's connection_lost() method will (eventually) be
called with None as its argument.
TN)rM _abortrN r r
r
r abort s
z_SSLProtocolTransport.abort)N)NN)rF rG rH r Z
_SendfileModeZFALLBACKZ_sendfile_compatibler rT rX rZ r[ r] warningswarnr` rb rc rd re rf rJ rg r2 ro rq r
r
r
r rK s$
rK c @ s e Zd ZdZd,ddZdd Zd-d d
Zd d Zd
d Zdd Z dd Z
dd Z dd Z d.ddZ
dd Zdd Zd d Zd d Zd!d" Zd#d$ Zd/d&d'Zd(d) Zd*d+ ZdS )0 SSLProtocolzSSL protocol.
Implementation of SSL on top of a socket using incoming and outgoing
buffers which are ssl.MemoryBIO objects.
FNTc C s t d krtd|d kr tj}n|dkr6td| |sDt||}|| _|rZ|sZ|| _nd | _|| _t |d| _
t | _
d| _|| _|| _| | t| j| | _d | _d| _d| _d| _d | _|| _|| _d S )Nz stdlib ssl module not availabler z7ssl_handshake_timeout should be a positive number, got )r F)r r& r ZSSL_HANDSHAKE_TIMEOUTr r r r _sslcontextdict_extra collectionsdeque_write_backlog_write_buffer_size_waiterrL rV rK _app_transport_sslpipe_session_established
_in_handshake _in_shutdownra _call_connection_made_ssl_handshake_timeout) r rO app_protocolr Zwaiterr
r Zcall_connection_madeZssl_handshake_timeoutr
r
r r s@
zSSLProtocol.__init__c C s || _ t|tj| _d S rU )rY rh r ZBufferedProtocol_app_protocol_is_buffer)r r r
r
r rV s
z SSLProtocol._set_app_protocolc C sD | j d krd S | j s:|d k r.| j | n | j d d | _ d S rU )r| Z cancelledZ
set_exceptionZ
set_resultr r? r
r
r _wakeup_waiter s
zSSLProtocol._wakeup_waiterc C s& || _ t| j| j| j| _| dS )zXCalled when the low-level connection is made.
Start the SSL handshake.
N)ra r ru r r r~ _start_handshake)r transportr
r
r connection_made s zSSLProtocol.connection_madec C sn | j r d| _ | j| jj| n| jdk r2d| j_d| _d| _t| ddrT| j
| | d| _d| _ dS )zCalled when the low-level connection is lost or closed.
The argument is an exception object or None (the latter
meaning a regular EOF is received or the connection was
aborted or closed).
FNT_handshake_timeout_handle)
r rL call_soonrY connection_lostr} rN ra r8 r cancelr r~ r r
r
r r s
zSSLProtocol.connection_lostc C s | j dS )z\Called when the low-level transport's buffer goes over
the high-water mark.
N)rY
pause_writingr r
r
r r s zSSLProtocol.pause_writingc C s | j dS )z^Called when the low-level transport's buffer drains below
the low-water mark.
N)rY resume_writingr r
r
r r s zSSLProtocol.resume_writingc C s" | j dkrdS z| j |\}}W nL ttfk
r< Y n4 tk
rn } z| |d W Y dS d}~X Y nX |D ]}| j| qt|D ]}|rz&| jrt
| j | n | j | W nP ttfk
r Y n8 tk
r
} z| |d W Y dS d}~X Y nX q|
q qdS )zXCalled when some SSL data is received.
The argument is a bytes object.
NzSSL error in data receivedz/application protocol failed to receive SSL data)r~ r(
SystemExitKeyboardInterrupt
BaseException _fatal_errorra r2 r r Z _feed_data_to_buffered_protorY
data_receivedr\ )r r= r+ r, er> Zexr
r
r r s<
zSSLProtocol.data_receivedc C sT zB| j rtd| | t | js@| j
}|r@t d W 5 | j X dS )a Called when the other end of the low-level stream
is half-closed.
If this returns a false value (including None), the transport
will close itself. If it returns a true value, closing the
transport is up to the protocol.
z%r received EOFz?returning true from eof_received() has no effect when using sslN) ra r] rL get_debugr debugr ConnectionResetErrorr rY eof_receivedZwarning)r Z keep_openr
r
r r - s
zSSLProtocol.eof_receivedc C s4 || j kr| j | S | jd k r,| j||S |S d S rU )rw ra rT rQ r
r
r rP C s
zSSLProtocol._get_extra_infoc C s. | j r
d S | jr| nd| _ | d d S )NTr$ )r r rp rm r r
r
r r\ K s
zSSLProtocol._start_shutdownc C s. | j |df | jt|7 _| d S )Nr )rz r5 r{ rA _process_write_backlogrn r
r
r rm T s zSSLProtocol._write_appdatac C s\ | j r$td| | j | _nd | _d| _| jd | j | j
| j | _ |
d S )Nz%r starts SSL handshakeT)r$ r )rL r r r time_handshake_start_timer rz r5 Z
call_laterr _check_handshake_timeoutr r r r
r
r r Y s
z SSLProtocol._start_handshakec C s* | j dkr&d| j d}| t| d S )NTz$SSL handshake is taking longer than z! seconds: aborting the connection)r r r ConnectionAbortedError)r msgr
r
r r h s
z$SSLProtocol._check_handshake_timeoutc
C s d| _ | j | jj}z|d k r&|| }W nb ttfk
rJ Y nJ tk
r } z,t |t
j rld}nd}| || W Y d S d }~X Y nX | j
r| j
| j }td| |d | jj|| | |d | jr| j| j | d| _ | j
| j d S )NFz1SSL handshake failed on verifying the certificatezSSL handshake failedz %r: SSL handshake took %.1f msg @@)peercertcipher compressionr T) r r r r~ r Z getpeercertr r r rh r r7 r rL r r r r r rw updater r r rY r r} r r r r )r Z
handshake_excZsslobjr r? r Zdtr
r
r _on_handshake_completeq s8
z"SSLProtocol._on_handshake_completec
C sB | j d ks| jd krd S ztt| jD ]}| jd \}}|rR| j||\}}n*|rj| j| j}d}n| j| j }d}|D ]}| j
| q|t|k r||f| jd< | j j r| j q| jd= | j
t|8 _
q(W n\ ttfk
r Y nD tk
r< } z$| jr | | n | |d W 5 d }~X Y nX d S )Nr r z Fatal error on SSL transport)ra r~ rangerA rz rE r- r r/ _finalizer2 Z_pausedrd r{ r r r r r )r ir= rD r+ r> r? r
r
r r s:
z"SSLProtocol._process_write_backlogFatal error on transportc C sV t |tr(| j r@tjd| |dd n| j||| j| d | jrR| j| d S )Nz%r: %sT)exc_info)messageZ exceptionr rW ) rh OSErrorrL r r r Zcall_exception_handlerra Z _force_close)r r? r r
r
r r s
zSSLProtocol._fatal_errorc C s d | _ | jd k r| j d S rU )r~ ra r] r r
r
r r s
zSSLProtocol._finalizec C s( z| jd k r| j W 5 | X d S rU )r ra rq r r
r
r rp s
zSSLProtocol._abort)FNTN)N)N)r )rF rG rH rI r rV r r r r r r r rP r\ rm r r r r r r rp r
r
r
r rt s0
.
&
)+
rt )rx rr r ImportError r r r r logr r r r' r" r. objectr Z_FlowControlMixinZ TransportrK ZProtocolrt r
r
r
r s*
yxPK ! _P + __pycache__/base_tasks.cpython-38.opt-1.pycnu [ U
if @ sD d dl Z d dlZddlmZ ddlmZ dd Zdd Zd d
ZdS ) N ) base_futures)
coroutinesc C sn t | }| jrd|d< |dd| t| j}|dd| d | jd k rj|dd | j |S )
NZ
cancellingr r zname=%r zcoro=<> z wait_for=) r Z_future_repr_infoZ _must_cancelinsertZget_namer Z_format_coroutine_coroZ _fut_waiter)taskinfocoro r
7/opt/alt/python38/lib64/python3.8/asyncio/base_tasks.py_task_repr_info s
r c C s g }t | jdr| jj}n0t | jdr0| jj}nt | jdrF| jj}nd }|d k r|d k r|d k rt|dkrlq|d8 }|| |j}qR| nH| jd k r| jj }|d k r|d k r|dkrq|d8 }||j
|j }q|S )Ncr_framegi_frameag_framer r ) hasattrr r r r appendf_backreverse
_exception
__traceback__tb_frametb_next)r
limitZframesftbr
r
r _task_get_stack s6
r c C s g }t }| j|dD ]Z}|j}|j}|j}|j} ||krN|| t| t |||j
}
| ||| |
f q| j } |st
d| |d n2| d k rt
d| d|d nt
d| d|d tj||d | d k rt| j| D ]}
t
|
|dd qd S ) N)r z
No stack for )filezTraceback for z (most recent call last):z
Stack for )r end)setZ get_stackf_linenof_code co_filenameco_nameadd linecache
checkcachegetline f_globalsr r print traceback
print_listformat_exception_only __class__) r
r r extracted_listcheckedr linenocofilenamenamelineexcr
r
r _task_print_stack< s,
r9 )r( r- r r r r r r9 r
r
r
r s #PK ! O O ( __pycache__/streams.cpython-38.opt-1.pycnu [ U
if h @ s& d Z ddlZddlZddlZddlZeedr6e d7 Z ddlmZ ddlmZ ddlm Z dd lm
Z
dd
lm Z dd l m
Z
dd lmZ d
Zd dedddZd dedddZeedrd!dedddZd"dedddZG dd de jZG dd dee jZG dd d ZG d d d ZdS )#) StreamReader StreamWriterStreamReaderProtocolopen_connection start_server NZAF_UNIX)open_unix_connectionstart_unix_server )
coroutines)events)
exceptions)format_helpers) protocols)logger)sleepi )looplimitc st |dkrt }ntjdtdd t||d}t||d |j fdd| |f|I dH \}}t| ||}||fS ) a A wrapper for create_connection() returning a (reader, writer) pair.
The reader returned is a StreamReader instance; the writer is a
StreamWriter instance.
The arguments are all the usual arguments to create_connection()
except protocol_factory; most common are positional host and port,
with various optional keyword arguments following.
Additional optional keyword arguments are loop (to set the event loop
instance to use) and limit (to set the buffer limit passed to the
StreamReader).
(If you want to customize the StreamReader and/or
StreamReaderProtocol classes, just copy the code -- there's
really nothing special here except some convenience.)
N[The loop argument is deprecated since Python 3.8, and scheduled for removal in Python 3.10.
stacklevelr r r c s S N r protocolr 4/opt/alt/python38/lib64/python3.8/asyncio/streams.py5 z!open_connection..) r get_event_loopwarningswarnDeprecationWarningr r Zcreate_connectionr ) hostportr r kwdsreader transport_writerr r r r s"
r c sJ dkrt ntjdtdd fdd}j|||f|I dH S )a Start a socket server, call back for each client connected.
The first parameter, `client_connected_cb`, takes two parameters:
client_reader, client_writer. client_reader is a StreamReader
object, while client_writer is a StreamWriter object. This
parameter can either be a plain callback function or a coroutine;
if it is a coroutine, it will be automatically converted into a
Task.
The rest of the arguments are all the usual arguments to
loop.create_server() except protocol_factory; most common are
positional host and port, with various optional keyword arguments
following. The return value is the same as loop.create_server().
Additional optional keyword arguments are loop (to set the event loop
instance to use) and limit (to set the buffer limit passed to the
StreamReader).
The return value is the same as loop.create_server(), i.e. a
Server object which can be used to stop the service.
Nr r r c s t d} t| d}|S Nr r r r r' r client_connected_cbr r r r factoryX s
z start_server..factory)r r r! r" r# Z
create_server)r/ r$ r% r r r& r0 r r. r r : s
r c sr |dkrt }ntjdtdd t||d}t||d |j fdd| f|I dH \}}t| ||}||fS ) z@Similar to `open_connection` but works with UNIX Domain Sockets.Nr r r r r c s S r r r r r r r p r z&open_unix_connection..) r r r! r" r# r r Zcreate_unix_connectionr )pathr r r& r' r( r) r* r r r r d s
r c sH dkrt ntjdtdd fdd}j||f|I dH S )z=Similar to `start_server` but works with UNIX Domain Sockets.Nr r r c s t d} t| d}|S r+ r, r- r. r r r0 ~ s
z"start_unix_server..factory)r r r! r" r# Zcreate_unix_server)r/ r1 r r r& r0 r r. r r t s
r c @ sB e Zd ZdZdddZdd Zdd Zd d
Zd d Zd
d Z dS )FlowControlMixina) Reusable flow control logic for StreamWriter.drain().
This implements the protocol methods pause_writing(),
resume_writing() and connection_lost(). If the subclass overrides
these it must call the super methods.
StreamWriter.drain() must wait for _drain_helper() coroutine.
Nc C s0 |d krt | _n|| _d| _d | _d| _d S NF)r r _loop_paused
_drain_waiter_connection_lost)selfr r r r __init__ s zFlowControlMixin.__init__c C s d| _ | j r td| d S )NTz%r pauses writing)r5 r4 get_debugr debugr8 r r r
pause_writing s
z FlowControlMixin.pause_writingc C sF d| _ | j r td| | j}|d k rBd | _| sB|d d S )NFz%r resumes writing)r5 r4 r: r r; r6 done
set_resultr8 waiterr r r resume_writing s
z FlowControlMixin.resume_writingc C sV d| _ | jsd S | j}|d kr"d S d | _| r4d S |d krH|d n
|| d S NT)r7 r5 r6 r> r?
set_exceptionr8 excrA r r r connection_lost s z FlowControlMixin.connection_lostc s< | j rtd| jsd S | j}| j }|| _|I d H d S )NzConnection lost)r7 ConnectionResetErrorr5 r6 r4
create_futurer@ r r r
_drain_helper s
z FlowControlMixin._drain_helperc C s t d S r )NotImplementedErrorr8 streamr r r _get_close_waiter s z"FlowControlMixin._get_close_waiter)N)
__name__
__module__ __qualname____doc__r9 r= rB rG rJ rN r r r r r2 s
r2 c sf e Zd ZdZdZd fdd Zedd Zdd Z fd d
Z d d Z
d
d Z dd Z dd Z
ZS )r a= Helper class to adapt between Protocol and StreamReader.
(This is a helper class instead of making StreamReader itself a
Protocol subclass, because the StreamReader has other potential
uses, and to prevent the user of the StreamReader to accidentally
call inappropriate methods of the protocol.)
Nc sn t j|d |d k r,t|| _|j| _nd | _|d k r@|| _d| _d | _d | _ || _
d| _ | j
| _d S )Nr F)superr9 weakrefref_stream_reader_wr_source_traceback_strong_reader_reject_connection_stream_writer
_transport_client_connected_cb _over_sslr4 rI _closed)r8 Z
stream_readerr/ r __class__r r r9 s
z StreamReaderProtocol.__init__c C s | j d krd S | S r )rV r< r r r _stream_reader s
z#StreamReaderProtocol._stream_readerc C s | j r6ddi}| jr | j|d< | j| | d S || _| j}|d k rT|| |dd k | _ | j
d k rt || || j| _ |
|| j }t
|r| j| d | _d S )NmessagezpAn open stream was garbage collected prior to establishing network connection; call "stream.close()" explicitly.Zsource_tracebackZ
sslcontext)rY rW r4 Zcall_exception_handlerabortr[ ra
set_transportget_extra_infor] r\ r rZ r
Z iscoroutineZ create_taskrX )r8 r( contextr' resr r r connection_made s2
z$StreamReaderProtocol.connection_madec sx | j }|d k r*|d kr | n
|| | j sV|d krJ| jd n | j| t | d | _d | _ d | _
d S r ) ra feed_eofrD r^ r> r? rS rG rV rZ r[ )r8 rF r' r_ r r rG
s
z$StreamReaderProtocol.connection_lostc C s | j }|d k r|| d S r )ra feed_data)r8 datar' r r r
data_received s z"StreamReaderProtocol.data_receivedc C s$ | j }|d k r| | jr dS dS )NFT)ra ri r] )r8 r' r r r eof_received s z!StreamReaderProtocol.eof_receivedc C s | j S r )r^ rL r r r rN + s z&StreamReaderProtocol._get_close_waiterc C s" | j }| r | s | d S r )r^ r> cancelled exception)r8 closedr r r __del__. s z StreamReaderProtocol.__del__)NN)rO rP rQ rR rW r9 propertyra rh rG rl rm rN rq
__classcell__r r r_ r r s
r c @ sv e Zd ZdZdd Zdd Zedd Zdd Zd
d Z d d
Z
dd Z dd Z dd Z
dd ZdddZdd ZdS ) r a' Wraps a Transport.
This exposes write(), writelines(), [can_]write_eof(),
get_extra_info() and close(). It adds drain() which returns an
optional Future on which you can wait for flow control. It also
adds a transport property which references the Transport
directly.
c C s4 || _ || _|| _|| _| j | _| jd d S r )r[ _protocol_readerr4 rI Z
_complete_futr? )r8 r( r r' r r r r r9 @ s zStreamWriter.__init__c C s@ | j jd| jg}| jd k r0|d| j dd|S )N
transport=zreader=<{}> )r` rO r[ ru appendformatjoinr8 infor r r __repr__J s
zStreamWriter.__repr__c C s | j S r r[ r< r r r r( P s zStreamWriter.transportc C s | j | d S r )r[ writer8 rk r r r r T s zStreamWriter.writec C s | j | d S r )r[
writelinesr r r r r W s zStreamWriter.writelinesc C s
| j S r )r[ write_eofr< r r r r Z s zStreamWriter.write_eofc C s
| j S r )r[
can_write_eofr< r r r r ] s zStreamWriter.can_write_eofc C s
| j S r )r[ closer< r r r r ` s zStreamWriter.closec C s
| j S r )r[
is_closingr< r r r r c s zStreamWriter.is_closingc s | j | I d H d S r )rt rN r< r r r wait_closedf s zStreamWriter.wait_closedNc C s | j ||S r )r[ re )r8 namedefaultr r r re i s zStreamWriter.get_extra_infoc sL | j dk r | j }|dk r || j r8tdI dH | j I dH dS )zyFlush the write buffer.
The intended use is to write
w.write(data)
await w.drain()
Nr )ru ro r[ r r rt rJ )r8 rF r r r drainl s
zStreamWriter.drain)N)rO rP rQ rR r9 r~ rr r( r r r r r r r re r r r r r r 6 s
r c @ s e Zd ZdZedfddZdd Zdd Zdd Zd
d Z d d
Z
dd Z dd Z dd Z
dd Zdd Zdd Zd&dd Zd'd d Zd d! Zd"d# Zd$d% ZdS )(r Nc C sv |dkrt d|| _|d kr*t | _n|| _t | _d| _d | _d | _ d | _
d| _ | j rrt
td| _d S )Nr zLimit cannot be <= 0Fr )
ValueError_limitr r r4 bytearray_buffer_eof_waiter
_exceptionr[ r5 r: r
extract_stacksys _getframerW )r8 r r r r r r9 s
zStreamReader.__init__c C s dg}| j r"|t| j d | jr2|d | jtkrN|d| j | jrf|d| j | jr~|d| j | jr|d| j | j r|d d
d
|S ) Nr z byteseofzlimit=zwaiter=z
exception=rv Zpausedrw rx ) r ry lenr r _DEFAULT_LIMITr r r[ r5 rz r{ r| r r r r~ s
zStreamReader.__repr__c C s | j S r )r r< r r r ro s zStreamReader.exceptionc C s0 || _ | j}|d k r,d | _| s,|| d S r )r r rn rD rE r r r rD s zStreamReader.set_exceptionc C s* | j }|dk r&d| _ | s&|d dS )z1Wakeup read*() functions waiting for data or EOF.N)r rn r? r@ r r r _wakeup_waiter s
zStreamReader._wakeup_waiterc C s
|| _ d S r r )r8 r( r r r rd s zStreamReader.set_transportc C s* | j r&t| j| jkr&d| _ | j d S r3 )r5 r r r r[ resume_readingr< r r r _maybe_resume_transport s z$StreamReader._maybe_resume_transportc C s d| _ | d S rC )r r r< r r r ri s zStreamReader.feed_eofc C s | j o | j S )z=Return True if the buffer is empty and 'feed_eof' was called.)r r r< r r r at_eof s zStreamReader.at_eofc C st |sd S | j | | | jd k rp| jspt| j d| j krpz| j W n tk
rh d | _Y nX d| _d S )Nr T) r extendr r[ r5 r r Z
pause_readingrK r r r r rj s
zStreamReader.feed_datac sX | j dk rt| d| jr.d| _| j | j | _ z| j I dH W 5 d| _ X dS )zpWait until feed_data() or feed_eof() is called.
If stream was paused, automatically resume it.
NzF() called while another coroutine is already waiting for incoming dataF)r RuntimeErrorr5 r[ r r4 rI )r8 Z func_namer r r _wait_for_data s
zStreamReader._wait_for_datac
s d}t |}z| |I dH }W n tjk
rN } z|j W Y S d}~X Y nh tjk
r } zH| j||jr| jd|j| = n
| j |
t |j d W 5 d}~X Y nX |S )a Read chunk of data from the stream until newline (b'
') is found.
On success, return chunk that ends with newline. If only partial
line can be read due to EOF, return incomplete line without
terminating newline. When EOF was reached while no bytes read, empty
bytes object is returned.
If limit is reached, ValueError will be raised. In that case, if
newline was found, complete line including newline will be removed
from internal buffer. Else, internal buffer will be cleared. Limit is
compared against part of the line without newline.
If stream was paused, this function will automatically resume it if
needed.
Nr )
r readuntilr IncompleteReadErrorpartialLimitOverrunErrorr
startswithconsumedclearr r args)r8 sepseplenlineer r r readline s
zStreamReader.readliner c s t |}|dkrtd| jdk r(| jd}t | j}|| |kr|| j||}|dkrZq|d | }|| jkr|td|| jrt | j}| j
t |d| dI dH q,|| jkrtd|| jd|| }| jd|| = |
t |S ) aV Read data from the stream until ``separator`` is found.
On success, the data and separator will be removed from the
internal buffer (consumed). Returned data will include the
separator at the end.
Configured stream limit is used to check result. Limit sets the
maximal length of data that can be returned, not counting the
separator.
If an EOF occurs and the complete separator is still not found,
an IncompleteReadError exception will be raised, and the internal
buffer will be reset. The IncompleteReadError.partial attribute
may contain the separator partially.
If the data cannot be read because of over limit, a
LimitOverrunError exception will be raised, and the data
will be left in the internal buffer, so it can be read again.
r z,Separator should be at least one-byte stringNr z2Separator is not found, and chunk exceed the limitr z2Separator is found, but chunk is longer than limit)r r r r findr r r r bytesr r r r )r8 Z separatorr offsetZbuflenZisepchunkr r r r ( s>
zStreamReader.readuntilr c s | j dk r| j |dkr dS |dk rVg }| | jI dH }|s@qL|| q(d|S | jsr| jsr| dI dH t| jd| }| jd|= | |S )a Read up to `n` bytes from the stream.
If n is not provided, or set to -1, read until EOF and return all read
bytes. If the EOF was received and the internal buffer is empty, return
an empty bytes object.
If n is zero, return empty bytes object immediately.
If n is positive, this function try to read `n` bytes, and may return
less or equal bytes than requested, but at least one byte. If EOF was
received before any byte is read, this function returns empty byte
object.
Returned value is not limited with limit, configured at stream
creation.
If stream was paused, this function will automatically resume it if
needed.
Nr r read)
r r r ry r{ r r r r r )r8 nZblocksblockrk r r r r s"
zStreamReader.readc s |dk rt d| jdk r | j|dkr,dS t| j|k rr| jr`t| j}| j t||| dI dH q,t| j|krt| j}| j n t| jd| }| jd|= |
|S )a Read exactly `n` bytes.
Raise an IncompleteReadError if EOF is reached before `n` bytes can be
read. The IncompleteReadError.partial attribute of the exception will
contain the partial read bytes.
if n is zero, return empty bytes object.
Returned value is not limited with limit, configured at stream
creation.
If stream was paused, this function will automatically resume it if
needed.
r z*readexactly size can not be less than zeroNr readexactly) r r r r r r r r r r r )r8 r Z
incompleterk r r r r s&
zStreamReader.readexactlyc C s | S r r r< r r r __aiter__ s zStreamReader.__aiter__c s | I d H }|dkrt|S )Nr )r StopAsyncIteration)r8 valr r r __anext__ s zStreamReader.__anext__)r )r )rO rP rQ rW r r9 r~ ro rD r rd r ri r rj r r r r r r r r r r r r s$
[
2)r )NN)NN)N)N)__all__Zsocketr r! rT hasattr r
r r r
r logr Ztasksr r r r r r ZProtocolr2 r r r r r r r sF
! '
DkPPK ! Ҕ + __pycache__/coroutines.cpython-38.opt-1.pycnu [ U
if]" @ s d Z ddlZddlZddlZddlZddlZddlZddlZddl Z ddl
m Z ddl
m Z ddl
m
Z
ddlmZ dd Ze ZG d
d d Zd d
Ze Zdd ZejejejjefZe Z dd Z dd Z dS )) coroutineiscoroutinefunction iscoroutine N ) base_futures) constants)format_helpers)loggerc C s" t jjp t jj o ttjdS )NZPYTHONASYNCIODEBUG)sysflagsdev_modeignore_environmentboolosenvironget r r 7/opt/alt/python38/lib64/python3.8/asyncio/coroutines.py_is_debug_mode s r c @ s e Zd Zd ddZdd Zdd Zdd Zd
d Zd d d
Zdd Z e
dd Z e
dd Z e
dd Z
dd Ze
dd Zdd ZdS ) CoroWrapperNc C s> || _ || _ttd| _t|dd | _t|dd | _ d S )Nr __name__ __qualname__)
genfuncr
extract_stackr
_getframe_source_tracebackgetattrr r )selfr r r r r __init__' s
zCoroWrapper.__init__c C sJ t | }| jr4| jd }|d|d d|d 7 }d| jj d| dS ) Nz
, created at r :r < >)_format_coroutiner __class__r )r coro_reprframer r r __repr__/ s
zCoroWrapper.__repr__c C s | S Nr r r r r __iter__7 s zCoroWrapper.__iter__c C s | j d S r* r sendr+ r r r __next__: s zCoroWrapper.__next__c C s | j |S r* r- )r valuer r r r. = s zCoroWrapper.sendc C s | j |||S r* )r throw)r typer0 tracebackr r r r1 @ s zCoroWrapper.throwc C s
| j S r* )r closer+ r r r r4 C s zCoroWrapper.closec C s | j jS r* )r gi_framer+ r r r r5 F s zCoroWrapper.gi_framec C s | j jS r* )r
gi_runningr+ r r r r6 J s zCoroWrapper.gi_runningc C s | j jS r* )r gi_coder+ r r r r7 N s zCoroWrapper.gi_codec C s | S r* r r+ r r r __await__R s zCoroWrapper.__await__c C s | j jS r* )r gi_yieldfromr+ r r r r9 U s zCoroWrapper.gi_yieldfromc C s t | dd }t |dd }|d k r||jdkr|| d}t | dd}|rrdt|}|dtj d 7 }|| 7 }t | d S )
Nr r5 r z was never yielded fromr r zB
Coroutine object created at (most recent call last, truncated to z last lines):
)
r f_lastijoinr3 format_listr ZDEBUG_STACK_DEPTHrstripr error)r r r( msgtbr r r __del__Y s
zCoroWrapper.__del__)N)NN)r
__module__r r r) r, r/ r. r1 r4 propertyr5 r6 r7 r8 r9 rB r r r r r $ s"
r c sz t jdtdd tr S tr. ntfdd t t
sX }nt fdd}t |_ |S )zDecorator to mark coroutines.
If the coroutine is not yielded from before it is destroyed,
an error message is logged.
zN"@coroutine" decorator is deprecated since Python 3.8, use "async def" instead )
stacklevelc ? sr | |}t |s(t|s(t|tr4|E d H }n:z
|j}W n tk
rR Y n X t|tj j
rn| E d H }|S r* ) r ZisfutureinspectZ isgenerator
isinstancer r8 AttributeError collectionsabc Awaitable)argskwresZ
await_methr r r coroz s
zcoroutine..coroc s@ t | |d}|jr |jd= tdd |_tdd |_|S )NrP r r r )r r r r r )rM kwdswrQ r r r wrapper s zcoroutine..wrapper) warningswarnDeprecationWarningrG r isgeneratorfunction functoolswrapstypesr _DEBUG
_is_coroutine)r rU r rT r r i s"
r c C s t | pt| ddtkS )z6Return True if func is a decorated coroutine function.r^ N)rG r r r^ rP r r r r s
r c C s@ t | tkrdS t| tr8ttdk r4tt | dS dS dS )z)Return True if obj is a coroutine object.Td FN)r2 _iscoroutine_typecacherH _COROUTINE_TYPESlenadd)objr r r r s
r c
sh t | t fdd}dd }d }t| dr:| jr:| j}nt| drP| jrP| j}|| }|sr|| rn| dS |S d }t| dr| jr| j}nt| d r| jr| j}|jpd
}d } r$| jd k r$t
| js$t | j}|d k r|\}}|d kr| d | d
| } n| d| d
| } n@|d k rJ|j
}| d| d
| } n|j}| d | d
| } | S )Nc s` rt | jdi S t| dr,| jr,| j}n*t| drD| jrD| j}ndt| j d}| dS )Nr r r r" z without __name__>z())r Z_format_callbackr hasattrr r r2 )rQ coro_nameZis_corowrapperr r get_name s z#_format_coroutine..get_namec S sH z| j W S tk
rB z | jW Y S tk
r< Y Y dS X Y nX d S )NF)
cr_runningrI r6 )rQ r r r
is_running s z%_format_coroutine..is_runningcr_coder7 z runningr5 cr_framezr z done, defined at r! z running, defined at z running at )rH r re rk r7 r5 rl co_filenamer rG rY r Z_get_function_sourcef_linenoco_firstlineno)
rQ rh rj Z coro_coderf Z
coro_framefilenamelinenosourcer' r rg r r% sJ
r% ) __all__Zcollections.abcrJ rZ rG r r
r3 r\ rV r: r r r logr r r] r r objectr^ r
CoroutineType
GeneratorTyperK Coroutinera setr` r r% r r r r s2 E8 PK ! b^ ^ __pycache__/tasks.cpython-38.pycnu [ U
if @ sv d Z dZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl m Z ddl m
Z
ddl mZ ddl mZ dd l mZ dd
l
mZ edjZdBd d ZdCd
dZdDddZdd ZG dd dejZeZz ddl Z W n e k
r Y n X e j ZZ ddddZ ejj Z ejj!Z!ejj"Z"dde"dddZ#dd Z$dd d d Z%d d! Z&d"d# Z'ddd$d%d&Z(ej)d'd( Z*dEdd d)d*Z+dd d+d,Z,ej)d-d. Z-ee-_G d/d0 d0ej.Z/dd1d2d3d4Z0dd d5d6Z1d7d8 Z2e
3 Z4i Z5d9d: Z6d;d< Z7d=d> Z8d?d@ Z9e6Z:e9Z;e7Ze9Z?e7Z@e8ZAdS )Fz0Support for tasks, coroutines and the scheduler.)Task create_taskFIRST_COMPLETEDFIRST_EXCEPTION
ALL_COMPLETEDwaitwait_for as_completedsleepgathershield
ensure_futurerun_coroutine_threadsafe current_task all_tasks_register_task_unregister_task _enter_task _leave_task N )
base_tasks)
coroutines)events)
exceptions)futures)
_is_coroutinec C s | dkrt } t| S )z!Return a currently executed task.N)r get_running_loop_current_tasksgetloop r! 2/opt/alt/python38/lib64/python3.8/asyncio/tasks.pyr " s r c s^ dkrt d}z tt}W qL tk
rF |d7 }|dkrB Y qX qLq fdd|D S )z'Return a set of all tasks for the loop.Nr r c s& h | ] }t | kr| s|qS r! )r _get_loopdone.0tr r! r" < s z all_tasks..)r r list
_all_tasks RuntimeErrorr iZtasksr! r r" r ) s r c s^ d krt d}z tt}W qL tk
rF |d7 }|dkrB Y qX qLq fdd|D S )Nr r r# c s h | ]}t | kr|qS r! )r r$ r& r r! r" r) U s z$_all_tasks_compat..)r get_event_loopr* r+ r, r- r! r r" _all_tasks_compat@ s r0 c C s4 |d k r0z
| j }W n tk
r& Y n
X || d S N)set_nameAttributeError)tasknamer2 r! r! r" _set_task_nameX s
r6 c s e Zd ZdZdZed%ddZed&ddZddd fd d
Z fd d Z d
d Z
dd Z dd Z dd Z
dd Zdd ZddddZddd d d Zd d Zd' fd!d" Zd#d$ Z ZS )(r z A coroutine wrapped in a Future.TNc C s( t jdtdd |dkr t }t|S )zReturn the currently running task in an event loop or None.
By default the current task for the current event loop is returned.
None is returned when called not in the context of a Task.
zVTask.current_task() is deprecated since Python 3.7, use asyncio.current_task() instead
stacklevelN)warningswarnDeprecationWarningr r/ r clsr r! r! r" r t s zTask.current_taskc C s t jdtdd t|S )z|Return a set of all tasks for an event loop.
By default all tasks for the current event loop are returned.
zPTask.all_tasks() is deprecated since Python 3.7, use asyncio.all_tasks() insteadr7 r8 )r: r; r< r0 r= r! r! r" r s
zTask.all_tasks)r r5 c s t j|d | jr | jd= t|s:d| _td||d krRdt | _n
t || _d| _
d | _ || _ t
| _| jj| j| jd t| d S )Nr Fz a coroutine was expected, got zTask-context)super__init___source_tracebackr iscoroutine_log_destroy_pending TypeError_task_name_counter_namestr _must_cancel _fut_waiter_coro contextvarsZ copy_context_context_loop call_soon _Task__stepr )selfcoror r5 __class__r! r" rC s
z
Task.__init__c sF | j tjkr8| jr8| dd}| jr,| j|d< | j| t d S )Nz%Task was destroyed but it is pending!)r4 messageZsource_traceback) Z_stater Z_PENDINGrF rD rP Zcall_exception_handlerrB __del__)rS rA rU r! r" rX s
z Task.__del__c C s
t | S r1 )r Z_task_repr_inforS r! r! r"
_repr_info s zTask._repr_infoc C s | j S r1 )rM rY r! r! r" get_coro s z
Task.get_coroc C s | j S r1 )rI rY r! r! r" get_name s z
Task.get_namec C s t || _d S r1 )rJ rI )rS valuer! r! r" r2 s z
Task.set_namec C s t dd S )Nz*Task does not support set_result operationr, )rS resultr! r! r"
set_result s zTask.set_resultc C s t dd S )Nz-Task does not support set_exception operationr^ )rS exceptionr! r! r"
set_exception s zTask.set_exception)limitc C s t | |S )a Return the list of stack frames for this task's coroutine.
If the coroutine is not done, this returns the stack where it is
suspended. If the coroutine has completed successfully or was
cancelled, this returns an empty list. If the coroutine was
terminated by an exception, this returns the list of traceback
frames.
The frames are always ordered from oldest to newest.
The optional limit gives the maximum number of frames to
return; by default all available frames are returned. Its
meaning differs depending on whether a stack or a traceback is
returned: the newest frames of a stack are returned, but the
oldest frames of a traceback are returned. (This matches the
behavior of the traceback module.)
For reasons beyond our control, only one stack frame is
returned for a suspended coroutine.
)r Z_task_get_stack)rS rc r! r! r" get_stack s zTask.get_stack)rc filec C s t | ||S )an Print the stack or traceback for this task's coroutine.
This produces output similar to that of the traceback module,
for the frames retrieved by get_stack(). The limit argument
is passed to get_stack(). The file argument is an I/O stream
to which the output is written; by default output is written
to sys.stderr.
)r Z_task_print_stack)rS rc re r! r! r" print_stack s zTask.print_stackc C s4 d| _ | rdS | jdk r*| j r*dS d| _dS )a Request that this task cancel itself.
This arranges for a CancelledError to be thrown into the
wrapped coroutine on the next cycle through the event loop.
The coroutine then has a chance to clean up or even deny
the request using try/except/finally.
Unlike Future.cancel, this does not guarantee that the
task will be cancelled: the exception might be caught and
acted upon, delaying cancellation of the task or preventing
cancellation completely. The task may also return a value or
raise a different exception.
Immediately after this method is called, Task.cancelled() will
not return True (unless the task was already cancelled). A
task will be marked as cancelled when the wrapped coroutine
terminates with a CancelledError exception (even if cancel()
was not called).
FNT)Z_log_tracebackr% rL cancelrK rY r! r! r" rg s
z Task.cancelc
s | r td| d|| jr>t|tjs8t }d| _| j}d | _t| j | zfz"|d krp| d }n
| |}W n t
k
r } z*| jrd| _t nt |j W 5 d }~X Y n tjk
r t Y n ttfk
r } zt | W 5 d }~X Y n tk
rL } zt | W 5 d }~X Y npX t|dd }|d k r@t|| j k rtd| d|d}| j j| j|| j d n|r|| krtd | }| j j| j|| j d n8d|_ |j | j | j d || _| jr>| j r>d| _n*td
| d |}| j j| j|| j d n||d kr`| j j| j| j d n\t !|rtd | d |}| j j| j|| j d n$td
|}| j j| j|| j d W 5 t
| j | d } X d S )Nz_step(): already done: z, F_asyncio_future_blockingzTask z got Future z attached to a different loopr@ z Task cannot await on itself: z-yield was used instead of yield from in task z with z;yield was used instead of yield from for generator in task zTask got bad yield: )"r% r ZInvalidStateErrorrK
isinstanceCancelledErrorrM rL r rP r sendthrow
StopIterationrB rg r` r] KeyboardInterrupt
SystemExitrb
BaseExceptiongetattrr r$ r, rQ rR rO rh add_done_callback
_Task__wakeupinspectZ isgenerator)rS excrT r_ Zblockingnew_excrU r! r" Z__step s
z Task.__stepc
C sJ z | W n, tk
r8 } z| | W 5 d }~X Y n
X | d } d S r1 )r_ rp rR )rS futureru r! r! r" Z__wakeup[ s z
Task.__wakeup)N)N)N)__name__
__module__ __qualname____doc__rF classmethodr r rC rX rZ r[ r\ r2 r` rb rd rf rg rR rs
__classcell__r! r! rU r" r b s&
!Tr )r5 c C s t }|| }t|| |S )z]Schedule the execution of a coroutine object in a spawn task.
Return a Task object.
)r r r r6 )rT r5 r r4 r! r! r" r x s
r )r timeout return_whenc s t | st| r(tdt| j | s4td|tt t
fkrPtd| dkrbt nt
jdtdd fdd t| D } t| || I dH S )
a Wait for the Futures and coroutines given by fs to complete.
The fs iterable must not be empty.
Coroutines will be wrapped in Tasks.
Returns two sets of Future: (done, pending).
Usage:
done, pending = await asyncio.wait(fs)
Note: This does not raise TimeoutError! Futures that aren't done
when the timeout occurs are returned in the second set.
z expect a list of futures, not z#Set of coroutines/Futures is empty.zInvalid return_when value: N[The loop argument is deprecated since Python 3.8, and scheduled for removal in Python 3.10.r7 r8 c s h | ]}t | d qS r r r' fr r! r" r) s zwait..)r isfuturer rE rG typerx
ValueErrorr r r r r r: r; r< set_wait)fsr r~ r r! r r" r s
r c G s | s| d d S r1 )r% r` )waiterargsr! r! r" _release_waiter s r r c
s |dkrt }ntjdtdd |dkr4| I dH S |dkrt| |d} | rX| S t| |dI dH z | W n. t j
k
r } zt |W 5 d}~X Y n
X t | }|
|t|}tt|}t| |d} | | zz|I dH W nP t j
k
rF | r$| Y W dS | | t| |dI dH Y nX | r^| W *S | | t| |dI dH t W 5 | X dS )a Wait for the single Future or coroutine to complete, with timeout.
Coroutine will be wrapped in Task.
Returns result of the Future or coroutine. When a timeout occurs,
it cancels the task and raises TimeoutError. To avoid the task
cancellation, wrap it in shield().
If the wait is cancelled, the task is also cancelled.
This function is a coroutine.
Nr r7 r8 r r )r r r: r; r< r r% r_ _cancel_and_waitr rj TimeoutError
create_future
call_laterr functoolspartialrr rg remove_done_callback)futr~ r ru r timeout_handlecbr! r! r" r sL
r c
s | s t d| d|dk r.||tt| fdd}| D ]}|| qLzI dH W 5 dk r| | D ]}|| qX t t }}| D ]"}| r|
| q|
| q||fS )zVInternal helper for wait().
The fs argument must be a collection of Futures.
zSet of Futures is empty.Nc sZ d8 dks4t ks4tkrV| sV| d k rVd k rD sVd d S )Nr r )r r cancelledra rg r% r` r Zcounterr r r r! r" _on_completion s
z _wait.._on_completion) AssertionErrorr r r lenrr rg r r r% add)r r~ r r r r r% Zpendingr! r r" r s* r c sF | }tt|}| | z| |I dH W 5 | | X dS )z.c s* D ]} | d q d S r1 )r
put_nowaitclearr )r r% todor! r" _on_timeoutX s
z!as_completed.._on_timeoutc s4 sd S | | s0d k r0 d S r1 )remover rg r )r% r r r! r" r ^ s
z$as_completed.._on_completionc s$ I d H } | d kr tj| S r1 )r r r r_ r )r% r! r"
_wait_for_onef s z#as_completed.._wait_for_one)r r r rE rG r rx Zqueuesr r r/ r: r; r< r rr r ranger )r r r~ r r r r _r! )r r% r r r r" r 7 s*
r c c s
dV dS )zSkip one event loop run cycle.
This is a private helper for 'asyncio.sleep()', used
when the 'delay' is set to 0. It uses a bare 'yield'
expression (which Task.__step knows how to handle)
instead of creating a Future object.
Nr! r! r! r! r" __sleep0u s r c sr | dkrt I dH |S |dkr*t }ntjdtdd | }|| tj ||}z|I dH W S |
X dS )z9Coroutine that completes after a given time (in seconds).r Nr r7 r8 ) r r r r: r; r< r r r Z _set_result_unless_cancelledrg )Zdelayr_ r rw hr! r! r" r s$
r c C s t | r6|dkrt }|| }|jr2|jd= |S t| rb|dk r^|t| k r^t d| S t
| r|t t
| |dS tddS )zmWrap a coroutine or an awaitable in a future.
If the argument is a Future, it is returned directly.
Nr? zRThe future belongs to a different loop than the one specified as the loop argumentr z:An asyncio.Future, a coroutine or an awaitable is required)r rE r r/ r rD r r r$ r rt Z isawaitabler _wrap_awaitablerG )Zcoro_or_futurer r4 r! r! r" r s
r c c s | E dH S )zHelper for asyncio.ensure_future().
Wraps awaitable (an object with __await__) into a coroutine
that will later be wrapped in a Task by ensure_future().
N) __await__)Z awaitabler! r! r" r s r c s. e Zd ZdZdd fdd
Zdd Z ZS )_GatheringFuturezHelper for gather().
This overrides cancel() to cancel all the children and act more
like Task.cancel(), which doesn't immediately mark itself as
cancelled.
Nr c s t j|d || _d| _d S )Nr F)rB rC _children_cancel_requested)rS childrenr rU r! r" rC s z_GatheringFuture.__init__c C s6 | r dS d}| jD ]}| rd}q|r2d| _|S )NFT)r% r rg r )rS ZretZchildr! r! r" rg s
z_GatheringFuture.cancel)rx ry rz r{ rC rg r} r! r! rU r" r s r F)r return_exceptionsc s |s<| dkrt } ntjdtdd | g S fdd}i }g dd|D ]f}||krt|| d}| dkrt |} ||k rd |_
d
7 |||< | | n|| } | qdt
| dS ) a Return a future aggregating results from the given coroutines/futures.
Coroutines will be wrapped in a future and scheduled in the event
loop. They will not necessarily be scheduled in the same order as
passed in.
All futures must share the same event loop. If all the tasks are
done successfully, the returned future's result is the list of
results (in the order of the original sequence, not necessarily
the order of results arrival). If *return_exceptions* is True,
exceptions in the tasks are treated the same as successful
results, and gathered in the result list; otherwise, the first
raised exception will be immediately propagated to the returned
future.
Cancellation: if the outer Future is cancelled, all children (that
have not completed yet) are also cancelled. If any child is
cancelled, this is treated as if it raised CancelledError --
the outer Future is *not* cancelled in this case. (This is to
prevent the cancellation of one child to cause other children to
be cancelled.)
If *return_exceptions* is False, cancelling gather() after it
has been marked done won't cancel any submitted awaitables.
For instance, gather can be marked done after propagating an
exception to the caller, therefore, calling ``gather.cancel()``
after catching an exception (raised by one of the awaitables) from
gather won't cancel any other awaitables.
Nr r7 r8 c s d7 r$| s | d S sd| rFt }| d S | }|d k rd| d S krg } D ]8} | rt }n| }|d kr| }|| qtjrĈt n
| d S )Nr )
r% r ra r rj rb r_ appendr r` )r ru Zresultsresr Z nfinishedZnfutsouterr r! r" _done_callback s4
z gather.._done_callbackr r Fr )r r/ r: r; r< r r` r r r$ rF rr r r )r r Zcoros_or_futuresr Z
arg_to_futargr r! r r" r
s:
1
r
c st |dk rt jdtdd t| |d r0S t}| fdd fdd } | S )
a. Wait for a future, shielding it from cancellation.
The statement
res = await shield(something())
is exactly equivalent to the statement
res = await something()
*except* that if the coroutine containing it is cancelled, the
task running in something() is not cancelled. From the POV of
something(), the cancellation did not happen. But its caller is
still cancelled, so the yield-from expression still raises
CancelledError. Note: If something() is cancelled by other means
this will still cancel shield().
If you want to completely ignore cancellation (not recommended)
you can combine shield() with a try/except clause, as follows:
try:
res = await shield(something())
except CancelledError:
res = None
Nr r7 r8 r c s\ r | s| d S | r. n*| }|d k rJ | n | d S r1 )r ra rg rb r` r_ )innerru r r! r" _inner_done_callbacku s
z$shield.._inner_done_callbackc s s d S r1 )r% r r )r r r! r" _outer_done_callback s z$shield.._outer_done_callback) r: r; r< r r% r r$ r rr )r r r r! )r r r r" r P s
r c s: t stdtj fdd}| S )zsSubmit a coroutine object to a given event loop.
Return a concurrent.futures.Future to access the result.
z A coroutine object is requiredc
sl zt t d W nN ttfk
r2 Y n6 tk
rf } z rT| W 5 d } ~ X Y nX d S )Nr )r Z
_chain_futurer ro rn rp Z set_running_or_notify_cancelrb )ru rT rw r r! r" callback s
z*run_coroutine_threadsafe..callback)r rE rG
concurrentr FutureZcall_soon_threadsafe)rT r r r! r r" r
s
r
c C s t | dS )z3Register a new task in asyncio as executed by loop.N)r+ r r4 r! r! r" r s r c C s4 t | }|d k r(td|d|d|t | < d S )NzCannot enter into task z while another task z is being executed.r r r, r r4 r r! r! r" r s
r c C s2 t | }||k r(td|d|dt | = d S )Nz
Leaving task z! does not match the current task .r r r! r! r" r s
r c C s t | dS )zUnregister a task.N)r+ discardr r! r! r" r s r )r r r r r+ r )N)N)N)N)Br{ __all__Zconcurrent.futuresr rN r rt itertoolstypesr: weakref r r r r r r count__next__rH r r r0 r6 Z _PyFuturer Z_PyTaskZ_asyncio ImportErrorZ_CTaskr r r r r r r r r r coroutiner r r r r r r
r r
ZWeakSetr+ r r r r r Z_py_register_taskZ_py_unregister_taskZ_py_enter_taskZ_py_leave_taskZ_c_register_taskZ_c_unregister_taskZ
_c_enter_taskZ
_c_leave_taskr! r! r! r" s
#H,>
x?$PK ! XFY
+ __pycache__/exceptions.cpython-38.opt-1.pycnu [ U
ifa @ sl d Z dZG dd deZG dd deZG dd deZG dd d eZG d
d d e Z
G d d
d
eZ dS )zasyncio exceptions.)CancelledErrorInvalidStateError TimeoutErrorIncompleteReadErrorLimitOverrunErrorSendfileNotAvailableErrorc @ s e Zd ZdZdS )r z!The Future or Task was cancelled.N__name__
__module__ __qualname____doc__ r r 7/opt/alt/python38/lib64/python3.8/asyncio/exceptions.pyr s r c @ s e Zd ZdZdS )r z*The operation exceeded the given deadline.Nr r r r r
r
s r c @ s e Zd ZdZdS )r z+The operation is not allowed in this state.Nr r r r r
r s r c @ s e Zd ZdZdS )r z~Sendfile syscall is not available.
Raised if OS does not support sendfile syscall for given socket or
file type.
Nr r r r r
r s r c s( e Zd ZdZ fddZdd Z ZS )r z
Incomplete read error. Attributes:
- partial: read bytes string before the end of stream was reached
- expected: total number of expected bytes (or None if unknown)
c s@ |d kr dnt |}t t| d| d || _|| _d S )NZ undefinedz bytes read on a total of z expected bytes)reprsuper__init__lenpartialexpected)selfr r Z
r_expected __class__r r
r $ s z IncompleteReadError.__init__c C s t | | j| jffS N)typer r r r r r
__reduce__+ s z IncompleteReadError.__reduce__r r r
r r r
__classcell__r r r r
r s r c s( e Zd ZdZ fddZdd Z ZS )r zReached the buffer limit while looking for a separator.
Attributes:
- consumed: total number of to be consumed bytes.
c s t | || _d S r )r r consumed)r messager r r r
r 5 s zLimitOverrunError.__init__c C s t | | jd | jffS )N )r argsr r r r r
r 9 s z LimitOverrunError.__reduce__r r r r r
r / s r N) r __all__
BaseExceptionr Exceptionr r RuntimeErrorr EOFErrorr r r r r r
s PK ! s̓*&9 &9 ) __pycache__/sslproto.cpython-38.opt-2.pycnu [ U
ifJj @ s d dl Z d dlZz d dlZW n ek
r4 dZY nX ddlmZ ddlmZ ddlmZ ddlmZ ddl m
Z
dd Z d
Z d Z
d Zd
ZG dd deZG dd dejejZG dd dejZdS ) N ) base_events) constants) protocols)
transports)loggerc C s" | r t dt }|s d|_|S )Nz(Server side SSL needs a valid SSLContextF)
ValueErrorsslZcreate_default_contextZcheck_hostname) server_sideserver_hostname
sslcontext r
5/opt/alt/python38/lib64/python3.8/asyncio/sslproto.py_create_transport_context s r Z UNWRAPPEDZ DO_HANDSHAKEZWRAPPEDZSHUTDOWNc @ sz e Zd ZdZdddZedd Zedd Zed d
Zed d Z dd
dZ
dddZ dd Z d ddZ
d ddZdS ) _SSLPipei Nc C sH || _ || _|| _t| _t | _t | _d | _ d| _
d | _ d | _ d S NF)
_context _server_side_server_hostname
_UNWRAPPED_stater Z MemoryBIO _incoming _outgoing_sslobj
_need_ssldata
_handshake_cb _shutdown_cb)selfcontextr
r r
r
r __init__8 s
z_SSLPipe.__init__c C s | j S N)r r r
r
r r N s z_SSLPipe.contextc C s | j S r )r r! r
r
r
ssl_objectS s z_SSLPipe.ssl_objectc C s | j S r )r r! r
r
r need_ssldata[ s z_SSLPipe.need_ssldatac C s
| j tkS r )r _WRAPPEDr! r
r
r wrappeda s z_SSLPipe.wrappedc C sR | j tkrtd| jj| j| j| j| jd| _ t
| _ || _ | j ddd\}}|S )Nz"handshake in progress or completed)r
r T)only_handshake)
r r RuntimeErrorr Zwrap_bior r r r r
_DO_HANDSHAKEr feed_ssldatar callbackssldataappdatar
r
r do_handshakej s
z_SSLPipe.do_handshakec C sB | j tkrtd| j tkr$tdt| _ || _| d\}}|S )Nzno security layer presentzshutdown in progressr& )r r r( _SHUTDOWNr r* r+ r
r
r shutdown s
z_SSLPipe.shutdownc C s | j | d\}}d S )Nr& )r Z write_eofr* )r r- r. r
r
r feed_eof s
z_SSLPipe.feed_eofFc
C s | j tkr"|r|g}ng }g |fS d| _|r8| j| g }g }z| j tkrz| j t| _ | j rl| d |rz||fW S | j tkr| j
| j }| | |sqqnJ| j t
kr| j d | _t| _ | jr| n| j tkr| | j
W nz tjtjfk
rl } zRt|dd }|tjtjtjfkrP| j tkrN| j rN| | |tjk| _W 5 d }~X Y nX | jjr| | j
||fS )NFerrno)r r r r writer) r r/ r$ r readmax_sizeappendr0 Zunwrapr r SSLErrorCertificateErrorgetattrSSL_ERROR_WANT_READSSL_ERROR_WANT_WRITESSL_ERROR_SYSCALLr pending)r datar' r. r- chunkexc exc_errnor
r
r r* sZ
z_SSLPipe.feed_ssldatar c
C s | j tkr6|t|k r&||d g}ng }|t|fS g }t|}d| _z(|t|k rn|| j||d 7 }W nh tjk
r } zHt |dd }|j
dkrtj }|_ |tj tj
tjfkr |tj k| _W 5 d }~X Y nX | jjr|| j |t|ks | jrBq qB||fS )NFr3 ZPROTOCOL_IS_SHUTDOWN)r r len
memoryviewr r r4 r r8 r: reasonr; r3 r< r= r r> r7 r5 )r r? offsetr- ZviewrA rB r
r
r feed_appdata s4
z_SSLPipe.feed_appdata)N)N)N)F)r )__name__
__module__ __qualname__r6 r propertyr r" r# r% r/ r1 r2 r* rG r
r
r
r r $ s
Kr c @ s e Zd ZejjZdd Zd"ddZdd Z dd Z
d
d Z d d
Z e
jfddZdd Zdd Zdd Zd#ddZdd Zedd Zd d Zd d Zd d! ZdS )$_SSLProtocolTransportc C s || _ || _d| _d S r )_loop
_ssl_protocol_closed)r loopZ ssl_protocolr
r
r r ! s z _SSLProtocolTransport.__init__Nc C s | j ||S r )rN _get_extra_infor namedefaultr
r
r get_extra_info' s z$_SSLProtocolTransport.get_extra_infoc C s | j | d S r )rN _set_app_protocol)r protocolr
r
r set_protocol+ s z"_SSLProtocolTransport.set_protocolc C s | j jS r )rN
_app_protocolr! r
r
r get_protocol. s z"_SSLProtocolTransport.get_protocolc C s | j S r )rO r! r
r
r
is_closing1 s z _SSLProtocolTransport.is_closingc C s d| _ | j d S NT)rO rN _start_shutdownr! r
r
r close4 s z_SSLProtocolTransport.closec C s& | j s"|d| t| d | d S )Nzunclosed transport )source)rO ResourceWarningr^ )r Z_warnr
r
r __del__? s z _SSLProtocolTransport.__del__c C s | j j}|d krtd| S )Nz*SSL transport has not been initialized yet)rN
_transportr(
is_reading)r Ztrr
r
r rc D s z _SSLProtocolTransport.is_readingc C s | j j d S r )rN rb
pause_readingr! r
r
r rd J s z#_SSLProtocolTransport.pause_readingc C s | j j d S r )rN rb resume_readingr! r
r
r re R s z$_SSLProtocolTransport.resume_readingc C s | j j|| d S r )rN rb set_write_buffer_limits)r ZhighZlowr
r
r rf Z s z-_SSLProtocolTransport.set_write_buffer_limitsc C s | j j S r )rN rb get_write_buffer_sizer! r
r
r rg o s z+_SSLProtocolTransport.get_write_buffer_sizec C s
| j jjS r )rN rb _protocol_pausedr! r
r
r rh s s z&_SSLProtocolTransport._protocol_pausedc C s< t |tttfs$tdt|j |s,d S | j| d S )Nz+data: expecting a bytes-like instance, got )
isinstancebytes bytearrayrD TypeErrortyperH rN _write_appdatar r? r
r
r r4 x s
z_SSLProtocolTransport.writec C s dS r r
r! r
r
r
can_write_eof s z#_SSLProtocolTransport.can_write_eofc C s | j d| _d S r\ )rN _abortrO r! r
r
r abort s
z_SSLProtocolTransport.abort)N)NN)rH rI rJ r Z
_SendfileModeZFALLBACKZ_sendfile_compatibler rU rX rZ r[ r^ warningswarnra rc rd re rf rg rK rh r4 rp rr r
r
r
r rL s$
rL c @ s e Zd Zd+ddZdd Zd,dd Zd
d Zd d
Zdd Zdd Z dd Z
dd Z d-ddZ dd Z
dd Zd d Zd d Zd d! Zd"d# Zd.d%d&Zd'd( Zd)d* ZdS )/ SSLProtocolFNTc C s t d krtd|d kr tj}n|dkr6td| |sDt||}|| _|rZ|sZ|| _nd | _|| _t |d| _
t | _
d| _|| _|| _| | t| j| | _d | _d| _d| _d| _d | _|| _|| _d S )Nz stdlib ssl module not availabler z7ssl_handshake_timeout should be a positive number, got )r F)r r( r ZSSL_HANDSHAKE_TIMEOUTr r r r _sslcontextdict_extra collectionsdeque_write_backlog_write_buffer_size_waiterrM rV rL _app_transport_sslpipe_session_established
_in_handshake _in_shutdownrb _call_connection_made_ssl_handshake_timeout) r rP app_protocolr Zwaiterr
r Zcall_connection_madeZssl_handshake_timeoutr
r
r r s@
zSSLProtocol.__init__c C s || _ t|tj| _d S r )rY ri r ZBufferedProtocol_app_protocol_is_buffer)r r r
r
r rV s
z SSLProtocol._set_app_protocolc C sD | j d krd S | j s:|d k r.| j | n | j d d | _ d S r )r} Z cancelledZ
set_exceptionZ
set_resultr rA r
r
r _wakeup_waiter s
zSSLProtocol._wakeup_waiterc C s& || _ t| j| j| j| _| d S r )rb r rv r r r _start_handshake)r transportr
r
r connection_made s zSSLProtocol.connection_madec C sn | j r d| _ | j| jj| n| jd k r2d| j_d | _d | _t| dd rT| j
| | d | _d | _ d S )NFT_handshake_timeout_handle)
r rM call_soonrY connection_lostr~ rO rb r: r cancelr r r r
r
r r s
zSSLProtocol.connection_lostc C s | j d S r )rY
pause_writingr! r
r
r r s zSSLProtocol.pause_writingc C s | j d S r )rY resume_writingr! r
r
r r s zSSLProtocol.resume_writingc C s" | j d krd S z| j |\}}W nL ttfk
r< Y n4 tk
rn } z| |d W Y d S d }~X Y nX |D ]}| j| qt|D ]}|rz&| jrt
| j | n | j | W nP ttfk
r Y n8 tk
r
} z| |d W Y d S d }~X Y nX q|
q qd S )NzSSL error in data receivedz/application protocol failed to receive SSL data)r r*
SystemExitKeyboardInterrupt
BaseException _fatal_errorrb r4 r r Z _feed_data_to_buffered_protorY
data_receivedr] )r r? r- r. er@ Zexr
r
r r s<
zSSLProtocol.data_receivedc C sT zB| j rtd| | t | js@| j
}|r@t d W 5 | j X d S )Nz%r received EOFz?returning true from eof_received() has no effect when using ssl) rb r^ rM get_debugr debugr ConnectionResetErrorr rY eof_receivedZwarning)r Z keep_openr
r
r r - s
zSSLProtocol.eof_receivedc C s4 || j kr| j | S | jd k r,| j||S |S d S r )rx rb rU rR r
r
r rQ C s
zSSLProtocol._get_extra_infoc C s. | j r
d S | jr| nd| _ | d d S )NTr& )r r rq rn r! r
r
r r] K s
zSSLProtocol._start_shutdownc C s. | j |df | jt|7 _| d S )Nr )r{ r7 r| rC _process_write_backlogro r
r
r rn T s zSSLProtocol._write_appdatac C s\ | j r$td| | j | _nd | _d| _| jd | j | j
| j | _ |
d S )Nz%r starts SSL handshakeT)r& r )rM r r r time_handshake_start_timer r{ r7 Z
call_laterr _check_handshake_timeoutr r r! r
r
r r Y s
z SSLProtocol._start_handshakec C s* | j dkr&d| j d}| t| d S )NTz$SSL handshake is taking longer than z! seconds: aborting the connection)r r r ConnectionAbortedError)r msgr
r
r r h s
z$SSLProtocol._check_handshake_timeoutc
C s d| _ | j | jj}z|d k r&|| }W nb ttfk
rJ Y nJ tk
r } z,t |t
j rld}nd}| || W Y d S d }~X Y nX | j
r| j
| j }td| |d | jj|| | |d | jr| j| j | d| _ | j
| j d S )NFz1SSL handshake failed on verifying the certificatezSSL handshake failedz %r: SSL handshake took %.1f msg @@)peercertcipher compressionr" T) r r r r r" Z getpeercertr r r ri r r9 r rM r r r r r rx updater r r rY r r~ r r r r )r Z
handshake_excZsslobjr rA r Zdtr
r
r _on_handshake_completeq s8
z"SSLProtocol._on_handshake_completec
C sB | j d ks| jd krd S ztt| jD ]}| jd \}}|rR| j||\}}n*|rj| j| j}d}n| j| j }d}|D ]}| j
| q|t|k r||f| jd< | j j r| j q| jd= | j
t|8 _
q(W n\ ttfk
r Y nD tk
r< } z$| jr | | n | |d W 5 d }~X Y nX d S )Nr r z Fatal error on SSL transport)rb r rangerC r{ rG r/ r r1 _finalizer4 Z_pausedre r| r r r r r )r ir? rF r- r@ rA r
r
r r s:
z"SSLProtocol._process_write_backlogFatal error on transportc C sV t |tr(| j r@tjd| |dd n| j||| j| d | jrR| j| d S )Nz%r: %sT)exc_info)messageZ exceptionr rW ) ri OSErrorrM r r r Zcall_exception_handlerrb Z _force_close)r rA r r
r
r r s
zSSLProtocol._fatal_errorc C s d | _ | jd k r| j d S r )r rb r^ r! r
r
r r s
zSSLProtocol._finalizec C s( z| jd k r| j W 5 | X d S r )r rb rr r! r
r
r rq s
zSSLProtocol._abort)FNTN)N)N)r )rH rI rJ r rV r r r r r r r rQ r] rn r r r r r r rq r
r
r
r ru s.
.
&
)+
ru )ry rs r ImportError r r r r logr r r r) r$ r0 objectr Z_FlowControlMixinZ TransportrL ZProtocolru r
r
r
r s*
yxPK ! _P % __pycache__/base_tasks.cpython-38.pycnu [ U
if @ sD d dl Z d dlZddlmZ ddlmZ dd Zdd Zd d
ZdS ) N ) base_futures)
coroutinesc C sn t | }| jrd|d< |dd| t| j}|dd| d | jd k rj|dd | j |S )
NZ
cancellingr r zname=%r zcoro=<> z wait_for=) r Z_future_repr_infoZ _must_cancelinsertZget_namer Z_format_coroutine_coroZ _fut_waiter)taskinfocoro r
7/opt/alt/python38/lib64/python3.8/asyncio/base_tasks.py_task_repr_info s
r c C s g }t | jdr| jj}n0t | jdr0| jj}nt | jdrF| jj}nd }|d k r|d k r|d k rt|dkrlq|d8 }|| |j}qR| nH| jd k r| jj }|d k r|d k r|dkrq|d8 }||j
|j }q|S )Ncr_framegi_frameag_framer r ) hasattrr r r r appendf_backreverse
_exception
__traceback__tb_frametb_next)r
limitZframesftbr
r
r _task_get_stack s6
r c C s g }t }| j|dD ]Z}|j}|j}|j}|j} ||krN|| t| t |||j
}
| ||| |
f q| j } |st
d| |d n2| d k rt
d| d|d nt
d| d|d tj||d | d k rt| j| D ]}
t
|
|dd qd S ) N)r z
No stack for )filezTraceback for z (most recent call last):z
Stack for )r end)setZ get_stackf_linenof_code co_filenameco_nameadd linecache
checkcachegetline f_globalsr r print traceback
print_listformat_exception_only __class__) r
r r extracted_listcheckedr linenocofilenamenamelineexcr
r
r _task_print_stack< s,
r9 )r( r- r r r r r r9 r
r
r
r s #PK ! hGB + __pycache__/subprocess.cpython-38.opt-1.pycnu [ U
if @ s d Z ddlZddlZddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ej
Z
ej Z ej Z G d d
d
ej
ejZG d d d Zddddejfd
dZddddejdddZdS ))create_subprocess_execcreate_subprocess_shell N )events) protocols)streams)tasks)loggerc sX e Zd ZdZ fddZdd Zdd Zdd Zd
d Zd d
Z dd Z
dd Z Z S )SubprocessStreamProtocolz0Like StreamReaderProtocol, but for a subprocess.c sH t j|d || _d | _ | _| _d | _d| _g | _| j
| _ d S )NloopF) super__init___limitstdinstdoutstderr
_transport_process_exited _pipe_fds_loopZ
create_future
_stdin_closed)selflimitr __class__ 7/opt/alt/python38/lib64/python3.8/asyncio/subprocess.pyr s z!SubprocessStreamProtocol.__init__c C sn | j jg}| jd k r&|d| j | jd k rB|d| j | jd k r^|d| j dd|S )Nzstdin=zstdout=zstderr=z<{}> )r __name__r appendr r formatjoin)r infor r r __repr__ s
z!SubprocessStreamProtocol.__repr__c C s || _ |d}|d k rDtj| j| jd| _| j| | j d |d}|d k rtj| j| jd| _
| j
| | j d |d}|d k rtj || d | jd| _ d S )Nr r r r )protocolreaderr )
r get_pipe_transportr StreamReaderr r r Z
set_transportr r r StreamWriterr )r transportZstdout_transportZstderr_transportZstdin_transportr r r connection_made) s,
z(SubprocessStreamProtocol.connection_madec C s: |dkr| j }n|dkr | j}nd }|d k r6|| d S )Nr r& )r r Z feed_data)r fddatar( r r r pipe_data_receivedA s z+SubprocessStreamProtocol.pipe_data_receivedc C s |dkrN| j }|d k r | | | |d kr>| jd n | j| d S |dkr^| j}n|dkrn| j}nd }|d k r|d kr| n
|| || j kr| j
| | d S )Nr r r& ) r closeZconnection_lostr Z
set_resultZ
set_exceptionr r Zfeed_eofr remove_maybe_close_transport)r r. excpiper( r r r pipe_connection_lostK s*
z-SubprocessStreamProtocol.pipe_connection_lostc C s d| _ | d S )NT)r r3 r r r r process_exitedf s z'SubprocessStreamProtocol.process_exitedc C s( t | jdkr$| jr$| j d | _d S )Nr )lenr r r r1 r7 r r r r3 j s
z/SubprocessStreamProtocol._maybe_close_transportc C s || j kr| jS d S N)r r )r streamr r r _get_close_waitero s
z*SubprocessStreamProtocol._get_close_waiter)
r
__module__ __qualname____doc__r r$ r- r0 r6 r8 r3 r<
__classcell__r r r r r
s
r
c @ sj e Zd Zdd Zdd Zedd Zdd Zd d
Zd d Z d
d Z
dd Z dd Z dd Z
dddZdS )Processc C s8 || _ || _|| _|j| _|j| _|j| _| | _d S r: )r Z _protocolr r r r Zget_pidpid)r r, r' r r r r r u s zProcess.__init__c C s d| j j d| j dS )N)r r rB r7 r r r r$ ~ s zProcess.__repr__c C s
| j S r: )r Zget_returncoder7 r r r
returncode s zProcess.returncodec s | j I dH S )z?Wait until the process exit and return the process return code.N)r Z_waitr7 r r r wait s z Process.waitc C s | j | d S r: )r send_signal)r signalr r r rG s zProcess.send_signalc C s | j d S r: )r terminater7 r r r rI s zProcess.terminatec C s | j d S r: )r killr7 r r r rJ s z Process.killc
s | j }| j| |r,td| t| z| j I d H W n8 tt fk
rx } z|rhtd| | W 5 d }~X Y nX |rtd| | j
d S )Nz%%r communicate: feed stdin (%s bytes)z %r communicate: stdin got %rz%r communicate: close stdin) r get_debugr writer debugr9 ZdrainBrokenPipeErrorConnectionResetErrorr1 )r inputrM r4 r r r _feed_stdin s
zProcess._feed_stdinc s d S r: r r7 r r r _noop s z
Process._noopc s | j |}|dkr | j}n| j}| j rJ|dkr8dnd}td| | | I d H }| j r|dkrndnd}td| | | |S )Nr& r r r z%r communicate: read %sz%r communicate: close %s)
r r) r r r rK r rM readr1 )r r. r, r; nameoutputr r r _read_stream s
zProcess._read_streamNc s |d k r| |}n| }| jd k r2| d}n| }| jd k rP| d}n| }tj|||| jdI d H \}}}| I d H ||fS )Nr r& r ) rQ rR r rV r r Zgatherr rF )r rP r r r r r r communicate s
zProcess.communicate)N)r r= r> r r$ propertyrE rF rG rI rJ rQ rR rV rW r r r r rA t s
rA c
sb d krt ntjdtdd fdd}j|| f|||d|I d H \}} t|| S )NZThe loop argument is deprecated since Python 3.8 and scheduled for removal in Python 3.10.r&
stacklevelc s t dS Nr% r
r r% r r s z)create_subprocess_shell..r r r )r get_event_loopwarningswarnDeprecationWarningZsubprocess_shellrA )
cmdr r r r r kwdsprotocol_factoryr, r' r r% r r s$
r )r r r r r c sf d krt ntjdtdd fdd}j|| f||||d|I d H \} }
t| |
S )NrY r& rZ c s t dS r\ r] r r% r r r^ s z(create_subprocess_exec..r_ )r r` ra rb rc Zsubprocess_execrA ) Zprogramr r r r r argsre rf r, r' r r% r r s(
r )__all__
subprocessra r r r r logr PIPEZSTDOUTZDEVNULLZFlowControlMixinZSubprocessProtocolr
rA Z_DEFAULT_LIMITr r r r r r s. bV
PK ! مT T * __pycache__/constants.cpython-38.opt-2.pycnu [ U
ifx @ s2 d dl Z dZdZdZdZdZG dd de jZdS ) N
g N@i c @ s$ e Zd Ze Ze Ze ZdS )
_SendfileModeN)__name__
__module__ __qualname__enumautoZ UNSUPPORTEDZ
TRY_NATIVEZFALLBACK r r 6/opt/alt/python38/lib64/python3.8/asyncio/constants.pyr s r )r Z!LOG_THRESHOLD_FOR_CONNLOST_WRITESZACCEPT_RETRY_DELAYZDEBUG_STACK_DEPTHZSSL_HANDSHAKE_TIMEOUTZ!SENDFILE_FALLBACK_READBUFFER_SIZEEnumr r r r r s PK ! ? " __pycache__/runners.cpython-38.pycnu [ U
if @ sB d Z ddlmZ ddlmZ ddlmZ ddddZd d
ZdS ) )run )
coroutines)events)tasksN)debugc C s t dk rtdt| s,td| t }z*t | |dk rR|
| | | W S zt
| | | W 5 t d | X X dS )a Execute the coroutine and return the result.
This function runs the passed coroutine, taking care of
managing the asyncio event loop and finalizing asynchronous
generators.
This function cannot be called when another asyncio event loop is
running in the same thread.
If debug is True, the event loop will be run in debug mode.
This function always creates a new event loop and closes it at the end.
It should be used as a main entry point for asyncio programs, and should
ideally only be called once.
Example:
async def main():
await asyncio.sleep(1)
print('hello')
asyncio.run(main())
Nz8asyncio.run() cannot be called from a running event loopz"a coroutine was expected, got {!r})r Z_get_running_loop RuntimeErrorr Z iscoroutine
ValueErrorformatZnew_event_loopZset_event_loopclose_cancel_all_tasksrun_until_completeZshutdown_asyncgensZ set_debug)mainr loop r 4/opt/alt/python38/lib64/python3.8/asyncio/runners.pyr s"
r c C sv t | }|sd S |D ] }| q| t j|| dd |D ]0}| rNq@| d k r@| d| |d q@d S )NT)r Zreturn_exceptionsz1unhandled exception during asyncio.run() shutdown)message exceptiontask)r Z all_tasksZcancelr ZgatherZ cancelledr Zcall_exception_handler)r Z to_cancelr r r r r 6 s"
r )__all__ r r r r r r r r r