PK [ v��4f 4f 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',
'_get_running_loop',
)
import contextvars
import os
import socket
import subprocess
import sys
import threading
from . import format_helpers
from . import exceptions
class Handle:
"""Object returned by callback registration methods."""
__slots__ = ('_callback', '_args', '_cancelled', '_loop',
'_source_traceback', '_repr', '__weakref__',
'_context')
def __init__(self, callback, args, loop, context=None):
if context is None:
context = contextvars.copy_context()
self._context = context
self._loop = loop
self._callback = callback
self._args = args
self._cancelled = False
self._repr = None
if self._loop.get_debug():
self._source_traceback = format_helpers.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_helpers._format_callback_source(
self._callback, self._args))
if self._source_traceback:
frame = self._source_traceback[-1]
info.append(f'created at {frame[0]}:{frame[1]}')
return info
def __repr__(self):
if self._repr is not None:
return self._repr
info = self._repr_info()
return '<{}>'.format(' '.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 <Handle...> took 2.5 second"
self._repr = repr(self)
self._callback = None
self._args = None
def cancelled(self):
return self._cancelled
def _run(self):
try:
self._context.run(self._callback, *self._args)
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
cb = format_helpers._format_callback_source(
self._callback, self._args)
msg = f'Exception in callback {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, context=None):
assert when is not None
super().__init__(callback, args, loop, context)
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, f'when={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()
def when(self):
"""Return a scheduled callback time.
The time is an absolute timestamp, using the same time
reference as loop.time().
"""
return self._when
class AbstractServer:
"""Abstract server returned by create_server()."""
def close(self):
"""Stop serving. This leaves existing connections open."""
raise NotImplementedError
def get_loop(self):
"""Get the event loop the Server object is attached to."""
raise NotImplementedError
def is_serving(self):
"""Return True if the server is accepting connections."""
raise NotImplementedError
async def start_serving(self):
"""Start accepting connections.
This method is idempotent, so it can be called when
the server is already being serving.
"""
raise NotImplementedError
async def serve_forever(self):
"""Start accepting connections until the coroutine is cancelled.
The server is closed when the coroutine is cancelled.
"""
raise NotImplementedError
async def wait_closed(self):
"""Coroutine to wait until service is closed."""
raise NotImplementedError
async def __aenter__(self):
return self
async def __aexit__(self, *exc):
self.close()
await self.wait_closed()
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
async 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, *, name=None):
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.
async def getaddrinfo(self, host, port, *,
family=0, type=0, proto=0, flags=0):
raise NotImplementedError
async def getnameinfo(self, sockaddr, flags=0):
raise NotImplementedError
async 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,
ssl_handshake_timeout=None,
happy_eyeballs_delay=None, interleave=None):
raise NotImplementedError
async 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,
ssl_handshake_timeout=None,
start_serving=True):
"""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.
"""
raise NotImplementedError
async def sendfile(self, transport, file, offset=0, count=None,
*, fallback=True):
"""Send a file through a transport.
Return an amount of sent bytes.
"""
raise NotImplementedError
async def start_tls(self, transport, protocol, sslcontext, *,
server_side=False,
server_hostname=None,
ssl_handshake_timeout=None):
"""Upgrade a transport to TLS.
Return a new transport that *protocol* should start using
immediately.
"""
raise NotImplementedError
async def create_unix_connection(
self, protocol_factory, path=None, *,
ssl=None, sock=None,
server_hostname=None,
ssl_handshake_timeout=None):
raise NotImplementedError
async def create_unix_server(
self, protocol_factory, path=None, *,
sock=None, backlog=100, ssl=None,
ssl_handshake_timeout=None,
start_serving=True):
"""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.
"""
raise NotImplementedError
async 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, 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.
"""
raise NotImplementedError
# Pipes and subprocesses.
async 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
async 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
async def subprocess_shell(self, protocol_factory, cmd, *,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
**kwargs):
raise NotImplementedError
async 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.
async def sock_recv(self, sock, nbytes):
raise NotImplementedError
async def sock_recv_into(self, sock, buf):
raise NotImplementedError
async def sock_sendall(self, sock, data):
raise NotImplementedError
async def sock_connect(self, sock, address):
raise NotImplementedError
async def sock_accept(self, sock):
raise NotImplementedError
async def sock_sendfile(self, sock, file, offset=0, count=None,
*, fallback=None):
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 for the current context.
Returns an instance of EventLoop or raises an exception.
"""
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_pid = (None, None)
_running_loop = _RunningLoop()
def get_running_loop():
"""Return the running event loop. Raise a RuntimeError if there is none.
This function is thread-specific.
"""
# NOTE: this function is implemented in C (see _asynciomodule.c)
loop = _get_running_loop()
if loop is None:
raise RuntimeError('no running event loop')
return loop
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.
"""
# NOTE: this function is implemented in C (see _asynciomodule.c)
running_loop, pid = _running_loop.loop_pid
if running_loop is not None and 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.
"""
# NOTE: this function is implemented in C (see _asynciomodule.c)
_running_loop.loop_pid = (loop, os.getpid())
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.
"""
# NOTE: this function is implemented in C (see _asynciomodule.c)
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)
# Alias pure-Python implementations for testing purposes.
_py__get_running_loop = _get_running_loop
_py__set_running_loop = _set_running_loop
_py_get_running_loop = get_running_loop
_py_get_event_loop = get_event_loop
try:
# get_event_loop() is one of the most frequently called
# functions in asyncio. Pure Python implementation is
# about 4 times slower than C-accelerated.
from _asyncio import (_get_running_loop, _set_running_loop,
get_running_loop, get_event_loop)
except ImportError:
pass
else:
# Alias C implementations for testing purposes.
_c__get_running_loop = _get_running_loop
_c__set_running_loop = _set_running_loop
_c_get_running_loop = get_running_loop
_c_get_event_loop = get_event_loop
PK [��,��( �(
transports.pynu �[��� """Abstract Transport class."""
__all__ = (
'BaseTransport', 'ReadTransport', 'WriteTransport',
'Transport', 'DatagramTransport', 'SubprocessTransport',
)
class BaseTransport:
"""Base class for transports."""
__slots__ = ('_extra',)
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) be
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."""
__slots__ = ()
def is_reading(self):
"""Return True if the transport is receiving."""
raise NotImplementedError
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."""
__slots__ = ()
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 = b''.join(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.
"""
__slots__ = ()
class DatagramTransport(BaseTransport):
"""Interface for datagram (UDP) transports."""
__slots__ = ()
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):
__slots__ = ()
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.
"""
__slots__ = ('_loop', '_protocol_paused', '_high_water', '_low_water')
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 (SystemExit, KeyboardInterrupt):
raise
except BaseException 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 (SystemExit, KeyboardInterrupt):
raise
except BaseException 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(
f'high ({high!r}) must be >= low ({low!r}) must be >= 0')
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 [#ƅ� h h
streams.pynu �[��� __all__ = (
'StreamReader', 'StreamWriter', 'StreamReaderProtocol',
'open_connection', 'start_server')
import socket
import sys
import warnings
import weakref
if hasattr(socket, 'AF_UNIX'):
__all__ += ('open_unix_connection', 'start_unix_server')
from . import coroutines
from . import events
from . import exceptions
from . import format_helpers
from . import protocols
from .log import logger
from .tasks import sleep
_DEFAULT_LIMIT = 2 ** 16 # 64 KiB
async def open_connection(host=None, port=None, *,
loop=None, limit=_DEFAULT_LIMIT, **kwds):
"""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.)
"""
if loop is None:
loop = events.get_event_loop()
else:
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
reader = StreamReader(limit=limit, loop=loop)
protocol = StreamReaderProtocol(reader, loop=loop)
transport, _ = await loop.create_connection(
lambda: protocol, host, port, **kwds)
writer = StreamWriter(transport, protocol, reader, loop)
return reader, writer
async def start_server(client_connected_cb, host=None, port=None, *,
loop=None, limit=_DEFAULT_LIMIT, **kwds):
"""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.
"""
if loop is None:
loop = events.get_event_loop()
else:
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
def factory():
reader = StreamReader(limit=limit, loop=loop)
protocol = StreamReaderProtocol(reader, client_connected_cb,
loop=loop)
return protocol
return await loop.create_server(factory, host, port, **kwds)
if hasattr(socket, 'AF_UNIX'):
# UNIX Domain Sockets are supported on this platform
async def open_unix_connection(path=None, *,
loop=None, limit=_DEFAULT_LIMIT, **kwds):
"""Similar to `open_connection` but works with UNIX Domain Sockets."""
if loop is None:
loop = events.get_event_loop()
else:
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
reader = StreamReader(limit=limit, loop=loop)
protocol = StreamReaderProtocol(reader, loop=loop)
transport, _ = await loop.create_unix_connection(
lambda: protocol, path, **kwds)
writer = StreamWriter(transport, protocol, reader, loop)
return reader, writer
async def start_unix_server(client_connected_cb, path=None, *,
loop=None, limit=_DEFAULT_LIMIT, **kwds):
"""Similar to `start_server` but works with UNIX Domain Sockets."""
if loop is None:
loop = events.get_event_loop()
else:
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
def factory():
reader = StreamReader(limit=limit, loop=loop)
protocol = StreamReaderProtocol(reader, client_connected_cb,
loop=loop)
return protocol
return await loop.create_unix_server(factory, path, **kwds)
class FlowControlMixin(protocols.Protocol):
"""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.
"""
def __init__(self, loop=None):
if loop is None:
self._loop = events.get_event_loop()
else:
self._loop = loop
self._paused = False
self._drain_waiter = None
self._connection_lost = False
def pause_writing(self):
assert not self._paused
self._paused = True
if self._loop.get_debug():
logger.debug("%r pauses writing", self)
def resume_writing(self):
assert self._paused
self._paused = False
if self._loop.get_debug():
logger.debug("%r resumes writing", self)
waiter = self._drain_waiter
if waiter is not None:
self._drain_waiter = None
if not waiter.done():
waiter.set_result(None)
def connection_lost(self, exc):
self._connection_lost = True
# Wake up the writer if currently paused.
if not self._paused:
return
waiter = self._drain_waiter
if waiter is None:
return
self._drain_waiter = None
if waiter.done():
return
if exc is None:
waiter.set_result(None)
else:
waiter.set_exception(exc)
async def _drain_helper(self):
if self._connection_lost:
raise ConnectionResetError('Connection lost')
if not self._paused:
return
waiter = self._drain_waiter
assert waiter is None or waiter.cancelled()
waiter = self._loop.create_future()
self._drain_waiter = waiter
await waiter
def _get_close_waiter(self, stream):
raise NotImplementedError
class StreamReaderProtocol(FlowControlMixin, protocols.Protocol):
"""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.)
"""
_source_traceback = None
def __init__(self, stream_reader, client_connected_cb=None, loop=None):
super().__init__(loop=loop)
if stream_reader is not None:
self._stream_reader_wr = weakref.ref(stream_reader)
self._source_traceback = stream_reader._source_traceback
else:
self._stream_reader_wr = None
if client_connected_cb is not None:
# This is a stream created by the `create_server()` function.
# Keep a strong reference to the reader until a connection
# is established.
self._strong_reader = stream_reader
self._reject_connection = False
self._stream_writer = None
self._transport = None
self._client_connected_cb = client_connected_cb
self._over_ssl = False
self._closed = self._loop.create_future()
@property
def _stream_reader(self):
if self._stream_reader_wr is None:
return None
return self._stream_reader_wr()
def connection_made(self, transport):
if self._reject_connection:
context = {
'message': ('An open stream was garbage collected prior to '
'establishing network connection; '
'call "stream.close()" explicitly.')
}
if self._source_traceback:
context['source_traceback'] = self._source_traceback
self._loop.call_exception_handler(context)
transport.abort()
return
self._transport = transport
reader = self._stream_reader
if reader is not None:
reader.set_transport(transport)
self._over_ssl = transport.get_extra_info('sslcontext') is not None
if self._client_connected_cb is not None:
self._stream_writer = StreamWriter(transport, self,
reader,
self._loop)
res = self._client_connected_cb(reader,
self._stream_writer)
if coroutines.iscoroutine(res):
self._loop.create_task(res)
self._strong_reader = None
def connection_lost(self, exc):
reader = self._stream_reader
if reader is not None:
if exc is None:
reader.feed_eof()
else:
reader.set_exception(exc)
if not self._closed.done():
if exc is None:
self._closed.set_result(None)
else:
self._closed.set_exception(exc)
super().connection_lost(exc)
self._stream_reader_wr = None
self._stream_writer = None
self._transport = None
def data_received(self, data):
reader = self._stream_reader
if reader is not None:
reader.feed_data(data)
def eof_received(self):
reader = self._stream_reader
if reader is not None:
reader.feed_eof()
if self._over_ssl:
# Prevent a warning in SSLProtocol.eof_received:
# "returning true from eof_received()
# has no effect when using ssl"
return False
return True
def _get_close_waiter(self, stream):
return self._closed
def __del__(self):
# Prevent reports about unhandled exceptions.
# Better than self._closed._log_traceback = False hack
closed = self._closed
if closed.done() and not closed.cancelled():
closed.exception()
class StreamWriter:
"""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.
"""
def __init__(self, transport, protocol, reader, loop):
self._transport = transport
self._protocol = protocol
# drain() expects that the reader has an exception() method
assert reader is None or isinstance(reader, StreamReader)
self._reader = reader
self._loop = loop
self._complete_fut = self._loop.create_future()
self._complete_fut.set_result(None)
def __repr__(self):
info = [self.__class__.__name__, f'transport={self._transport!r}']
if self._reader is not None:
info.append(f'reader={self._reader!r}')
return '<{}>'.format(' '.join(info))
@property
def transport(self):
return self._transport
def write(self, data):
self._transport.write(data)
def writelines(self, data):
self._transport.writelines(data)
def write_eof(self):
return self._transport.write_eof()
def can_write_eof(self):
return self._transport.can_write_eof()
def close(self):
return self._transport.close()
def is_closing(self):
return self._transport.is_closing()
async def wait_closed(self):
await self._protocol._get_close_waiter(self)
def get_extra_info(self, name, default=None):
return self._transport.get_extra_info(name, default)
async def drain(self):
"""Flush the write buffer.
The intended use is to write
w.write(data)
await w.drain()
"""
if self._reader is not None:
exc = self._reader.exception()
if exc is not None:
raise exc
if self._transport.is_closing():
# Wait for protocol.connection_lost() call
# Raise connection closing error if any,
# ConnectionResetError otherwise
# Yield to the event loop so connection_lost() may be
# called. Without this, _drain_helper() would return
# immediately, and code that calls
# write(...); await drain()
# in a loop would never call connection_lost(), so it
# would not see an error when the socket is closed.
await sleep(0)
await self._protocol._drain_helper()
class StreamReader:
_source_traceback = None
def __init__(self, limit=_DEFAULT_LIMIT, loop=None):
# The line length limit is a security feature;
# it also doubles as half the buffer limit.
if limit <= 0:
raise ValueError('Limit cannot be <= 0')
self._limit = limit
if loop is None:
self._loop = events.get_event_loop()
else:
self._loop = loop
self._buffer = bytearray()
self._eof = False # Whether we're done.
self._waiter = None # A future used by _wait_for_data()
self._exception = None
self._transport = None
self._paused = False
if self._loop.get_debug():
self._source_traceback = format_helpers.extract_stack(
sys._getframe(1))
def __repr__(self):
info = ['StreamReader']
if self._buffer:
info.append(f'{len(self._buffer)} bytes')
if self._eof:
info.append('eof')
if self._limit != _DEFAULT_LIMIT:
info.append(f'limit={self._limit}')
if self._waiter:
info.append(f'waiter={self._waiter!r}')
if self._exception:
info.append(f'exception={self._exception!r}')
if self._transport:
info.append(f'transport={self._transport!r}')
if self._paused:
info.append('paused')
return '<{}>'.format(' '.join(info))
def exception(self):
return self._exception
def set_exception(self, exc):
self._exception = exc
waiter = self._waiter
if waiter is not None:
self._waiter = None
if not waiter.cancelled():
waiter.set_exception(exc)
def _wakeup_waiter(self):
"""Wakeup read*() functions waiting for data or EOF."""
waiter = self._waiter
if waiter is not None:
self._waiter = None
if not waiter.cancelled():
waiter.set_result(None)
def set_transport(self, transport):
assert self._transport is None, 'Transport already set'
self._transport = transport
def _maybe_resume_transport(self):
if self._paused and len(self._buffer) <= self._limit:
self._paused = False
self._transport.resume_reading()
def feed_eof(self):
self._eof = True
self._wakeup_waiter()
def at_eof(self):
"""Return True if the buffer is empty and 'feed_eof' was called."""
return self._eof and not self._buffer
def feed_data(self, data):
assert not self._eof, 'feed_data after feed_eof'
if not data:
return
self._buffer.extend(data)
self._wakeup_waiter()
if (self._transport is not None and
not self._paused and
len(self._buffer) > 2 * self._limit):
try:
self._transport.pause_reading()
except NotImplementedError:
# The transport can't be paused.
# We'll just have to buffer all data.
# Forget the transport so we don't keep trying.
self._transport = None
else:
self._paused = True
async def _wait_for_data(self, func_name):
"""Wait until feed_data() or feed_eof() is called.
If stream was paused, automatically resume it.
"""
# StreamReader uses a future to link the protocol feed_data() method
# to a read coroutine. Running two read coroutines at the same time
# would have an unexpected behaviour. It would not possible to know
# which coroutine would get the next data.
if self._waiter is not None:
raise RuntimeError(
f'{func_name}() called while another coroutine is '
f'already waiting for incoming data')
assert not self._eof, '_wait_for_data after EOF'
# Waiting for data while paused will make deadlock, so prevent it.
# This is essential for readexactly(n) for case when n > self._limit.
if self._paused:
self._paused = False
self._transport.resume_reading()
self._waiter = self._loop.create_future()
try:
await self._waiter
finally:
self._waiter = None
async def readline(self):
"""Read chunk of data from the stream until newline (b'\n') 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.
"""
sep = b'\n'
seplen = len(sep)
try:
line = await self.readuntil(sep)
except exceptions.IncompleteReadError as e:
return e.partial
except exceptions.LimitOverrunError as e:
if self._buffer.startswith(sep, e.consumed):
del self._buffer[:e.consumed + seplen]
else:
self._buffer.clear()
self._maybe_resume_transport()
raise ValueError(e.args[0])
return line
async def readuntil(self, separator=b'\n'):
"""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.
"""
seplen = len(separator)
if seplen == 0:
raise ValueError('Separator should be at least one-byte string')
if self._exception is not None:
raise self._exception
# Consume whole buffer except last bytes, which length is
# one less than seplen. Let's check corner cases with
# separator='SEPARATOR':
# * we have received almost complete separator (without last
# byte). i.e buffer='some textSEPARATO'. In this case we
# can safely consume len(separator) - 1 bytes.
# * last byte of buffer is first byte of separator, i.e.
# buffer='abcdefghijklmnopqrS'. We may safely consume
# everything except that last byte, but this require to
# analyze bytes of buffer that match partial separator.
# This is slow and/or require FSM. For this case our
# implementation is not optimal, since require rescanning
# of data that is known to not belong to separator. In
# real world, separator will not be so long to notice
# performance problems. Even when reading MIME-encoded
# messages :)
# `offset` is the number of bytes from the beginning of the buffer
# where there is no occurrence of `separator`.
offset = 0
# Loop until we find `separator` in the buffer, exceed the buffer size,
# or an EOF has happened.
while True:
buflen = len(self._buffer)
# Check if we now have enough data in the buffer for `separator` to
# fit.
if buflen - offset >= seplen:
isep = self._buffer.find(separator, offset)
if isep != -1:
# `separator` is in the buffer. `isep` will be used later
# to retrieve the data.
break
# see upper comment for explanation.
offset = buflen + 1 - seplen
if offset > self._limit:
raise exceptions.LimitOverrunError(
'Separator is not found, and chunk exceed the limit',
offset)
# Complete message (with full separator) may be present in buffer
# even when EOF flag is set. This may happen when the last chunk
# adds data which makes separator be found. That's why we check for
# EOF *ater* inspecting the buffer.
if self._eof:
chunk = bytes(self._buffer)
self._buffer.clear()
raise exceptions.IncompleteReadError(chunk, None)
# _wait_for_data() will resume reading if stream was paused.
await self._wait_for_data('readuntil')
if isep > self._limit:
raise exceptions.LimitOverrunError(
'Separator is found, but chunk is longer than limit', isep)
chunk = self._buffer[:isep + seplen]
del self._buffer[:isep + seplen]
self._maybe_resume_transport()
return bytes(chunk)
async def read(self, n=-1):
"""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.
"""
if self._exception is not None:
raise self._exception
if n == 0:
return b''
if n < 0:
# This used to just loop creating a new waiter hoping to
# collect everything in self._buffer, but that would
# deadlock if the subprocess sends more than self.limit
# bytes. So just call self.read(self._limit) until EOF.
blocks = []
while True:
block = await self.read(self._limit)
if not block:
break
blocks.append(block)
return b''.join(blocks)
if not self._buffer and not self._eof:
await self._wait_for_data('read')
# This will work right even if buffer is less than n bytes
data = bytes(self._buffer[:n])
del self._buffer[:n]
self._maybe_resume_transport()
return data
async def readexactly(self, n):
"""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.
"""
if n < 0:
raise ValueError('readexactly size can not be less than zero')
if self._exception is not None:
raise self._exception
if n == 0:
return b''
while len(self._buffer) < n:
if self._eof:
incomplete = bytes(self._buffer)
self._buffer.clear()
raise exceptions.IncompleteReadError(incomplete, n)
await self._wait_for_data('readexactly')
if len(self._buffer) == n:
data = bytes(self._buffer)
self._buffer.clear()
else:
data = bytes(self._buffer[:n])
del self._buffer[:n]
self._maybe_resume_transport()
return data
def __aiter__(self):
return self
async def __anext__(self):
val = await self.readline()
if val == b'':
raise StopAsyncIteration
return val
PK [�xD�Jj Jj sslproto.pynu �[��� import collections
import warnings
try:
import ssl
except ImportError: # pragma: no cover
ssl = None
from . import base_events
from . import constants
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.
# Python 3.4+: use up-to-date strong settings.
sslcontext = ssl.create_default_context()
if not server_hostname:
sslcontext.check_hostname = False
return sslcontext
# 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:
exc_errno = getattr(exc, 'errno', None)
if exc_errno 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.
exc_errno = getattr(exc, 'errno', None)
if exc.reason == 'PROTOCOL_IS_SHUTDOWN':
exc_errno = 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):
_sendfile_compatible = constants._SendfileMode.FALLBACK
def __init__(self, loop, ssl_protocol):
self._loop = loop
# SSLProtocol instance
self._ssl_protocol = ssl_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._ssl_protocol._set_app_protocol(protocol)
def get_protocol(self):
return self._ssl_protocol._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()
def __del__(self, _warn=warnings.warn):
if not self._closed:
_warn(f"unclosed transport {self!r}", ResourceWarning, source=self)
self.close()
def is_reading(self):
tr = self._ssl_protocol._transport
if tr is None:
raise RuntimeError('SSL transport has not been initialized yet')
return tr.is_reading()
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()
@property
def _protocol_paused(self):
# Required for sendfile fallback pause_writing/resume_writing logic
return self._ssl_protocol._transport._protocol_paused
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(f"data: expecting a bytes-like instance, "
f"got {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()
self._closed = True
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,
ssl_handshake_timeout=None):
if ssl is None:
raise RuntimeError('stdlib ssl module not available')
if ssl_handshake_timeout is None:
ssl_handshake_timeout = constants.SSL_HANDSHAKE_TIMEOUT
elif ssl_handshake_timeout <= 0:
raise ValueError(
f"ssl_handshake_timeout should be a positive number, "
f"got {ssl_handshake_timeout}")
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._set_app_protocol(app_protocol)
self._app_transport = _SSLProtocolTransport(self._loop, self)
# _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
self._ssl_handshake_timeout = ssl_handshake_timeout
def _set_app_protocol(self, app_protocol):
self._app_protocol = app_protocol
self._app_protocol_is_buffer = \
isinstance(app_protocol, protocols.BufferedProtocol)
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)
else:
# Most likely an exception occurred while in SSL handshake.
# Just mark the app transport as closed so that its __del__
# doesn't complain.
if self._app_transport is not None:
self._app_transport._closed = True
self._transport = None
self._app_transport = None
if getattr(self, '_handshake_timeout_handle', None):
self._handshake_timeout_handle.cancel()
self._wakeup_waiter(exc)
self._app_protocol = None
self._sslpipe = None
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.
"""
if self._sslpipe is None:
# transport closing, sslpipe is destroyed
return
try:
ssldata, appdata = self._sslpipe.feed_ssldata(data)
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as e:
self._fatal_error(e, 'SSL error in data received')
return
for chunk in ssldata:
self._transport.write(chunk)
for chunk in appdata:
if chunk:
try:
if self._app_protocol_is_buffer:
protocols._feed_data_to_buffered_proto(
self._app_protocol, chunk)
else:
self._app_protocol.data_received(chunk)
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as ex:
self._fatal_error(
ex, 'application protocol failed to receive SSL data')
return
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._handshake_timeout_handle = \
self._loop.call_later(self._ssl_handshake_timeout,
self._check_handshake_timeout)
self._process_write_backlog()
def _check_handshake_timeout(self):
if self._in_handshake is True:
msg = (
f"SSL handshake is taking longer than "
f"{self._ssl_handshake_timeout} seconds: "
f"aborting the connection"
)
self._fatal_error(ConnectionAbortedError(msg))
def _on_handshake_complete(self, handshake_exc):
self._in_handshake = False
self._handshake_timeout_handle.cancel()
sslobj = self._sslpipe.ssl_object
try:
if handshake_exc is not None:
raise handshake_exc
peercert = sslobj.getpeercert()
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
if isinstance(exc, ssl.CertificateError):
msg = 'SSL handshake failed on verifying the certificate'
else:
msg = 'SSL handshake failed'
self._fatal_error(exc, msg)
return
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 or self._sslpipe 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 (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
if self._in_handshake:
# Exceptions will be re-raised in _on_handshake_complete.
self._on_handshake_complete(exc)
else:
self._fatal_error(exc, 'Fatal error on SSL transport')
def _fatal_error(self, exc, message='Fatal error on transport'):
if isinstance(exc, OSError):
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 [�4/�" �" base_subprocess.pynu �[��� import collections
import subprocess
import warnings
from . import protocols
from . import transports
from .log import logger
class BaseSubprocessTransport(transports.SubprocessTransport):
def __init__(self, loop, protocol, args, shell,
stdin, stdout, stderr, bufsize,
waiter=None, extra=None, **kwargs):
super().__init__(extra)
self._closed = False
self._protocol = protocol
self._loop = loop
self._proc = None
self._pid = None
self._returncode = None
self._exit_waiters = []
self._pending_calls = collections.deque()
self._pipes = {}
self._finished = False
if stdin == subprocess.PIPE:
self._pipes[0] = None
if stdout == subprocess.PIPE:
self._pipes[1] = None
if stderr == subprocess.PIPE:
self._pipes[2] = None
# Create the child process: set the _proc attribute
try:
self._start(args=args, shell=shell, stdin=stdin, stdout=stdout,
stderr=stderr, bufsize=bufsize, **kwargs)
except:
self.close()
raise
self._pid = self._proc.pid
self._extra['subprocess'] = self._proc
if self._loop.get_debug():
if isinstance(args, (bytes, str)):
program = args
else:
program = args[0]
logger.debug('process %r created: pid %s',
program, self._pid)
self._loop.create_task(self._connect_pipes(waiter))
def __repr__(self):
info = [self.__class__.__name__]
if self._closed:
info.append('closed')
if self._pid is not None:
info.append(f'pid={self._pid}')
if self._returncode is not None:
info.append(f'returncode={self._returncode}')
elif self._pid is not None:
info.append('running')
else:
info.append('not started')
stdin = self._pipes.get(0)
if stdin is not None:
info.append(f'stdin={stdin.pipe}')
stdout = self._pipes.get(1)
stderr = self._pipes.get(2)
if stdout is not None and stderr is stdout:
info.append(f'stdout=stderr={stdout.pipe}')
else:
if stdout is not None:
info.append(f'stdout={stdout.pipe}')
if stderr is not None:
info.append(f'stderr={stderr.pipe}')
return '<{}>'.format(' '.join(info))
def _start(self, args, shell, stdin, stdout, stderr, bufsize, **kwargs):
raise NotImplementedError
def set_protocol(self, protocol):
self._protocol = protocol
def get_protocol(self):
return self._protocol
def is_closing(self):
return self._closed
def close(self):
if self._closed:
return
self._closed = True
for proto in self._pipes.values():
if proto is None:
continue
proto.pipe.close()
if (self._proc is not None and
# has the child process finished?
self._returncode is None and
# the child process has finished, but the
# transport hasn't been notified yet?
self._proc.poll() is None):
if self._loop.get_debug():
logger.warning('Close running child process: kill %r', self)
try:
self._proc.kill()
except ProcessLookupError:
pass
# Don't clear the _proc reference yet: _post_init() may still run
def __del__(self, _warn=warnings.warn):
if not self._closed:
_warn(f"unclosed transport {self!r}", ResourceWarning, source=self)
self.close()
def get_pid(self):
return self._pid
def get_returncode(self):
return self._returncode
def get_pipe_transport(self, fd):
if fd in self._pipes:
return self._pipes[fd].pipe
else:
return None
def _check_proc(self):
if self._proc is None:
raise ProcessLookupError()
def send_signal(self, signal):
self._check_proc()
self._proc.send_signal(signal)
def terminate(self):
self._check_proc()
self._proc.terminate()
def kill(self):
self._check_proc()
self._proc.kill()
async def _connect_pipes(self, waiter):
try:
proc = self._proc
loop = self._loop
if proc.stdin is not None:
_, pipe = await loop.connect_write_pipe(
lambda: WriteSubprocessPipeProto(self, 0),
proc.stdin)
self._pipes[0] = pipe
if proc.stdout is not None:
_, pipe = await loop.connect_read_pipe(
lambda: ReadSubprocessPipeProto(self, 1),
proc.stdout)
self._pipes[1] = pipe
if proc.stderr is not None:
_, pipe = await loop.connect_read_pipe(
lambda: ReadSubprocessPipeProto(self, 2),
proc.stderr)
self._pipes[2] = pipe
assert self._pending_calls is not None
loop.call_soon(self._protocol.connection_made, self)
for callback, data in self._pending_calls:
loop.call_soon(callback, *data)
self._pending_calls = None
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
if waiter is not None and not waiter.cancelled():
waiter.set_exception(exc)
else:
if waiter is not None and not waiter.cancelled():
waiter.set_result(None)
def _call(self, cb, *data):
if self._pending_calls is not None:
self._pending_calls.append((cb, data))
else:
self._loop.call_soon(cb, *data)
def _pipe_connection_lost(self, fd, exc):
self._call(self._protocol.pipe_connection_lost, fd, exc)
self._try_finish()
def _pipe_data_received(self, fd, data):
self._call(self._protocol.pipe_data_received, fd, data)
def _process_exited(self, returncode):
assert returncode is not None, returncode
assert self._returncode is None, self._returncode
if self._loop.get_debug():
logger.info('%r exited with return code %r', self, returncode)
self._returncode = returncode
if self._proc.returncode is None:
# asyncio uses a child watcher: copy the status into the Popen
# object. On Python 3.6, it is required to avoid a ResourceWarning.
self._proc.returncode = returncode
self._call(self._protocol.process_exited)
self._try_finish()
# wake up futures waiting for wait()
for waiter in self._exit_waiters:
if not waiter.cancelled():
waiter.set_result(returncode)
self._exit_waiters = None
async def _wait(self):
"""Wait until the process exit and return the process return code.
This method is a coroutine."""
if self._returncode is not None:
return self._returncode
waiter = self._loop.create_future()
self._exit_waiters.append(waiter)
return await waiter
def _try_finish(self):
assert not self._finished
if self._returncode is None:
return
if all(p is not None and p.disconnected
for p in self._pipes.values()):
self._finished = True
self._call(self._call_connection_lost, None)
def _call_connection_lost(self, exc):
try:
self._protocol.connection_lost(exc)
finally:
self._loop = None
self._proc = None
self._protocol = None
class WriteSubprocessPipeProto(protocols.BaseProtocol):
def __init__(self, proc, fd):
self.proc = proc
self.fd = fd
self.pipe = None
self.disconnected = False
def connection_made(self, transport):
self.pipe = transport
def __repr__(self):
return f'<{self.__class__.__name__} fd={self.fd} pipe={self.pipe!r}>'
def connection_lost(self, exc):
self.disconnected = True
self.proc._pipe_connection_lost(self.fd, exc)
self.proc = None
def pause_writing(self):
self.proc._protocol.pause_writing()
def resume_writing(self):
self.proc._protocol.resume_writing()
class ReadSubprocessPipeProto(WriteSubprocessPipeProto,
protocols.Protocol):
def data_received(self, data):
self.proc._pipe_data_received(self.fd, data)
PK [l5Z
�: �:
test_utils.pynu �[��� """Utilities shared by tests."""
import collections
import contextlib
import io
import logging
import os
import re
import socket
import socketserver
import sys
import tempfile
import threading
import time
import unittest
import weakref
from unittest import mock
from http.server import HTTPServer
from wsgiref.simple_server import WSGIRequestHandler, WSGIServer
try:
import ssl
except ImportError: # pragma: no cover
ssl = None
from . import base_events
from . import compat
from . import events
from . import futures
from . import selectors
from . import tasks
from .coroutines import coroutine
from .log import logger
from test import support
if sys.platform == 'win32': # pragma: no cover
from .windows_utils import socketpair
else:
from socket import socketpair # pragma: no cover
def data_file(filename):
if hasattr(support, 'TEST_HOME_DIR'):
fullname = os.path.join(support.TEST_HOME_DIR, filename)
if os.path.isfile(fullname):
return fullname
fullname = os.path.join(os.path.dirname(os.__file__), 'test', filename)
if os.path.isfile(fullname):
return fullname
raise FileNotFoundError(filename)
ONLYCERT = data_file('ssl_cert.pem')
ONLYKEY = data_file('ssl_key.pem')
def dummy_ssl_context():
if ssl is None:
return None
else:
return ssl.SSLContext(ssl.PROTOCOL_SSLv23)
def run_briefly(loop):
@coroutine
def once():
pass
gen = once()
t = loop.create_task(gen)
# Don't log a warning if the task is not done after run_until_complete().
# It occurs if the loop is stopped or if a task raises a BaseException.
t._log_destroy_pending = False
try:
loop.run_until_complete(t)
finally:
gen.close()
def run_until(loop, pred, timeout=30):
deadline = time.time() + timeout
while not pred():
if timeout is not None:
timeout = deadline - time.time()
if timeout <= 0:
raise futures.TimeoutError()
loop.run_until_complete(tasks.sleep(0.001, loop=loop))
def run_once(loop):
"""Legacy API to run once through the event loop.
This is the recommended pattern for test code. It will poll the
selector once and run all callbacks scheduled in response to I/O
events.
"""
loop.call_soon(loop.stop)
loop.run_forever()
class SilentWSGIRequestHandler(WSGIRequestHandler):
def get_stderr(self):
return io.StringIO()
def log_message(self, format, *args):
pass
class SilentWSGIServer(WSGIServer):
request_timeout = 2
def get_request(self):
request, client_addr = super().get_request()
request.settimeout(self.request_timeout)
return request, client_addr
def handle_error(self, request, client_address):
pass
class SSLWSGIServerMixin:
def finish_request(self, request, client_address):
# The relative location of our test directory (which
# contains the ssl key and certificate files) differs
# between the stdlib and stand-alone asyncio.
# Prefer our own if we can find it.
keyfile = ONLYKEY
certfile = ONLYCERT
context = ssl.SSLContext()
context.load_cert_chain(certfile, keyfile)
ssock = context.wrap_socket(request, server_side=True)
try:
self.RequestHandlerClass(ssock, client_address, self)
ssock.close()
except OSError:
# maybe socket has been closed by peer
pass
class SSLWSGIServer(SSLWSGIServerMixin, SilentWSGIServer):
pass
def _run_test_server(*, address, use_ssl=False, server_cls, server_ssl_cls):
def app(environ, start_response):
status = '200 OK'
headers = [('Content-type', 'text/plain')]
start_response(status, headers)
return [b'Test message']
# Run the test WSGI server in a separate thread in order not to
# interfere with event handling in the main thread
server_class = server_ssl_cls if use_ssl else server_cls
httpd = server_class(address, SilentWSGIRequestHandler)
httpd.set_app(app)
httpd.address = httpd.server_address
server_thread = threading.Thread(
target=lambda: httpd.serve_forever(poll_interval=0.05))
server_thread.start()
try:
yield httpd
finally:
httpd.shutdown()
httpd.server_close()
server_thread.join()
if hasattr(socket, 'AF_UNIX'):
class UnixHTTPServer(socketserver.UnixStreamServer, HTTPServer):
def server_bind(self):
socketserver.UnixStreamServer.server_bind(self)
self.server_name = '127.0.0.1'
self.server_port = 80
class UnixWSGIServer(UnixHTTPServer, WSGIServer):
request_timeout = 2
def server_bind(self):
UnixHTTPServer.server_bind(self)
self.setup_environ()
def get_request(self):
request, client_addr = super().get_request()
request.settimeout(self.request_timeout)
# Code in the stdlib expects that get_request
# will return a socket and a tuple (host, port).
# However, this isn't true for UNIX sockets,
# as the second return value will be a path;
# hence we return some fake data sufficient
# to get the tests going
return request, ('127.0.0.1', '')
class SilentUnixWSGIServer(UnixWSGIServer):
def handle_error(self, request, client_address):
pass
class UnixSSLWSGIServer(SSLWSGIServerMixin, SilentUnixWSGIServer):
pass
def gen_unix_socket_path():
with tempfile.NamedTemporaryFile() as file:
return file.name
@contextlib.contextmanager
def unix_socket_path():
path = gen_unix_socket_path()
try:
yield path
finally:
try:
os.unlink(path)
except OSError:
pass
@contextlib.contextmanager
def run_test_unix_server(*, use_ssl=False):
with unix_socket_path() as path:
yield from _run_test_server(address=path, use_ssl=use_ssl,
server_cls=SilentUnixWSGIServer,
server_ssl_cls=UnixSSLWSGIServer)
@contextlib.contextmanager
def run_test_server(*, host='127.0.0.1', port=0, use_ssl=False):
yield from _run_test_server(address=(host, port), use_ssl=use_ssl,
server_cls=SilentWSGIServer,
server_ssl_cls=SSLWSGIServer)
def make_test_protocol(base):
dct = {}
for name in dir(base):
if name.startswith('__') and name.endswith('__'):
# skip magic names
continue
dct[name] = MockCallback(return_value=None)
return type('TestProtocol', (base,) + base.__bases__, dct)()
class TestSelector(selectors.BaseSelector):
def __init__(self):
self.keys = {}
def register(self, fileobj, events, data=None):
key = selectors.SelectorKey(fileobj, 0, events, data)
self.keys[fileobj] = key
return key
def unregister(self, fileobj):
return self.keys.pop(fileobj)
def select(self, timeout):
return []
def get_map(self):
return self.keys
class TestLoop(base_events.BaseEventLoop):
"""Loop for unittests.
It manages self time directly.
If something scheduled to be executed later then
on next loop iteration after all ready handlers done
generator passed to __init__ is calling.
Generator should be like this:
def gen():
...
when = yield ...
... = yield time_advance
Value returned by yield is absolute time of next scheduled handler.
Value passed to yield is time advance to move loop's time forward.
"""
def __init__(self, gen=None):
super().__init__()
if gen is None:
def gen():
yield
self._check_on_close = False
else:
self._check_on_close = True
self._gen = gen()
next(self._gen)
self._time = 0
self._clock_resolution = 1e-9
self._timers = []
self._selector = TestSelector()
self.readers = {}
self.writers = {}
self.reset_counters()
self._transports = weakref.WeakValueDictionary()
def time(self):
return self._time
def advance_time(self, advance):
"""Move test time forward."""
if advance:
self._time += advance
def close(self):
super().close()
if self._check_on_close:
try:
self._gen.send(0)
except StopIteration:
pass
else: # pragma: no cover
raise AssertionError("Time generator is not finished")
def _add_reader(self, fd, callback, *args):
self.readers[fd] = events.Handle(callback, args, self)
def _remove_reader(self, fd):
self.remove_reader_count[fd] += 1
if fd in self.readers:
del self.readers[fd]
return True
else:
return False
def assert_reader(self, fd, callback, *args):
if fd not in self.readers:
raise AssertionError(f'fd {fd} is not registered')
handle = self.readers[fd]
if handle._callback != callback:
raise AssertionError(
f'unexpected callback: {handle._callback} != {callback}')
if handle._args != args:
raise AssertionError(
f'unexpected callback args: {handle._args} != {args}')
def assert_no_reader(self, fd):
if fd in self.readers:
raise AssertionError(f'fd {fd} is registered')
def _add_writer(self, fd, callback, *args):
self.writers[fd] = events.Handle(callback, args, self)
def _remove_writer(self, fd):
self.remove_writer_count[fd] += 1
if fd in self.writers:
del self.writers[fd]
return True
else:
return False
def assert_writer(self, fd, callback, *args):
assert fd in self.writers, 'fd {} is not registered'.format(fd)
handle = self.writers[fd]
assert handle._callback == callback, '{!r} != {!r}'.format(
handle._callback, callback)
assert handle._args == args, '{!r} != {!r}'.format(
handle._args, args)
def _ensure_fd_no_transport(self, fd):
try:
transport = self._transports[fd]
except KeyError:
pass
else:
raise RuntimeError(
'File descriptor {!r} is used by transport {!r}'.format(
fd, transport))
def add_reader(self, fd, callback, *args):
"""Add a reader callback."""
self._ensure_fd_no_transport(fd)
return self._add_reader(fd, callback, *args)
def remove_reader(self, fd):
"""Remove a reader callback."""
self._ensure_fd_no_transport(fd)
return self._remove_reader(fd)
def add_writer(self, fd, callback, *args):
"""Add a writer callback.."""
self._ensure_fd_no_transport(fd)
return self._add_writer(fd, callback, *args)
def remove_writer(self, fd):
"""Remove a writer callback."""
self._ensure_fd_no_transport(fd)
return self._remove_writer(fd)
def reset_counters(self):
self.remove_reader_count = collections.defaultdict(int)
self.remove_writer_count = collections.defaultdict(int)
def _run_once(self):
super()._run_once()
for when in self._timers:
advance = self._gen.send(when)
self.advance_time(advance)
self._timers = []
def call_at(self, when, callback, *args):
self._timers.append(when)
return super().call_at(when, callback, *args)
def _process_events(self, event_list):
return
def _write_to_self(self):
pass
def MockCallback(**kwargs):
return mock.Mock(spec=['__call__'], **kwargs)
class MockPattern(str):
"""A regex based str with a fuzzy __eq__.
Use this helper with 'mock.assert_called_with', or anywhere
where a regex comparison between strings is needed.
For instance:
mock_call.assert_called_with(MockPattern('spam.*ham'))
"""
def __eq__(self, other):
return bool(re.search(str(self), other, re.S))
def get_function_source(func):
source = events._get_function_source(func)
if source is None:
raise ValueError("unable to get the source of %r" % (func,))
return source
class TestCase(unittest.TestCase):
@staticmethod
def close_loop(loop):
executor = loop._default_executor
if executor is not None:
executor.shutdown(wait=True)
loop.close()
def set_event_loop(self, loop, *, cleanup=True):
assert loop is not None
# ensure that the event loop is passed explicitly in asyncio
events.set_event_loop(None)
if cleanup:
self.addCleanup(self.close_loop, loop)
def new_test_loop(self, gen=None):
loop = TestLoop(gen)
self.set_event_loop(loop)
return loop
def unpatch_get_running_loop(self):
events._get_running_loop = self._get_running_loop
def setUp(self):
self._get_running_loop = events._get_running_loop
events._get_running_loop = lambda: None
self._thread_cleanup = support.threading_setup()
def tearDown(self):
self.unpatch_get_running_loop()
events.set_event_loop(None)
# Detect CPython bug #23353: ensure that yield/yield-from is not used
# in an except block of a generator
self.assertEqual(sys.exc_info(), (None, None, None))
self.doCleanups()
support.threading_cleanup(*self._thread_cleanup)
support.reap_children()
if not compat.PY34:
# Python 3.3 compatibility
def subTest(self, *args, **kwargs):
class EmptyCM:
def __enter__(self):
pass
def __exit__(self, *exc):
pass
return EmptyCM()
@contextlib.contextmanager
def disable_logger():
"""Context manager to disable asyncio logger.
For example, it can be used to ignore warnings in debug mode.
"""
old_level = logger.level
try:
logger.setLevel(logging.CRITICAL+1)
yield
finally:
logger.setLevel(old_level)
def mock_nonblocking_socket(proto=socket.IPPROTO_TCP, type=socket.SOCK_STREAM,
family=socket.AF_INET):
"""Create a mock of a non-blocking socket."""
sock = mock.MagicMock(socket.socket)
sock.proto = proto
sock.type = type
sock.family = family
sock.gettimeout.return_value = 0.0
return sock
def force_legacy_ssl_support():
return mock.patch('asyncio.sslproto._is_sslproto_available',
return_value=False)
PK [�pCP compat.pynu �[��� """Compatibility helpers for the different Python versions."""
import sys
PY34 = sys.version_info >= (3, 4)
PY35 = sys.version_info >= (3, 5)
PY352 = sys.version_info >= (3, 5, 2)
def flatten_list_bytes(list_of_data):
"""Concatenate a sequence of bytes-like objects."""
if not PY34:
# On Python 3.3 and older, bytes.join() doesn't handle
# memoryview.
list_of_data = (
bytes(data) if isinstance(data, memoryview) else data
for data in list_of_data)
return b''.join(list_of_data)
PK [=�|C |C locks.pynu �[��� """Synchronization primitives."""
__all__ = ('Lock', 'Event', 'Condition', 'Semaphore', 'BoundedSemaphore')
import collections
import types
import warnings
from . import events
from . import futures
from . import exceptions
from .import coroutines
class _ContextManager:
"""Context manager.
This enables the following idiom for acquiring and releasing a
lock around a block:
with (yield from lock):
<block>
while failing loudly when accidentally using:
with lock:
<block>
Deprecated, use 'async with' statement:
async with lock:
<block>
"""
def __init__(self, lock):
self._lock = lock
def __enter__(self):
# We have no use for the "as ..." clause in the with
# statement for locks.
return None
def __exit__(self, *args):
try:
self._lock.release()
finally:
self._lock = None # Crudely prevent reuse.
class _ContextManagerMixin:
def __enter__(self):
raise RuntimeError(
'"yield from" should be used as context manager expression')
def __exit__(self, *args):
# This must exist because __enter__ exists, even though that
# always raises; that's how the with-statement works.
pass
@types.coroutine
def __iter__(self):
# This is not a coroutine. It is meant to enable the idiom:
#
# with (yield from lock):
# <block>
#
# as an alternative to:
#
# yield from lock.acquire()
# try:
# <block>
# finally:
# lock.release()
# Deprecated, use 'async with' statement:
# async with lock:
# <block>
warnings.warn("'with (yield from lock)' is deprecated "
"use 'async with lock' instead",
DeprecationWarning, stacklevel=2)
yield from self.acquire()
return _ContextManager(self)
# The flag is needed for legacy asyncio.iscoroutine()
__iter__._is_coroutine = coroutines._is_coroutine
async def __acquire_ctx(self):
await self.acquire()
return _ContextManager(self)
def __await__(self):
warnings.warn("'with await lock' is deprecated "
"use 'async with lock' instead",
DeprecationWarning, stacklevel=2)
# To make "with await lock" work.
return self.__acquire_ctx().__await__()
async def __aenter__(self):
await self.acquire()
# We have no use for the "as ..." clause in the with
# statement for locks.
return None
async def __aexit__(self, exc_type, exc, tb):
self.release()
class Lock(_ContextManagerMixin):
"""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
...
"""
def __init__(self, *, loop=None):
self._waiters = None
self._locked = False
if loop is None:
self._loop = events.get_event_loop()
else:
self._loop = loop
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
def __repr__(self):
res = super().__repr__()
extra = 'locked' if self._locked else 'unlocked'
if self._waiters:
extra = f'{extra}, waiters:{len(self._waiters)}'
return f'<{res[1:-1]} [{extra}]>'
def locked(self):
"""Return True if lock is acquired."""
return self._locked
async def acquire(self):
"""Acquire a lock.
This method blocks until the lock is unlocked, then sets it to
locked and returns True.
"""
if (not self._locked and (self._waiters is None or
all(w.cancelled() for w in self._waiters))):
self._locked = True
return True
if self._waiters is None:
self._waiters = collections.deque()
fut = self._loop.create_future()
self._waiters.append(fut)
# Finally block should be called before the CancelledError
# handling as we don't want CancelledError to call
# _wake_up_first() and attempt to wake up itself.
try:
try:
await fut
finally:
self._waiters.remove(fut)
except exceptions.CancelledError:
if not self._locked:
self._wake_up_first()
raise
self._locked = True
return True
def release(self):
"""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.
"""
if self._locked:
self._locked = False
self._wake_up_first()
else:
raise RuntimeError('Lock is not acquired.')
def _wake_up_first(self):
"""Wake up the first waiter if it isn't done."""
if not self._waiters:
return
try:
fut = next(iter(self._waiters))
except StopIteration:
return
# .done() necessarily means that a waiter will wake up later on and
# either take the lock, or, if it was cancelled and lock wasn't
# taken already, will hit this again and wake up a new waiter.
if not fut.done():
fut.set_result(True)
class Event:
"""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.
"""
def __init__(self, *, loop=None):
self._waiters = collections.deque()
self._value = False
if loop is None:
self._loop = events.get_event_loop()
else:
self._loop = loop
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
def __repr__(self):
res = super().__repr__()
extra = 'set' if self._value else 'unset'
if self._waiters:
extra = f'{extra}, waiters:{len(self._waiters)}'
return f'<{res[1:-1]} [{extra}]>'
def is_set(self):
"""Return True if and only if the internal flag is true."""
return self._value
def set(self):
"""Set 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.
"""
if not self._value:
self._value = True
for fut in self._waiters:
if not fut.done():
fut.set_result(True)
def clear(self):
"""Reset the internal flag to false. Subsequently, coroutines calling
wait() will block until set() is called to set the internal flag
to true again."""
self._value = False
async def wait(self):
"""Block 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.
"""
if self._value:
return True
fut = self._loop.create_future()
self._waiters.append(fut)
try:
await fut
return True
finally:
self._waiters.remove(fut)
class Condition(_ContextManagerMixin):
"""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.
"""
def __init__(self, lock=None, *, loop=None):
if loop is None:
self._loop = events.get_event_loop()
else:
self._loop = loop
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
if lock is None:
lock = Lock(loop=loop)
elif lock._loop is not self._loop:
raise ValueError("loop argument must agree with lock")
self._lock = lock
# Export the lock's locked(), acquire() and release() methods.
self.locked = lock.locked
self.acquire = lock.acquire
self.release = lock.release
self._waiters = collections.deque()
def __repr__(self):
res = super().__repr__()
extra = 'locked' if self.locked() else 'unlocked'
if self._waiters:
extra = f'{extra}, waiters:{len(self._waiters)}'
return f'<{res[1:-1]} [{extra}]>'
async def wait(self):
"""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.
"""
if not self.locked():
raise RuntimeError('cannot wait on un-acquired lock')
self.release()
try:
fut = self._loop.create_future()
self._waiters.append(fut)
try:
await fut
return True
finally:
self._waiters.remove(fut)
finally:
# Must reacquire lock even if wait is cancelled
cancelled = False
while True:
try:
await self.acquire()
break
except exceptions.CancelledError:
cancelled = True
if cancelled:
raise exceptions.CancelledError
async def wait_for(self, predicate):
"""Wait 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.
"""
result = predicate()
while not result:
await self.wait()
result = predicate()
return result
def notify(self, n=1):
"""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.
"""
if not self.locked():
raise RuntimeError('cannot notify on un-acquired lock')
idx = 0
for fut in self._waiters:
if idx >= n:
break
if not fut.done():
idx += 1
fut.set_result(False)
def notify_all(self):
"""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.
"""
self.notify(len(self._waiters))
class Semaphore(_ContextManagerMixin):
"""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.
"""
def __init__(self, value=1, *, loop=None):
if value < 0:
raise ValueError("Semaphore initial value must be >= 0")
self._value = value
self._waiters = collections.deque()
if loop is None:
self._loop = events.get_event_loop()
else:
self._loop = loop
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
def __repr__(self):
res = super().__repr__()
extra = 'locked' if self.locked() else f'unlocked, value:{self._value}'
if self._waiters:
extra = f'{extra}, waiters:{len(self._waiters)}'
return f'<{res[1:-1]} [{extra}]>'
def _wake_up_next(self):
while self._waiters:
waiter = self._waiters.popleft()
if not waiter.done():
waiter.set_result(None)
return
def locked(self):
"""Returns True if semaphore can not be acquired immediately."""
return self._value == 0
async def acquire(self):
"""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.
"""
while self._value <= 0:
fut = self._loop.create_future()
self._waiters.append(fut)
try:
await fut
except:
# See the similar code in Queue.get.
fut.cancel()
if self._value > 0 and not fut.cancelled():
self._wake_up_next()
raise
self._value -= 1
return True
def release(self):
"""Release 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.
"""
self._value += 1
self._wake_up_next()
class BoundedSemaphore(Semaphore):
"""A bounded semaphore implementation.
This raises ValueError in release() if it would increase the value
above the initial value.
"""
def __init__(self, value=1, *, loop=None):
if loop:
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
self._bound_value = value
super().__init__(value, loop=loop)
def release(self):
if self._value >= self._bound_value:
raise ValueError('BoundedSemaphore released too many times')
super().release()
PK [V�CC� � windows_utils.pynu �[��� """Various Windows specific bits and pieces."""
import sys
if sys.platform != 'win32': # pragma: no cover
raise ImportError('win32 only')
import _winapi
import itertools
import msvcrt
import os
import subprocess
import tempfile
import warnings
__all__ = 'pipe', 'Popen', 'PIPE', 'PipeHandle'
# Constants/globals
BUFSIZE = 8192
PIPE = subprocess.PIPE
STDOUT = subprocess.STDOUT
_mmap_counter = itertools.count()
# Replacement for os.pipe() using handles instead of fds
def pipe(*, duplex=False, overlapped=(True, True), bufsize=BUFSIZE):
"""Like os.pipe() but with overlapped support and using handles not fds."""
address = tempfile.mktemp(
prefix=r'\\.\pipe\python-pipe-{:d}-{:d}-'.format(
os.getpid(), next(_mmap_counter)))
if duplex:
openmode = _winapi.PIPE_ACCESS_DUPLEX
access = _winapi.GENERIC_READ | _winapi.GENERIC_WRITE
obsize, ibsize = bufsize, bufsize
else:
openmode = _winapi.PIPE_ACCESS_INBOUND
access = _winapi.GENERIC_WRITE
obsize, ibsize = 0, bufsize
openmode |= _winapi.FILE_FLAG_FIRST_PIPE_INSTANCE
if overlapped[0]:
openmode |= _winapi.FILE_FLAG_OVERLAPPED
if overlapped[1]:
flags_and_attribs = _winapi.FILE_FLAG_OVERLAPPED
else:
flags_and_attribs = 0
h1 = h2 = None
try:
h1 = _winapi.CreateNamedPipe(
address, openmode, _winapi.PIPE_WAIT,
1, obsize, ibsize, _winapi.NMPWAIT_WAIT_FOREVER, _winapi.NULL)
h2 = _winapi.CreateFile(
address, access, 0, _winapi.NULL, _winapi.OPEN_EXISTING,
flags_and_attribs, _winapi.NULL)
ov = _winapi.ConnectNamedPipe(h1, overlapped=True)
ov.GetOverlappedResult(True)
return h1, h2
except:
if h1 is not None:
_winapi.CloseHandle(h1)
if h2 is not None:
_winapi.CloseHandle(h2)
raise
# Wrapper for a pipe handle
class PipeHandle:
"""Wrapper for an overlapped pipe handle which is vaguely file-object like.
The IOCP event loop can use these instead of socket objects.
"""
def __init__(self, handle):
self._handle = handle
def __repr__(self):
if self._handle is not None:
handle = f'handle={self._handle!r}'
else:
handle = 'closed'
return f'<{self.__class__.__name__} {handle}>'
@property
def handle(self):
return self._handle
def fileno(self):
if self._handle is None:
raise ValueError("I/O operation on closed pipe")
return self._handle
def close(self, *, CloseHandle=_winapi.CloseHandle):
if self._handle is not None:
CloseHandle(self._handle)
self._handle = None
def __del__(self, _warn=warnings.warn):
if self._handle is not None:
_warn(f"unclosed {self!r}", ResourceWarning, source=self)
self.close()
def __enter__(self):
return self
def __exit__(self, t, v, tb):
self.close()
# Replacement for subprocess.Popen using overlapped pipe handles
class Popen(subprocess.Popen):
"""Replacement for subprocess.Popen using overlapped pipe handles.
The stdin, stdout, stderr are None or instances of PipeHandle.
"""
def __init__(self, args, stdin=None, stdout=None, stderr=None, **kwds):
assert not kwds.get('universal_newlines')
assert kwds.get('bufsize', 0) == 0
stdin_rfd = stdout_wfd = stderr_wfd = None
stdin_wh = stdout_rh = stderr_rh = None
if stdin == PIPE:
stdin_rh, stdin_wh = pipe(overlapped=(False, True), duplex=True)
stdin_rfd = msvcrt.open_osfhandle(stdin_rh, os.O_RDONLY)
else:
stdin_rfd = stdin
if stdout == PIPE:
stdout_rh, stdout_wh = pipe(overlapped=(True, False))
stdout_wfd = msvcrt.open_osfhandle(stdout_wh, 0)
else:
stdout_wfd = stdout
if stderr == PIPE:
stderr_rh, stderr_wh = pipe(overlapped=(True, False))
stderr_wfd = msvcrt.open_osfhandle(stderr_wh, 0)
elif stderr == STDOUT:
stderr_wfd = stdout_wfd
else:
stderr_wfd = stderr
try:
super().__init__(args, stdin=stdin_rfd, stdout=stdout_wfd,
stderr=stderr_wfd, **kwds)
except:
for h in (stdin_wh, stdout_rh, stderr_rh):
if h is not None:
_winapi.CloseHandle(h)
raise
else:
if stdin_wh is not None:
self.stdin = PipeHandle(stdin_wh)
if stdout_rh is not None:
self.stdout = PipeHandle(stdout_rh)
if stderr_rh is not None:
self.stderr = PipeHandle(stderr_rh)
finally:
if stdin == PIPE:
os.close(stdin_rfd)
if stdout == PIPE:
os.close(stdout_wfd)
if stderr == PIPE:
os.close(stderr_wfd)
PK [l���� �� tasks.pynu �[��� """Support for tasks, coroutines and the scheduler."""
__all__ = (
'Task', 'create_task',
'FIRST_COMPLETED', 'FIRST_EXCEPTION', 'ALL_COMPLETED',
'wait', 'wait_for', 'as_completed', 'sleep',
'gather', 'shield', 'ensure_future', 'run_coroutine_threadsafe',
'current_task', 'all_tasks',
'_register_task', '_unregister_task', '_enter_task', '_leave_task',
)
import concurrent.futures
import contextvars
import functools
import inspect
import itertools
import types
import warnings
import weakref
from . import base_tasks
from . import coroutines
from . import events
from . import exceptions
from . import futures
from .coroutines import _is_coroutine
# Helper to generate new task names
# This uses itertools.count() instead of a "+= 1" operation because the latter
# is not thread safe. See bpo-11866 for a longer explanation.
_task_name_counter = itertools.count(1).__next__
def current_task(loop=None):
"""Return a currently executed task."""
if loop is None:
loop = events.get_running_loop()
return _current_tasks.get(loop)
def all_tasks(loop=None):
"""Return a set of all tasks for the loop."""
if loop is None:
loop = events.get_running_loop()
# Looping over a WeakSet (_all_tasks) isn't safe as it can be updated from another
# thread while we do so. Therefore we cast it to list prior to filtering. The list
# cast itself requires iteration, so we repeat it several times ignoring
# RuntimeErrors (which are not very likely to occur). See issues 34970 and 36607 for
# details.
i = 0
while True:
try:
tasks = list(_all_tasks)
except RuntimeError:
i += 1
if i >= 1000:
raise
else:
break
return {t for t in tasks
if futures._get_loop(t) is loop and not t.done()}
def _all_tasks_compat(loop=None):
# Different from "all_task()" by returning *all* Tasks, including
# the completed ones. Used to implement deprecated "Tasks.all_task()"
# method.
if loop is None:
loop = events.get_event_loop()
# Looping over a WeakSet (_all_tasks) isn't safe as it can be updated from another
# thread while we do so. Therefore we cast it to list prior to filtering. The list
# cast itself requires iteration, so we repeat it several times ignoring
# RuntimeErrors (which are not very likely to occur). See issues 34970 and 36607 for
# details.
i = 0
while True:
try:
tasks = list(_all_tasks)
except RuntimeError:
i += 1
if i >= 1000:
raise
else:
break
return {t for t in tasks if futures._get_loop(t) is loop}
def _set_task_name(task, name):
if name is not None:
try:
set_name = task.set_name
except AttributeError:
pass
else:
set_name(name)
class Task(futures._PyFuture): # Inherit Python Task implementation
# from a Python Future implementation.
"""A coroutine wrapped in a Future."""
# An important invariant maintained while a Task not done:
#
# - Either _fut_waiter is None, and _step() is scheduled;
# - or _fut_waiter is some Future, and _step() is *not* scheduled.
#
# The only transition from the latter to the former is through
# _wakeup(). When _fut_waiter is not None, one of its callbacks
# must be _wakeup().
# If False, don't log a message if the task is destroyed whereas its
# status is still pending
_log_destroy_pending = True
@classmethod
def current_task(cls, loop=None):
"""Return 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.
"""
warnings.warn("Task.current_task() is deprecated since Python 3.7, "
"use asyncio.current_task() instead",
DeprecationWarning,
stacklevel=2)
if loop is None:
loop = events.get_event_loop()
return current_task(loop)
@classmethod
def all_tasks(cls, loop=None):
"""Return a set of all tasks for an event loop.
By default all tasks for the current event loop are returned.
"""
warnings.warn("Task.all_tasks() is deprecated since Python 3.7, "
"use asyncio.all_tasks() instead",
DeprecationWarning,
stacklevel=2)
return _all_tasks_compat(loop)
def __init__(self, coro, *, loop=None, name=None):
super().__init__(loop=loop)
if self._source_traceback:
del self._source_traceback[-1]
if not coroutines.iscoroutine(coro):
# raise after Future.__init__(), attrs are required for __del__
# prevent logging for pending task in __del__
self._log_destroy_pending = False
raise TypeError(f"a coroutine was expected, got {coro!r}")
if name is None:
self._name = f'Task-{_task_name_counter()}'
else:
self._name = str(name)
self._must_cancel = False
self._fut_waiter = None
self._coro = coro
self._context = contextvars.copy_context()
self._loop.call_soon(self.__step, context=self._context)
_register_task(self)
def __del__(self):
if self._state == futures._PENDING and self._log_destroy_pending:
context = {
'task': self,
'message': 'Task was destroyed but it is pending!',
}
if self._source_traceback:
context['source_traceback'] = self._source_traceback
self._loop.call_exception_handler(context)
super().__del__()
def _repr_info(self):
return base_tasks._task_repr_info(self)
def get_coro(self):
return self._coro
def get_name(self):
return self._name
def set_name(self, value):
self._name = str(value)
def set_result(self, result):
raise RuntimeError('Task does not support set_result operation')
def set_exception(self, exception):
raise RuntimeError('Task does not support set_exception operation')
def get_stack(self, *, limit=None):
"""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.
"""
return base_tasks._task_get_stack(self, limit)
def print_stack(self, *, limit=None, file=None):
"""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.
"""
return base_tasks._task_print_stack(self, limit, file)
def cancel(self):
"""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).
"""
self._log_traceback = False
if self.done():
return False
if self._fut_waiter is not None:
if self._fut_waiter.cancel():
# Leave self._fut_waiter; it may be a Task that
# catches and ignores the cancellation so we may have
# to cancel it again later.
return True
# It must be the case that self.__step is already scheduled.
self._must_cancel = True
return True
def __step(self, exc=None):
if self.done():
raise exceptions.InvalidStateError(
f'_step(): already done: {self!r}, {exc!r}')
if self._must_cancel:
if not isinstance(exc, exceptions.CancelledError):
exc = exceptions.CancelledError()
self._must_cancel = False
coro = self._coro
self._fut_waiter = None
_enter_task(self._loop, self)
# Call either coro.throw(exc) or coro.send(None).
try:
if exc is None:
# We use the `send` method directly, because coroutines
# don't have `__iter__` and `__next__` methods.
result = coro.send(None)
else:
result = coro.throw(exc)
except StopIteration as exc:
if self._must_cancel:
# Task is cancelled right before coro stops.
self._must_cancel = False
super().cancel()
else:
super().set_result(exc.value)
except exceptions.CancelledError:
super().cancel() # I.e., Future.cancel(self).
except (KeyboardInterrupt, SystemExit) as exc:
super().set_exception(exc)
raise
except BaseException as exc:
super().set_exception(exc)
else:
blocking = getattr(result, '_asyncio_future_blocking', None)
if blocking is not None:
# Yielded Future must come from Future.__iter__().
if futures._get_loop(result) is not self._loop:
new_exc = RuntimeError(
f'Task {self!r} got Future '
f'{result!r} attached to a different loop')
self._loop.call_soon(
self.__step, new_exc, context=self._context)
elif blocking:
if result is self:
new_exc = RuntimeError(
f'Task cannot await on itself: {self!r}')
self._loop.call_soon(
self.__step, new_exc, context=self._context)
else:
result._asyncio_future_blocking = False
result.add_done_callback(
self.__wakeup, context=self._context)
self._fut_waiter = result
if self._must_cancel:
if self._fut_waiter.cancel():
self._must_cancel = False
else:
new_exc = RuntimeError(
f'yield was used instead of yield from '
f'in task {self!r} with {result!r}')
self._loop.call_soon(
self.__step, new_exc, context=self._context)
elif result is None:
# Bare yield relinquishes control for one event loop iteration.
self._loop.call_soon(self.__step, context=self._context)
elif inspect.isgenerator(result):
# Yielding a generator is just wrong.
new_exc = RuntimeError(
f'yield was used instead of yield from for '
f'generator in task {self!r} with {result!r}')
self._loop.call_soon(
self.__step, new_exc, context=self._context)
else:
# Yielding something else is an error.
new_exc = RuntimeError(f'Task got bad yield: {result!r}')
self._loop.call_soon(
self.__step, new_exc, context=self._context)
finally:
_leave_task(self._loop, self)
self = None # Needed to break cycles when an exception occurs.
def __wakeup(self, future):
try:
future.result()
except BaseException as exc:
# This may also be a cancellation.
self.__step(exc)
else:
# Don't pass the value of `future.result()` explicitly,
# as `Future.__iter__` and `Future.__await__` don't need it.
# If we call `_step(value, None)` instead of `_step()`,
# Python eval loop would use `.send(value)` method call,
# instead of `__next__()`, which is slower for futures
# that return non-generator iterators from their `__iter__`.
self.__step()
self = None # Needed to break cycles when an exception occurs.
_PyTask = Task
try:
import _asyncio
except ImportError:
pass
else:
# _CTask is needed for tests.
Task = _CTask = _asyncio.Task
def create_task(coro, *, name=None):
"""Schedule the execution of a coroutine object in a spawn task.
Return a Task object.
"""
loop = events.get_running_loop()
task = loop.create_task(coro)
_set_task_name(task, name)
return task
# wait() and as_completed() similar to those in PEP 3148.
FIRST_COMPLETED = concurrent.futures.FIRST_COMPLETED
FIRST_EXCEPTION = concurrent.futures.FIRST_EXCEPTION
ALL_COMPLETED = concurrent.futures.ALL_COMPLETED
async def wait(fs, *, loop=None, timeout=None, return_when=ALL_COMPLETED):
"""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.
"""
if futures.isfuture(fs) or coroutines.iscoroutine(fs):
raise TypeError(f"expect a list of futures, not {type(fs).__name__}")
if not fs:
raise ValueError('Set of coroutines/Futures is empty.')
if return_when not in (FIRST_COMPLETED, FIRST_EXCEPTION, ALL_COMPLETED):
raise ValueError(f'Invalid return_when value: {return_when}')
if loop is None:
loop = events.get_running_loop()
else:
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
fs = {ensure_future(f, loop=loop) for f in set(fs)}
return await _wait(fs, timeout, return_when, loop)
def _release_waiter(waiter, *args):
if not waiter.done():
waiter.set_result(None)
async def wait_for(fut, timeout, *, loop=None):
"""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.
"""
if loop is None:
loop = events.get_running_loop()
else:
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
if timeout is None:
return await fut
if timeout <= 0:
fut = ensure_future(fut, loop=loop)
if fut.done():
return fut.result()
await _cancel_and_wait(fut, loop=loop)
try:
fut.result()
except exceptions.CancelledError as exc:
raise exceptions.TimeoutError() from exc
else:
raise exceptions.TimeoutError()
waiter = loop.create_future()
timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
cb = functools.partial(_release_waiter, waiter)
fut = ensure_future(fut, loop=loop)
fut.add_done_callback(cb)
try:
# wait until the future completes or the timeout
try:
await waiter
except exceptions.CancelledError:
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
# We must ensure that the task is not running
# after wait_for() returns.
# See https://bugs.python.org/issue32751
await _cancel_and_wait(fut, loop=loop)
raise
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
# We must ensure that the task is not running
# after wait_for() returns.
# See https://bugs.python.org/issue32751
await _cancel_and_wait(fut, loop=loop)
raise exceptions.TimeoutError()
finally:
timeout_handle.cancel()
async def _wait(fs, timeout, return_when, loop):
"""Internal helper for wait().
The fs argument must be a collection of Futures.
"""
assert fs, 'Set of Futures is empty.'
waiter = loop.create_future()
timeout_handle = None
if timeout is not None:
timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
counter = len(fs)
def _on_completion(f):
nonlocal counter
counter -= 1
if (counter <= 0 or
return_when == FIRST_COMPLETED or
return_when == FIRST_EXCEPTION and (not f.cancelled() and
f.exception() is not None)):
if timeout_handle is not None:
timeout_handle.cancel()
if not waiter.done():
waiter.set_result(None)
for f in fs:
f.add_done_callback(_on_completion)
try:
await waiter
finally:
if timeout_handle is not None:
timeout_handle.cancel()
for f in fs:
f.remove_done_callback(_on_completion)
done, pending = set(), set()
for f in fs:
if f.done():
done.add(f)
else:
pending.add(f)
return done, pending
async def _cancel_and_wait(fut, loop):
"""Cancel the *fut* future or task and wait until it completes."""
waiter = loop.create_future()
cb = functools.partial(_release_waiter, waiter)
fut.add_done_callback(cb)
try:
fut.cancel()
# We cannot wait on *fut* directly to make
# sure _cancel_and_wait itself is reliably cancellable.
await waiter
finally:
fut.remove_done_callback(cb)
# This is *not* a @coroutine! It is just an iterator (yielding Futures).
def as_completed(fs, *, loop=None, timeout=None):
"""Return an iterator whose values are coroutines.
When waiting for the yielded coroutines you'll get the results (or
exceptions!) of the original Futures (or coroutines), in the order
in which and as soon as they complete.
This differs from PEP 3148; the proper way to use this is:
for f in as_completed(fs):
result = await f # The 'await' may raise.
# Use result.
If a timeout is specified, the 'await' will raise
TimeoutError when the timeout occurs before all Futures are done.
Note: The futures 'f' are not necessarily members of fs.
"""
if futures.isfuture(fs) or coroutines.iscoroutine(fs):
raise TypeError(f"expect an iterable of futures, not {type(fs).__name__}")
from .queues import Queue # Import here to avoid circular import problem.
done = Queue(loop=loop)
if loop is None:
loop = events.get_event_loop()
else:
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
todo = {ensure_future(f, loop=loop) for f in set(fs)}
timeout_handle = None
def _on_timeout():
for f in todo:
f.remove_done_callback(_on_completion)
done.put_nowait(None) # Queue a dummy value for _wait_for_one().
todo.clear() # Can't do todo.remove(f) in the loop.
def _on_completion(f):
if not todo:
return # _on_timeout() was here first.
todo.remove(f)
done.put_nowait(f)
if not todo and timeout_handle is not None:
timeout_handle.cancel()
async def _wait_for_one():
f = await done.get()
if f is None:
# Dummy value from _on_timeout().
raise exceptions.TimeoutError
return f.result() # May raise f.exception().
for f in todo:
f.add_done_callback(_on_completion)
if todo and timeout is not None:
timeout_handle = loop.call_later(timeout, _on_timeout)
for _ in range(len(todo)):
yield _wait_for_one()
@types.coroutine
def __sleep0():
"""Skip 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.
"""
yield
async def sleep(delay, result=None, *, loop=None):
"""Coroutine that completes after a given time (in seconds)."""
if delay <= 0:
await __sleep0()
return result
if loop is None:
loop = events.get_running_loop()
else:
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
future = loop.create_future()
h = loop.call_later(delay,
futures._set_result_unless_cancelled,
future, result)
try:
return await future
finally:
h.cancel()
def ensure_future(coro_or_future, *, loop=None):
"""Wrap a coroutine or an awaitable in a future.
If the argument is a Future, it is returned directly.
"""
if coroutines.iscoroutine(coro_or_future):
if loop is None:
loop = events.get_event_loop()
task = loop.create_task(coro_or_future)
if task._source_traceback:
del task._source_traceback[-1]
return task
elif futures.isfuture(coro_or_future):
if loop is not None and loop is not futures._get_loop(coro_or_future):
raise ValueError('The future belongs to a different loop than '
'the one specified as the loop argument')
return coro_or_future
elif inspect.isawaitable(coro_or_future):
return ensure_future(_wrap_awaitable(coro_or_future), loop=loop)
else:
raise TypeError('An asyncio.Future, a coroutine or an awaitable is '
'required')
@types.coroutine
def _wrap_awaitable(awaitable):
"""Helper for asyncio.ensure_future().
Wraps awaitable (an object with __await__) into a coroutine
that will later be wrapped in a Task by ensure_future().
"""
return (yield from awaitable.__await__())
_wrap_awaitable._is_coroutine = _is_coroutine
class _GatheringFuture(futures.Future):
"""Helper for gather().
This overrides cancel() to cancel all the children and act more
like Task.cancel(), which doesn't immediately mark itself as
cancelled.
"""
def __init__(self, children, *, loop=None):
super().__init__(loop=loop)
self._children = children
self._cancel_requested = False
def cancel(self):
if self.done():
return False
ret = False
for child in self._children:
if child.cancel():
ret = True
if ret:
# If any child tasks were actually cancelled, we should
# propagate the cancellation request regardless of
# *return_exceptions* argument. See issue 32684.
self._cancel_requested = True
return ret
def gather(*coros_or_futures, loop=None, return_exceptions=False):
"""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.
"""
if not coros_or_futures:
if loop is None:
loop = events.get_event_loop()
else:
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
outer = loop.create_future()
outer.set_result([])
return outer
def _done_callback(fut):
nonlocal nfinished
nfinished += 1
if outer.done():
if not fut.cancelled():
# Mark exception retrieved.
fut.exception()
return
if not return_exceptions:
if fut.cancelled():
# Check if 'fut' is cancelled first, as
# 'fut.exception()' will *raise* a CancelledError
# instead of returning it.
exc = exceptions.CancelledError()
outer.set_exception(exc)
return
else:
exc = fut.exception()
if exc is not None:
outer.set_exception(exc)
return
if nfinished == nfuts:
# All futures are done; create a list of results
# and set it to the 'outer' future.
results = []
for fut in children:
if fut.cancelled():
# Check if 'fut' is cancelled first, as
# 'fut.exception()' will *raise* a CancelledError
# instead of returning it.
res = exceptions.CancelledError()
else:
res = fut.exception()
if res is None:
res = fut.result()
results.append(res)
if outer._cancel_requested:
# If gather is being cancelled we must propagate the
# cancellation regardless of *return_exceptions* argument.
# See issue 32684.
outer.set_exception(exceptions.CancelledError())
else:
outer.set_result(results)
arg_to_fut = {}
children = []
nfuts = 0
nfinished = 0
for arg in coros_or_futures:
if arg not in arg_to_fut:
fut = ensure_future(arg, loop=loop)
if loop is None:
loop = futures._get_loop(fut)
if fut is not arg:
# 'arg' was not a Future, therefore, 'fut' is a new
# Future created specifically for 'arg'. Since the caller
# can't control it, disable the "destroy pending task"
# warning.
fut._log_destroy_pending = False
nfuts += 1
arg_to_fut[arg] = fut
fut.add_done_callback(_done_callback)
else:
# There's a duplicate Future object in coros_or_futures.
fut = arg_to_fut[arg]
children.append(fut)
outer = _GatheringFuture(children, loop=loop)
return outer
def shield(arg, *, loop=None):
"""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
"""
if loop is not None:
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
inner = ensure_future(arg, loop=loop)
if inner.done():
# Shortcut.
return inner
loop = futures._get_loop(inner)
outer = loop.create_future()
def _inner_done_callback(inner):
if outer.cancelled():
if not inner.cancelled():
# Mark inner's result as retrieved.
inner.exception()
return
if inner.cancelled():
outer.cancel()
else:
exc = inner.exception()
if exc is not None:
outer.set_exception(exc)
else:
outer.set_result(inner.result())
def _outer_done_callback(outer):
if not inner.done():
inner.remove_done_callback(_inner_done_callback)
inner.add_done_callback(_inner_done_callback)
outer.add_done_callback(_outer_done_callback)
return outer
def run_coroutine_threadsafe(coro, loop):
"""Submit a coroutine object to a given event loop.
Return a concurrent.futures.Future to access the result.
"""
if not coroutines.iscoroutine(coro):
raise TypeError('A coroutine object is required')
future = concurrent.futures.Future()
def callback():
try:
futures._chain_future(ensure_future(coro, loop=loop), future)
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
if future.set_running_or_notify_cancel():
future.set_exception(exc)
raise
loop.call_soon_threadsafe(callback)
return future
# WeakSet containing all alive tasks.
_all_tasks = weakref.WeakSet()
# Dictionary containing tasks that are currently active in
# all running event loops. {EventLoop: Task}
_current_tasks = {}
def _register_task(task):
"""Register a new task in asyncio as executed by loop."""
_all_tasks.add(task)
def _enter_task(loop, task):
current_task = _current_tasks.get(loop)
if current_task is not None:
raise RuntimeError(f"Cannot enter into task {task!r} while another "
f"task {current_task!r} is being executed.")
_current_tasks[loop] = task
def _leave_task(loop, task):
current_task = _current_tasks.get(loop)
if current_task is not task:
raise RuntimeError(f"Leaving task {task!r} does not match "
f"the current task {current_task!r}.")
del _current_tasks[loop]
def _unregister_task(task):
"""Unregister a task."""
_all_tasks.discard(task)
_py_register_task = _register_task
_py_unregister_task = _unregister_task
_py_enter_task = _enter_task
_py_leave_task = _leave_task
try:
from _asyncio import (_register_task, _unregister_task,
_enter_task, _leave_task,
_all_tasks, _current_tasks)
except ImportError:
pass
else:
_c_register_task = _register_task
_c_unregister_task = _unregister_task
_c_enter_task = _enter_task
_c_leave_task = _leave_task
PK [�h�� �
subprocess.pynu �[��� __all__ = 'create_subprocess_exec', 'create_subprocess_shell'
import subprocess
import warnings
from . import events
from . import protocols
from . import streams
from . import tasks
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 = []
self._stdin_closed = self._loop.create_future()
def __repr__(self):
info = [self.__class__.__name__]
if self.stdin is not None:
info.append(f'stdin={self.stdin!r}')
if self.stdout is not None:
info.append(f'stdout={self.stdout!r}')
if self.stderr is not None:
info.append(f'stderr={self.stderr!r}')
return '<{}>'.format(' '.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)
if exc is None:
self._stdin_closed.set_result(None)
else:
self._stdin_closed.set_exception(exc)
return
if fd == 1:
reader = self.stdout
elif fd == 2:
reader = self.stderr
else:
reader = None
if reader is not 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
def _get_close_waiter(self, stream):
if stream is self.stdin:
return self._stdin_closed
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 f'<{self.__class__.__name__} {self.pid}>'
@property
def returncode(self):
return self._transport.get_returncode()
async def wait(self):
"""Wait until the process exit and return the process return code."""
return await 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()
async 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:
await 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()
async def _noop(self):
return None
async 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 = await 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
async 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 = await tasks.gather(stdin, stdout, stderr,
loop=self._loop)
await self.wait()
return (stdout, stderr)
async 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()
else:
warnings.warn("The loop argument is deprecated since Python 3.8 "
"and scheduled for removal in Python 3.10.",
DeprecationWarning,
stacklevel=2
)
protocol_factory = lambda: SubprocessStreamProtocol(limit=limit,
loop=loop)
transport, protocol = await loop.subprocess_shell(
protocol_factory,
cmd, stdin=stdin, stdout=stdout,
stderr=stderr, **kwds)
return Process(transport, protocol, loop)
async 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()
else:
warnings.warn("The loop argument is deprecated since Python 3.8 "
"and scheduled for removal in Python 3.10.",
DeprecationWarning,
stacklevel=2
)
protocol_factory = lambda: SubprocessStreamProtocol(limit=limit,
loop=loop)
transport, protocol = await loop.subprocess_exec(
protocol_factory,
program, *args,
stdin=stdin, stdout=stdout,
stderr=stderr, **kwds)
return Process(transport, protocol, loop)
PK [(s8�x x constants.pynu �[��� import enum
# After the connection is lost, log warnings after this many write()s.
LOG_THRESHOLD_FOR_CONNLOST_WRITES = 5
# Seconds to wait before retrying accept().
ACCEPT_RETRY_DELAY = 1
# Number of stack entries to capture in debug mode.
# The larger the number, the slower the operation in debug mode
# (see extract_stack() in format_helpers.py).
DEBUG_STACK_DEPTH = 10
# Number of seconds to wait for SSL handshake to complete
# The default timeout matches that of Nginx.
SSL_HANDSHAKE_TIMEOUT = 60.0
# Used in sendfile fallback code. We use fallback for platforms
# that don't support sendfile, or for TLS connections.
SENDFILE_FALLBACK_READBUFFER_SIZE = 1024 * 256
# The enum should be here to break circular dependencies between
# base_events and sslproto
class _SendfileMode(enum.Enum):
UNSUPPORTED = enum.auto()
TRY_NATIVE = enum.auto()
FALLBACK = enum.auto()
PK [��yT� T� selector_events.pynu �[��� """Event 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.
"""
__all__ = 'BaseSelectorEventLoop',
import collections
import errno
import functools
import selectors
import socket
import warnings
import weakref
try:
import ssl
except ImportError: # pragma: no cover
ssl = None
from . import base_events
from . import constants
from . import events
from . import futures
from . import protocols
from . import sslproto
from . import transports
from . import trsock
from .log import logger
def _test_selector_event(selector, fd, event):
# Test if the selector is monitoring 'event' events
# for the file descriptor 'fd'.
try:
key = selector.get_key(fd)
except KeyError:
return False
else:
return bool(key.events & event)
def _check_ssl_socket(sock):
if ssl is not None and isinstance(sock, ssl.SSLSocket):
raise TypeError("Socket cannot be of type SSLSocket")
class BaseSelectorEventLoop(base_events.BaseEventLoop):
"""Selector event loop.
See events.EventLoop for API specification.
"""
def __init__(self, selector=None):
super().__init__()
if selector is None:
selector = selectors.DefaultSelector()
logger.debug('Using selector: %s', selector.__class__.__name__)
self._selector = selector
self._make_self_pipe()
self._transports = weakref.WeakValueDictionary()
def _make_socket_transport(self, sock, protocol, waiter=None, *,
extra=None, server=None):
return _SelectorSocketTransport(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,
ssl_handshake_timeout=constants.SSL_HANDSHAKE_TIMEOUT):
ssl_protocol = sslproto.SSLProtocol(
self, protocol, sslcontext, waiter,
server_side, server_hostname,
ssl_handshake_timeout=ssl_handshake_timeout)
_SelectorSocketTransport(self, rawsock, ssl_protocol,
extra=extra, server=server)
return ssl_protocol._app_transport
def _make_datagram_transport(self, sock, protocol,
address=None, waiter=None, extra=None):
return _SelectorDatagramTransport(self, sock, protocol,
address, waiter, extra)
def close(self):
if self.is_running():
raise RuntimeError("Cannot close a running event loop")
if self.is_closed():
return
self._close_self_pipe()
super().close()
if self._selector is not None:
self._selector.close()
self._selector = None
def _close_self_pipe(self):
self._remove_reader(self._ssock.fileno())
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 = socket.socketpair()
self._ssock.setblocking(False)
self._csock.setblocking(False)
self._internal_fds += 1
self._add_reader(self._ssock.fileno(), self._read_from_self)
def _process_self_data(self, data):
pass
def _read_from_self(self):
while True:
try:
data = self._ssock.recv(4096)
if not data:
break
self._process_self_data(data)
except InterruptedError:
continue
except BlockingIOError:
break
def _write_to_self(self):
# This may be called from a different thread, possibly after
# _close_self_pipe() has been called or even while it is
# running. Guard for self._csock being None or closed. When
# a socket is closed, send() raises OSError (with errno set to
# EBADF, but let's not rely on the exact error code).
csock = self._csock
if csock is None:
return
try:
csock.send(b'\0')
except OSError:
if self._debug:
logger.debug("Fail to write a null byte into the "
"self-pipe socket",
exc_info=True)
def _start_serving(self, protocol_factory, sock,
sslcontext=None, server=None, backlog=100,
ssl_handshake_timeout=constants.SSL_HANDSHAKE_TIMEOUT):
self._add_reader(sock.fileno(), self._accept_connection,
protocol_factory, sock, sslcontext, server, backlog,
ssl_handshake_timeout)
def _accept_connection(
self, protocol_factory, sock,
sslcontext=None, server=None, backlog=100,
ssl_handshake_timeout=constants.SSL_HANDSHAKE_TIMEOUT):
# This method is only called once for each event loop tick where the
# listening socket has triggered an EVENT_READ. There may be multiple
# connections waiting for an .accept() so it is called in a loop.
# See https://bugs.python.org/issue27906 for more details.
for _ in range(backlog):
try:
conn, addr = sock.accept()
if self._debug:
logger.debug("%r got a new connection from %r: %r",
server, addr, conn)
conn.setblocking(False)
except (BlockingIOError, InterruptedError, ConnectionAbortedError):
# Early exit because the socket accept buffer is empty.
return None
except OSError as exc:
# There's nowhere to send the error, so just log it.
if exc.errno in (errno.EMFILE, errno.ENFILE,
errno.ENOBUFS, errno.ENOMEM):
# Some platforms (e.g. Linux keep reporting the FD as
# ready, so we remove the read handler temporarily.
# We'll try again in a while.
self.call_exception_handler({
'message': 'socket.accept() out of system resource',
'exception': exc,
'socket': trsock.TransportSocket(sock),
})
self._remove_reader(sock.fileno())
self.call_later(constants.ACCEPT_RETRY_DELAY,
self._start_serving,
protocol_factory, sock, sslcontext, server,
backlog, ssl_handshake_timeout)
else:
raise # The event loop will catch, log and ignore it.
else:
extra = {'peername': addr}
accept = self._accept_connection2(
protocol_factory, conn, extra, sslcontext, server,
ssl_handshake_timeout)
self.create_task(accept)
async def _accept_connection2(
self, protocol_factory, conn, extra,
sslcontext=None, server=None,
ssl_handshake_timeout=constants.SSL_HANDSHAKE_TIMEOUT):
protocol = None
transport = None
try:
protocol = protocol_factory()
waiter = self.create_future()
if sslcontext:
transport = self._make_ssl_transport(
conn, protocol, sslcontext, waiter=waiter,
server_side=True, extra=extra, server=server,
ssl_handshake_timeout=ssl_handshake_timeout)
else:
transport = self._make_socket_transport(
conn, protocol, waiter=waiter, extra=extra,
server=server)
try:
await waiter
except BaseException:
transport.close()
raise
# It's now up to the protocol to handle the connection.
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
if self._debug:
context = {
'message':
'Error on transport creation for incoming connection',
'exception': exc,
}
if protocol is not None:
context['protocol'] = protocol
if transport is not None:
context['transport'] = transport
self.call_exception_handler(context)
def _ensure_fd_no_transport(self, fd):
fileno = fd
if not isinstance(fileno, int):
try:
fileno = int(fileno.fileno())
except (AttributeError, TypeError, ValueError):
# This code matches selectors._fileobj_to_fd function.
raise ValueError(f"Invalid file object: {fd!r}") from None
try:
transport = self._transports[fileno]
except KeyError:
pass
else:
if not transport.is_closing():
raise RuntimeError(
f'File descriptor {fd!r} is used by transport '
f'{transport!r}')
def _add_reader(self, fd, callback, *args):
self._check_closed()
handle = events.Handle(callback, args, self, None)
try:
key = self._selector.get_key(fd)
except KeyError:
self._selector.register(fd, selectors.EVENT_READ,
(handle, None))
else:
mask, (reader, writer) = key.events, key.data
self._selector.modify(fd, mask | selectors.EVENT_READ,
(handle, writer))
if reader is not None:
reader.cancel()
def _remove_reader(self, fd):
if self.is_closed():
return False
try:
key = self._selector.get_key(fd)
except KeyError:
return False
else:
mask, (reader, writer) = key.events, key.data
mask &= ~selectors.EVENT_READ
if not mask:
self._selector.unregister(fd)
else:
self._selector.modify(fd, mask, (None, writer))
if reader is not None:
reader.cancel()
return True
else:
return False
def _add_writer(self, fd, callback, *args):
self._check_closed()
handle = events.Handle(callback, args, self, None)
try:
key = self._selector.get_key(fd)
except KeyError:
self._selector.register(fd, selectors.EVENT_WRITE,
(None, handle))
else:
mask, (reader, writer) = key.events, key.data
self._selector.modify(fd, mask | selectors.EVENT_WRITE,
(reader, handle))
if writer is not None:
writer.cancel()
def _remove_writer(self, fd):
"""Remove a writer callback."""
if self.is_closed():
return False
try:
key = self._selector.get_key(fd)
except KeyError:
return False
else:
mask, (reader, writer) = key.events, key.data
# Remove both writer and connector.
mask &= ~selectors.EVENT_WRITE
if not mask:
self._selector.unregister(fd)
else:
self._selector.modify(fd, mask, (reader, None))
if writer is not None:
writer.cancel()
return True
else:
return False
def add_reader(self, fd, callback, *args):
"""Add a reader callback."""
self._ensure_fd_no_transport(fd)
return self._add_reader(fd, callback, *args)
def remove_reader(self, fd):
"""Remove a reader callback."""
self._ensure_fd_no_transport(fd)
return self._remove_reader(fd)
def add_writer(self, fd, callback, *args):
"""Add a writer callback.."""
self._ensure_fd_no_transport(fd)
return self._add_writer(fd, callback, *args)
def remove_writer(self, fd):
"""Remove a writer callback."""
self._ensure_fd_no_transport(fd)
return self._remove_writer(fd)
async def sock_recv(self, sock, n):
"""Receive 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.
"""
_check_ssl_socket(sock)
if self._debug and sock.gettimeout() != 0:
raise ValueError("the socket must be non-blocking")
try:
return sock.recv(n)
except (BlockingIOError, InterruptedError):
pass
fut = self.create_future()
fd = sock.fileno()
self.add_reader(fd, self._sock_recv, fut, sock, n)
fut.add_done_callback(
functools.partial(self._sock_read_done, fd))
return await fut
def _sock_read_done(self, fd, fut):
self.remove_reader(fd)
def _sock_recv(self, fut, sock, n):
# _sock_recv() can add itself as an I/O callback if the operation can't
# be done immediately. Don't use it directly, call sock_recv().
if fut.done():
return
try:
data = sock.recv(n)
except (BlockingIOError, InterruptedError):
return # try again next time
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
fut.set_exception(exc)
else:
fut.set_result(data)
async def sock_recv_into(self, sock, buf):
"""Receive data from the socket.
The received data is written into *buf* (a writable buffer).
The return value is the number of bytes written.
"""
_check_ssl_socket(sock)
if self._debug and sock.gettimeout() != 0:
raise ValueError("the socket must be non-blocking")
try:
return sock.recv_into(buf)
except (BlockingIOError, InterruptedError):
pass
fut = self.create_future()
fd = sock.fileno()
self.add_reader(fd, self._sock_recv_into, fut, sock, buf)
fut.add_done_callback(
functools.partial(self._sock_read_done, fd))
return await fut
def _sock_recv_into(self, fut, sock, buf):
# _sock_recv_into() can add itself as an I/O callback if the operation
# can't be done immediately. Don't use it directly, call
# sock_recv_into().
if fut.done():
return
try:
nbytes = sock.recv_into(buf)
except (BlockingIOError, InterruptedError):
return # try again next time
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
fut.set_exception(exc)
else:
fut.set_result(nbytes)
async def sock_sendall(self, sock, data):
"""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.
"""
_check_ssl_socket(sock)
if self._debug and sock.gettimeout() != 0:
raise ValueError("the socket must be non-blocking")
try:
n = sock.send(data)
except (BlockingIOError, InterruptedError):
n = 0
if n == len(data):
# all data sent
return
fut = self.create_future()
fd = sock.fileno()
fut.add_done_callback(
functools.partial(self._sock_write_done, fd))
# use a trick with a list in closure to store a mutable state
self.add_writer(fd, self._sock_sendall, fut, sock,
memoryview(data), [n])
return await fut
def _sock_sendall(self, fut, sock, view, pos):
if fut.done():
# Future cancellation can be scheduled on previous loop iteration
return
start = pos[0]
try:
n = sock.send(view[start:])
except (BlockingIOError, InterruptedError):
return
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
fut.set_exception(exc)
return
start += n
if start == len(view):
fut.set_result(None)
else:
pos[0] = start
async def sock_connect(self, sock, address):
"""Connect to a remote socket at address.
This method is a coroutine.
"""
_check_ssl_socket(sock)
if self._debug and sock.gettimeout() != 0:
raise ValueError("the socket must be non-blocking")
if not hasattr(socket, 'AF_UNIX') or sock.family != socket.AF_UNIX:
resolved = await self._ensure_resolved(
address, family=sock.family, proto=sock.proto, loop=self)
_, _, _, _, address = resolved[0]
fut = self.create_future()
self._sock_connect(fut, sock, address)
return await fut
def _sock_connect(self, fut, sock, address):
fd = sock.fileno()
try:
sock.connect(address)
except (BlockingIOError, InterruptedError):
# Issue #23618: When the C function connect() fails with EINTR, the
# connection runs in background. We have to wait until the socket
# becomes writable to be notified when the connection succeed or
# fails.
fut.add_done_callback(
functools.partial(self._sock_write_done, fd))
self.add_writer(fd, self._sock_connect_cb, fut, sock, address)
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
fut.set_exception(exc)
else:
fut.set_result(None)
def _sock_write_done(self, fd, fut):
self.remove_writer(fd)
def _sock_connect_cb(self, fut, sock, address):
if fut.done():
return
try:
err = sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
if err != 0:
# Jump to any except clause below.
raise OSError(err, f'Connect call failed {address}')
except (BlockingIOError, InterruptedError):
# socket is still registered, the callback will be retried later
pass
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
fut.set_exception(exc)
else:
fut.set_result(None)
async def sock_accept(self, sock):
"""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.
"""
_check_ssl_socket(sock)
if self._debug and sock.gettimeout() != 0:
raise ValueError("the socket must be non-blocking")
fut = self.create_future()
self._sock_accept(fut, False, sock)
return await fut
def _sock_accept(self, fut, registered, sock):
fd = sock.fileno()
if registered:
self.remove_reader(fd)
if fut.done():
return
try:
conn, address = sock.accept()
conn.setblocking(False)
except (BlockingIOError, InterruptedError):
self.add_reader(fd, self._sock_accept, fut, True, sock)
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
fut.set_exception(exc)
else:
fut.set_result((conn, address))
async def _sendfile_native(self, transp, file, offset, count):
del self._transports[transp._sock_fd]
resume_reading = transp.is_reading()
transp.pause_reading()
await transp._make_empty_waiter()
try:
return await self.sock_sendfile(transp._sock, file, offset, count,
fallback=False)
finally:
transp._reset_empty_waiter()
if resume_reading:
transp.resume_reading()
self._transports[transp._sock_fd] = transp
def _process_events(self, event_list):
for key, mask in event_list:
fileobj, (reader, writer) = key.fileobj, key.data
if mask & selectors.EVENT_READ and reader is not None:
if reader._cancelled:
self._remove_reader(fileobj)
else:
self._add_callback(reader)
if mask & selectors.EVENT_WRITE and writer is not None:
if writer._cancelled:
self._remove_writer(fileobj)
else:
self._add_callback(writer)
def _stop_serving(self, sock):
self._remove_reader(sock.fileno())
sock.close()
class _SelectorTransport(transports._FlowControlMixin,
transports.Transport):
max_size = 256 * 1024 # Buffer size passed to recv().
_buffer_factory = bytearray # Constructs initial value for self._buffer.
# Attribute used in the destructor: it must be set even if the constructor
# is not called (see _SelectorSslTransport which may start by raising an
# exception)
_sock = None
def __init__(self, loop, sock, protocol, extra=None, server=None):
super().__init__(extra, loop)
self._extra['socket'] = trsock.TransportSocket(sock)
try:
self._extra['sockname'] = sock.getsockname()
except OSError:
self._extra['sockname'] = None
if 'peername' not in self._extra:
try:
self._extra['peername'] = sock.getpeername()
except socket.error:
self._extra['peername'] = None
self._sock = sock
self._sock_fd = sock.fileno()
self._protocol_connected = False
self.set_protocol(protocol)
self._server = server
self._buffer = self._buffer_factory()
self._conn_lost = 0 # Set when call to connection_lost scheduled.
self._closing = False # Set when close() called.
if self._server is not None:
self._server._attach()
loop._transports[self._sock_fd] = self
def __repr__(self):
info = [self.__class__.__name__]
if self._sock is None:
info.append('closed')
elif self._closing:
info.append('closing')
info.append(f'fd={self._sock_fd}')
# test if the transport was closed
if self._loop is not None and not self._loop.is_closed():
polling = _test_selector_event(self._loop._selector,
self._sock_fd, selectors.EVENT_READ)
if polling:
info.append('read=polling')
else:
info.append('read=idle')
polling = _test_selector_event(self._loop._selector,
self._sock_fd,
selectors.EVENT_WRITE)
if polling:
state = 'polling'
else:
state = 'idle'
bufsize = self.get_write_buffer_size()
info.append(f'write=<{state}, bufsize={bufsize}>')
return '<{}>'.format(' '.join(info))
def abort(self):
self._force_close(None)
def set_protocol(self, protocol):
self._protocol = protocol
self._protocol_connected = True
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._loop._remove_reader(self._sock_fd)
if not self._buffer:
self._conn_lost += 1
self._loop._remove_writer(self._sock_fd)
self._loop.call_soon(self._call_connection_lost, None)
def __del__(self, _warn=warnings.warn):
if self._sock is not None:
_warn(f"unclosed transport {self!r}", ResourceWarning, source=self)
self._sock.close()
def _fatal_error(self, exc, message='Fatal error on transport'):
# Should be called from exception handler only.
if isinstance(exc, OSError):
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._conn_lost:
return
if self._buffer:
self._buffer.clear()
self._loop._remove_writer(self._sock_fd)
if not self._closing:
self._closing = True
self._loop._remove_reader(self._sock_fd)
self._conn_lost += 1
self._loop.call_soon(self._call_connection_lost, exc)
def _call_connection_lost(self, exc):
try:
if self._protocol_connected:
self._protocol.connection_lost(exc)
finally:
self._sock.close()
self._sock = None
self._protocol = None
self._loop = None
server = self._server
if server is not None:
server._detach()
self._server = None
def get_write_buffer_size(self):
return len(self._buffer)
def _add_reader(self, fd, callback, *args):
if self._closing:
return
self._loop._add_reader(fd, callback, *args)
class _SelectorSocketTransport(_SelectorTransport):
_start_tls_compatible = True
_sendfile_compatible = constants._SendfileMode.TRY_NATIVE
def __init__(self, loop, sock, protocol, waiter=None,
extra=None, server=None):
self._read_ready_cb = None
super().__init__(loop, sock, protocol, extra, server)
self._eof = False
self._paused = False
self._empty_waiter = None
# Disable the Nagle algorithm -- small writes will be
# sent without waiting for the TCP ACK. This generally
# decreases the latency (in some cases significantly.)
base_events._set_nodelay(self._sock)
self._loop.call_soon(self._protocol.connection_made, self)
# only start reading when connection_made() has been called
self._loop.call_soon(self._add_reader,
self._sock_fd, self._read_ready)
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 set_protocol(self, protocol):
if isinstance(protocol, protocols.BufferedProtocol):
self._read_ready_cb = self._read_ready__get_buffer
else:
self._read_ready_cb = self._read_ready__data_received
super().set_protocol(protocol)
def is_reading(self):
return not self._paused and not self._closing
def pause_reading(self):
if self._closing or self._paused:
return
self._paused = True
self._loop._remove_reader(self._sock_fd)
if self._loop.get_debug():
logger.debug("%r pauses reading", self)
def resume_reading(self):
if self._closing or not self._paused:
return
self._paused = False
self._add_reader(self._sock_fd, self._read_ready)
if self._loop.get_debug():
logger.debug("%r resumes reading", self)
def _read_ready(self):
self._read_ready_cb()
def _read_ready__get_buffer(self):
if self._conn_lost:
return
try:
buf = self._protocol.get_buffer(-1)
if not len(buf):
raise RuntimeError('get_buffer() returned an empty buffer')
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
self._fatal_error(
exc, 'Fatal error: protocol.get_buffer() call failed.')
return
try:
nbytes = self._sock.recv_into(buf)
except (BlockingIOError, InterruptedError):
return
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
self._fatal_error(exc, 'Fatal read error on socket transport')
return
if not nbytes:
self._read_ready__on_eof()
return
try:
self._protocol.buffer_updated(nbytes)
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
self._fatal_error(
exc, 'Fatal error: protocol.buffer_updated() call failed.')
def _read_ready__data_received(self):
if self._conn_lost:
return
try:
data = self._sock.recv(self.max_size)
except (BlockingIOError, InterruptedError):
return
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
self._fatal_error(exc, 'Fatal read error on socket transport')
return
if not data:
self._read_ready__on_eof()
return
try:
self._protocol.data_received(data)
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
self._fatal_error(
exc, 'Fatal error: protocol.data_received() call failed.')
def _read_ready__on_eof(self):
if self._loop.get_debug():
logger.debug("%r received EOF", self)
try:
keep_open = self._protocol.eof_received()
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
self._fatal_error(
exc, 'Fatal error: protocol.eof_received() call failed.')
return
if keep_open:
# We're keeping the connection open so the
# protocol can write more, but we still can't
# receive more, so remove the reader callback.
self._loop._remove_reader(self._sock_fd)
else:
self.close()
def write(self, data):
if not isinstance(data, (bytes, bytearray, memoryview)):
raise TypeError(f'data argument must be a bytes-like object, '
f'not {type(data).__name__!r}')
if self._eof:
raise RuntimeError('Cannot call write() after write_eof()')
if self._empty_waiter is not None:
raise RuntimeError('unable to write; sendfile is in progress')
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
if not self._buffer:
# Optimization: try to send now.
try:
n = self._sock.send(data)
except (BlockingIOError, InterruptedError):
pass
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
self._fatal_error(exc, 'Fatal write error on socket transport')
return
else:
data = data[n:]
if not data:
return
# Not all was written; register write handler.
self._loop._add_writer(self._sock_fd, self._write_ready)
# Add it to the buffer.
self._buffer.extend(data)
self._maybe_pause_protocol()
def _write_ready(self):
assert self._buffer, 'Data should not be empty'
if self._conn_lost:
return
try:
n = self._sock.send(self._buffer)
except (BlockingIOError, InterruptedError):
pass
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
self._loop._remove_writer(self._sock_fd)
self._buffer.clear()
self._fatal_error(exc, 'Fatal write error on socket transport')
if self._empty_waiter is not None:
self._empty_waiter.set_exception(exc)
else:
if n:
del self._buffer[:n]
self._maybe_resume_protocol() # May append to buffer.
if not self._buffer:
self._loop._remove_writer(self._sock_fd)
if self._empty_waiter is not None:
self._empty_waiter.set_result(None)
if self._closing:
self._call_connection_lost(None)
elif self._eof:
self._sock.shutdown(socket.SHUT_WR)
def write_eof(self):
if self._closing or self._eof:
return
self._eof = True
if not self._buffer:
self._sock.shutdown(socket.SHUT_WR)
def can_write_eof(self):
return True
def _call_connection_lost(self, exc):
super()._call_connection_lost(exc)
if self._empty_waiter is not None:
self._empty_waiter.set_exception(
ConnectionError("Connection is closed by peer"))
def _make_empty_waiter(self):
if self._empty_waiter is not None:
raise RuntimeError("Empty waiter is already set")
self._empty_waiter = self._loop.create_future()
if not self._buffer:
self._empty_waiter.set_result(None)
return self._empty_waiter
def _reset_empty_waiter(self):
self._empty_waiter = None
class _SelectorDatagramTransport(_SelectorTransport):
_buffer_factory = collections.deque
def __init__(self, loop, sock, protocol, address=None,
waiter=None, extra=None):
super().__init__(loop, sock, protocol, extra)
self._address = address
self._loop.call_soon(self._protocol.connection_made, self)
# only start reading when connection_made() has been called
self._loop.call_soon(self._add_reader,
self._sock_fd, self._read_ready)
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 get_write_buffer_size(self):
return sum(len(data) for data, _ in self._buffer)
def _read_ready(self):
if self._conn_lost:
return
try:
data, addr = self._sock.recvfrom(self.max_size)
except (BlockingIOError, InterruptedError):
pass
except OSError as exc:
self._protocol.error_received(exc)
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
self._fatal_error(exc, 'Fatal read error on datagram transport')
else:
self._protocol.datagram_received(data, addr)
def sendto(self, data, addr=None):
if not isinstance(data, (bytes, bytearray, memoryview)):
raise TypeError(f'data argument must be a bytes-like object, '
f'not {type(data).__name__!r}')
if not data:
return
if self._address:
if addr not in (None, self._address):
raise ValueError(
f'Invalid address: must be None or {self._address}')
addr = self._address
if self._conn_lost and self._address:
if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
logger.warning('socket.send() raised exception.')
self._conn_lost += 1
return
if not self._buffer:
# Attempt to send it right away first.
try:
if self._extra['peername']:
self._sock.send(data)
else:
self._sock.sendto(data, addr)
return
except (BlockingIOError, InterruptedError):
self._loop._add_writer(self._sock_fd, self._sendto_ready)
except OSError as exc:
self._protocol.error_received(exc)
return
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
self._fatal_error(
exc, 'Fatal write error on datagram transport')
return
# Ensure that what we buffer is immutable.
self._buffer.append((bytes(data), addr))
self._maybe_pause_protocol()
def _sendto_ready(self):
while self._buffer:
data, addr = self._buffer.popleft()
try:
if self._extra['peername']:
self._sock.send(data)
else:
self._sock.sendto(data, addr)
except (BlockingIOError, InterruptedError):
self._buffer.appendleft((data, addr)) # Try again later.
break
except OSError as exc:
self._protocol.error_received(exc)
return
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
self._fatal_error(
exc, 'Fatal write error on datagram transport')
return
self._maybe_resume_protocol() # May append to buffer.
if not self._buffer:
self._loop._remove_writer(self._sock_fd)
if self._closing:
self._call_connection_lost(None)
PK [6߾ê � % __pycache__/subprocess.cpython-36.pycnu �[��� 3
\� � @ s� d dgZ ddlZddlmZ ddlmZ ddlmZ ddlmZ dd lmZ dd
l m
Z
ej Z ej Z ej
Z
G d d � d ejej�ZG d
d� d�Zeddddejfdd��Zeddddejd�dd ��ZdS )�create_subprocess_exec�create_subprocess_shell� N� )�events)� protocols)�streams)�tasks)� coroutine)�loggerc sP e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
� Z S )�SubprocessStreamProtocolz0Like StreamReaderProtocol, but for a subprocess.c s< t � j|d� || _d | _ | _| _d | _d| _g | _d S )N)�loopF) �super�__init__�_limit�stdin�stdout�stderr�
_transport�_process_exited� _pipe_fds)�self�limitr )� __class__� �*/usr/lib64/python3.6/asyncio/subprocess.pyr s z!SubprocessStreamProtocol.__init__c C sf | j jg}| jd k r$|jd| j � | jd k r>|jd| j � | jd k rX|jd| j � ddj|� S )Nzstdin=%rz stdout=%rz stderr=%rz<%s>� )r �__name__r �appendr r �join)r �infor r r �__repr__ s
z!SubprocessStreamProtocol.__repr__c C s� || _ |jd�}|d k rDtj| j| jd�| _| jj|� | jj d� |jd�}|d k r�tj| j| jd�| _
| j
j|� | jj d� |jd�}|d k r�tj || d | jd�| _ d S )Nr )r r � r )�protocol�readerr )
r �get_pipe_transportr � StreamReaderr �_loopr 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|j|� d S )Nr r! )r r Z feed_data)r �fd�datar# r r r �pipe_data_received@ s z+SubprocessStreamProtocol.pipe_data_receivedc C s� |dkr,| j }|d k r |j� | j|� d S |dkr<| j}n|dkrL| j}nd }|d krt|d krj|j� n
|j|� || jkr�| jj|� | j � d S )Nr r r! )
r �closeZconnection_lostr r Zfeed_eofZ
set_exceptionr �remove�_maybe_close_transport)r r* �exc�piper# r r r �pipe_connection_lostJ s$
z-SubprocessStreamProtocol.pipe_connection_lostc C s d| _ | j� d S )NT)r r/ )r r r r �process_exiteda s z'SubprocessStreamProtocol.process_exitedc C s( t | j�dkr$| jr$| jj� d | _d S )Nr )�lenr r r r- )r r r r r/ e s
z/SubprocessStreamProtocol._maybe_close_transport) r �
__module__� __qualname__�__doc__r r r) r, r2 r3 r/ �
__classcell__r r )r r r s
r c @ s~ e Zd Zdd� Zdd� Zedd� �Zedd� �Zd d
� Z d d � Z
d
d� Z edd� �Z edd� �Z
edd� �Zeddd��ZdS )�Processc C s8 || _ || _|| _|j| _|j| _|j| _|j� | _d S )N)r Z _protocolr& r r r Zget_pid�pid)r r( r" r r r r r l s zProcess.__init__c C s d| j j| jf S )Nz<%s %s>)r r r: )r r r r r u s zProcess.__repr__c C s
| j j� S )N)r Zget_returncode)r r r r �
returncodex s zProcess.returncodec c s | j j� E dH S )zdWait until the process exit and return the process return code.
This method is a coroutine.N)r Z_wait)r r r r �wait| s z Process.waitc C s | j j|� d S )N)r � send_signal)r �signalr r r r= � s zProcess.send_signalc C s | j j� d S )N)r � terminate)r r r r r? � s zProcess.terminatec C s | j j� d S )N)r �kill)r r r r r@ � s z Process.killc c s� | j j� }| jj|� |r,tjd| t|�� y| jj� E d H W n8 tt fk
rx } z|rhtjd| |� W Y d d }~X nX |r�tjd| � | jj
� d S )Nz%%r communicate: feed stdin (%s bytes)z %r communicate: stdin got %rz%r communicate: close stdin) r& � get_debugr �writer
�debugr4 Zdrain�BrokenPipeError�ConnectionResetErrorr- )r �inputrC r0 r r r � _feed_stdin� s
zProcess._feed_stdinc C s d S )Nr )r r r r �_noop� s z
Process._noopc c s� | j j|�}|dkr | j}n|dks(t�| j}| jj� rV|dkrDdnd}tjd| |� |j � E d H }| jj� r�|dkrzdnd}tjd| |� |j
� |S )Nr! r r r z%r communicate: read %sz%r communicate: close %s) r r$ r �AssertionErrorr r& rA r
rC �readr- )r r* r( �stream�name�outputr r r � _read_stream� s
zProcess._read_streamNc c s� |d k r| j |�}n| j� }| jd k r2| jd�}n| j� }| jd k rP| jd�}n| j� }tj|||| jd�E d H \}}}| j� E d H ||fS )Nr r! )r ) rG rH r rN r r Zgatherr& r< )r rF r r r r r r � communicate� s
zProcess.communicate)N)r r5 r6 r r �propertyr; r r< r= r? r@ rG rH rN rO r r r r r9 k s r9 c
+ sP �d krt j� �� �fdd�}�j|| f|||d�|��E d H \}} t|| ��S )Nc s t � �d�S )N)r r )r r )r r r r �<lambda>� s z)create_subprocess_shell.<locals>.<lambda>)r r r )r �get_event_loopZsubprocess_shellr9 )
�cmdr r r r r �kwds�protocol_factoryr( r" r )r r r r � s )r r r r r c / sT �d krt j� �� �fdd�}�j|| f|�|||d�|��E d H \} }
t| |
��S )Nc s t � �d�S )N)r r )r r )r r r r rQ � s z(create_subprocess_exec.<locals>.<lambda>)r r r )r rR Zsubprocess_execr9 ) Zprogramr r r r r �argsrT rU r( r" r )r r r r � s )�__all__�
subprocess� r r r r Z
coroutinesr �logr
�PIPEZSTDOUTZDEVNULLZFlowControlMixinZSubprocessProtocolr r9 Z_DEFAULT_LIMITr r r r r r �<module> s( X] PK [��)� ) __pycache__/__init__.cpython-36.opt-1.pycnu �[��� 3
\� � @ sB d Z ddlZyddlmZ W n ek
r8 ddlZY nX ejdkrryddlmZ W n ek
rp ddlZY nX ddlT ddlT ddl T ddl
T ddl T ddl T ddl
T ddlT ddlT ddlT ddlT ejej e j e
j e j e j e
j ej ej ej ej Zejdk�r,ddlT eej7 ZnddlT eej7 ZdS )z'The asyncio package, tracking PEP 3156.� N� )� selectorsZwin32)� _overlapped)�*)�__doc__�sys� r � ImportError�platformr Z base_eventsZ
coroutinesZeventsZfuturesZlocksZ protocolsZqueuesZstreams�
subprocessZtasksZ
transports�__all__Zwindows_eventsZ unix_events� r
r
�(/usr/lib64/python3.6/asyncio/__init__.py�<module> s8
: PK [@!�)Ř Ř , __pycache__/base_events.cpython-36.opt-1.pycnu �[��� 3
\� � @ s� d Z ddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl
Z
ddlZddlZddlZddlmZ ddlmZ ddlmZ ddlmZ ddlmZ dd lmZ dd
lmZ d gZd Zd
Z e e e fZ e!e d�Z"d)Z#dd� Z$dd� Z%dd� Z&dd� Z'dd� Z(dd � Z)de j*ddd �d d �Z+e!e d ��rRd!d"� Z,nd#d"� Z,d$d%� Z-G d&d'� d'ej.�Z/G d(d � d ej0�Z1dS )*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� )�compat)�
coroutines)�events)�futures)�tasks)� coroutine)�logger�
BaseEventLoop�d g �?�AF_INET6� i c C s0 | j }tt|dd �tj�r$t|j�S t| �S d S )N�__self__)Z _callback�
isinstance�getattrr �Task�reprr �str)�handle�cb� r �+/usr/lib64/python3.6/asyncio/base_events.py�_format_handle? s
r c C s( | t jkrdS | t jkr dS t| �S d S )Nz<pipe>z<stdout>)�
subprocess�PIPE�STDOUTr )�fdr r r � _format_pipeH s
r c C sL t td�std��n4y| jtjtjd� W n tk
rF td��Y 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.)�hasattr�socket�
ValueError�
setsockopt�
SOL_SOCKETr �OSError)�sockr r r �_set_reuseportQ s
r& c C s& t td�r| d@ tjkS | tjkS d S )N�
SOCK_NONBLOCK� )r r � SOCK_STREAM)� sock_typer r r �_is_stream_socket\ s
r+ c C s& t td�r| d@ tjkS | tjkS d S )Nr' r( )r r �
SOCK_DGRAM)r* r r r �_is_dgram_socketh s
r- c C sv t td�sd S |dtjtjhks(| d kr,d S t|�r<tj}nt|�rLtj}nd S |d kr^d}nVt|t�rv|dkrvd}n>t|t�r�|dkr�d}n&y t |�}W n t
t fk
r� d S X |tj kr�tj
g}tr�|jtj� n|g}t| t�r�| jd�} d| k�r d S xp|D ]h}yJtj|| � t�r@|tjk�r@|||d| |ddffS |||d| |ffS W n tk
�rj Y nX �qW d S )N� inet_ptonr � � Zidna�%)r r � IPPROTO_TCPZ IPPROTO_UDPr+ r- r �bytesr �int� TypeErrorr! � AF_UNSPEC�AF_INET� _HAS_IPv6�appendr �decoder. r$ )�host�port�family�type�protoZafs�afr r r � _ipaddr_infop sL
rA )r= r> r? �flagsc
C sZ | d d� \}}t |||||�}|d k r@|j� } | j|g� | S |j||||||d�S d S )N� )r= r> r? rB )rA �
create_future�
set_result� getaddrinfo)
�addressr= r> r? rB �loopr; r< �info�futr r r �_ensure_resolved� s rK � TCP_NODELAYc C s> | j tjtjhkr:t| j�r:| jtjkr:| jtjtj d� d S )Nr )
r= r r7 r r+ r> r? r2 r" rL )r% r r r � _set_nodelay� s
rM c C s d S )Nr )r% r r r rM � s c C s. | j }t|t�r t|t� r d S | jj� d S )N)Z
_exceptionr �
BaseException� Exception�_loop�stop)rJ �excr r r �_run_until_complete_cb� s
rS c @ sH e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Ze d
d� �Z
dS )�Serverc C s || _ || _d| _g | _d S )Nr )rP �sockets�
_active_count�_waiters)�selfrH rU r r r �__init__� s zServer.__init__c C s d| j j| jf S )Nz<%s sockets=%r>)� __class__�__name__rU )rX r r r �__repr__� s zServer.__repr__c C s | j d7 _ d S )Nr )rV )rX r r r �_attach� s zServer._attachc C s. | j d8 _ | j dkr*| jd kr*| j� d S )Nr r )rV rU �_wakeup)rX r r r �_detach� s zServer._detachc C sH | j }|d krd S d | _ x|D ]}| jj|� q W | jdkrD| j� d S )Nr )rU rP Z
_stop_servingrV r^ )rX rU r% r r r �close� s
z Server.closec C s0 | j }d | _ x |D ]}|j� s|j|� qW d S )N)rW �donerE )rX �waiters�waiterr r r r^ � s
zServer._wakeupc c s< | j d ks| jd krd S | jj� }| jj|� |E d H d S )N)rU rW rP rD r9 )rX rc r r r � wait_closed� s
zServer.wait_closedN) r[ �
__module__� __qualname__rY r\ r] r_ r` r^ r rd r r r r rT � s
rT c
@ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd�d
d
d�dd�Z d�dd
d
d
d�dd�Z
d�dd�Z d�dd�Z d�dd�Z
ed�dd ��Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zed'd(� �Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zej � r�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)dMdMdMdMdN�dOdP�Z*d�dQdR�Z+ed�d
dMdMdMd
d
d
dS�dTdU��Z,ed�dVdW��Z-ed�dMdMdMd
d
d
d
dX�dYdZ��Z.ed[d\� �Z/ed�e0j1e0j2d
d]d
d
d
d^�d_d`��Z3ed
da�dbdc��Z4eddde� �Z5edfdg� �Z6dhdi� Z7ee8j9e8j9e8j9ddjdMdk�dldm��Z:ee8j9e8j9e8j9dddMdk�dndo��Z;dpdq� Z<drds� Z=dtdu� Z>dvdw� Z?dxdy� Z@dzd{� ZAd|d}� ZBd~d� ZCd�d�� ZDd�d�� ZEd�d�� ZFd
S )�r
c C s� d| _ d| _d| _tj� | _g | _d | _d| _d | _ t
j d�j | _
d | _| jtjj odttjjd��� d| _d | _d | _d| _ttd�r�t j � | _ nd | _ d| _ d S )Nr F� monotonicZPYTHONASYNCIODEBUGg�������?�get_asyncgen_hooks) �_timer_cancelled_count�_closed� _stopping� collections�deque�_ready�
_scheduled�_default_executorZ
_internal_fds�
_thread_id�timeZget_clock_infoZ
resolution�_clock_resolution�_exception_handler� set_debug�sysrB �ignore_environment�bool�os�environ�get�slow_callback_duration�_current_handle�
_task_factory�_coroutine_wrapper_setr �weakref�WeakSet�
_asyncgens�_asyncgens_shutdown_called)rX r r r rY � s(
zBaseEventLoop.__init__c C s d| j j| j� | j� | j� f S )Nz"<%s running=%s closed=%s debug=%s>)rZ r[ �
is_running� is_closed� get_debug)rX r r r r\ s zBaseEventLoop.__repr__c C s t j| d�S )z,Create a Future object attached to the loop.)rH )r ZFuture)rX r r r rD % s zBaseEventLoop.create_futurec C s@ | j � | jdkr0tj|| d�}|jr<|jd= n | j| |�}|S )zDSchedule a coroutine object.
Return a task object.
N)rH r ���)�
_check_closedr~ r r �_source_traceback)rX �coroZtaskr r r � create_task) s
zBaseEventLoop.create_taskc C s$ |dk rt |� rtd��|| _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~ )rX �factoryr r r �set_task_factory7 s
z BaseEventLoop.set_task_factoryc C s | j S )z<Return a task factory, or None if the default one is in use.)r~ )rX r r r �get_task_factoryE s z BaseEventLoop.get_task_factoryN)�extra�serverc C s t �dS )zCreate socket transport.N)�NotImplementedError)rX r% �protocolrc r� r� r r r �_make_socket_transportI s z$BaseEventLoop._make_socket_transportF)� server_side�server_hostnamer� r� c C s t �dS )zCreate SSL transport.N)r� ) rX Zrawsockr� �
sslcontextrc r� r� r� r� r r r �_make_ssl_transportN s z!BaseEventLoop._make_ssl_transportc C s t �dS )zCreate datagram transport.N)r� )rX r% r� rG rc r� r r r �_make_datagram_transportT s z&BaseEventLoop._make_datagram_transportc C s t �dS )zCreate read pipe transport.N)r� )rX �piper� rc r� r r r �_make_read_pipe_transportY s z'BaseEventLoop._make_read_pipe_transportc C s t �dS )z Create write pipe transport.N)r� )rX r� r� rc r� r r r �_make_write_pipe_transport^ s z(BaseEventLoop._make_write_pipe_transportc
K s t �dS )z Create subprocess transport.N)r� )
rX r� �args�shell�stdin�stdout�stderr�bufsizer� �kwargsr r r �_make_subprocess_transportc s z(BaseEventLoop._make_subprocess_transportc C s t �dS )z�Write a byte to self-pipe, to wake up the event loop.
This may be called from a different thread.
The subclass is responsible for implementing the self-pipe.
N)r� )rX r r r �_write_to_selfj s z BaseEventLoop._write_to_selfc C s t �dS )zProcess selector events.N)r� )rX �
event_listr r r �_process_eventss s z BaseEventLoop._process_eventsc C s | j rtd��d S )NzEvent loop is closed)rj � RuntimeError)rX r r r r� w s zBaseEventLoop._check_closedc C s* | j j|� | j� s&| j| j|j� � d S )N)r� �discardr� �call_soon_threadsafer� �aclose)rX �agenr r r �_asyncgen_finalizer_hook{ s z&BaseEventLoop._asyncgen_finalizer_hookc C s, | j r tjdj|�t| d� | jj|� d S )NzNasynchronous generator {!r} was scheduled after loop.shutdown_asyncgens() call)�source)r� �warnings�warn�format�ResourceWarningr� �add)rX r� r r r �_asyncgen_firstiter_hook� s
z&BaseEventLoop._asyncgen_firstiter_hookc c s� d| _ | jdks t| j� r dS t| j�}| jj� tjdd� |D �d| d��}|E dH }x8t||�D ]*\}}t|t �rf| j
dj |�||d�� qfW dS )z,Shutdown all active asynchronous generators.TNc S s g | ] }|j � �qS r )r� )�.0Zagr r r �
<listcomp>� s z4BaseEventLoop.shutdown_asyncgens.<locals>.<listcomp>)Zreturn_exceptionsrH z?an error occurred during closing of asynchronous generator {!r})�message� exceptionZasyncgen) r� r� �len�list�clearr �gather�zipr rO �call_exception_handlerr� )rX Z
closing_agensZ
shutdown_coroZresults�resultr� r r r �shutdown_asyncgens� s"
z BaseEventLoop.shutdown_asyncgensc C s� | j � | j� rtd��tj� dk r,td��| j| j� tj� | _ | j
dk rft j � }t j
| j| jd� z$tj| � x| j� | jrtP qtW W dd| _d| _ tjd� | jd� | j
dk r�t j
|� X dS )zRun until stop() is called.z"This event loop is already runningNz7Cannot run the event loop while another loop is running)� firstiter� finalizerF)r� r� r� r Z_get_running_loop�_set_coroutine_wrapper�_debug� threading� get_identrq r� rv rh �set_asyncgen_hooksr� r� Z_set_running_loop� _run_oncerk )rX Zold_agen_hooksr r r � run_forever� s0
zBaseEventLoop.run_foreverc C s� | j � tj|� }tj|| d�}|r,d|_|jt� z>y | j� W n, |rj|j � rj|j
� rj|j � � Y nX W d|j t� X |j � s�t
d��|j� S )a\ Run until the Future is done.
If the argument is a coroutine, it is wrapped in a Task.
WARNING: It would be disastrous to call run_until_complete()
with the same coroutine twice -- it would wrap it in two
different Tasks and that can't be good.
Return the Future's result, or raise its exception.
)rH FNz+Event loop stopped before Future completed.)r� r Zisfuturer Z
ensure_futureZ_log_destroy_pendingZadd_done_callbackrS r� ra Z cancelledr� Zremove_done_callbackr� r� )rX ZfutureZnew_taskr r r �run_until_complete� s
z BaseEventLoop.run_until_completec C s
d| _ dS )z�Stop running the event loop.
Every callback already scheduled will still run. This simply informs
run_forever to stop looping after a complete iteration.
TN)rk )rX r r r rQ � s zBaseEventLoop.stopc C sj | j � rtd��| jrdS | jr,tjd| � d| _| jj� | jj� | j }|dk rfd| _ |j
dd� dS )z�Close the event loop.
This clears the queues and shuts down the executor,
but does not wait for the executor to finish.
The event loop must not be running.
z!Cannot close a running event loopNzClose %rTF)�wait) r� r� rj r� r �debugrn r� ro rp Zshutdown)rX �executorr r r r` � s
zBaseEventLoop.closec C s | j S )z*Returns True if the event loop was closed.)rj )rX r r r r� s zBaseEventLoop.is_closedc C s0 | j � s,tjd| t| d� | j� s,| j� d S )Nzunclosed event loop %r)r� )r� r� r� r� r� r` )rX r r r �__del__ s
zBaseEventLoop.__del__c C s
| j dk S )z*Returns True if the event loop is running.N)rq )rX r r r r� s zBaseEventLoop.is_runningc C s t j� S )z�Return the time according to the event loop's clock.
This is a float expressed in seconds since an epoch, but the
epoch, precision, accuracy and drift are unspecified and may
differ per event loop.
)rr rg )rX r r r rr s zBaseEventLoop.timec G s, | j | j� | |f|�� }|jr(|jd= |S )a8 Arrange for a callback to be called at a given time.
Return a Handle: an opaque object with a cancel() method that
can be used to cancel the call.
The delay can be an int or float, expressed in seconds. It is
always relative to the current time.
Each callback will be called exactly once. If two callbacks
are scheduled for exactly the same time, it undefined which
will be called first.
Any positional arguments after the callback will be passed to
the callback when it is called.
r r� )�call_atrr r� )rX Zdelay�callbackr� �timerr r r �
call_later s zBaseEventLoop.call_laterc G sX | j � | jr"| j� | j|d� tj|||| �}|jr@|jd= tj| j |� d|_ |S )z|Like call_later(), but uses an absolute time.
Absolute time corresponds to the event loop's time() method.
r� r Tr� )
r� r� �
_check_thread�_check_callbackr Z TimerHandler� �heapq�heappushro )rX �whenr� r� r� r r r r� 5 s zBaseEventLoop.call_atc G s@ | j � | jr"| j� | j|d� | j||�}|jr<|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� r� �
_call_soonr� )rX r� r� r r r r r� E s
zBaseEventLoop.call_soonc C s> t j|�st j|�r"tdj|���t|�s:tdj||���d S )Nz#coroutines cannot be used with {}()z0a callable object was expected by {}(), got {!r})r Z iscoroutineZiscoroutinefunctionr5 r� r� )rX r� �methodr r r r� X s
z BaseEventLoop._check_callbackc C s, t j||| �}|jr |jd= | jj|� |S )Nr r� )r ZHandler� rn r9 )rX r� r� r r r r r� c s
zBaseEventLoop._call_soonc C s, | j dkrdS tj� }|| j kr(td��dS )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)rq r� r� r� )rX Z thread_idr r r r� j s
zBaseEventLoop._check_threadc G s@ | j � | jr| j|d� | j||�}|jr4|jd= | j� |S )z"Like call_soon(), but thread-safe.r� r r� )r� r� r� r� r� r� )rX r� r� r r r r r� { s z"BaseEventLoop.call_soon_threadsafec G sZ | j � | jr| j|d� |d kr@| j}|d kr@tjj� }|| _tj|j|f|�� | d�S )N�run_in_executor)rH ) r� r� r� rp �
concurrentr ZThreadPoolExecutorZ wrap_futureZsubmit)rX r� �funcr� r r r r� � s
z BaseEventLoop.run_in_executorc C s
|| _ d S )N)rp )rX r� r r r �set_default_executor� s z"BaseEventLoop.set_default_executorc C s� d||f g}|r |j d| � |r2|j d| � |rD|j d| � |rV|j d| � dj|�}tjd|� | j� }tj||||||�} | j� | }
d||
d | f }|
| jkr�tj|� n
tj|� | S )
Nz%s:%rz family=%rztype=%rzproto=%rzflags=%rz, zGet address info %sz(Getting address info %s took %.3f ms: %rg @�@) r9 �joinr r� rr r rF r| rI ) rX r; r< r= r> r? rB �msg�t0Zaddrinfo�dtr r r �_getaddrinfo_debug� s(
z BaseEventLoop._getaddrinfo_debugr )r= r> r? rB c C s> | j r | jd | j||||||�S | jd tj||||||�S d S )N)r� r� r� r rF )rX r; r< r= r> r? rB r r r rF � s
zBaseEventLoop.getaddrinfoc C s | j d tj||�S )N)r� r � getnameinfo)rX ZsockaddrrB r r r r� � s zBaseEventLoop.getnameinfo)�sslr= r? rB r% �
local_addrr� c # s |
dk r| rt d��|
dkr2|r2|s.t d��|}
|dk sD|dk �r�|dk rTt d��t||f|tj||| d�} | g} | dk r�t| |tj||| d�}
| j|
� nd}
tj| | d�E dH | j� }|s�td��|
dk r�|
j� }|s�td��g }�x�|D �]B\}}}}}y�tj|||d�}|j d � |
dk �r�x�|D ]j\}}}}}y|j
|� P W nH tk
�r� } z*t|j d
j ||j
j� ��}|j|� W Y dd}~X nX �q.W |j� d}w�| j�r�tjd ||� | j||�E dH W n^ tk
�r } z"|dk �r�|j� |j|� W Y dd}~X q� |dk �r,|j� � Y q�X P q�W t|�d k�rR|d
�nJt|d
�� t� fdd�|D ���r~|d
�tdj djdd� |D �����n,|dk�r�t d��t|j��s�t dj |���| j||||
�E dH \}}| j�r
|jd�}tjd|||||� ||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 hostz8host/port and sock can not be specified at the same time)r= r> r? rB rH )rH z!getaddrinfo() returned empty list)r= r> r? Fz2error while attempting to bind on address {!r}: {}zconnect %r to %rr r c 3 s | ]}t |�� kV qd S )N)r )r� rR )�modelr r � <genexpr> s z2BaseEventLoop.create_connection.<locals>.<genexpr>zMultiple exceptions: {}z, c s s | ]}t |�V qd S )N)r )r� rR r r r r� # s z5host and port was not specified and no sock specifiedz&A Stream Socket was expected, got {!r}r z %r connected to %s:%r: (%r, %r)) r! rK r r) r9 r r� r� r$ � setblocking�bind�errnor� �strerror�lowerr` r� r r� � sock_connectr� r �allr� r+ r> � _create_connection_transport�get_extra_info)rX �protocol_factoryr; r< r� r= r? rB r% r� r� �f1�fs�f2�infosZ laddr_infos�
exceptionsr> ZcnamerG �_ZladdrrR � transportr� r )r� r �create_connection� s�
"
z BaseEventLoop.create_connectionc
c s� |j d� |� }| j� }|rFt|t�r*d n|}| j||||||d�} n| j|||�} y|E d H W n | j� � Y nX | |fS )NF)r� r� )r� rD r rx r� r� r` )
rX r% r� r� r� r� r� rc r� r� r r r r� = s
z*BaseEventLoop._create_connection_transport)r= r? rB �
reuse_address�
reuse_port�allow_broadcastr% c # s8 |
dk r�t |
j�s tdj|
���� s@�s@|s@|s@|s@|s@|s@| r~t� �|||||| d�} djdd� | j� D ��} tdj| ���|
jd� d}
�n*� p��s�|d kr�td
��||fdff}n�tj � }x�d � fd �ffD ]~\}}|dk r�t
||t j ||| d �E dH }|�s t
d
��xB|D ]:\}}}}}||f}||k�r>ddg||< ||| |< �qW q�W � �fdd�|j� D �}|�sztd��g }|dk�r�tjdk�o�tjdk}�x|D �]\\}}\}}d}
d}
y�t j |t j |d�}
|�r�|
jt jt jd � |�r�t|
� | �r|
jt jt jd � |
jd� � �r,|
j|� ��rH| j|
|�E dH |}
W n^ t
k
�r� } z"|
dk �rp|
j� |j|� W Y dd}~X n" |
dk �r�|
j� � Y nX P �q�W |d �|� } | j� } | j |
| |
| �} | j �r
� �r�t j d� �| | � nt j d�| | � y| E dH W n | j� � Y nX | | fS )zCreate datagram connection.Nz#A UDP Socket was expected, got {!r})r� � remote_addrr= r? rB r� r� r� z, c s s" | ]\}}|rd j ||�V qdS )z{}={}N)r� )r� �k�vr r r r� i s z9BaseEventLoop.create_datagram_endpoint.<locals>.<genexpr>zNsocket modifier keyword arguments can not be used when sock is specified. ({})Fr zunexpected address familyr )r= r> r? rB rH z!getaddrinfo() returned empty listc s8 g | ]0\}}� r |d dkp*�o*|d dks||f�qS )r Nr r )r� �keyZ addr_pair)r� r� r r r� � s z:BaseEventLoop.create_datagram_endpoint.<locals>.<listcomp>z can not get address information�posix�cygwin)r= r> r? z@Datagram endpoint local_addr=%r remote_addr=%r created: (%r, %r)z2Datagram endpoint remote_addr=%r created: (%r, %r))NN)!r- r> r! r� �dictr� �itemsr� rl � OrderedDictrK r r, r$ ry �namerv �platformr" r# � SO_REUSEADDRr& Z SO_BROADCASTr� r� r` r9 rD r� r� r rI r� ) rX r� r� r� r= r? rB r� r� r� r% ZoptsZproblemsZr_addrZaddr_pairs_infoZ
addr_infos�idxZaddrr� Zfamr� ZprorG r r� Z
local_addressZremote_addressrR r� rc r� r )r� r� r �create_datagram_endpointU s�
z&BaseEventLoop.create_datagram_endpointc c s4 t ||f|tj|| d�E d H }|s0tdj|���|S )N)r= r> rB rH z%getaddrinfo({!r}) returned empty list)rK r r) r$ r� )rX r; r< r= rB r� r r r �_create_server_getaddrinfo� s
z(BaseEventLoop._create_server_getaddrinfor )r= rB r% �backlogr� r� r� c # s� t |t�rtd��|dk s$�dk �r|dk r4td��| dkrPtjdkoNtjdk} g } |dkrddg} n$t |t�s|t |t j
� r�|g} n|} � ���fdd�| D �}
t j |
d �i�E dH }t
tjj|��}d
}�z �x|D �]
}|\}}}}}ytj|||�}W n6 tjk
�r2 �j�r,tjd |||d d
� w�Y nX | j|� | �rV|jtjtjd � |
�rdt|� t�r�|tj k�r�t td��r�|jtj tj d � y|j |� W q� t!k
�r� } z t!|j"d||j#j$� f ��W Y dd}~X q�X q�W d }W d|�s x| D ]}|j%� �q�W X n2|dk�r"td��t&|j'��s<tdj(|���|g} t)�| �}x4| D ],}|j*|� |j+d
� �j,|||||� �qRW �j�r�tj-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 NoneNz8host/port and sock can not be specified at the same timer r r0 c s g | ]}�j |�� �d ��qS ))r= rB )r )r� r; )r= rB r< rX r r r� s z/BaseEventLoop.create_server.<locals>.<listcomp>rH Fz:create_server() failed to create socket.socket(%r, %r, %r)T)�exc_info� IPPROTO_IPV6z0error while attempting to bind on address %r: %sz)Neither host/port nor sock were specifiedz&A Stream Socket was expected, got {!r}z
%r is serving).r rx r5 r! ry r rv r r rl �Iterabler r� �set� itertools�chain�
from_iterabler �errorr� r �warningr9 r" r# r r& r8 r r r Z IPV6_V6ONLYr� r$ r� r� r� r` r+ r> r� rT Zlistenr� Z_start_servingrI )rX r� r; r< r= rB r% r
r� r� r� rU Zhostsr� r� Z completed�resr@ Zsocktyper? Z canonnameZsa�errr� r )r= rB r< rX r �
create_server� s�
(
zBaseEventLoop.create_server)r� c c s^ t |j�stdj|���| j|||ddd�E dH \}}| jrV|jd�}tjd|||� ||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.
z&A Stream Socket was expected, got {!r}r0 T)r� Nr z%r handled: (%r, %r)) r+ r> r! r� r� r� r� r r� )rX r� r% r� r� r� r r r �connect_accepted_socketA s
z%BaseEventLoop.connect_accepted_socketc c sd |� }| j � }| j|||�}y|E d H W n |j� � Y nX | jr\tjd|j� ||� ||fS )Nz Read pipe %r connected: (%r, %r))rD r� r` r� r r� �fileno)rX r� r� r� rc r� r r r �connect_read_pipeX s z BaseEventLoop.connect_read_pipec c sd |� }| j � }| j|||�}y|E d H W n |j� � Y nX | jr\tjd|j� ||� ||fS )Nz!Write pipe %r connected: (%r, %r))rD r� r` r� r r� r )rX r� r� r� rc r� r r r �connect_write_pipei s z BaseEventLoop.connect_write_pipec C s� |g}|d k r |j dt|� � |d k rF|tjkrF|j dt|� � n4|d k r`|j dt|� � |d k rz|j dt|� � tjdj|�� d S )Nzstdin=%szstdout=stderr=%sz stdout=%sz stderr=%s� )r9 r r r r r� r� )rX r� r� r� r� rI r r r �_log_subprocessz s z BaseEventLoop._log_subprocessT)r� r� r� �universal_newlinesr� r� c
k s� t |ttf�std��|r"td��|s.td��|dkr>td��|� }
d } | jrfd| } | j| |||� | j|
|d||||f| �E d H } | jr�| d k r�tjd| | � | |
fS ) Nzcmd must be a stringz universal_newlines must be Falsezshell must be Truer zbufsize must be 0zrun shell command %rTz%s: %r) r r3 r r! r� r r� r rI )
rX r� �cmdr� r� r� r r� r� r� r� � debug_logr� r r r �subprocess_shell� s$ z BaseEventLoop.subprocess_shellc o s� |r t d��|rt d��|dkr(t d��|f| } x,| D ]$} t| ttf�s8tdt| �j ��q8W |� }
d }| jr�d| }| j||||� | j |
| d||||f|
�E d H }| jr�|d k r�t
j d||� ||
fS ) Nz universal_newlines must be Falsezshell must be Falser zbufsize must be 0z8program arguments must be a bytes or text string, not %szexecute program %rFz%s: %r) r! r r r3 r5 r> r[ r� r r� r rI )rX r� Zprogramr� r� r� r r� r� r� r� Z
popen_args�argr� r" r� r r r �subprocess_exec� s,
z BaseEventLoop.subprocess_execc C s | j S )zKReturn an exception handler, or None if the default one is in use.
)rt )rX r r r �get_exception_handler� s z#BaseEventLoop.get_exception_handlerc C s* |dk r t |� r tdj|���|| _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})r� r5 r� rt )rX Zhandlerr r r �set_exception_handler� s z#BaseEventLoop.set_exception_handlerc C s |j d�}|sd}|j d�}|dk r6t|�||jf}nd}d|kr`| jdk r`| jjr`| jj|d< |g}x�t|�D ]�}|dkr~qp|| }|dkr�djtj|��}d }||j � 7 }n2|dkr�djtj|��}d
}||j � 7 }nt
|�}|j d j ||�� qpW t
jd j|�|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 loopr� NFZsource_tracebackZhandle_tracebackr0 z+Object created at (most recent call last):
z+Handle created at (most recent call last):
z{}: {}�
)r > r� r� )r{ r> �
__traceback__r} r� �sortedr� � traceback� format_list�rstripr r9 r� r r ) rX �contextr� r� r Z log_linesr �value�tbr r r �default_exception_handler� s6
z'BaseEventLoop.default_exception_handlerc C s� | j dkr>y| j|� W q� tk
r: tjddd� Y q�X nny| j | |� W n\ tk
r� } z@y| jd||d�� W n" tk
r� tjddd� Y nX W Y dd}~X nX dS )a 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;
- '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 handlerT)r z$Unhandled error in exception handler)r� r� r. zeException in default exception handler while handling an unexpected error in custom exception handler)rt r1 rO r r )rX r. rR r r r r� s"
z$BaseEventLoop.call_exception_handlerc C s |j r
dS | jj|� dS )z3Add a Handle to _scheduled (TimerHandle) or _ready.N)�
_cancelledrn r9 )rX r r r r �
_add_callback9 s zBaseEventLoop._add_callbackc C s | j |� | j� dS )z6Like _add_callback() but called from a signal handler.N)r3 r� )rX r r r r �_add_callback_signalsafeA s
z&BaseEventLoop._add_callback_signalsafec C s |j r| jd7 _dS )z3Notification that a TimerHandle has been cancelled.r N)ro ri )rX r r r r �_timer_handle_cancelledF s z%BaseEventLoop._timer_handle_cancelledc C s� t | j�}|tkrd| j| tkrdg }x&| jD ] }|jr>d|_q,|j|� q,W tj|� || _d| _n8x6| jr�| jd jr�| jd8 _tj | j�}d|_qfW d}| j
s�| j r�d}n*| jr�| jd j }t
td|| j� �t�}| jo�|dk�r�| j� }| jj|�}| j� | }|dk�r tj} ntj} t |�}
|dk�rLtj| d|d |
� nD|
�rntj| d|d |d |
� n"|dk�r�tj| d |d |d � n | jj|�}| j|� | j� | j } xD| j�r�| jd }|j | k�r�P tj | j�}d|_| j
j|� �q�W t | j
�} x�t| �D ]|}
| j
j � }|j�r*�q| j�r�zD|| _ | j� }|j � | j� | }|| j k�rttj d
t!|�|� W dd| _ X n|j � �qW d}dS ) z�Run one full iteration of the event loop.
This calls all currently ready callbacks, polls for I/O,
schedules the resulting callbacks, and finally schedules
'call_later' callbacks.
Fr r Ng �?z poll took %.3f ms: %s eventsg @�@z$poll %.3f ms took %.3f ms: %s eventsz"poll %.3f ms took %.3f ms: timeoutz Executing %s took %.3f seconds)"r� ro � _MIN_SCHEDULED_TIMER_HANDLESri �%_MIN_CANCELLED_TIMER_HANDLES_FRACTIONr2 r9 r� �heapify�heappoprn rk Z_when�min�maxrr �MAXIMUM_SELECT_TIMEOUTr� Z _selectorZselect�logging�INFO�DEBUGr �logr� rs �range�popleftr} Z_runr| r r )rX Z sched_countZ
new_scheduledr Ztimeoutr� r� r� r� �levelZneventZend_timeZntodo�ir r r r� K s�
zBaseEventLoop._run_oncec C s� yt j}t j}W n tk
r$ d S X t|�}| j|kr<d S tj}|� }|rz|d |fkrjtj d| t
� q�||� d| _n,|d |fkr�tj d| t
� n|d � d| _d S )Nz[loop.set_debug(True): cannot set debug coroutine wrapper; another wrapper is already set %rTzWloop.set_debug(False): cannot unset debug coroutine wrapper; another wrapper was set %rF) rv �set_coroutine_wrapper�get_coroutine_wrapper�AttributeErrorrx r r Z
debug_wrapperr� r� �RuntimeWarning)rX �enabledZ set_wrapperZ get_wrapper�wrapperZcurrent_wrapperr r r r� � s.
z$BaseEventLoop._set_coroutine_wrapperc C s | j S )N)r� )rX r r r r� � s zBaseEventLoop.get_debugc C s || _ | j� r| j|� d S )N)r� r� r� )rX rI r r r ru � s zBaseEventLoop.set_debug)N)N)NNN)NN)NN)N)r )NN)F)NN)NN)Gr[ re rf rY r\ rD r� r� r� r� r� r� r� r� r r� r� r� r� r� r� r� r� r� rQ r` r� r ZPY34r� r� rr r� r� r� r� r� r� r� r� r� r� rF r� r� r� r r r r6 Z
AI_PASSIVEr r r r r r r r# r% r& r' r1 r� r3 r4 r5 r� r� r� ru r r r r r
� s� !
%
u `
12c!i�Q )2�__doc__rl Zconcurrent.futuresr� r� �inspectr r= ry r r r� rr r+ rv r� r� r0 r r r r r r r@ r �__all__r6 r7 �BrokenPipeError�ConnectionResetError�ConnectionAbortedErrorZ_FATAL_ERROR_IGNOREr r8 r< r r r& r+ r- rA r) rK rM rS ZAbstractServerrT ZAbstractEventLoopr
r r r r �<module> sV
;
/PK [P�\~z z , __pycache__/base_events.cpython-36.opt-2.pycnu �[��� 3
\� � @ s� d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl Z d dl
Z
d dl Z d dl Z d dl
Z
d dlZd dlZddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ dd lmZ d
gZd Zd Ze e e fZ e ed
�Z!d(Z"dd� Z#dd� Z$dd� Z%dd� Z&dd� Z'dd� Z(d ej)d d d �d d �Z*e ed ��rNd d!� Z+nd"d!� Z+d#d$� Z,G d%d&� d&ej-�Z.G d'd
� d
ej/�Z0dS ))� N� )�compat)�
coroutines)�events)�futures)�tasks)� coroutine)�logger�
BaseEventLoop�d g �?�AF_INET6� i c C s0 | j }tt|dd �tj�r$t|j�S t| �S d S )N�__self__)Z _callback�
isinstance�getattrr �Task�reprr �str)�handle�cb� r �+/usr/lib64/python3.6/asyncio/base_events.py�_format_handle? s
r c C s( | t jkrdS | t jkr dS t| �S d S )Nz<pipe>z<stdout>)�
subprocess�PIPE�STDOUTr )�fdr r r � _format_pipeH s
r c C sL t td�std��n4y| jtjtjd� W n tk
rF td��Y 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.)�hasattr�socket�
ValueError�
setsockopt�
SOL_SOCKETr �OSError)�sockr r r �_set_reuseportQ s
r& c C s& t td�r| d@ tjkS | tjkS d S )N�
SOCK_NONBLOCK� )r r � SOCK_STREAM)� sock_typer r r �_is_stream_socket\ s
r+ c C s& t td�r| d@ tjkS | tjkS d S )Nr' r( )r r �
SOCK_DGRAM)r* r r r �_is_dgram_socketh s
r- c C sv t td�sd S |dtjtjhks(| d kr,d S t|�r<tj}nt|�rLtj}nd S |d kr^d}nVt|t�rv|dkrvd}n>t|t�r�|dkr�d}n&y t |�}W n t
t fk
r� d S X |tj kr�tj
g}tr�|jtj� n|g}t| t�r�| jd�} d| k�r d S xp|D ]h}yJtj|| � t�r@|tjk�r@|||d| |ddffS |||d| |ffS W n tk
�rj Y nX �qW d S )N� inet_ptonr � � Zidna�%)r r � IPPROTO_TCPZ IPPROTO_UDPr+ r- r �bytesr �int� TypeErrorr! � AF_UNSPEC�AF_INET� _HAS_IPv6�appendr �decoder. r$ )�host�port�family�type�protoZafs�afr r r � _ipaddr_infop sL
rA )r= r> r? �flagsc
C sZ | d d� \}}t |||||�}|d k r@|j� } | j|g� | S |j||||||d�S d S )N� )r= r> r? rB )rA �
create_future�
set_result� getaddrinfo)
�addressr= r> r? rB �loopr; r< �info�futr r r �_ensure_resolved� s rK � TCP_NODELAYc C s> | j tjtjhkr:t| j�r:| jtjkr:| jtjtj d� d S )Nr )
r= r r7 r r+ r> r? r2 r" rL )r% r r r � _set_nodelay� s
rM c C s d S )Nr )r% r r r rM � s c C s. | j }t|t�r t|t� r d S | jj� d S )N)Z
_exceptionr �
BaseException� Exception�_loop�stop)rJ �excr r r �_run_until_complete_cb� s
rS c @ sH e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Ze d
d� �Z
dS )�Serverc C s || _ || _d| _g | _d S )Nr )rP �sockets�
_active_count�_waiters)�selfrH rU r r r �__init__� s zServer.__init__c C s d| j j| jf S )Nz<%s sockets=%r>)� __class__�__name__rU )rX r r r �__repr__� s zServer.__repr__c C s | j d7 _ d S )Nr )rV )rX r r r �_attach� s zServer._attachc C s. | j d8 _ | j dkr*| jd kr*| j� d S )Nr r )rV rU �_wakeup)rX r r r �_detach� s zServer._detachc C sH | j }|d krd S d | _ x|D ]}| jj|� q W | jdkrD| j� d S )Nr )rU rP Z
_stop_servingrV r^ )rX rU r% r r r �close� s
z Server.closec C s0 | j }d | _ x |D ]}|j� s|j|� qW d S )N)rW �donerE )rX �waiters�waiterr r r r^ � s
zServer._wakeupc c s< | j d ks| jd krd S | jj� }| jj|� |E d H d S )N)rU rW rP rD r9 )rX rc r r r � wait_closed� s
zServer.wait_closedN) r[ �
__module__� __qualname__rY r\ r] r_ r` r^ r rd r r r r rT � s
rT c
@ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd�d
d
d�dd�Z d�dd
d
d
d�dd�Z
d�dd�Z d�dd�Z d�dd�Z
ed�dd ��Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zed'd(� �Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zej � r�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)dMdMdMdMdN�dOdP�Z*d�dQdR�Z+ed�d
dMdMdMd
d
d
dS�dTdU��Z,ed�dVdW��Z-ed�dMdMdMd
d
d
d
dX�dYdZ��Z.ed[d\� �Z/ed�e0j1e0j2d
d]d
d
d
d^�d_d`��Z3ed
da�dbdc��Z4eddde� �Z5edfdg� �Z6dhdi� Z7ee8j9e8j9e8j9ddjdMdk�dldm��Z:ee8j9e8j9e8j9dddMdk�dndo��Z;dpdq� Z<drds� Z=dtdu� Z>dvdw� Z?dxdy� Z@dzd{� ZAd|d}� ZBd~d� ZCd�d�� ZDd�d�� ZEd�d�� ZFd
S )�r
c C s� d| _ d| _d| _tj� | _g | _d | _d| _d | _ t
j d�j | _
d | _| jtjj odttjjd��� d| _d | _d | _d| _ttd�r�t j � | _ nd | _ d| _ d S )Nr F� monotonicZPYTHONASYNCIODEBUGg�������?�get_asyncgen_hooks) �_timer_cancelled_count�_closed� _stopping� collections�deque�_ready�
_scheduled�_default_executorZ
_internal_fds�
_thread_id�timeZget_clock_infoZ
resolution�_clock_resolution�_exception_handler� set_debug�sysrB �ignore_environment�bool�os�environ�get�slow_callback_duration�_current_handle�
_task_factory�_coroutine_wrapper_setr �weakref�WeakSet�
_asyncgens�_asyncgens_shutdown_called)rX r r r rY � s(
zBaseEventLoop.__init__c C s d| j j| j� | j� | j� f S )Nz"<%s running=%s closed=%s debug=%s>)rZ r[ �
is_running� is_closed� get_debug)rX r r r r\ s zBaseEventLoop.__repr__c C s t j| d�S )N)rH )r ZFuture)rX r r r rD % s zBaseEventLoop.create_futurec C s@ | j � | jd kr0tj|| d�}|jr<|jd= n | j| |�}|S )N)rH r ���)�
_check_closedr~ r r �_source_traceback)rX �coroZtaskr r r � create_task) s
zBaseEventLoop.create_taskc C s$ |d k rt |� rtd��|| _d S )Nz'task factory must be a callable or None)�callabler5 r~ )rX �factoryr r r �set_task_factory7 s
z BaseEventLoop.set_task_factoryc C s | j S )N)r~ )rX r r r �get_task_factoryE s z BaseEventLoop.get_task_factoryN)�extra�serverc C s t �d S )N)�NotImplementedError)rX r% �protocolrc r� r� r r r �_make_socket_transportI s z$BaseEventLoop._make_socket_transportF)� server_side�server_hostnamer� r� c C s t �d S )N)r� ) rX Zrawsockr� �
sslcontextrc r� r� r� r� r r r �_make_ssl_transportN s z!BaseEventLoop._make_ssl_transportc C s t �d S )N)r� )rX r% r� rG rc r� r r r �_make_datagram_transportT s z&BaseEventLoop._make_datagram_transportc C s t �d S )N)r� )rX �piper� rc r� r r r �_make_read_pipe_transportY s z'BaseEventLoop._make_read_pipe_transportc C s t �d S )N)r� )rX r� r� rc r� r r r �_make_write_pipe_transport^ s z(BaseEventLoop._make_write_pipe_transportc
K s t �d S )N)r� )
rX r� �args�shell�stdin�stdout�stderr�bufsizer� �kwargsr r r �_make_subprocess_transportc s z(BaseEventLoop._make_subprocess_transportc C s t �d S )N)r� )rX r r r �_write_to_selfj s z BaseEventLoop._write_to_selfc C s t �d S )N)r� )rX �
event_listr r r �_process_eventss s z BaseEventLoop._process_eventsc C s | j rtd��d S )NzEvent loop is closed)rj � RuntimeError)rX r r r r� w s zBaseEventLoop._check_closedc C s* | j j|� | j� s&| j| j|j� � d S )N)r� �discardr� �call_soon_threadsafer� �aclose)rX �agenr r r �_asyncgen_finalizer_hook{ s z&BaseEventLoop._asyncgen_finalizer_hookc C s, | j r tjdj|�t| d� | jj|� d S )NzNasynchronous generator {!r} was scheduled after loop.shutdown_asyncgens() call)�source)r� �warnings�warn�format�ResourceWarningr� �add)rX r� r r r �_asyncgen_firstiter_hook� s
z&BaseEventLoop._asyncgen_firstiter_hookc c s� d| _ | jd ks t| j� r d S t| j�}| jj� tjdd� |D �d| d��}|E d H }x8t||�D ]*\}}t|t �rf| j
dj |�||d�� qfW d S )NTc S s g | ] }|j � �qS r )r� )�.0Zagr r r �
<listcomp>� s z4BaseEventLoop.shutdown_asyncgens.<locals>.<listcomp>)Zreturn_exceptionsrH z?an error occurred during closing of asynchronous generator {!r})�message� exceptionZasyncgen) r� r� �len�list�clearr �gather�zipr rO �call_exception_handlerr� )rX Z
closing_agensZ
shutdown_coroZresults�resultr� r r r �shutdown_asyncgens� s"
z BaseEventLoop.shutdown_asyncgensc C s� | j � | j� rtd��tj� d k r,td��| j| j� tj� | _ | j
d k rft j � }t j
| j| jd� z$tj| � x| j� | jrtP qtW W d d| _d | _ tjd � | jd� | j
d k r�t j
|� X d S )Nz"This event loop is already runningz7Cannot run the event loop while another loop is running)� firstiter� finalizerF)r� r� r� r Z_get_running_loop�_set_coroutine_wrapper�_debug� threading� get_identrq r� rv rh �set_asyncgen_hooksr� r� Z_set_running_loop� _run_oncerk )rX Zold_agen_hooksr r r � run_forever� s0
zBaseEventLoop.run_foreverc C s� | j � tj|� }tj|| d�}|r,d|_|jt� z>y | j� W n, |rj|j � rj|j
� rj|j � � Y nX W d |j t� X |j � s�t
d��|j� S )N)rH Fz+Event loop stopped before Future completed.)r� r Zisfuturer Z
ensure_futureZ_log_destroy_pendingZadd_done_callbackrS r� ra Z cancelledr� Zremove_done_callbackr� r� )rX ZfutureZnew_taskr r r �run_until_complete� s
z BaseEventLoop.run_until_completec C s
d| _ d S )NT)rk )rX r r r rQ � s zBaseEventLoop.stopc C sj | j � rtd��| jrd S | jr,tjd| � d| _| jj� | jj� | j }|d k rfd | _ |j
dd� d S )Nz!Cannot close a running event loopzClose %rTF)�wait) r� r� rj r� r �debugrn r� ro rp Zshutdown)rX �executorr r r r` � s
zBaseEventLoop.closec C s | j S )N)rj )rX r r r r� s zBaseEventLoop.is_closedc C s0 | j � s,tjd| t| d� | j� s,| j� d S )Nzunclosed event loop %r)r� )r� r� r� r� r� r` )rX r r r �__del__ s
zBaseEventLoop.__del__c C s
| j d k S )N)rq )rX r r r r� s zBaseEventLoop.is_runningc C s t j� S )N)rr rg )rX r r r rr s zBaseEventLoop.timec G s, | j | j� | |f|�� }|jr(|jd= |S )Nr r� )�call_atrr r� )rX Zdelay�callbackr� �timerr r r �
call_later s zBaseEventLoop.call_laterc G sX | j � | jr"| j� | j|d� tj|||| �}|jr@|jd= tj| j |� d|_ |S )Nr� r Tr� )
r� r� �
_check_thread�_check_callbackr Z TimerHandler� �heapq�heappushro )rX �whenr� r� r� r r r r� 5 s zBaseEventLoop.call_atc G s@ | j � | jr"| j� | j|d� | j||�}|jr<|jd= |S )N� call_soonr r� )r� r� r� r� �
_call_soonr� )rX r� r� r r r r r� E s
zBaseEventLoop.call_soonc C s> t j|�st j|�r"tdj|���t|�s:tdj||���d S )Nz#coroutines cannot be used with {}()z0a callable object was expected by {}(), got {!r})r Z iscoroutineZiscoroutinefunctionr5 r� r� )rX r� �methodr r r r� X s
z BaseEventLoop._check_callbackc C s, t j||| �}|jr |jd= | jj|� |S )Nr r� )r ZHandler� rn r9 )rX r� r� r r r r r� c s
zBaseEventLoop._call_soonc C s, | j d krd S tj� }|| j kr(td��d S )NzMNon-thread-safe operation invoked on an event loop other than the current one)rq r� r� r� )rX Z thread_idr r r r� j s
zBaseEventLoop._check_threadc G s@ | j � | jr| j|d� | j||�}|jr4|jd= | j� |S )Nr� r r� )r� r� r� r� r� r� )rX r� r� r r r r r� { s z"BaseEventLoop.call_soon_threadsafec G sZ | j � | jr| j|d� |d kr@| j}|d kr@tjj� }|| _tj|j|f|�� | d�S )N�run_in_executor)rH ) r� r� r� rp �
concurrentr ZThreadPoolExecutorZ wrap_futureZsubmit)rX r� �funcr� r r r r� � s
z BaseEventLoop.run_in_executorc C s
|| _ d S )N)rp )rX r� r r r �set_default_executor� s z"BaseEventLoop.set_default_executorc C s� d||f g}|r |j d| � |r2|j d| � |rD|j d| � |rV|j d| � dj|�}tjd|� | j� }tj||||||�} | j� | }
d||
d | f }|
| jkr�tj|� n
tj|� | S )
Nz%s:%rz family=%rztype=%rzproto=%rzflags=%rz, zGet address info %sz(Getting address info %s took %.3f ms: %rg @�@) r9 �joinr r� rr r rF r| rI ) rX r; r< r= r> r? rB �msg�t0Zaddrinfo�dtr r r �_getaddrinfo_debug� s(
z BaseEventLoop._getaddrinfo_debugr )r= r> r? rB c C s> | j r | jd | j||||||�S | jd tj||||||�S d S )N)r� r� r� r rF )rX r; r< r= r> r? rB r r r rF � s
zBaseEventLoop.getaddrinfoc C s | j d tj||�S )N)r� r � getnameinfo)rX ZsockaddrrB r r r r� � s zBaseEventLoop.getnameinfo)�sslr= r? rB r% �
local_addrr� c # s |
d k r| rt d��|
d kr2|r2|s.t d��|}
|d k sD|d k �r�|d k rTt d��t||f|tj||| d�} | g} | d k r�t| |tj||| d�}
| j|
� nd }
tj| | d�E d H | j� }|s�td��|
d k r�|
j� }|s�td��g }�x�|D �]B\}}}}}y�tj|||d�}|j d� |
d k �r�x�|D ]j\}}}}}y|j
|� P W nH tk
�r� } z*t|j d j ||j
j� ��}|j|� W Y d d }~X nX �q.W |j� d }w�| j�r�tjd
||� | j||�E d H W n^ tk
�r } z"|d k �r�|j� |j|� W Y d d }~X q� |d k �r,|j� � Y q�X P q�W t|�d k�rR|d �nJt|d �� t� fd
d�|D ���r~|d �tdj djdd� |D �����n,|d k�r�t d��t|j��s�t dj |���| j||||
�E d H \}}| j�r
|jd�}tjd|||||� ||fS )Nz+server_hostname is only meaningful with sslz:You must set server_hostname when using ssl without a hostz8host/port and sock can not be specified at the same time)r= r> r? rB rH )rH z!getaddrinfo() returned empty list)r= r> r? Fz2error while attempting to bind on address {!r}: {}zconnect %r to %rr r c 3 s | ]}t |�� kV qd S )N)r )r� rR )�modelr r � <genexpr> s z2BaseEventLoop.create_connection.<locals>.<genexpr>zMultiple exceptions: {}z, c s s | ]}t |�V qd S )N)r )r� rR r r r r� # s z5host and port was not specified and no sock specifiedz&A Stream Socket was expected, got {!r}r z %r connected to %s:%r: (%r, %r)) r! rK r r) r9 r r� r� r$ � setblocking�bind�errnor� �strerror�lowerr` r� r r� � sock_connectr� r �allr� r+ r> � _create_connection_transport�get_extra_info)rX �protocol_factoryr; r< r� r= r? rB r% r� r� �f1�fs�f2�infosZ laddr_infos�
exceptionsr> ZcnamerG �_ZladdrrR � transportr� r )r� r �create_connection� s�
"
z BaseEventLoop.create_connectionc
c s� |j d� |� }| j� }|rFt|t�r*d n|}| j||||||d�} n| j|||�} y|E d H W n | j� � Y nX | |fS )NF)r� r� )r� rD r rx r� r� r` )
rX r% r� r� r� r� r� rc r� r� r r r r� = s
z*BaseEventLoop._create_connection_transport)r= r? rB �
reuse_address�
reuse_port�allow_broadcastr% c # s8 |
d k r�t |
j�s tdj|
���� s@�s@|s@|s@|s@|s@|s@| r~t� �|||||| d�} djdd� | j� D ��} tdj| ���|
jd� d }
�n*� p��s�|dkr�td ��||fdff}n�tj � }x�d� fd
�ffD ]~\}}|d k r�t
||t j ||| d �E d H }|�s t
d ��xB|D ]:\}}}}}||f}||k�r>d d g||< ||| |< �qW q�W � �fd
d�|j� D �}|�sztd��g }|d k�r�tjdk�o�tjdk}�x|D �]\\}}\}}d }
d }
y�t j |t j |d�}
|�r�|
jt jt jd
� |�r�t|
� | �r|
jt jt jd
� |
jd� � �r,|
j|� ��rH| j|
|�E d H |}
W n^ t
k
�r� } z"|
d k �rp|
j� |j|� W Y d d }~X n" |
d k �r�|
j� � Y nX P �q�W |d �|� } | j� } | j |
| |
| �} | j �r
� �r�t j d� �| | � nt j d�| | � y| E d H W n | j� � Y nX | | fS )Nz#A UDP Socket was expected, got {!r})r� � remote_addrr= r? rB r� r� r� z, c s s" | ]\}}|rd j ||�V qdS )z{}={}N)r� )r� �k�vr r r r� i s z9BaseEventLoop.create_datagram_endpoint.<locals>.<genexpr>zNsocket modifier keyword arguments can not be used when sock is specified. ({})Fr zunexpected address familyr )r= r> r? rB rH z!getaddrinfo() returned empty listc s8 g | ]0\}}� r |d dkp*�o*|d dks||f�qS )r Nr r )r� �keyZ addr_pair)r� r� r r r� � s z:BaseEventLoop.create_datagram_endpoint.<locals>.<listcomp>z can not get address information�posix�cygwin)r= r> r? z@Datagram endpoint local_addr=%r remote_addr=%r created: (%r, %r)z2Datagram endpoint remote_addr=%r created: (%r, %r))NN)!r- r> r! r� �dictr� �itemsr� rl � OrderedDictrK r r, r$ ry �namerv �platformr" r# � SO_REUSEADDRr& Z SO_BROADCASTr� r� r` r9 rD r� r� r rI r� ) rX r� r� r� r= r? rB r� r� r� r% ZoptsZproblemsZr_addrZaddr_pairs_infoZ
addr_infos�idxZaddrr� Zfamr� ZprorG r r� Z
local_addressZremote_addressrR r� rc r� r )r� r� r �create_datagram_endpointU s�
z&BaseEventLoop.create_datagram_endpointc c s4 t ||f|tj|| d�E d H }|s0tdj|���|S )N)r= r> rB rH z%getaddrinfo({!r}) returned empty list)rK r r) r$ r� )rX r; r< r= rB r� r r r �_create_server_getaddrinfo� s
z(BaseEventLoop._create_server_getaddrinfor )r= rB r% �backlogr� r� r� c # s� t |t�rtd��|d k s$�d k �r|d k r4td��| d krPtjdkoNtjdk} g } |dkrdd g} n$t |t�s|t |t j
� r�|g} n|} � ���fdd�| D �}
t j |
d�i�E d H }t
tjj|��}d }�z �x|D �]
}|\}}}}}ytj|||�}W n6 tjk
�r2 �j�r,tjd
|||d d � w�Y nX | j|� | �rV|jtjtjd � |
�rdt|� t�r�|tj k�r�t td
��r�|jtj tj d � y|j |� W q� t!k
�r� } z t!|j"d||j#j$� f ��W Y d d }~X q�X q�W d }W d |�s x| D ]}|j%� �q�W X n2|d k�r"td��t&|j'��s<tdj(|���|g} t)�| �}x4| D ],}|j*|� |j+d � �j,|||||� �qRW �j�r�tj-d|� |S )Nz*ssl argument must be an SSLContext or Nonez8host/port and sock can not be specified at the same timer r r0 c s g | ]}�j |�� �d ��qS ))r= rB )r )r� r; )r= rB r< rX r r r� s z/BaseEventLoop.create_server.<locals>.<listcomp>rH Fz:create_server() failed to create socket.socket(%r, %r, %r)T)�exc_info� IPPROTO_IPV6z0error while attempting to bind on address %r: %sz)Neither host/port nor sock were specifiedz&A Stream Socket was expected, got {!r}z
%r is serving).r rx r5 r! ry r rv r r rl �Iterabler r� �set� itertools�chain�
from_iterabler �errorr� r �warningr9 r" r# r r& r8 r r r Z IPV6_V6ONLYr� r$ r� r� r� r` r+ r> r� rT Zlistenr� Z_start_servingrI )rX r� r; r< r= rB r% r
r� r� r� rU Zhostsr� r� Z completed�resr@ Zsocktyper? Z canonnameZsa�errr� r )r= rB r< rX r �
create_server� s�
(
zBaseEventLoop.create_server)r� c c s^ t |j�stdj|���| j|||ddd�E d H \}}| jrV|jd�}tjd|||� ||fS )Nz&A Stream Socket was expected, got {!r}r0 T)r� r z%r handled: (%r, %r)) r+ r> r! r� r� r� r� r r� )rX r� r% r� r� r� r r r �connect_accepted_socketA s
z%BaseEventLoop.connect_accepted_socketc c sd |� }| j � }| j|||�}y|E d H W n |j� � Y nX | jr\tjd|j� ||� ||fS )Nz Read pipe %r connected: (%r, %r))rD r� r` r� r r� �fileno)rX r� r� r� rc r� r r r �connect_read_pipeX s z BaseEventLoop.connect_read_pipec c sd |� }| j � }| j|||�}y|E d H W n |j� � Y nX | jr\tjd|j� ||� ||fS )Nz!Write pipe %r connected: (%r, %r))rD r� r` r� r r� r )rX r� r� r� rc r� r r r �connect_write_pipei s z BaseEventLoop.connect_write_pipec C s� |g}|d k r |j dt|� � |d k rF|tjkrF|j dt|� � n4|d k r`|j dt|� � |d k rz|j dt|� � tjdj|�� d S )Nzstdin=%szstdout=stderr=%sz stdout=%sz stderr=%s� )r9 r r r r r� r� )rX r� r� r� r� rI r r r �_log_subprocessz s z BaseEventLoop._log_subprocessT)r� r� r� �universal_newlinesr� r� c
k s� t |ttf�std��|r"td��|s.td��|dkr>td��|� }
d } | jrfd| } | j| |||� | j|
|d||||f| �E d H } | jr�| d k r�tjd| | � | |
fS ) Nzcmd must be a stringz universal_newlines must be Falsezshell must be Truer zbufsize must be 0zrun shell command %rTz%s: %r) r r3 r r! r� r r� r rI )
rX r� �cmdr� r� r� r r� r� r� r� � debug_logr� r r r �subprocess_shell� s$ z BaseEventLoop.subprocess_shellc o s� |r t d��|rt d��|dkr(t d��|f| } x,| D ]$} t| ttf�s8tdt| �j ��q8W |� }
d }| jr�d| }| j||||� | j |
| d||||f|
�E d H }| jr�|d k r�t
j d||� ||
fS ) Nz universal_newlines must be Falsezshell must be Falser zbufsize must be 0z8program arguments must be a bytes or text string, not %szexecute program %rFz%s: %r) r! r r r3 r5 r> r[ r� r r� r rI )rX r� Zprogramr� r� r� r r� r� r� r� Z
popen_args�argr� r" r� r r r �subprocess_exec� s,
z BaseEventLoop.subprocess_execc C s | j S )N)rt )rX r r r �get_exception_handler� s z#BaseEventLoop.get_exception_handlerc C s* |d k r t |� r tdj|���|| _d S )Nz/A callable object or None is expected, got {!r})r� r5 r� rt )rX Zhandlerr r r �set_exception_handler� s z#BaseEventLoop.set_exception_handlerc C s |j d�}|sd}|j d�}|d k r6t|�||jf}nd}d|kr`| jd k r`| jjr`| jj|d< |g}x�t|�D ]�}|d
kr~qp|| }|dkr�djtj|��}d}||j � 7 }n2|dkr�djtj|��}d }||j � 7 }nt
|�}|j d
j ||�� qpW t
jd j|�|d � d S )Nr� z!Unhandled exception in event loopr� FZsource_tracebackZhandle_tracebackr0 z+Object created at (most recent call last):
z+Handle created at (most recent call last):
z{}: {}�
)r > r� r� )r{ r> �
__traceback__r} r� �sortedr� � traceback� format_list�rstripr r9 r� r r ) rX �contextr� r� r Z log_linesr �value�tbr r r �default_exception_handler� s6
z'BaseEventLoop.default_exception_handlerc C s� | j d kr>y| j|� W q� tk
r: tjddd� Y q�X nny| j | |� W n\ tk
r� } z@y| jd||d�� W n" tk
r� tjddd� Y nX W Y d d }~X nX d S )Nz&Exception in default exception handlerT)r z$Unhandled error in exception handler)r� r� r. zeException in default exception handler while handling an unexpected error in custom exception handler)rt r1 rO r r )rX r. rR r r r r� s"
z$BaseEventLoop.call_exception_handlerc C s |j r
d S | jj|� d S )N)�
_cancelledrn r9 )rX r r r r �
_add_callback9 s zBaseEventLoop._add_callbackc C s | j |� | j� d S )N)r3 r� )rX r r r r �_add_callback_signalsafeA s
z&BaseEventLoop._add_callback_signalsafec C s |j r| jd7 _d S )Nr )ro ri )rX r r r r �_timer_handle_cancelledF s z%BaseEventLoop._timer_handle_cancelledc C s� t | j�}|tkrd| j| tkrdg }x&| jD ] }|jr>d|_q,|j|� q,W tj|� || _d| _n8x6| jr�| jd jr�| jd8 _tj | j�}d|_qfW d }| j
s�| j r�d}n*| jr�| jd j }t
td|| j� �t�}| jo�|dk�r�| j� }| jj|�}| j� | }|dk�r tj} ntj} t |�}
|d k�rLtj| d|d |
� nD|
�rntj| d|d |d |
� n"|dk�r�tj| d|d |d � n | jj|�}| j|� | j� | j } xD| j�r�| jd }|j | k�r�P tj | j�}d|_| j
j|� �q�W t | j
�} x�t| �D ]|}
| j
j � }|j�r*�q| j�r�zD|| _ | j� }|j � | j� | }|| j k�rttj d t!|�|� W d d | _ X n|j � �qW d }d S )
NFr r g �?z poll took %.3f ms: %s eventsg @�@z$poll %.3f ms took %.3f ms: %s eventsz"poll %.3f ms took %.3f ms: timeoutz Executing %s took %.3f seconds)"r� ro � _MIN_SCHEDULED_TIMER_HANDLESri �%_MIN_CANCELLED_TIMER_HANDLES_FRACTIONr2 r9 r� �heapify�heappoprn rk Z_when�min�maxrr �MAXIMUM_SELECT_TIMEOUTr� Z _selectorZselect�logging�INFO�DEBUGr �logr� rs �range�popleftr} Z_runr| r r )rX Z sched_countZ
new_scheduledr Ztimeoutr� r� r� r� �levelZneventZend_timeZntodo�ir r r r� K s�
zBaseEventLoop._run_oncec C s� yt j}t j}W n tk
r$ d S X t|�}| j|kr<d S tj}|� }|rz|d |fkrjtj d| t
� q�||� d| _n,|d |fkr�tj d| t
� n|d � d| _d S )Nz[loop.set_debug(True): cannot set debug coroutine wrapper; another wrapper is already set %rTzWloop.set_debug(False): cannot unset debug coroutine wrapper; another wrapper was set %rF) rv �set_coroutine_wrapper�get_coroutine_wrapper�AttributeErrorrx r r Z
debug_wrapperr� r� �RuntimeWarning)rX �enabledZ set_wrapperZ get_wrapper�wrapperZcurrent_wrapperr r r r� � s.
z$BaseEventLoop._set_coroutine_wrapperc C s | j S )N)r� )rX r r r r� � s zBaseEventLoop.get_debugc C s || _ | j� r| j|� d S )N)r� r� r� )rX rI r r r ru � s zBaseEventLoop.set_debug)N)N)NNN)NN)NN)N)r )NN)F)NN)NN)Gr[ re rf rY r\ rD r� r� r� r� r� r� r� r� r r� r� r� r� r� r� r� r� r� rQ r` r� r ZPY34r� r� rr r� r� r� r� r� r� r� r� r� r� rF r� r� r� r r r r6 Z
AI_PASSIVEr r r r r r r r# r% r& r' r1 r� r3 r4 r5 r� r� r� ru r r r r r
� s� !
%
u `
12c!i�Q )1rl Zconcurrent.futuresr� r� �inspectr r= ry r r r� rr r+ rv r� r� r0 r r r r r r r@ r �__all__r6 r7 �BrokenPipeError�ConnectionResetError�ConnectionAbortedErrorZ_FATAL_ERROR_IGNOREr r8 r< r r r& r+ r- rA r) rK rM rS ZAbstractServerrT ZAbstractEventLoopr
r r r r �<module> sT
;
/PK [�f� �I �I & __pycache__/tasks.cpython-36.opt-1.pycnu �[��� 3
\�a �
@ s� d Z ddddddddd d
d d d
g
ZddlZddlZddlZddlZddlZddlm Z ddlm
Z
ddlm Z ddlm Z ddlm
Z
ddl mZ G dd� de
j�ZeZy ddlZW n ek
r� Y n X ej ZZej
jZej
jZej
jZedded�dd��Zdd� Zedd �d d��Zed d � �Zddd �d!d�Z ed/dd �d"d��Z dd �d#d$�Z e e � d < d e _ [ dd �d%d �Z!ed&d'� �Z"G d(d)� d)e
j�Z#dd*d+�d,d
�Z$dd �d-d �Z%d.d
� Z&dS )0z0Support for tasks, coroutines and the scheduler.�Task�FIRST_COMPLETED�FIRST_EXCEPTION�
ALL_COMPLETED�wait�wait_for� as_completed�sleep�async�gather�shield�
ensure_future�run_coroutine_threadsafe� N� )�
base_tasks)�compat)�
coroutines)�events)�futures)� coroutinec s� e Zd ZdZej� Zi ZdZe ddd��Z
e d dd��Z dd�� fd d
�
Z e
jrXd d � Zd
d� Zdd�dd�Zddd�dd�Zdd� Zd � fdd� Zdd� Z� ZS ) r z A coroutine wrapped in a Future.TNc C s |dkrt j� }| jj|�S )z�Return 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.
N)r �get_event_loop�_current_tasks�get)�cls�loop� r �%/usr/lib64/python3.6/asyncio/tasks.py� current_task. s zTask.current_taskc s$ � dkrt j� � � fdd�| jD �S )z|Return a set of all tasks for an event loop.
By default all tasks for the current event loop are returned.
Nc s h | ]}|j � kr|�qS r )�_loop)�.0�t)r r r � <setcomp>B s z!Task.all_tasks.<locals>.<setcomp>)r r �
_all_tasks)r r r )r r � all_tasks: s zTask.all_tasks)r c sN t � j|d� | jr | jd= || _d | _d| _| jj| j� | j j
j | � d S )N)r r F���) �super�__init__�_source_traceback�_coro� _fut_waiter� _must_cancelr � call_soon�_step� __class__r" �add)�self�coror )r- r r r& D s z
Task.__init__c C sH | j tjkr8| jr8| dd�}| jr,| j|d< | jj|� tjj| � d S )Nz%Task was destroyed but it is pending!)�task�messageZsource_traceback) Z_stater Z_PENDING�_log_destroy_pendingr' r Zcall_exception_handler�Future�__del__)r/ �contextr r r r5 S s
z Task.__del__c C s
t j| �S )N)r Z_task_repr_info)r/ r r r �
_repr_info^ s zTask._repr_info)�limitc C s t j| |�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)r/ r8 r r r � get_stacka s zTask.get_stack)r8 �filec C s t j| ||�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)r/ r8 r: r r r � print_stackx s zTask.print_stackc C s4 d| _ | j� rdS | jdk r*| jj� 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_traceback�doner) �cancelr* )r/ r r r r= � s
z Task.cancelc sf | j r t|tj�stj� }d| _ | j}d | _| | jj| j< �zy"|d krT|j d �}n
|j
|�}W n� t k
r� } z.| j r�d| _ | j tj� � n | j
|j� W Y d d }~X �n� tjk
r� t� j� Y �n| tk
r� } z| j |� W Y d d }~X �nP tk
�r( } z| j |� � W Y d d }~X �n X t|dd �}|d k �r�|j| jk �rl| jj| jtdj| |��� n||�r�|| k�r�| jj| jtdj| ��� n2d|_|j| j� || _| j �r�| jj� �r�d| _ n | jj| jtdj| |��� n^|d k�r| jj| j� nDtj |��r.| jj| jtdj| |��� n| jj| jtdj|��� W d | jjj | j� d } X d S )NF�_asyncio_future_blockingz6Task {!r} got Future {!r} attached to a different loopz!Task cannot await on itself: {!r}z;yield was used instead of yield from in task {!r} with {!r}zIyield was used instead of yield from for generator in task {!r} with {!r}zTask got bad yield: {!r}) r* �
isinstancer �CancelledErrorr( r) r- r r �send�throw�
StopIteration�
set_exception�
set_result�valuer% r= � Exception�
BaseException�getattrr+ r, � RuntimeError�formatr> �add_done_callback�_wakeup�inspectZ isgenerator�pop)r/ �excr0 �resultZblocking)r- r r r, � s~
z
Task._stepc C sJ y |j � W n, tk
r8 } z| j|� W Y d d }~X n
X | j� d } d S )N)rQ rG r, )r/ �futurerP r r r rM � s z Task._wakeup)N)N)N)�__name__�
__module__� __qualname__�__doc__�weakref�WeakSetr" r r3 � classmethodr r# r& r ZPY34r5 r7 r9 r; r= r, rM �
__classcell__r r )r- r r s" !T)r �timeout� return_whenc # s� t j| �stj| �r&tdt| �j ��| s2td��|tt t
fkrNtdj |���� dkr^t j
� � � fdd�t| �D �} t| ||� �E dH S )a� Wait for the Futures and coroutines given by fs to complete.
The sequence futures must not be empty.
Coroutines will be wrapped in Tasks.
Returns two sets of Future: (done, pending).
Usage:
done, pending = yield from 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 %sz#Set of coroutines/Futures is empty.z Invalid return_when value: {}Nc s h | ]}t |� d ��qS ))r )r )r �f)r r r r! 7 s zwait.<locals>.<setcomp>)r �isfuturer � iscoroutine� TypeError�typerS �
ValueErrorr r r rK r r �set�_wait)�fsr r[ r\ r )r r r s c G s | j � s| jd � d S )N)r< rE )�waiter�argsr r r �_release_waiter< s rh )r c c s� |dkrt j� }|dkr"| E dH S |j� }|j|t|�}tjt|�}t| |d�} | j|� zhy|E dH W n* t j
k
r� | j |� | j � � Y nX | j
� r�| j� S | j |� | j � t j� �W d|j � 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.
N)r )r r �
create_future�
call_laterrh � functools�partialr rL r r@ �remove_done_callbackr= r< rQ � TimeoutError)�futr[ r rf �timeout_handle�cbr r r r A s,
c # s� |j � �d�|dk r"|j|t���t| �� � ���fdd�}x| D ]}|j|� qBW z�E dH W d�dk rt�j� X t� t� }}x4| D ],}|j|� |j� r�|j |� q�|j |� q�W ||fS )zeInternal helper for wait() and wait_for().
The fs argument must be a collection of Futures.
Nc s\ � d8 � � dks6�t ks6�tkrX| j� rX| j� d k rX�d k rF�j� �j� sX�jd � d S )Nr r )r r � cancelled� exceptionr= r< rE )r] )�counterr\ rp rf r r �_on_completion| s z _wait.<locals>._on_completion)
ri rj rh �lenrL r= rc rm r< r. )re r[ r\ r ru r] r< �pendingr )rt r\ rp rf r rd o s&
rd )r r[ c # s� t j| �stj| �r&tdt| �j ���dk r2�ntj� ��fdd�t | �D ��ddl
m } |�d��d�� ��fdd �}���fd
d �� t �fd d
��}x�D ]}|j
� � q�W �r�|dk rʈj||��x tt���D ] }|� V q�W dS )am Return an iterator whose values are coroutines.
When waiting for the yielded coroutines you'll get the results (or
exceptions!) of the original Futures (or coroutines), in the order
in which and as soon as they complete.
This differs from PEP 3148; the proper way to use this is:
for f in as_completed(fs):
result = yield from f # The 'yield from' may raise.
# Use result.
If a timeout is specified, the 'yield from' will raise
TimeoutError when the timeout occurs before all Futures are done.
Note: The futures 'f' are not necessarily members of fs.
z expect a list of futures, not %sNc s h | ]}t |� d ��qS ))r )r )r r] )r r r r! � s z as_completed.<locals>.<setcomp>r )�Queue)r c s. x �D ]} | j � � �jd � qW �j� d S )N)rm �
put_nowait�clear)r] )ru r< �todor r � _on_timeout� s
z!as_completed.<locals>._on_timeoutc s6 �sd S �j | � � j| � � r2�d k r2�j� d S )N)�removery r= )r] )r< rp r{ r r ru � s
z$as_completed.<locals>._on_completionc 3 s$ � j � E d H } | d kr tj�| j� S )N)r r rn rQ )r] )r< r r �
_wait_for_one� s z#as_completed.<locals>._wait_for_one)r r^ r r_ r` ra rS r r rc Zqueuesrx r rL rj �rangerv )re r r[ rx r| r~ r] �_r )ru r< r rp r{ r r � s
c
c sX | dkrdV |S |dkr"t j� }|j� }|jj| tj||�}z
|E dH S |j� X dS )z9Coroutine that completes after a given time (in seconds).r N)r r ri r rj r Z _set_result_unless_cancelledr= )ZdelayrQ r rR �hr r r r � s
c C s t jdtdd� t| |d�S )z�Wrap a coroutine in a future.
If the argument is a Future, it is returned directly.
This function is deprecated in 3.5. Use asyncio.ensure_future() instead.
z;asyncio.async() function is deprecated, use ensure_future()� )�
stacklevel)r )�warnings�warn�DeprecationWarningr )�coro_or_futurer r r r �async_� s r� c C s� t j| �r(|dk r$|| jk r$td��| S tj| �r^|dkrBtj� }|j| �}|j rZ|j d= |S t
j r~t j
| �r~tt| �|d�S td��dS )zmWrap a coroutine or an awaitable in a future.
If the argument is a Future, it is returned directly.
Nz$loop argument must agree with Futurer )r z:An asyncio.Future, a coroutine or an awaitable is requiredr$ )r r^ r rb r r_ r r Z create_taskr' r ZPY35rN Z isawaitabler �_wrap_awaitabler` )r� r r1 r r r r � s
c c s | j � E dH S )z�Helper 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 )�_GatheringFuturez�Helper for gather().
This overrides cancel() to cancel all the children and act more
like Task.cancel(), which doesn't immediately mark itself as
cancelled.
N)r c s t � j|d� || _d| _d S )N)r F)r% r& � _children�_cancel_requested)r/ �childrenr )r- r r r& $ s z_GatheringFuture.__init__c C s: | j � r dS d}x| jD ]}|j� rd}qW |r6d| _|S )NFT)r< r� r= r� )r/ ZretZchildr r r r= ) s z_GatheringFuture.cancel)rS rT rU rV r& r= rZ r r )r- r r� s r� F)r �return_exceptionsc s |s*| dkrt j� } | j� ��jg � �S i � xjt|�D ]^}tj|�sht|| d�}| dkr`|j} d|_ n&|}| dkr||j} n|j| k r�t
d��|� |< q8W � fdd�|D �}t |��t || d��d�dg� ������fdd �}x&t
|�D ]\}}|jtj||�� q�W �S )
a7 Return a future aggregating results from the given coroutines
or 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.)
N)r Fz)futures are tied to different event loopsc s g | ] }� | �qS r r )r �arg)�
arg_to_futr r �
<listcomp>h s zgather.<locals>.<listcomp>r c s� �j � r |j� s|j� d S |j� r@tj� }�sl�j|� d S n,|jd k rf|j� }�sl�j|� d S n|j}|�| < �d7 ��� kr��jr��jtj� � n
�j �� d S )Nr )
r< rr rs r r@ rD Z
_exceptionZ_resultr� rE )�iro �res)� nchildren� nfinished�outer�resultsr� r r �_done_callbackn s*
z gather.<locals>._done_callback)r r ri rE rc r r^ r r r3 rb rv r� � enumeraterL rk rl )r r� Zcoros_or_futuresr� ro r� r� r� r )r� r� r� r� r� r� r r
8 s8
c s@ t | |d�}|j� r|S |j}|j� � � fdd�}|j|� � S )a= Wait for a future, shielding it from cancellation.
The statement
res = yield from shield(something())
is exactly equivalent to the statement
res = yield from 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 = yield from shield(something())
except CancelledError:
res = None
)r c s\ � j � r | j � s| j� d S | j � r.� j� n*| j� }|d k rJ� j|� n� j| j� � d S )N)rr rs r= rD rE rQ )�innerrP )r� r r r� � s
z shield.<locals>._done_callback)r r< r ri rL )r� r r� r� r )r� r r � s
c s: t j� �std��tjj� �� ��fdd�}�j|� �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 sT yt jt� �d��� W n6 tk
rN } z�j� r<�j| � � W Y d d } ~ X nX d S )N)r )r Z
_chain_futurer rG Z set_running_or_notify_cancelrD )rP )r0 rR r r r �callback� s
z*run_coroutine_threadsafe.<locals>.callback)r r_ r` �
concurrentr r4 Zcall_soon_threadsafe)r0 r r� r )r0 rR r r r
� s
)N)'rV �__all__Zconcurrent.futuresr� rk rN r� rW � r r r r r r r4 r Z_PyTaskZ_asyncio� ImportErrorZ_CTaskr r r r rh r rd r r r� �globalsrS r r� r� r
r r
r r r r �<module> sZ
s
- -8
W5PK [�X��" �" & __pycache__/locks.cpython-36.opt-2.pycnu �[��� 3
\�< � @ s� d ddddgZ ddlZddlmZ dd lmZ dd
lmZ dd lmZ G d d
� d
�ZG dd� d�Z G dd � d e �Z
G dd� d�Z G dd� de �Z G dd� de �Z
G dd� de
�ZdS )�Lock�Event� Condition� Semaphore�BoundedSemaphore� N� )�compat)�events)�futures)� coroutinec @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�_ContextManagerc C s
|| _ d S )N)�_lock)�self�lock� r �%/usr/lib64/python3.6/asyncio/locks.py�__init__ s z_ContextManager.__init__c C s d S )Nr )r r r r � __enter__ s z_ContextManager.__enter__c G s z| j j� W d d | _ X d S )N)r
�release)r �argsr r r �__exit__$ s z_ContextManager.__exit__N)�__name__�
__module__� __qualname__r r r r r r r r
s r c @ sN e Zd Zdd� Zdd� Zedd� �ZejrJdd� Z ed d
� �Z
ed d � �Z d
S )�_ContextManagerMixinc C s t d��d S )Nz9"yield from" should be used as context manager expression)� RuntimeError)r r r r r , s z _ContextManagerMixin.__enter__c G s d S )Nr )r r r r r r 0 s z _ContextManagerMixin.__exit__c c s | j � E d H t| �S )N)�acquirer )r r r r �__iter__5 s z _ContextManagerMixin.__iter__c c s | j � E d H t| �S )N)r r )r r r r � __await__H s z _ContextManagerMixin.__await__c c s | j � E d H d S )N)r )r r r r �
__aenter__M s z _ContextManagerMixin.__aenter__c C s | j � d S )N)r )r �exc_type�exc�tbr r r � __aexit__T s z _ContextManagerMixin.__aexit__N) r r r r r r r r ZPY35r r r# r r r r r + s r c sN e Zd Zdd�dd�Z� fdd�Zdd� Zed d
� �Zd d � Zd
d� Z � Z
S )r N)�loopc C s. t j� | _d| _|d k r || _n
tj� | _d S )NF)� collections�deque�_waiters�_locked�_loopr �get_event_loop)r r$ r r r r � s
z
Lock.__init__c sD t � j� }| jrdnd}| jr0dj|t| j��}dj|dd� |�S )N�locked�unlockedz
{},waiters:{}z <{} [{}]>r ���)�super�__repr__r( r' �format�len)r �res�extra)� __class__r r r/ � s
z
Lock.__repr__c C s | j S )N)r( )r r r r r+ � s z Lock.lockedc c s� | j r&tdd� | jD ��r&d| _ dS | jj� }| jj|� y"z|E d H W d | jj|� X W n& tjk
r� | j s~| j � � Y nX d| _ dS )Nc s s | ]}|j � V qd S )N)� cancelled)�.0�wr r r � <genexpr>� s z Lock.acquire.<locals>.<genexpr>T)
r( �allr' r) �
create_future�append�remover
�CancelledError�_wake_up_first)r �futr r r r � s
z Lock.acquirec C s" | j rd| _ | j� ntd��d S )NFzLock is not acquired.)r( r> r )r r r r r � s
z Lock.releasec C s> yt t| j��}W n tk
r& d S X |j� s:|jd� d S )NT)�next�iterr' �
StopIteration�done�
set_result)r r? r r r r> � s zLock._wake_up_first) r r r r r/ r+ r r r r> �
__classcell__r r )r4 r r Y s 6 c sN e Zd Zdd�dd�Z� fdd�Zdd� Zd d
� Zd d � Zed
d� �Z � Z
S )r N)r$ c C s. t j� | _d| _|d k r || _n
tj� | _d S )NF)r% r& r' �_valuer) r r* )r r$ r r r r � s
zEvent.__init__c sD t � j� }| jrdnd}| jr0dj|t| j��}dj|dd� |�S )N�setZunsetz
{},waiters:{}z <{} [{}]>r r- )r. r/ rF r' r0 r1 )r r2 r3 )r4 r r r/ � s
zEvent.__repr__c C s | j S )N)rF )r r r r �is_set� s z Event.is_setc C s2 | j s.d| _ x | jD ]}|j� s|jd� qW d S )NT)rF r' rC rD )r r? r r r rG � s
z Event.setc C s
d| _ d S )NF)rF )r r r r �clear s z Event.clearc c sB | j r
dS | jj� }| jj|� z|E d H dS | jj|� X d S )NT)rF r) r: r' r; r< )r r? r r r �wait
s
z
Event.wait) r r r r r/ rH rG rI r rJ rE r r )r4 r r � s c sV e Zd Zddd�dd�Z� fdd�Zedd� �Zed d
� �Zdd d
�Zdd� Z � Z
S )r N)r$ c C sp |d k r|| _ n
tj� | _ |d kr0t| j d�}n|j | j k rDtd��|| _|j| _|j| _|j| _t j
� | _ d S )N)r$ z"loop argument must agree with lock) r) r r* r �
ValueErrorr
r+ r r r% r& r' )r r r$ r r r r + s
zCondition.__init__c sF t � j� }| j� rdnd}| jr2dj|t| j��}dj|dd� |�S )Nr+ r, z
{},waiters:{}z <{} [{}]>r r- )r. r/ r+ r' r0 r1 )r r2 r3 )r4 r r r/ > s
zCondition.__repr__c c s� | j � std��| j� z8| jj� }| jj|� z|E d H dS | jj|� X W d d}x4y| j� E d H P W qX t j
k
r� d}Y qXX qXW |r�t j
�X d S )Nz cannot wait on un-acquired lockTF) r+ r r r) r: r' r; r< r r
r= )r r? r5 r r r rJ E s&
zCondition.waitc c s( |� }x |s"| j � E d H |� }qW |S )N)rJ )r Z predicate�resultr r r �wait_fork s
zCondition.wait_forr c C sL | j � std��d}x2| jD ](}||kr*P |j� s |d7 }|jd� q W d S )Nz!cannot notify on un-acquired lockr r F)r+ r r' rC rD )r �n�idxr? r r r �notifyy s zCondition.notifyc C s | j t| j�� d S )N)rP r1 r' )r r r r �
notify_all� s zCondition.notify_all)N)r ) r r r r r/ r rJ rM rP rQ rE r r )r4 r r ! s
&
c sP e Zd Zddd�dd�Z� fdd�Zdd � Zd
d � Zed d
� �Zdd� Z � Z
S )r r N)r$ c C s> |dk rt d��|| _tj� | _|d k r0|| _n
tj� | _d S )Nr z$Semaphore initial value must be >= 0)rK rF r% r& r' r) r r* )r �valuer$ r r r r � s
zSemaphore.__init__c sN t � j� }| j� rdn
dj| j�}| jr:dj|t| j��}dj|dd� |�S )Nr+ zunlocked,value:{}z
{},waiters:{}z <{} [{}]>r r- )r. r/ r+ r0 rF r' r1 )r r2 r3 )r4 r r r/ � s
zSemaphore.__repr__c C s0 x*| j r*| j j� }|j� s|jd � d S qW d S )N)r' �popleftrC rD )r Zwaiterr r r �
_wake_up_next� s
zSemaphore._wake_up_nextc C s
| j dkS )Nr )rF )r r r r r+ � s zSemaphore.lockedc c sz xf| j dkrf| jj� }| jj|� y|E d H W q |j� | j dkr\|j� r\| j� � Y qX qW | j d8 _ dS )Nr r T)rF r) r: r' r; Zcancelr5 rT )r r? r r r r � s
zSemaphore.acquirec C s | j d7 _ | j� d S )Nr )rF rT )r r r r r � s zSemaphore.release)r ) r r r r r/ rT r+ r r r rE r r )r4 r r � s
c s0 e Zd Zddd�� fdd� Z� fdd�Z� ZS ) r r N)r$ c s || _ t� j||d� d S )N)r$ )� _bound_valuer. r )r rR r$ )r4 r r r � s zBoundedSemaphore.__init__c s" | j | jkrtd��t� j� d S )Nz(BoundedSemaphore released too many times)rF rU rK r. r )r )r4 r r r � s zBoundedSemaphore.release)r )r r r r r rE r r )r4 r r � s )�__all__r% � r r r
Z
coroutinesr r r r r r r r r r r r �<module> s . ByMPK [ ��o�5 �5 " __pycache__/futures.cpython-36.pycnu �[��� 3
\ > � @ s
d Z ddddddgZddlZddlZddlZddlZd d
lmZ d d lm Z d d lm
Z
ej Z ej Z ej
Z
ejZejZejZejZejd ZG d
d� d�ZG dd� d�ZeZdd� Zdd� Zdd� Zdd� Zdd�dd�Zy ddl Z W n e k
r� Y n X e j ZZ dS )z.A Future class similar to the one in PEP 3148.�CancelledError� TimeoutError�InvalidStateError�Future� wrap_future�isfuture� N� )� base_futures)�compat)�eventsc @ s4 e Zd ZdZdZdd� Zdd � Zd
d � Zd d
� ZdS )�_TracebackLoggera
Helper to log a traceback upon destruction if not cleared.
This solves a nasty problem with Futures and Tasks that have an
exception set: if nobody asks for the exception, the exception is
never logged. This violates the Zen of Python: 'Errors should
never pass silently. Unless explicitly silenced.'
However, we don't want to log the exception as soon as
set_exception() is called: if the calling code is written
properly, it will get the exception and handle it properly. But
we *do* want to log it if result() or exception() was never called
-- otherwise developers waste a lot of time wondering why their
buggy code fails silently.
An earlier attempt added a __del__() method to the Future class
itself, but this backfired because the presence of __del__()
prevents garbage collection from breaking cycles. A way out of
this catch-22 is to avoid having a __del__() method on the Future
class itself, but instead to have a reference to a helper object
with a __del__() method that logs the traceback, where we ensure
that the helper object doesn't participate in cycles, and only the
Future has a reference to it.
The helper object is added when set_exception() is called. When
the Future is collected, and the helper is present, the helper
object is also collected, and its __del__() method will log the
traceback. When the Future's result() or exception() method is
called (and a helper object is present), it removes the helper
object, after calling its clear() method to prevent it from
logging.
One downside is that we do a fair amount of work to extract the
traceback from the exception, even when it is never logged. It
would seem cheaper to just store the exception object, but that
references the traceback, which references stack frames, which may
reference the Future, which references the _TracebackLogger, and
then the _TracebackLogger would be included in a cycle, which is
what we're trying to avoid! As an optimization, we don't
immediately format the exception; we only do the work when
activate() is called, which call is delayed until after all the
Future's callbacks have run. Since usually a Future has at least
one callback (typically set by 'yield from') and usually that
callback extracts the callback, thereby removing the need to
format the exception.
PS. I don't claim credit for this solution. I first heard of it
in a discussion about closing files when they are collected.
�loop�source_traceback�exc�tbc C s |j | _|j| _|| _d | _d S )N)�_loopr
�_source_tracebackr r r )�self�futurer � r �'/usr/lib64/python3.6/asyncio/futures.py�__init__R s z_TracebackLogger.__init__c C s, | j }|d k r(d | _ tj|j||j�| _d S )N)r � traceback�format_exception� __class__�
__traceback__r )r r r r r �activateX s
z_TracebackLogger.activatec C s d | _ d | _d S )N)r r )r r r r �clear_ s z_TracebackLogger.clearc C sb | j r^d}| jr:djtj| j��}|d7 }|d|j� 7 }|dj| j �j� 7 }| jjd|i� d S )Nz*Future/Task exception was never retrieved
� z0Future/Task created at (most recent call last):
z%s
�message)r r �joinr � format_list�rstripr
�call_exception_handler)r �msg�srcr r r �__del__c s z_TracebackLogger.__del__N)r
r r r ) �__name__�
__module__� __qualname__�__doc__� __slots__r r r r& r r r r r s 0r c @ s� e Zd ZdZeZdZdZdZdZ dZ
dZ dd�dd�Z e
jZdd� ZejrRd d
� Zd d � Zd
d� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd � Z d d � Z d d � Z ej r�e Z dS )!r a, This class is *almost* compatible with concurrent.futures.Future.
Differences:
- This class is not thread-safe.
- result() and exception() do not take a timeout argument and
raise an exception when the future isn't done yet.
- Callbacks registered with add_done_callback() are always called
via the event loop's call_soon().
- This class is not compatible with the wait() and as_completed()
methods in the concurrent.futures package.
(In Python 3.4 or later we may be able to unify the implementations.)
NF)r
c C s@ |dkrt j� | _n|| _g | _| jj� r<t jtjd��| _dS )z�Initialize the future.
The optional event_loop argument allows explicitly setting the event
loop object used by the future. If it's not provided, the future uses
the default event loop.
Nr ) r �get_event_loopr �
_callbacksZ get_debug�
extract_stack�sys� _getframer )r r
r r r r � s
zFuture.__init__c C s d| j jdj| j� �f S )Nz<%s %s>� )r r' r �
_repr_info)r r r r �__repr__� s zFuture.__repr__c C sD | j s
d S | j}d| jj || d�}| jr4| j|d< | jj|� d S )Nz %s exception was never retrieved)r � exceptionr r )�_log_traceback�
_exceptionr r' r r r# )r r �contextr r r r& � s
zFuture.__del__c C s& d| _ | jtkrdS t| _| j� dS )z�Cancel the future and schedule callbacks.
If the future is already done or cancelled, return False. Otherwise,
change the future's state to cancelled, schedule the callbacks and
return True.
FT)r5 �_state�_PENDING�
_CANCELLED�_schedule_callbacks)r r r r �cancel� s
z
Future.cancelc C sD | j dd� }|sdS g | j dd�< x|D ]}| jj|| � q*W dS )z�Internal: Ask the event loop to call all callbacks.
The callbacks are scheduled to be called as soon as possible. Also
clears the callback list.
N)r- r � call_soon)r Z callbacks�callbackr r r r; � s
zFuture._schedule_callbacksc C s
| j tkS )z(Return True if the future was cancelled.)r8 r: )r r r r � cancelled� s zFuture.cancelledc C s
| j tkS )z�Return True if the future is done.
Done means either that a result / exception are available, or that the
future was cancelled.
)r8 r9 )r r r r �done� s z Future.donec C s< | j tkrt�| j tkr td��d| _| jdk r6| j�| jS )a Return the result this future represents.
If the future has been cancelled, raises CancelledError. If the
future's result isn't yet available, raises InvalidStateError. If
the future is done and has an exception set, this exception is raised.
zResult is not ready.FN)r8 r: r � _FINISHEDr r5 r6 �_result)r r r r �result� s
z
Future.resultc C s, | j tkrt�| j tkr td��d| _| jS )a& Return the exception that was set on this future.
The exception (or None if no exception was set) is returned only if
the future is done. If the future has been cancelled, raises
CancelledError. If the future isn't done yet, raises
InvalidStateError.
zException is not set.F)r8 r: r rA r r5 r6 )r r r r r4 � s
zFuture.exceptionc C s* | j tkr| jj|| � n | jj|� dS )z�Add a callback to be run when the future becomes done.
The callback is called with a single argument - the future object. If
the future is already done when this is called, the callback is
scheduled with call_soon.
N)r8 r9 r r= r- �append)r �fnr r r �add_done_callback s
zFuture.add_done_callbackc s< � fdd�| j D �}t| j �t|� }|r8|| j dd�< |S )z}Remove all instances of a callback from the "call when done" list.
Returns the number of callbacks removed.
c s g | ]}|� kr|�qS r r )�.0�f)rE r r �
<listcomp> s z/Future.remove_done_callback.<locals>.<listcomp>N)r- �len)r rE Zfiltered_callbacksZ
removed_countr )rE r �remove_done_callback s
zFuture.remove_done_callbackc C s4 | j tkr tdj| j | ���|| _t| _ | j� dS )z�Mark the future done and set its result.
If the future is already done when this method is called, raises
InvalidStateError.
z{}: {!r}N)r8 r9 r �formatrB rA r; )r rC r r r �
set_result s
zFuture.set_resultc C s� | j tkr tdj| j | ���t|t�r,|� }t|�tkr@td��|| _t | _ | j
� t j rbd| _
n t| |�| _| jj| jj� dS )z�Mark the future done and set an exception.
If the future is already done when this method is called, raises
InvalidStateError.
z{}: {!r}zPStopIteration interacts badly with generators and cannot be raised into a FutureTN)r8 r9 r rL �
isinstance�type�
StopIteration� TypeErrorr6 rA r; r
�PY34r5 r Z
_tb_loggerr r= r )r r4 r r r �
set_exception, s
zFuture.set_exceptionc c s, | j � sd| _| V | j � s$td��| j� S )NTz"yield from wasn't used with future)r@ �_asyncio_future_blocking�AssertionErrorrC )r r r r �__iter__D s
zFuture.__iter__)!r' r( r) r* r9 r8 rB r6 r r rT r5 r r Z_future_repr_infor2 r3 r
rR r& r< r; r? r@ rC r4 rF rK rM rS rV ZPY35� __await__r r r r r n s4
c C s | j � r dS | j|� dS )z?Helper setting the result only if the future was not cancelled.N)r? rM )ZfutrC r r r � _set_result_unless_cancelledS s rX c C sZ |j � s t�|j� r | j� | j� s(dS |j� }|dk rD| j|� n|j� }| j|� dS )z8Copy state from a future to a concurrent.futures.Future.N) r@ rU r? r< Z set_running_or_notify_cancelr4 rS rC rM )�
concurrent�sourcer4 rC r r r � _set_concurrent_future_stateZ s r[ c C sj | j � s t�|j� rdS |j � s&t�| j� r8|j� n.| j� }|dk rT|j|� n| j� }|j|� dS )zqInternal helper to copy state from another Future.
The other Future may be a concurrent.futures.Future.
N)r@ rU r? r< r4 rS rC rM )rZ �destr4 rC r r r �_copy_future_statei s
r] c s� t �� r"t�tjj� r"td��t �� rDt�tjj� rDtd��t ��rR�jnd�t ��rd�jnd�dd� � ���fdd�}� ���fdd �}�j|� �j|� dS )
a Chain two futures so that when one completes, so does the other.
The result (or exception) of source will be copied to destination.
If destination is cancelled, source gets cancelled too.
Compatible with both asyncio.Future and concurrent.futures.Future.
z(A future is required for source argumentz-A future is required for destination argumentNc S s" t | �rt|| � n
t| |� d S )N)r r] r[ )r �otherr r r �
_set_state� s z!_chain_future.<locals>._set_statec s2 | j � r.�d ks�� kr"�j� n �j�j� d S )N)r? r< �call_soon_threadsafe)� destination)� dest_looprZ � source_loopr r �_call_check_cancel� s
z)_chain_future.<locals>._call_check_cancelc sJ �j � r �d k r �j� r d S �d ks,��kr8� �| � n�j� �| � d S )N)r? Z is_closedr` )rZ )r_ rb ra rc r r �_call_set_state� s z&_chain_future.<locals>._call_set_state)r rN rY �futuresr rQ r rF )rZ ra rd re r )r_ rb ra rZ rc r �
_chain_future} s
rg )r
c C sN t | �r | S t| tjj�s(tdj| ���|dkr8tj� }|j � }t
| |� |S )z&Wrap concurrent.futures.Future object.z/concurrent.futures.Future is expected, got {!r}N) r rN rY rf r rU rL r r, Z
create_futurerg )r r
Z
new_futurer r r r � s
) r* �__all__Zconcurrent.futuresrY Zloggingr/ r r r r
r r r r r r9 r: rA �DEBUGZ STACK_DEBUGr r Z _PyFuturerX r[ r] rg r Z_asyncio� ImportErrorZ_CFuturer r r r �<module> s>
P c*
PK [�%�O�S �S ) __pycache__/windows_events.cpython-36.pycnu �[��� 3
\�l � @ s� d Z ddlZddlZddlZddlZddlZddlZddlmZ ddlm Z ddlm
Z
ddlm Z ddlm Z dd lm
Z
dd
lmZ dd lmZ dd lmZ dd
lmZ ddddgZdZdZdZdZdZdZG dd� de
j�Z G dd� de
j�Z G dd � d e �Z G d d � d e �Z G d d � d e �Z!G d!d"� d"e j"�Z#G d#d� de j$�Z%G d$d� d�Z&G d%d&� d&e j'�Z(e#Z)G d'd(� d(ej*�Z+e+Z,dS ))z.Selector and proactor event loops for Windows.� N� )�events)�base_subprocess)�futures)�proactor_events)�selector_events)�tasks)�
windows_utils)� _overlapped)� coroutine)�logger�SelectorEventLoop�ProactorEventLoop� IocpProactor�DefaultEventLoopPolicyl �� i� i� g����MbP?g�������?c s^ e Zd ZdZdd�� fdd�
Z� fdd�Zdd � Z� fd
d �Z� fd d
�Z� fdd�Z � Z
S )�_OverlappedFuturez�Subclass of Future which represents an overlapped operation.
Cancelling it will immediately cancel the overlapped operation.
N)�loopc s& t � j|d� | jr | jd= || _d S )N)r r ���)�super�__init__�_source_traceback�_ov)�self�ovr )� __class__� �./usr/lib64/python3.6/asyncio/windows_events.pyr - s z_OverlappedFuture.__init__c s@ t � j� }| jd k r<| jjr dnd}|jdd|| jjf � |S )N�pendingZ completedr zoverlapped=<%s, %#x>)r �
_repr_infor r �insert�address)r �info�state)r r r r 3 s
z _OverlappedFuture._repr_infoc C sr | j d krd S y| j j� W nJ tk
rf } z.d|| d�}| jrJ| j|d< | jj|� W Y d d }~X nX d | _ d S )Nz&Cancelling an overlapped future failed)�message� exception�future�source_traceback)r �cancel�OSErrorr �_loop�call_exception_handler)r �exc�contextr r r �_cancel_overlapped: s
z$_OverlappedFuture._cancel_overlappedc s | j � t� j� S )N)r- r r' )r )r r r r' J s z_OverlappedFuture.cancelc s t � j|� | j� d S )N)r �
set_exceptionr- )r r$ )r r r r. N s z _OverlappedFuture.set_exceptionc s t � j|� d | _d S )N)r �
set_resultr )r �result)r r r r/ R s z _OverlappedFuture.set_result) �__name__�
__module__� __qualname__�__doc__r r r- r' r. r/ �
__classcell__r r )r r r ' s r c sn e Zd ZdZdd�� fdd�
Zdd� Z� fdd �Zd
d � Zd d
� Z� fdd�Z � fdd�Z
� fdd�Z � Z S )�_BaseWaitHandleFuturez2Subclass of Future which represents a wait handle.N)r c s8 t � j|d� | jr | jd= || _|| _|| _d| _d S )N)r r Tr )r r r r �_handle� _wait_handle� _registered)r r �handle� wait_handler )r r r r Z s z _BaseWaitHandleFuture.__init__c C s t j| jd�t jkS )Nr )�_winapiZWaitForSingleObjectr7 Z
WAIT_OBJECT_0)r r r r �_pollh s z_BaseWaitHandleFuture._pollc s\ t � j� }|jd| j � | jd k r>| j� r0dnd}|j|� | jd k rX|jd| j � |S )Nz
handle=%#xZsignaledZwaitingzwait_handle=%#x)r r �appendr7 r= r8 )r r! r" )r r r r m s
z _BaseWaitHandleFuture._repr_infoc C s
d | _ d S )N)r )r �futr r r �_unregister_wait_cbw s z)_BaseWaitHandleFuture._unregister_wait_cbc C s� | j s
d S d| _ | j}d | _ytj|� W nZ tk
r� } z>|jtjkrtd|| d�}| jrd| j|d< | jj |� d S W Y d d }~X nX | j
d � d S )NFz$Failed to unregister the wait handle)r# r$ r% r& ) r9 r8 r
ZUnregisterWaitr( �winerror�ERROR_IO_PENDINGr r) r* r@ )r r; r+ r, r r r �_unregister_wait| s"
z&_BaseWaitHandleFuture._unregister_waitc s | j � t� j� S )N)rC r r' )r )r r r r' � s z _BaseWaitHandleFuture.cancelc s | j � t� j|� d S )N)rC r r. )r r$ )r r r r. � s z#_BaseWaitHandleFuture.set_exceptionc s | j � t� j|� d S )N)rC r r/ )r r0 )r r r r/ � s z _BaseWaitHandleFuture.set_result)
r1 r2 r3 r4 r r= r r@ rC r' r. r/ r5 r r )r r r6 W s
r6 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.
N)r c s t � j||||d� d | _d S )N)r )r r �_done_callback)r r �eventr; r )r r r r � s z_WaitCancelFuture.__init__c C s t d��d S )Nz'_WaitCancelFuture must not be cancelled)� RuntimeError)r r r r r' � s z_WaitCancelFuture.cancelc s$ t � j|� | jd k r | j| � d S )N)r r/ rE )r r0 )r r r r/ � s
z _WaitCancelFuture.set_resultc s$ t � j|� | jd k r | j| � d S )N)r r. rE )r r$ )r r r r. � s
z _WaitCancelFuture.set_exception) r1 r2 r3 r4 r r' r/ r. r5 r r )r r rD � s
rD c s6 e Zd Zdd�� fdd�
Z� fdd�Zdd� Z� ZS ) �_WaitHandleFutureN)r c s< t � j||||d� || _d| _tjd ddd �| _d | _d S )N)r TF)r r � _proactorZ_unregister_proactorr
Z CreateEvent�_event�
_event_fut)r r r: r; �proactorr )r r r r � s
z_WaitHandleFuture.__init__c sF | j d k r"tj| j � d | _ d | _| jj| j� d | _t� j|� d S )N) rJ r< � CloseHandlerK rI � _unregisterr r r@ )r r? )r r r r@ � s
z%_WaitHandleFuture._unregister_wait_cbc C s� | j s
d S d| _ | j}d | _ytj|| j� W nZ tk
r� } z>|jtjkrxd|| d�}| jrh| j|d< | j j
|� d S W Y d d }~X nX | j j | j| j
�| _d S )NFz$Failed to unregister the wait handle)r# r$ r% r& )r9 r8 r
ZUnregisterWaitExrJ r( rA rB r r) r* rI � _wait_cancelr@ rK )r r; r+ r, r r r rC � s$
z"_WaitHandleFuture._unregister_wait)r1 r2 r3 r r@ rC r5 r r )r r rH � s rH 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, || _ tj� | _d | _d | _| jd�| _d S )NT)�_address�weakref�WeakSet�_free_instances�_pipe�_accept_pipe_future�_server_pipe_handle)r r r r r r � s
zPipeServer.__init__c C s | j | jd� }| _ |S )NF)rU rW )r �tmpr r r �_get_unconnected_pipe� s z PipeServer._get_unconnected_pipec C sr | j � r d S tjtjB }|r&|tjO }tj| j|tjtjB tj B tj
t j t j tj
tj�}t j|�}| jj|� |S )N)�closedr< ZPIPE_ACCESS_DUPLEXZFILE_FLAG_OVERLAPPEDZ FILE_FLAG_FIRST_PIPE_INSTANCEZCreateNamedPiperQ ZPIPE_TYPE_MESSAGEZPIPE_READMODE_MESSAGEZ PIPE_WAITZPIPE_UNLIMITED_INSTANCESr ZBUFSIZEZNMPWAIT_WAIT_FOREVER�NULL�
PipeHandlerT �add)r �first�flags�h�piper r r rW s
z PipeServer._server_pipe_handlec C s
| j d kS )N)rQ )r r r r rZ s zPipeServer.closedc C sV | j d k r| j j� d | _ | jd k rRx| jD ] }|j� q,W d | _d | _| jj� d S )N)rV r' rQ rT �closerU �clear)r ra r r r rb s
zPipeServer.closeN)
r1 r2 r3 r4 r rY rW rZ rb �__del__r r r r rP � s
rP c @ s e Zd ZdZdd� ZdS )�_WindowsSelectorEventLoopz'Windows version of selector event loop.c C s t j� S )N)r �
socketpair)r r r r � _socketpair+ s z%_WindowsSelectorEventLoop._socketpairN)r1 r2 r3 r4 rg r r r r re ( s re c sP e Zd ZdZd
� fdd� Zdd� Zedd� �Zed d
� �Zedd d ��Z � Z
S )r z2Windows version of proactor event loop using IOCP.Nc s |d krt � }t� j|� d S )N)r r r )r rL )r r r r 2 s zProactorEventLoop.__init__c C s t j� S )N)r rf )r r r r rg 7 s z ProactorEventLoop._socketpairc c s8 | j j|�}|E d H }|� }| j||d|id�}||fS )N�addr)�extra)rI � connect_pipe�_make_duplex_pipe_transport)r �protocol_factoryr �fra �protocol�transr r r �create_pipe_connection: s
z(ProactorEventLoop.create_pipe_connectionc s. t � ��d� ����fdd� ��j�� �gS )Nc s d }yj| rL| j � }�jj|� �j� r2|j� d S �� }�j||d� id� �j� }|d kr`d S �jj|�} W n� t k
r� } zH|r�|j
� d kr��j d||d�� |j� n�j r�t
jd|dd� W Y d d }~X n2 tjk
r� |r�|j� Y nX | �_| j�� d S )
Nrh )ri r zPipe accept failed)r# r$ ra z Accept pipe failed on pipe %rT)�exc_infor )r0 rT �discardrZ rb rk rY rI � accept_piper( �filenor* Z_debugr Zwarningr �CancelledErrorrV �add_done_callback)rm ra rn r+ )r �loop_accept_piperl r �serverr r rw G s<
z>ProactorEventLoop.start_serving_pipe.<locals>.loop_accept_pipe)N)rP Z call_soon)r rl r r )r rw rl r rx r �start_serving_pipeC s (
z$ProactorEventLoop.start_serving_pipec k s� | j � }
t| |||||||f|
|d�| ��} y|
E d H W n& tk
r` } z
| }
W Y d d } ~ X nX d }
|
d k r�| j� | j� E d H |
�| S )N)�waiterri )�
create_future�_WindowsSubprocessTransport� Exceptionrb Z_wait)r rn �args�shell�stdin�stdout�stderr�bufsizeri �kwargsrz Ztranspr+ �errr r r �_make_subprocess_transportr s
z,ProactorEventLoop._make_subprocess_transport)N)N) r1 r2 r3 r4 r rg r rp ry r� r5 r r )r r r / s /c @ s� e Zd ZdZd1dd�Zdd� Zdd� Zd2d
d �Zd d
� Zd3dd�Z d4dd�Z
dd� Z dd� Z dd� Z
edd� �Zd5dd �Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd6d)d*�Zd+d,� Zd-d.� Zd/d0� Zd S )7r z#Proactor implementation using IOCP.� �� c C sD d | _ g | _tjtjtd|�| _i | _tj � | _
g | _ tj � | _ d S )Nr )
r) �_resultsr
�CreateIoCompletionPort�INVALID_HANDLE_VALUEr[ �_iocp�_cacherR rS r9 �
_unregistered�_stopped_serving)r Z concurrencyr r r r � s
zIocpProactor.__init__c C s d| j jt| j�t| j�f S )Nz <%s overlapped#=%s result#=%s>)r r1 �lenr� r� )r r r r �__repr__� s zIocpProactor.__repr__c C s
|| _ d S )N)r) )r r r r r �set_loop� s zIocpProactor.set_loopNc C s | j s| j|� | j }g | _ |S )N)r� r= )r �timeoutrX r r r �select� s
zIocpProactor.selectc C s | j j� }|j|� |S )N)r) r{ r/ )r �valuer? r r r �_result� s
zIocpProactor._resultr c C sz | j |� tjt�}y4t|tj�r6|j|j� ||� n|j|j� |� W n t k
rb | j
d�S X dd� }| j |||�S )N� c S sJ y|j � S tk
rD } z |jtjkr2t|j� �n� W Y d d }~X nX d S )N)� getresultr( rA r
�ERROR_NETNAME_DELETED�ConnectionResetErrorr~ )ro �keyr r+ r r r � finish_recv� s z&IocpProactor.recv.<locals>.finish_recv) �_register_with_iocpr
�
Overlappedr[ �
isinstance�socketZWSARecvrt ZReadFile�BrokenPipeErrorr� � _register)r �conn�nbytesr_ r r� r r r �recv� s
zIocpProactor.recvc C sZ | j |� tjt�}t|tj�r4|j|j� ||� n|j|j� |� dd� }| j |||�S )Nc S sJ y|j � S tk
rD } z |jtjkr2t|j� �n� W Y d d }~X nX d S )N)r� r( rA r
r� r� r~ )ro r� r r+ r r r � finish_send� s z&IocpProactor.send.<locals>.finish_send)
r� r
r� r[ r� r� ZWSASendrt Z WriteFiler� )r r� �bufr_ r r� r r r �send� s
zIocpProactor.sendc sz | j �� | j�j�� tjt�}|j�j� � j� � � �fdd�}tdd� �}| j |�|�}||� �}t
j || j d� |S )Nc sD |j � tjd�j� �}� jtjtj|� � j �j
� � � � j � fS )Nz@P) r� �structZpackrt �
setsockoptr� �
SOL_SOCKETr
ZSO_UPDATE_ACCEPT_CONTEXT�
settimeoutZ
gettimeoutZ getpeername)ro r� r r� )r� �listenerr r �
finish_accept� s
z*IocpProactor.accept.<locals>.finish_acceptc s s4 y| E d H W n t jk
r. |j� � Y nX d S )N)r ru rb )r% r� r r r � accept_coro� s
z(IocpProactor.accept.<locals>.accept_coro)r )
r� �_get_accept_socket�familyr
r� r[ ZAcceptExrt r r� r Z
ensure_futurer) )r r� r r� r� r% �coror )r� r� r �accept� s
zIocpProactor.acceptc s� | j � � ytj� j� � j� W nB tk
rb } z&|jtjkr@� � j � d dkrR� W Y d d }~X nX tj
t �}|j � j� |� � fdd�}| j
|� |�S )Nr r c s |j � � jtjtjd� � S )Nr )r� r� r� r� r
ZSO_UPDATE_CONNECT_CONTEXT)ro r� r )r� r r �finish_connect s
z,IocpProactor.connect.<locals>.finish_connect)r� r
Z BindLocalrt r� r( rA �errnoZ WSAEINVALZ getsocknamer� r[ Z ConnectExr� )r r� r �er r� r )r� r �connect� s
zIocpProactor.connectc sJ | j � � tjt�}|j� j� �}|r0| j� �S � fdd�}| j|� |�S )Nc s |j � � S )N)r� )ro r� r )ra r r �finish_accept_pipe s z4IocpProactor.accept_pipe.<locals>.finish_accept_pipe)r� r
r� r[ ZConnectNamedPipert r� r� )r ra r Z connectedr� r )ra r rs
s
zIocpProactor.accept_pipec c sz t }xjytj|�}P W n0 tk
rF } z|jtjkr6� W Y d d }~X nX t|d t�}tj || j
d�E d H qW t j |�S )N� )r )
�CONNECT_PIPE_INIT_DELAYr
Z ConnectPiper( rA ZERROR_PIPE_BUSY�min�CONNECT_PIPE_MAX_DELAYr Zsleepr) r r\ )r r Zdelayr: r+ r r r rj s
zIocpProactor.connect_pipec C s | j ||d�S )z�Wait 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 r: r� r r r �wait_for_handle/ s z IocpProactor.wait_for_handlec C s | j |d d�}||_|S )NT)r� rE )r rF Z
done_callbackr? r r r rO 7 s zIocpProactor._wait_cancelc s� |d krt j}ntj|d �}tjt�}tj|| j|j |�}|rTt
|||| j d�� nt |||| | j d�� � j
rv� j
d= � fdd�}� |d|f| j|j < � S )Ng @�@)r r c s � j � S )N)r= )ro r� r )rm r r �finish_wait_for_handleR s z=IocpProactor._wait_for_handle.<locals>.finish_wait_for_handler r )r< �INFINITE�math�ceilr
r� r[ ZRegisterWaitWithQueuer� r rD r) rH r r� )r r: r� Z
_is_cancel�msr r; r� r )rm r r� > s
z IocpProactor._wait_for_handlec C s0 || j kr,| j j|� tj|j� | jdd� d S )Nr )r9 r] r
r� rt r� )r �objr r r r� ^ s
z IocpProactor._register_with_iocpc C s� t || jd�}|jr |jd= |jsjy|d d |�}W n, tk
r^ } z|j|� W Y d d }~X n X |j|� ||||f| j|j< |S )N)r r r ) r r) r r r( r. r/ r� r )r r r� �callbackrm r� r� r r r r� h s
zIocpProactor._registerc C s | j 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> )r r r r r rN � s zIocpProactor._unregisterc C s t j |�}|jd� |S )Nr )r� r� )r r� �sr r r r� � s
z IocpProactor._get_accept_socketc C s� |d krt }n0|dk r td��n tj|d �}|t kr>td���xtj| j|�}|d krZP d}|\}}}}y| jj|�\}} }
} W nV t k
r� | j
j � r�| j
j dd||||f d�� |dtj
fkr�tj|� wBY nX |
| jkr�|j� qB|j� sBy| ||| �} W n: tk
�r@ }
z |j|
� | jj|� W Y d d }
~
X qBX |j| � | jj|� qBW x | jD ]} | jj| jd � �qdW | jj� d S )Nr znegative timeoutg @�@ztimeout too bigz8GetQueuedCompletionStatus() returned an unexpected eventz)err=%s transferred=%s key=%#x address=%#x)r# �status)r� �
ValueErrorr� r� r
ZGetQueuedCompletionStatusr� r� �pop�KeyErrorr) Z get_debugr* r� r< rM r� r' �doner( r. r� r> r/ r� r rc )r r� r� r� r� Z transferredr� r rm r r� r� r� r� r r r r= � sJ
zIocpProactor._pollc C s | j j|� d S )N)r� r] )r r� r r r �
_stop_serving� s zIocpProactor._stop_servingc C s� x�t | jj� �D ]�\}\}}}}|j� r*qt|t�r6qy |j� W q tk
r� } z8| jd k r�d||d�}|j rz|j |d< | jj
|� W Y d d }~X qX qW x | jr�| j d�s�t j
d� q�W g | _| jd k r�tj| j� d | _d S )NzCancelling a future failed)r# r$ r% r& r z"taking long time to close proactor)�listr� �itemsZ cancelledr� rD r' r( r) r r* r= r �debugr� r� r< rM )r r r? r r� r� r+ r, r r r rb � s,
"
zIocpProactor.closec C s | j � d S )N)rb )r r r r rd � s zIocpProactor.__del__)r� )N)r )r )N)N)r1 r2 r3 r4 r r� r� r� r� r� r� r� r� rs r rj r� rO r� r� r� rN r� r= r� rb rd r r r r r � s.
7 c @ s e Zd Zdd� ZdS )r| c
sP t j|f|||||d�|��� _� fdd�}� jjjt� jj��} | j|� d S )N)r r� r� r� r� c s � j j� }� j|� d S )N)�_procZpollZ_process_exited)rm �
returncode)r r r r� � s
z4_WindowsSubprocessTransport._start.<locals>.callback) r �Popenr� r) rI r� �intr7 rv )
r r~ r r� r� r� r� r� r� rm r )r r �_start� s z"_WindowsSubprocessTransport._startN)r1 r2 r3 r� r r r r r| � s r| c @ s e Zd ZeZdS )� _WindowsDefaultEventLoopPolicyN)r1 r2 r3 r
Z
_loop_factoryr r r r r� s r� )-r4 r< r� r� r� r� rR � r r r r r r r r
Z
coroutinesr �logr �__all__r[ r� ZERROR_CONNECTION_REFUSEDZERROR_CONNECTION_ABORTEDr� r� ZFuturer r6 rD rH �objectrP ZBaseSelectorEventLoopre ZBaseProactorEventLoopr r ZBaseSubprocessTransportr| r
ZBaseDefaultEventLoopPolicyr� r r r r r �<module> sL 0J4;] kPK [� H�O �O / __pycache__/windows_events.cpython-36.opt-2.pycnu �[��� 3
\�l � @ s� d dl Z d dlZd dlZd dlZd dlZd dlZddlmZ ddlmZ ddlm Z ddlm
Z
ddlm Z ddlm Z dd lm
Z
dd
lmZ dd lmZ dd lmZ d
dddgZd ZdZdZdZdZdZG dd� de j�ZG dd� de j�Z G dd� de �Z G d d � d e �Z G d d � d e �Z G d d!� d!e j!�Z"G d"d� de
j#�Z$G d#d� d�Z%G d$d%� d%ej&�Z'e"Z(G d&d'� d'ej)�Z*e*Z+dS )(� N� )�events)�base_subprocess)�futures)�proactor_events)�selector_events)�tasks)�
windows_utils)� _overlapped)� coroutine)�logger�SelectorEventLoop�ProactorEventLoop� IocpProactor�DefaultEventLoopPolicyl �� i� i� g����MbP?g�������?c sZ e Zd Zdd�� fdd�
Z� fdd�Zdd� Z� fd d
�Z� fd d �Z� fd
d�Z� Z S )�_OverlappedFutureN)�loopc s& t � j|d� | jr | jd= || _d S )N)r r ���)�super�__init__�_source_traceback�_ov)�self�ovr )� __class__� �./usr/lib64/python3.6/asyncio/windows_events.pyr - s z_OverlappedFuture.__init__c s@ t � j� }| jd k r<| jjr dnd}|jdd|| jjf � |S )N�pendingZ completedr zoverlapped=<%s, %#x>)r �
_repr_infor r �insert�address)r �info�state)r r r r 3 s
z _OverlappedFuture._repr_infoc C sr | j d krd S y| j j� W nJ tk
rf } z.d|| d�}| jrJ| j|d< | jj|� W Y d d }~X nX d | _ d S )Nz&Cancelling an overlapped future failed)�message� exception�future�source_traceback)r �cancel�OSErrorr �_loop�call_exception_handler)r �exc�contextr r r �_cancel_overlapped: s
z$_OverlappedFuture._cancel_overlappedc s | j � t� j� S )N)r- r r' )r )r r r r' J s z_OverlappedFuture.cancelc s t � j|� | j� d S )N)r �
set_exceptionr- )r r$ )r r r r. N s z _OverlappedFuture.set_exceptionc s t � j|� d | _d S )N)r �
set_resultr )r �result)r r r r/ R s z _OverlappedFuture.set_result)
�__name__�
__module__� __qualname__r r r- r' r. r/ �
__classcell__r r )r r r ' s r c sj e Zd Zdd�� fdd�
Zdd� Z� fdd�Zd d
� Zd d � Z� fd
d�Z� fdd�Z � fdd�Z
� Z S )�_BaseWaitHandleFutureN)r c s8 t � j|d� | jr | jd= || _|| _|| _d| _d S )N)r r Tr )r r r r �_handle� _wait_handle� _registered)r r �handle� wait_handler )r r r r Z s z _BaseWaitHandleFuture.__init__c C s t j| jd�t jkS )Nr )�_winapiZWaitForSingleObjectr6 Z
WAIT_OBJECT_0)r r r r �_pollh s z_BaseWaitHandleFuture._pollc s\ t � j� }|jd| j � | jd k r>| j� r0dnd}|j|� | jd k rX|jd| j � |S )Nz
handle=%#xZsignaledZwaitingzwait_handle=%#x)r r �appendr6 r< r7 )r r! r" )r r r r m s
z _BaseWaitHandleFuture._repr_infoc C s
d | _ d S )N)r )r �futr r r �_unregister_wait_cbw s z)_BaseWaitHandleFuture._unregister_wait_cbc C s� | j s
d S d| _ | j}d | _ytj|� W nZ tk
r� } z>|jtjkrtd|| d�}| jrd| j|d< | jj |� d S W Y d d }~X nX | j
d � d S )NFz$Failed to unregister the wait handle)r# r$ r% r& ) r8 r7 r
ZUnregisterWaitr( �winerror�ERROR_IO_PENDINGr r) r* r? )r r: r+ r, r r r �_unregister_wait| s"
z&_BaseWaitHandleFuture._unregister_waitc s | j � t� j� S )N)rB r r' )r )r r r r' � s z _BaseWaitHandleFuture.cancelc s | j � t� j|� d S )N)rB r r. )r r$ )r r r r. � s z#_BaseWaitHandleFuture.set_exceptionc s | j � t� j|� d S )N)rB r r/ )r r0 )r r r r/ � s z _BaseWaitHandleFuture.set_result) r1 r2 r3 r r< r r? rB r' r. r/ r4 r r )r r r5 W s
r5 c sB e Zd Zdd�� fdd�
Zdd� Z� fdd�Z� fd d
�Z� ZS ) �_WaitCancelFutureN)r c s t � j||||d� d | _d S )N)r )r r �_done_callback)r r �eventr: r )r r r r � s z_WaitCancelFuture.__init__c C s t d��d S )Nz'_WaitCancelFuture must not be cancelled)� RuntimeError)r r r r r' � s z_WaitCancelFuture.cancelc s$ t � j|� | jd k r | j| � d S )N)r r/ rD )r r0 )r r r r/ � s
z _WaitCancelFuture.set_resultc s$ t � j|� | jd k r | j| � d S )N)r r. rD )r r$ )r r r r. � s
z _WaitCancelFuture.set_exception)r1 r2 r3 r r' r/ r. r4 r r )r r rC � s rC c s6 e Zd Zdd�� fdd�
Z� fdd�Zdd� Z� ZS ) �_WaitHandleFutureN)r c s< t � j||||d� || _d| _tjd ddd �| _d | _d S )N)r TF)r r � _proactorZ_unregister_proactorr
Z CreateEvent�_event�
_event_fut)r r r9 r: �proactorr )r r r r � s
z_WaitHandleFuture.__init__c sF | j d k r"tj| j � d | _ d | _| jj| j� d | _t� j|� d S )N) rI r; � CloseHandlerJ rH � _unregisterr r r? )r r> )r r r r? � s
z%_WaitHandleFuture._unregister_wait_cbc C s� | j s
d S d| _ | j}d | _ytj|| j� W nZ tk
r� } z>|jtjkrxd|| d�}| jrh| j|d< | j j
|� d S W Y d d }~X nX | j j | j| j
�| _d S )NFz$Failed to unregister the wait handle)r# r$ r% r& )r8 r7 r
ZUnregisterWaitExrI r( r@ rA r r) r* rH � _wait_cancelr? rJ )r r: r+ r, r r r rB � s$
z"_WaitHandleFuture._unregister_wait)r1 r2 r3 r r? rB r4 r r )r r rG � s rG c @ s8 e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� ZeZd S ) �
PipeServerc C s, || _ tj� | _d | _d | _| jd�| _d S )NT)�_address�weakref�WeakSet�_free_instances�_pipe�_accept_pipe_future�_server_pipe_handle)r r r r r r � s
zPipeServer.__init__c C s | j | jd� }| _ |S )NF)rT rV )r �tmpr r r �_get_unconnected_pipe� s z PipeServer._get_unconnected_pipec C sr | j � r d S tjtjB }|r&|tjO }tj| j|tjtjB tj B tj
t j t j tj
tj�}t j|�}| jj|� |S )N)�closedr; ZPIPE_ACCESS_DUPLEXZFILE_FLAG_OVERLAPPEDZ FILE_FLAG_FIRST_PIPE_INSTANCEZCreateNamedPiperP ZPIPE_TYPE_MESSAGEZPIPE_READMODE_MESSAGEZ PIPE_WAITZPIPE_UNLIMITED_INSTANCESr ZBUFSIZEZNMPWAIT_WAIT_FOREVER�NULL�
PipeHandlerS �add)r �first�flags�h�piper r r rV s
z PipeServer._server_pipe_handlec C s
| j d kS )N)rP )r r r r rY s zPipeServer.closedc C sV | j d k r| j j� d | _ | jd k rRx| jD ] }|j� q,W d | _d | _| jj� d S )N)rU r' rP rS �closerT �clear)r r` r r r ra s
zPipeServer.closeN) r1 r2 r3 r rX rV rY ra �__del__r r r r rO � s
rO c @ s e Zd Zdd� ZdS )�_WindowsSelectorEventLoopc C s t j� S )N)r �
socketpair)r r r r � _socketpair+ s z%_WindowsSelectorEventLoop._socketpairN)r1 r2 r3 rf r r r r rd ( s rd c sL e Zd Zd � fdd� Zdd� Zedd� �Zedd � �Zed
d
d ��Z� Z S )r Nc s |d krt � }t� j|� d S )N)r r r )r rK )r r r r 2 s zProactorEventLoop.__init__c C s t j� S )N)r re )r r r r rf 7 s z ProactorEventLoop._socketpairc c s8 | j j|�}|E d H }|� }| j||d|id�}||fS )N�addr)�extra)rH � connect_pipe�_make_duplex_pipe_transport)r �protocol_factoryr �fr` �protocol�transr r r �create_pipe_connection: s
z(ProactorEventLoop.create_pipe_connectionc s. t � ��d� ����fdd� ��j�� �gS )Nc s d }yj| rL| j � }�jj|� �j� r2|j� d S �� }�j||d� id� �j� }|d kr`d S �jj|�} W n� t k
r� } zH|r�|j
� d kr��j d||d�� |j� n�j r�t
jd|dd� W Y d d }~X n2 tjk
r� |r�|j� Y nX | �_| j�� d S )
Nrg )rh r zPipe accept failed)r# r$ r` z Accept pipe failed on pipe %rT)�exc_infor )r0 rS �discardrY ra rj rX rH � accept_piper( �filenor* Z_debugr Zwarningr �CancelledErrorrU �add_done_callback)rl r` rm r+ )r �loop_accept_piperk r �serverr r rv G s<
z>ProactorEventLoop.start_serving_pipe.<locals>.loop_accept_pipe)N)rO Z call_soon)r rk r r )r rv rk r rw r �start_serving_pipeC s (
z$ProactorEventLoop.start_serving_pipec k s� | j � }
t| |||||||f|
|d�| ��} y|
E d H W n& tk
r` } z
| }
W Y d d } ~ X nX d }
|
d k r�| j� | j� E d H |
�| S )N)�waiterrh )�
create_future�_WindowsSubprocessTransport� Exceptionra Z_wait)r rm �args�shell�stdin�stdout�stderr�bufsizerh �kwargsry Ztranspr+ �errr r r �_make_subprocess_transportr s
z,ProactorEventLoop._make_subprocess_transport)N)N)
r1 r2 r3 r rf r ro rx r� r4 r r )r r r / s /c @ s� e Zd Zd0dd�Zdd� Zdd� Zd1d d
�Zd d � Zd2dd�Zd3dd�Z dd� Z
dd� Z dd� Z e
dd� �Zd4dd�Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd5d(d)�Zd*d+� Zd,d-� Zd.d/� ZdS )6r � �� c C sD d | _ g | _tjtjtd|�| _i | _tj � | _
g | _ tj � | _ d S )Nr )
r) �_resultsr
�CreateIoCompletionPort�INVALID_HANDLE_VALUErZ �_iocp�_cacherQ rR r8 �
_unregistered�_stopped_serving)r Z concurrencyr r r r � s
zIocpProactor.__init__c C s d| j jt| j�t| j�f S )Nz <%s overlapped#=%s result#=%s>)r r1 �lenr� r� )r r r r �__repr__� s zIocpProactor.__repr__c C s
|| _ d S )N)r) )r r r r r �set_loop� s zIocpProactor.set_loopNc C s | j s| j|� | j }g | _ |S )N)r� r< )r �timeoutrW r r r �select� s
zIocpProactor.selectc C s | j j� }|j|� |S )N)r) rz r/ )r �valuer> r r r �_result� s
zIocpProactor._resultr c C sz | j |� tjt�}y4t|tj�r6|j|j� ||� n|j|j� |� W n t k
rb | j
d�S X dd� }| j |||�S )N� c S sJ y|j � S tk
rD } z |jtjkr2t|j� �n� W Y d d }~X nX d S )N)� getresultr( r@ r
�ERROR_NETNAME_DELETED�ConnectionResetErrorr} )rn �keyr r+ r r r � finish_recv� s z&IocpProactor.recv.<locals>.finish_recv) �_register_with_iocpr
�
OverlappedrZ �
isinstance�socketZWSARecvrs ZReadFile�BrokenPipeErrorr� � _register)r �conn�nbytesr^ r r� r r r �recv� s
zIocpProactor.recvc C sZ | j |� tjt�}t|tj�r4|j|j� ||� n|j|j� |� dd� }| j |||�S )Nc S sJ y|j � S tk
rD } z |jtjkr2t|j� �n� W Y d d }~X nX d S )N)r� r( r@ r
r� r� r} )rn r� r r+ r r r � finish_send� s z&IocpProactor.send.<locals>.finish_send)
r� r
r� rZ r� r� ZWSASendrs Z WriteFiler� )r r� �bufr^ r r� r r r �send� s
zIocpProactor.sendc sz | j �� | j�j�� tjt�}|j�j� � j� � � �fdd�}tdd� �}| j |�|�}||� �}t
j || j d� |S )Nc sD |j � tjd�j� �}� jtjtj|� � j �j
� � � � j � fS )Nz@P) r� �structZpackrs �
setsockoptr� �
SOL_SOCKETr
ZSO_UPDATE_ACCEPT_CONTEXT�
settimeoutZ
gettimeoutZ getpeername)rn r� r r� )r� �listenerr r �
finish_accept� s
z*IocpProactor.accept.<locals>.finish_acceptc s s4 y| E d H W n t jk
r. |j� � Y nX d S )N)r rt ra )r% r� r r r � accept_coro� s
z(IocpProactor.accept.<locals>.accept_coro)r )
r� �_get_accept_socket�familyr
r� rZ ZAcceptExrs r r� r Z
ensure_futurer) )r r� r r� r� r% �coror )r� r� r �accept� s
zIocpProactor.acceptc s� | j � � ytj� j� � j� W nB tk
rb } z&|jtjkr@� � j � d dkrR� W Y d d }~X nX tj
t �}|j � j� |� � fdd�}| j
|� |�S )Nr r c s |j � � jtjtjd� � S )Nr )r� r� r� r� r
ZSO_UPDATE_CONNECT_CONTEXT)rn r� r )r� r r �finish_connect s
z,IocpProactor.connect.<locals>.finish_connect)r� r
Z BindLocalrs r� r( r@ �errnoZ WSAEINVALZ getsocknamer� rZ Z ConnectExr� )r r� r �er r� r )r� r �connect� s
zIocpProactor.connectc sJ | j � � tjt�}|j� j� �}|r0| j� �S � fdd�}| j|� |�S )Nc s |j � � S )N)r� )rn r� r )r` r r �finish_accept_pipe s z4IocpProactor.accept_pipe.<locals>.finish_accept_pipe)r� r
r� rZ ZConnectNamedPipers r� r� )r r` r Z connectedr� r )r` r rr
s
zIocpProactor.accept_pipec c sz t }xjytj|�}P W n0 tk
rF } z|jtjkr6� W Y d d }~X nX t|d t�}tj || j
d�E d H qW t j |�S )N� )r )
�CONNECT_PIPE_INIT_DELAYr
Z ConnectPiper( r@ ZERROR_PIPE_BUSY�min�CONNECT_PIPE_MAX_DELAYr Zsleepr) r r[ )r r Zdelayr9 r+ r r r ri s
zIocpProactor.connect_pipec C s | j ||d�S )NF)�_wait_for_handle)r r9 r� r r r �wait_for_handle/ s z IocpProactor.wait_for_handlec C s | j |d d�}||_|S )NT)r� rD )r rE Z
done_callbackr> r r r rN 7 s zIocpProactor._wait_cancelc s� |d krt j}ntj|d �}tjt�}tj|| j|j |�}|rTt
|||| j d�� nt |||| | j d�� � j
rv� j
d= � fdd�}� |d|f| j|j < � S )Ng @�@)r r c s � j � S )N)r< )rn r� r )rl r r �finish_wait_for_handleR s z=IocpProactor._wait_for_handle.<locals>.finish_wait_for_handler r )r; �INFINITE�math�ceilr
r� rZ ZRegisterWaitWithQueuer� r rC r) rG r r� )r r9 r� Z
_is_cancel�msr r: r� r )rl r r� > s
z IocpProactor._wait_for_handlec C s0 || j kr,| j j|� tj|j� | jdd� d S )Nr )r8 r\ r
r� rs r� )r �objr r r r� ^ s
z IocpProactor._register_with_iocpc C s� t || jd�}|jr |jd= |jsjy|d d |�}W n, tk
r^ } z|j|� W Y d d }~X n X |j|� ||||f| j|j< |S )N)r r r ) r r) r r r( r. r/ r� r )r r r� �callbackrl r� r� r r r r� h s
zIocpProactor._registerc C s | j j|� d S )N)r� r= )r r r r r rM � s zIocpProactor._unregisterc C s t j |�}|jd� |S )Nr )r� r� )r r� �sr r r r� � s
z IocpProactor._get_accept_socketc C s� |d krt }n0|dk r td��n tj|d �}|t kr>td���xtj| j|�}|d krZP d}|\}}}}y| jj|�\}} }
} W nV t k
r� | j
j � r�| j
j dd||||f d�� |dtj
fkr�tj|� wBY nX |
| jkr�|j� qB|j� sBy| ||| �} W n: tk
�r@ }
z |j|
� | jj|� W Y d d }
~
X qBX |j| � | jj|� qBW x | jD ]} | jj| jd � �qdW | jj� d S )Nr znegative timeoutg @�@ztimeout too bigz8GetQueuedCompletionStatus() returned an unexpected eventz)err=%s transferred=%s key=%#x address=%#x)r# �status)r� �
ValueErrorr� r� r
ZGetQueuedCompletionStatusr� r� �pop�KeyErrorr) Z get_debugr* r� r; rL r� r' �doner( r. r� r= r/ r� r rb )r r� r� r� r� Z transferredr� r rl r r� r� r� r� r r r r< � sJ
zIocpProactor._pollc C s | j j|� d S )N)r� r\ )r r� r r r �
_stop_serving� s zIocpProactor._stop_servingc C s� x�t | jj� �D ]�\}\}}}}|j� r*qt|t�r6qy |j� W q tk
r� } z8| jd k r�d||d�}|j rz|j |d< | jj
|� W Y d d }~X qX qW x | jr�| j d�s�t j
d� q�W g | _| jd k r�tj| j� d | _d S )NzCancelling a future failed)r# r$ r% r& r z"taking long time to close proactor)�listr� �itemsZ cancelledr� rC r' r( r) r r* r< r �debugr� r� r; rL )r r r> r r� r� r+ r, r r r ra � s,
"
zIocpProactor.closec C s | j � d S )N)ra )r r r r rc � s zIocpProactor.__del__)r� )N)r )r )N)N)r1 r2 r3 r r� r� r� r� r� r� r� r� rr r ri r� rN r� r� r� rM r� r< r� ra rc r r r r r � s,
7 c @ s e Zd Zdd� ZdS )r{ c
sP t j|f|||||d�|��� _� fdd�}� jjjt� jj��} | j|� d S )N)r~ r r� r� r� c s � j j� }� j|� d S )N)�_procZpollZ_process_exited)rl �
returncode)r r r r� � s
z4_WindowsSubprocessTransport._start.<locals>.callback) r �Popenr� r) rH r� �intr6 ru )
r r} r~ r r� r� r� r� r� rl r )r r �_start� s z"_WindowsSubprocessTransport._startN)r1 r2 r3 r� r r r r r{ � s r{ c @ s e Zd ZeZdS )� _WindowsDefaultEventLoopPolicyN)r1 r2 r3 r
Z
_loop_factoryr r r r r� s r� ),r; r� r� r� r� rQ � r r r r r r r r
Z
coroutinesr �logr �__all__rZ r� ZERROR_CONNECTION_REFUSEDZERROR_CONNECTION_ABORTEDr� r� ZFuturer r5 rC rG �objectrO ZBaseSelectorEventLooprd ZBaseProactorEventLoopr r ZBaseSubprocessTransportr{ r
ZBaseDefaultEventLoopPolicyr� r r r r r �<module> sJ 0J4;] kPK [6����D �D ' __pycache__/events.cpython-36.opt-2.pycnu �[��� 3
\�[ � @ s| d ddddddddd d
d d d
gZ ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
m Z ddl
m Z dd� Z
dd� Zd2dd�Zdd� Zd3d d �ZG d d� d�ZG d d� de�ZG d d� d�ZG d!d� d�ZG d"d � d �ZG d#d$� d$e�Zdaej� ZG d%d&� d&ej�Z e � Z d'd
� Z d(d � Z d)d*� Z d+d� Z!d,d� Z"d-d� Z#d.d� Z$d/d � Z%d0d
� Z&d1d � Z'dS )4�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� N� )�compat)� constantsc C st t jrtj| �} nt| d�r"| j} tj| �r>| j}|j|j fS t
| t j �rTt
| j�S t jrpt
| t j�rpt
| j�S d S )N� __wrapped__)r ZPY34�inspectZunwrap�hasattrr Z
isfunction�__code__� co_filename�co_firstlineno�
isinstance� functools�partial�_get_function_source�func�
partialmethod)r �code� r �&/usr/lib64/python3.6/asyncio/events.pyr s
r c C sJ g }| r |j dd� | D �� |r8|j dd� |j� D �� ddj|� d S )Nc s s | ]}t j|�V qd S )N)�reprlib�repr)�.0�argr r r! � <genexpr>1 s z*_format_args_and_kwargs.<locals>.<genexpr>c s s$ | ] \}}d j |tj|��V qdS )z{}={}N)�formatr" r# )r$ �k�vr r r! r& 3 s �(z, �))�extend�items�join)�args�kwargsr- r r r! �_format_args_and_kwargs) s
r1 � c C s� t | tj�r.t||�| }t| j| j| j|�S t| d�rF| j rF| j }n t| d�r^| j
r^| j
}nt | �}|t||�7 }|r�||7 }|S )N� __qualname__�__name__) r r r r1 �_format_callbackr r/ �keywordsr r3 r4 r# )r r/ r0 �suffix� func_reprr r r! r5 8 s r5 c C s( t | |d �}t| �}|r$|d| 7 }|S )Nz at %s:%s)r5 r )r r/ r8 �sourcer r r! �_format_callback_sourceI s
r: c C sD | d krt j� j} |d kr tj}tjjtj| �|dd�}|j � |S )NF)�limit� lookup_lines)
�sys� _getframe�f_backr ZDEBUG_STACK_DEPTH� traceback� StackSummary�extract�
walk_stack�reverse)�fr; �stackr r r! �
extract_stackQ s
rG c @ s8 e Zd ZdZdd � Zd
d � Zd d
� Zdd� Zdd� ZdS )r � _callback�_args�
_cancelled�_loop�_source_traceback�_repr� __weakref__c C sD || _ || _|| _d| _d | _| j j� r:ttjd��| _ nd | _ d S )NFr )
rK rH rI rJ rM � get_debugrG r= r> rL )�self�callbackr/ �loopr r r! �__init__h s
zHandle.__init__c C sf | j jg}| jr|jd� | jd k r8|jt| j| j�� | jrb| jd }|jd|d |d f � |S )NZ cancelledr zcreated at %s:%sr ���)� __class__r4 rJ �appendrH r: rI rL )rP �info�framer r r! �
_repr_infos s
zHandle._repr_infoc C s& | j d k r| j S | j� }ddj|� S )Nz<%s>� )rM rY r. )rP rW r r r! �__repr__~ s
zHandle.__repr__c C s0 | j s,d| _ | jj� r t| �| _d | _d | _d S )NT)rJ rK rO r# rM rH rI )rP r r r! �cancel� s
z
Handle.cancelc C s| y| j | j� W nb tk
rr } zFt| j | j�}dj|�}||| d�}| jrV| j|d< | jj|� W Y d d }~X nX d } d S )NzException in callback {})�messageZ exception�handleZsource_traceback)rH rI � Exceptionr: r' rL rK �call_exception_handler)rP �exc�cb�msg�contextr r r! �_run� s
z Handle._runN)rH rI rJ rK rL rM rN ) r4 �
__module__r3 � __slots__rS rY r[ r\ re r r r r! r b s c st e Zd ZddgZ� fdd�Z� fdd�Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z � fdd�Z
� ZS )r �
_scheduled�_whenc s. t � j|||� | jr | jd= || _d| _d S )Nr FrT )�superrS rL ri rh )rP �whenrQ r/ rR )rU r r! rS � s
zTimerHandle.__init__c s. t � j� }| jrdnd}|j|d| j � |S )N� r zwhen=%s)rj rY rJ �insertri )rP rW �pos)rU r r! rY � s
zTimerHandle._repr_infoc C s
t | j�S )N)�hashri )rP r r r! �__hash__� s zTimerHandle.__hash__c C s | j |j k S )N)ri )rP �otherr r r! �__lt__� s zTimerHandle.__lt__c C s | j |j k rdS | j|�S )NT)ri �__eq__)rP rq r r r! �__le__� s zTimerHandle.__le__c C s | j |j kS )N)ri )rP rq r r r! �__gt__� s zTimerHandle.__gt__c C s | j |j krdS | j|�S )NT)ri rs )rP rq r r r! �__ge__� s zTimerHandle.__ge__c C s> t |t�r:| j|jko8| j|jko8| j|jko8| j|jkS tS )N)r r ri rH rI rJ �NotImplemented)rP rq r r r! rs � s
zTimerHandle.__eq__c C s | j |�}|tkrtS | S )N)rs rw )rP rq Zequalr r r! �__ne__� s
zTimerHandle.__ne__c s | j s| jj| � t� j� d S )N)rJ rK �_timer_handle_cancelledrj r\ )rP )rU r r! r\ � s zTimerHandle.cancel)r4 rf r3 rg rS rY rp rr rt ru rv rs rx r\ �
__classcell__r r )rU r! r � s c @ s e Zd Zdd� Zdd� ZdS )r c C s t S )N)rw )rP r r r! �close� s zAbstractServer.closec C s t S )N)rw )rP r r r! � wait_closed� s zAbstractServer.wait_closedN)r4 rf r3 r{ r| r r r r! r � s c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d#d#d#d$�d%d&�Zdgd'd(�Zdhd)d#d#d#d)d)d)d*�d+d,�Zdiejejd)d-d)d)d)d.�d/d0�Zd)d)d)d1�d2d3�Zd)d-d)d4�d5d6�Z djd#d#d#d)d)d)d)d7�d8d9�Z d:d;� Z d<d=� Z e j!e j!e j!d>�d?d@�Z"e j!e j!e j!d>�dAdB�Z#dCdD� Z$dEdF� Z%dGdH� Z&dIdJ� Z'dKdL� Z(dMdN� Z)dOdP� Z*dQdR� Z+dSdT� Z,dUdV� Z-dWdX� Z.dYdZ� Z/d[d\� Z0d]d^� Z1d_d`� Z2dadb� Z3dcdd� Z4dedf� Z5d)S )kr c C s t �d S )N)�NotImplementedError)rP r r r! � run_forever� s z AbstractEventLoop.run_foreverc C s t �d S )N)r} )rP Zfuturer r r! �run_until_complete� s z$AbstractEventLoop.run_until_completec C s t �d S )N)r} )rP r r r! �stop� s zAbstractEventLoop.stopc C s t �d S )N)r} )rP r r r! �
is_running� s z AbstractEventLoop.is_runningc C s t �d S )N)r} )rP r r r! � is_closed s zAbstractEventLoop.is_closedc C s t �d S )N)r} )rP r r r! r{ s zAbstractEventLoop.closec C s t �d S )N)r} )rP r r r! �shutdown_asyncgens s z$AbstractEventLoop.shutdown_asyncgensc C s t �d S )N)r} )rP r^ r r r! ry s z)AbstractEventLoop._timer_handle_cancelledc G s | j d|f|�� S )Nr )�
call_later)rP rQ r/ r r r! � call_soon s zAbstractEventLoop.call_soonc G s t �d S )N)r} )rP ZdelayrQ r/ r r r! r� s z AbstractEventLoop.call_laterc G s t �d S )N)r} )rP rk rQ r/ r r r! �call_at s zAbstractEventLoop.call_atc C s t �d S )N)r} )rP r r r! �time" s zAbstractEventLoop.timec C s t �d S )N)r} )rP r r r! �
create_future% s z AbstractEventLoop.create_futurec C s t �d S )N)r} )rP �coror r r! � create_task* s z AbstractEventLoop.create_taskc G s t �d S )N)r} )rP rQ r/ r r r! �call_soon_threadsafe/ s z&AbstractEventLoop.call_soon_threadsafec G s t �d S )N)r} )rP �executorr r/ r r r! �run_in_executor2 s z!AbstractEventLoop.run_in_executorc C s t �d S )N)r} )rP r� r r r! �set_default_executor5 s z&AbstractEventLoop.set_default_executorr )�family�type�proto�flagsc C s t �d S )N)r} )rP �host�portr� r� r� r� r r r! � getaddrinfo: s z AbstractEventLoop.getaddrinfoc C s t �d S )N)r} )rP Zsockaddrr� r r r! � getnameinfo= s z AbstractEventLoop.getnameinfoN)�sslr� r� r� �sock�
local_addr�server_hostnamec C s t �d S )N)r} ) rP �protocol_factoryr� r� r� r� r� r� r� r� r� r r r! �create_connection@ s z#AbstractEventLoop.create_connection�d )r� r� r� �backlogr� �
reuse_address�
reuse_portc C s t �d S )N)r} ) rP r� r� r� r� r� r� r� r� r� r� r r r! �
create_serverE s 'z AbstractEventLoop.create_server)r� r� r� c C s t �d S )N)r} )rP r� �pathr� r� r� r r r! �create_unix_connectionn s z(AbstractEventLoop.create_unix_connection)r� r� r� c C s t �d S )N)r} )rP r� r� r� r� r� r r r! �create_unix_servers s z$AbstractEventLoop.create_unix_server)r� r� r� r� r� �allow_broadcastr� c C s t �d S )N)r} ) rP r� r� Z remote_addrr� r� r� r� r� r� r� r r r! �create_datagram_endpoint� s !z*AbstractEventLoop.create_datagram_endpointc C s t �d S )N)r} )rP r� �piper r r! �connect_read_pipe� s z#AbstractEventLoop.connect_read_pipec C s t �d S )N)r} )rP r� r� r r r! �connect_write_pipe� s z$AbstractEventLoop.connect_write_pipe)�stdin�stdout�stderrc K s t �d S )N)r} )rP r� �cmdr� r� r� r0 r r r! �subprocess_shell� s z"AbstractEventLoop.subprocess_shellc O s t �d S )N)r} )rP r� r� r� r� r/ r0 r r r! �subprocess_exec� s z!AbstractEventLoop.subprocess_execc G s t �d S )N)r} )rP �fdrQ r/ r r r! �
add_reader� s z AbstractEventLoop.add_readerc C s t �d S )N)r} )rP r� r r r! �
remove_reader� s z AbstractEventLoop.remove_readerc G s t �d S )N)r} )rP r� rQ r/ r r r! �
add_writer� s z AbstractEventLoop.add_writerc C s t �d S )N)r} )rP r� r r r! �
remove_writer� s z AbstractEventLoop.remove_writerc C s t �d S )N)r} )rP r� �nbytesr r r! � sock_recv� s zAbstractEventLoop.sock_recvc C s t �d S )N)r} )rP r� �datar r r! � sock_sendall� s z AbstractEventLoop.sock_sendallc C s t �d S )N)r} )rP r� Zaddressr r r! � sock_connect� s z AbstractEventLoop.sock_connectc C s t �d S )N)r} )rP r� r r r! � sock_accept� s z AbstractEventLoop.sock_acceptc G s t �d S )N)r} )rP �sigrQ r/ r r r! �add_signal_handler� s z$AbstractEventLoop.add_signal_handlerc C s t �d S )N)r} )rP r� r r r! �remove_signal_handler� s z'AbstractEventLoop.remove_signal_handlerc C s t �d S )N)r} )rP �factoryr r r! �set_task_factory� s z"AbstractEventLoop.set_task_factoryc C s t �d S )N)r} )rP r r r! �get_task_factory� s z"AbstractEventLoop.get_task_factoryc C s t �d S )N)r} )rP r r r! �get_exception_handler s z'AbstractEventLoop.get_exception_handlerc C s t �d S )N)r} )rP Zhandlerr r r! �set_exception_handler s z'AbstractEventLoop.set_exception_handlerc C s t �d S )N)r} )rP rd r r r! �default_exception_handler s z+AbstractEventLoop.default_exception_handlerc C s t �d S )N)r} )rP rd r r r! r` s z(AbstractEventLoop.call_exception_handlerc C s t �d S )N)r} )rP r r r! rO s zAbstractEventLoop.get_debugc C s t �d S )N)r} )rP Zenabledr r r! � set_debug s zAbstractEventLoop.set_debug)r )NN)NN)NN)6r4 rf r3 r~ r r� r� r� r{ r� ry r� r� r� r� r� r� r� r� r� r� r� r� �socketZ AF_UNSPECZ
AI_PASSIVEr� r� r� r� r� r� �
subprocess�PIPEr� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r` rO r� r r r r! r � sr
'!
c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd S ) r c C s t �d S )N)r} )rP r r r! r s z&AbstractEventLoopPolicy.get_event_loopc C s t �d S )N)r} )rP rR r r r! r $ s z&AbstractEventLoopPolicy.set_event_loopc C s t �d S )N)r} )rP r r r! r
( s z&AbstractEventLoopPolicy.new_event_loopc C s t �d S )N)r} )rP r r r! r 0 s z)AbstractEventLoopPolicy.get_child_watcherc C s t �d S )N)r} )rP �watcherr r r! r 4 s z)AbstractEventLoopPolicy.set_child_watcherN)r4 rf r3 r r r
r r r r r r! r s
c @ sB e Zd ZdZG dd� dej�Zdd� Zdd� Zdd � Z d
d � Z
dS ) �BaseDefaultEventLoopPolicyNc @ s e Zd ZdZdZdS )z!BaseDefaultEventLoopPolicy._LocalNF)r4 rf r3 rK � _set_calledr r r r! �_LocalH s r� c C s | j � | _d S )N)r� �_local)rP r r r! rS L s z#BaseDefaultEventLoopPolicy.__init__c C sZ | j jd kr4| j j r4ttj� tj�r4| j| j� � | j jd krRt dtj� j
��| j jS )Nz,There is no current event loop in thread %r.) r� rK r� r � threadingZcurrent_threadZ _MainThreadr r
� RuntimeError�name)rP r r r! r O s
z)BaseDefaultEventLoopPolicy.get_event_loopc C s d| j _|| j _d S )NT)r� r� rK )rP rR r r r! r ] s z)BaseDefaultEventLoopPolicy.set_event_loopc C s | j � S )N)�
_loop_factory)rP r r r! r
c s z)BaseDefaultEventLoopPolicy.new_event_loop) r4 rf r3 r� r� �localr� rS r r r
r r r r! r� 9 s
r� c @ s e Zd ZdZdS )� _RunningLoopN)NN)r4 rf r3 �loop_pidr r r r! r� w s r� c C s& t j\} }| d k r"|tj� kr"| S d S )N)�
_running_loopr� �os�getpid)Z running_loop�pidr r r! r ~ s
c C s | t j� ft_d S )N)r� r� r� r� )rR r r r! r
� s c C s. t � td kr ddlm} | � aW d Q R X d S )Nr )�DefaultEventLoopPolicy)�_lock�_event_loop_policyr2 r� )r� r r r! �_init_event_loop_policy� s r� c C s t d krt� t S )N)r� r� r r r r! r � s c C s | a d S )N)r� )Zpolicyr r r! r � s c C s t � } | d k r| S t� j� S )N)r r r )Z current_loopr r r! r � s c C s t � j| � d S )N)r r )rR r r r! r � s c C s
t � j� S )N)r r
r r r r! r
� s c C s
t � j� S )N)r r r r r r! r � s c C s t � j| �S )N)r r )r� r r r! r � s )r2 )NN)(�__all__r r r� r" r� r� r= r� r@ r2 r r r r1 r5 r: rG r r r r r r� r� ZLockr� r� r� r� r r
r� r r r r r
r r r r r r! �<module> sX
>8 5"7 PK [���� � ' __pycache__/compat.cpython-36.opt-1.pycnu �[��� 3
\ � @ s6 d Z ddlZejd kZejd
kZejd kZdd� ZdS ) z8Compatibility helpers for the different Python versions.� N� � � � c C s t sdd� | D �} dj| �S )z-Concatenate a sequence of bytes-like objects.c s s$ | ] }t |t�rt|�n|V qd S )N)�
isinstance�
memoryview�bytes)�.0�data� r �&/usr/lib64/python3.6/asyncio/compat.py� <genexpr> s z%flatten_list_bytes.<locals>.<genexpr>� )�PY34�join)Z list_of_datar r r �flatten_list_bytes
s r )r r )r r )r r r )�__doc__�sys� version_infor ZPY35ZPY352r r r r r �<module> s
PK [�a��Z< Z< & __pycache__/locks.cpython-36.opt-1.pycnu �[��� 3
\�< � @ s� d Z dddddgZddlZdd lmZ dd
lmZ dd lmZ dd lmZ G d
d� d�Z G dd� d�Z
G dd� de
�Z G dd� d�Z G dd� de
�Z
G dd� de
�ZG dd� de�ZdS )zSynchronization primitives.�Lock�Event� Condition� Semaphore�BoundedSemaphore� N� )�compat)�events)�futures)� coroutinec @ 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):
<block>
while failing loudly when accidentally using:
with lock:
<block>
c C s
|| _ d S )N)�_lock)�self�lock� r �%/usr/lib64/python3.6/asyncio/locks.py�__init__ s z_ContextManager.__init__c C s d S )Nr )r r r r � __enter__ s z_ContextManager.__enter__c G s z| j j� W d d | _ X d S )N)r
�release)r �argsr r r �__exit__$ s z_ContextManager.__exit__N)�__name__�
__module__� __qualname__�__doc__r r r r r r r r
s
r c @ sN e Zd Zdd� Zdd� Zedd� �ZejrJdd� Z ed d
� �Z
ed d � �Z d
S )�_ContextManagerMixinc C s t d��d S )Nz9"yield from" should be used as context manager expression)� RuntimeError)r r r r r , s z _ContextManagerMixin.__enter__c G s d S )Nr )r r r r r r 0 s z _ContextManagerMixin.__exit__c c s | j � E d H t| �S )N)�acquirer )r r r r �__iter__5 s z _ContextManagerMixin.__iter__c c s | j � E d H t| �S )N)r r )r r r r � __await__H s z _ContextManagerMixin.__await__c c s | j � E d H d S )N)r )r r r r �
__aenter__M s z _ContextManagerMixin.__aenter__c C s | j � d S )N)r )r �exc_type�exc�tbr r r � __aexit__T s z _ContextManagerMixin.__aexit__N) r r r r r r r r ZPY35r r r$ r r r r r + s r c sR e Zd ZdZdd�dd�Z� fdd�Zdd � Zed
d � �Zd d
� Z dd� 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 'yield from'.
Locks also support the context management protocol. '(yield from lock)'
should be used as the context manager expression.
Usage:
lock = Lock()
...
yield from lock
try:
...
finally:
lock.release()
Context manager usage:
lock = Lock()
...
with (yield from lock):
...
Lock objects can be tested for locking state:
if not lock.locked():
yield from lock
else:
# lock is acquired
...
N)�loopc C s. t j� | _d| _|d k r || _n
tj� | _d S )NF)� collections�deque�_waiters�_locked�_loopr �get_event_loop)r r% r r r r � s
z
Lock.__init__c sD t � j� }| jrdnd}| jr0dj|t| j��}dj|dd� |�S )N�locked�unlockedz
{},waiters:{}z <{} [{}]>r ���)�super�__repr__r) r( �format�len)r �res�extra)� __class__r r r0 � s
z
Lock.__repr__c C s | j S )z Return True if lock is acquired.)r) )r r r r r, � s z Lock.lockedc c s� | j r&tdd� | jD ��r&d| _ dS | jj� }| jj|� y"z|E dH W d| jj|� X W n& tjk
r� | j s~| j � � Y nX d| _ dS )z�Acquire a lock.
This method blocks until the lock is unlocked, then sets it to
locked and returns True.
c s s | ]}|j � V qd S )N)� cancelled)�.0�wr r r � <genexpr>� s z Lock.acquire.<locals>.<genexpr>TN)
r) �allr( r* �
create_future�append�remover
�CancelledError�_wake_up_first)r �futr r r r � s
z Lock.acquirec C s" | j rd| _ | j� ntd��dS )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)r) r? r )r r r r r � s
z Lock.releasec C s> yt t| j��}W n tk
r& dS X |j� s:|jd� dS )z*Wake up the first waiter if it isn't done.NT)�next�iterr( �
StopIteration�done�
set_result)r r@ r r r r? � s zLock._wake_up_first) r r r r r r0 r, r r r r? �
__classcell__r r )r5 r r Y s 4 c sR e Zd ZdZdd�dd�Z� fdd�Zdd � Zd
d � Zd d
� Ze dd� �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.
N)r% c C s. t j� | _d| _|d k r || _n
tj� | _d S )NF)r& r' r( �_valuer* r r+ )r r% r r r r � s
zEvent.__init__c sD t � j� }| jrdnd}| jr0dj|t| j��}dj|dd� |�S )N�setZunsetz
{},waiters:{}z <{} [{}]>r r. )r/ r0 rG r( r1 r2 )r r3 r4 )r5 r r r0 � s
zEvent.__repr__c C s | j S )z5Return True if and only if the internal flag is true.)rG )r r r r �is_set� s z Event.is_setc C s2 | j s.d| _ x | jD ]}|j� s|jd� qW dS )z�Set 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)rG r( rD rE )r r@ r r r rH � s
z Event.setc C s
d| _ dS )z�Reset the internal flag to false. Subsequently, coroutines calling
wait() will block until set() is called to set the internal flag
to true again.FN)rG )r r r r �clear s z Event.clearc c sB | j r
dS | jj� }| jj|� z|E dH dS | jj|� X dS )z�Block 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)rG r* r; r( r< r= )r r@ r r r �wait
s
z
Event.wait) r r r r r r0 rI rH rJ r rK rF r r )r5 r r � s c sZ e Zd ZdZddd�dd�Z� fdd�Zedd � �Zed
d � �Zdd
d�Z dd� 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.
N)r% c C sp |d k r|| _ n
tj� | _ |d kr0t| j d�}n|j | j k rDtd��|| _|j| _|j| _|j| _t j
� | _ d S )N)r% z"loop argument must agree with lock) r* r r+ r �
ValueErrorr
r, r r r& r' r( )r r r% r r r r + s
zCondition.__init__c sF t � j� }| j� rdnd}| jr2dj|t| j��}dj|dd� |�S )Nr, r- z
{},waiters:{}z <{} [{}]>r r. )r/ r0 r, r( r1 r2 )r r3 r4 )r5 r r r0 > s
zCondition.__repr__c c s� | j � std��| j� z8| jj� }| jj|� z|E dH dS | jj|� X W dd}x4y| j� E dH P W qX t j
k
r� d}Y qXX qXW |r�t j
�X 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 lockNTF) r, r r r* r; r( r< r= r r
r> )r r@ r6 r r r rK E s&
zCondition.waitc c s( |� }x |s"| j � E dH |� }qW |S )z�Wait 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)rK )r Z predicate�resultr r r �wait_fork s
zCondition.wait_forr c C sL | j � std��d}x2| jD ](}||kr*P |j� s |d7 }|jd� q W dS )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 r( rD rE )r �n�idxr@ r r r �notifyy s zCondition.notifyc C s | j 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)rQ r2 r( )r r r r �
notify_all� s zCondition.notify_all)N)r ) r r r r r r0 r rK rN rQ rR rF r r )r5 r r ! s &
c sT e Zd ZdZddd�dd�Z� fdd�Zd d
� Zd d � Zed
d� �Z dd� 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 N)r% c C s> |dk rt d��|| _tj� | _|d k r0|| _n
tj� | _d S )Nr z$Semaphore initial value must be >= 0)rL rG r& r' r( r* r r+ )r �valuer% r r r r � s
zSemaphore.__init__c sN t � j� }| j� rdn
dj| j�}| jr:dj|t| j��}dj|dd� |�S )Nr, zunlocked,value:{}z
{},waiters:{}z <{} [{}]>r r. )r/ r0 r, r1 rG r( r2 )r r3 r4 )r5 r r r0 � s
zSemaphore.__repr__c C s0 x*| j r*| j j� }|j� s|jd � d S qW d S )N)r( �popleftrD rE )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 )rG )r r r r r, � s zSemaphore.lockedc c sz xf| j dkrf| jj� }| jj|� y|E dH W q |j� | j dkr\|j� r\| j� � Y qX qW | 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)rG r* r; r( r< Zcancelr6 rU )r r@ r r r r � s
zSemaphore.acquirec C s | j d7 _ | j� dS )z�Release 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)rG rU )r r r r r � s zSemaphore.release)r ) r r r r r r0 rU r, r r r rF r r )r5 r r � s
c s4 e Zd ZdZd dd�� fdd� Z� fdd�Z� ZS )
r z�A bounded semaphore implementation.
This raises ValueError in release() if it would increase the value
above the initial value.
r N)r% c s || _ t� j||d� d S )N)r% )� _bound_valuer/ r )r rS r% )r5 r r r � s zBoundedSemaphore.__init__c s" | j | jkrtd��t� j� d S )Nz(BoundedSemaphore released too many times)rG rV rL r/ r )r )r5 r r r � s zBoundedSemaphore.release)r )r r r r r r rF r r )r5 r r � s )r �__all__r& � r r r
Z
coroutinesr r r r r r r r r r r r �<module> s . ByMPK [mʀ��L �L ( __pycache__/streams.cpython-36.opt-1.pycnu �[��� 3
\�_ � @ sL d Z dddddddgZdd lZeed
�r6ejd d g� d
dlmZ d
dlmZ d
dlmZ d
dlm Z d
dlm
Z
d
dl m Z d"Z
G dd� de�ZG dd� de�Ze
d#d e
d�dd��Ze
d$d e
d�dd��Zeed
��re
d%d e
d�dd ��Ze
d&d e
d�d d ��ZG d d � d e j�ZG d d� dee j�ZG d d� d�ZG d!d� d�Zd S )'zStream-related things.� StreamReader� StreamWriter�StreamReaderProtocol�open_connection� start_server�IncompleteReadError�LimitOverrunError� NZAF_UNIX�open_unix_connection�start_unix_server� )�
coroutines)�compat)�events)� protocols)� coroutine)�logger� � c s( e Zd ZdZ� fdd�Zdd� 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( t � jdt|�|f � || _|| _d S )Nz-%d bytes read on a total of %r expected bytes)�super�__init__�len�partial�expected)�selfr r )� __class__� �'/usr/lib64/python3.6/asyncio/streams.pyr s z IncompleteReadError.__init__c C s t | �| j| jffS )N)�typer r )r r r r �
__reduce__& s z IncompleteReadError.__reduce__)�__name__�
__module__� __qualname__�__doc__r r �
__classcell__r r )r r r s c s( e Zd ZdZ� fdd�Zdd� Z� ZS )r z�Reached the buffer limit while looking for a separator.
Attributes:
- consumed: total number of to be consumed bytes.
c s t � j|� || _d S )N)r r �consumed)r �messager$ )r r r r 0 s zLimitOverrunError.__init__c C s t | �| jd | jffS )Nr )r �argsr$ )r r r r r 4 s z LimitOverrunError.__reduce__)r r r! r" r r r# r r )r r r * s )�loop�limitc + sb |dkrt j� }t||d�}t||d�� |j� fdd�| |f|�E 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)r( r' )r' c s � S )Nr r )�protocolr r �<lambda>Q s z!open_connection.<locals>.<lambda>)r �get_event_loopr r Zcreate_connectionr ) �host�portr' r( �kwds�reader� transport�_�writerr )r) r r 8 s c + s8 �dkrt j� �� ��fdd�}�j|||f|�E 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.
Nc s t ��d�} t| � �d�}|S )N)r( r' )r' )r r )r/ r) )�client_connected_cbr( r' r r �factoryq s z start_server.<locals>.factory)r r+ Z
create_server)r3 r, r- r' r( r. r4 r )r3 r( r' r r V s c + s` |dkrt j� }t||d�}t||d�� |j� fdd�| f|�E dH \}}t|� ||�}||fS )z@Similar to `open_connection` but works with UNIX Domain Sockets.N)r( r' )r' c s � S )Nr r )r) r r r* � s z&open_unix_connection.<locals>.<lambda>)r r+ r r Zcreate_unix_connectionr )�pathr' r( r. r/ r0 r1 r2 r )r) r r } s c + s6 �dkrt j� �� ��fdd�}�j||f|�E dH S )z=Similar to `start_server` but works with UNIX Domain Sockets.Nc s t ��d�} t| � �d�}|S )N)r( r' )r' )r r )r/ r) )r3 r( r' r r r4 � s z"start_unix_server.<locals>.factory)r r+ Zcreate_unix_server)r3 r5 r' r( r. r4 r )r3 r( r' r r
� s c @ s> e Zd ZdZd
dd�Zdd� Zdd� Zd d
� Zed d � �Z dS )�FlowControlMixina) Reusable flow control logic for StreamWriter.drain().
This implements the protocol methods pause_writing(),
resume_reading() 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 j� | _n|| _d| _d | _d| _d S )NF)r r+ �_loop�_paused�
_drain_waiter�_connection_lost)r r' r r r r � s zFlowControlMixin.__init__c C s d| _ | jj� r tjd| � d S )NTz%r pauses writing)r8 r7 � get_debugr �debug)r r r r �
pause_writing� s
z FlowControlMixin.pause_writingc C sF d| _ | jj� r tjd| � | j}|d k rBd | _|j� sB|jd � d S )NFz%r resumes writing)r8 r7 r; r r< r9 �done�
set_result)r �waiterr r r �resume_writing� s
z FlowControlMixin.resume_writingc C sV d| _ | jsd S | j}|d kr"d S d | _|j� r4d S |d krH|jd � n
|j|� d S )NT)r: r8 r9 r> r? �
set_exception)r �excr@ r r r �connection_lost� s z FlowControlMixin.connection_lostc c s< | j rtd��| jsd S | j}| jj� }|| _|E d H d S )NzConnection lost)r: �ConnectionResetErrorr8 r9 r7 �
create_future)r r@ r r r �
_drain_helper� s
z FlowControlMixin._drain_helper)N)
r r r! r" r r= rA rD r rG r r r r r6 � s
r6 c sF e Zd ZdZd
� fdd� Zdd� Z� fdd�Zd d
� Zd d � Z� Z S )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 s* t � j|d� || _d | _|| _d| _d S )N)r' F)r r �_stream_reader�_stream_writer�_client_connected_cb� _over_ssl)r Z
stream_readerr3 r' )r r r r � s
z StreamReaderProtocol.__init__c C sd | j j|� |jd�d k | _| jd k r`t|| | j | j�| _| j| j | j�}tj |�r`| jj
|� d S )NZ
sslcontext) rH �
set_transport�get_extra_inforK rJ r r7 rI r Z iscoroutineZ create_task)r r0 �resr r r �connection_made� s
z$StreamReaderProtocol.connection_madec sF | j d k r*|d kr | j j� n | j j|� t� j|� d | _ d | _d S )N)rH �feed_eofrB r rD rI )r rC )r r r rD � s
z$StreamReaderProtocol.connection_lostc C s | j j|� d S )N)rH � feed_data)r �datar r r �
data_received s z"StreamReaderProtocol.data_receivedc C s | j j� | jrdS dS )NFT)rH rP rK )r r r r � eof_received s
z!StreamReaderProtocol.eof_received)NN)
r r r! r" r rO rD rS rT r# r r )r r r � s
c @ sj e Zd ZdZdd� Zdd� Zedd� �Zdd � Zd
d � Z d d
� Z
dd� Z dd� Z ddd�Z
edd� �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 s || _ || _|| _|| _d S )N)�
_transport� _protocol�_readerr7 )r r0 r) r/ r' r r r r s zStreamWriter.__init__c C s: | j jd| j g}| jd k r,|jd| j � ddj|� S )Nz transport=%rz reader=%rz<%s>� )r r rU rW �append�join)r �infor r r �__repr__! s
zStreamWriter.__repr__c C s | j S )N)rU )r r r r r0 ' s zStreamWriter.transportc C s | j j|� d S )N)rU �write)r rR r r r r] + s zStreamWriter.writec C s | j j|� d S )N)rU �
writelines)r rR r r r r^ . s zStreamWriter.writelinesc C s
| j j� S )N)rU � write_eof)r r r r r_ 1 s zStreamWriter.write_eofc C s
| j j� S )N)rU �
can_write_eof)r r r r r` 4 s zStreamWriter.can_write_eofc C s
| j j� S )N)rU �close)r r r r ra 7 s zStreamWriter.closeNc C s | j j||�S )N)rU rM )r �name�defaultr r r rM : s zStreamWriter.get_extra_infoc c sN | j dk r | j j� }|dk r |�| jdk r:| jj� r:dV | jj� E dH dS )z~Flush the write buffer.
The intended use is to write
w.write(data)
yield from w.drain()
N)rW � exceptionrU Z
is_closingrV rG )r rC r r r �drain= s
zStreamWriter.drain)N)r r r! r" r r\ �propertyr0 r] r^ r_ r` ra rM r re r r r r r s
c @ s� e Zd Zedfdd�Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
edd� �Zedd� �Zed'dd ��Zed)d d ��Zed d!� �Zejr�ed"d#� �Zed$d%� �Zejr�d&d#� ZdS )*r Nc C sZ |dkrt d��|| _|d kr*tj� | _n|| _t� | _d| _d | _d | _ d | _
d| _ d S )Nr zLimit cannot be <= 0F) �
ValueError�_limitr r+ r7 � bytearray�_buffer�_eof�_waiter�
_exceptionrU r8 )r r( r' r r r r X s zStreamReader.__init__c C s� dg}| j r |jdt| j � � | jr0|jd� | jtkrJ|jd| j � | jr`|jd| j � | jrv|jd| j � | jr�|jd| j � | j r�|jd� d d
j
|� S ) Nr z%d bytes�eofzl=%dzw=%rze=%rzt=%rZpausedz<%s>rX ) rj rY r rk rh �_DEFAULT_LIMITrl rm rU r8 rZ )r r[ r r r r\ k s
zStreamReader.__repr__c C s | j S )N)rm )r r r r rd } s zStreamReader.exceptionc C s0 || _ | j}|d k r,d | _|j� s,|j|� d S )N)rm rl � cancelledrB )r rC r@ r r r rB � s zStreamReader.set_exceptionc C s* | j }|dk r&d| _ |j� s&|jd� dS )z1Wakeup read*() functions waiting for data or EOF.N)rl rp r? )r r@ r r r �_wakeup_waiter� s
zStreamReader._wakeup_waiterc C s
|| _ d S )N)rU )r r0 r r r rL � s zStreamReader.set_transportc C s* | j r&t| j�| jkr&d| _ | jj� d S )NF)r8 r rj rh rU �resume_reading)r r r r �_maybe_resume_transport� s z$StreamReader._maybe_resume_transportc C s d| _ | j� d S )NT)rk rq )r r r r rP � s zStreamReader.feed_eofc C s | j o | j S )z=Return True if the buffer is empty and 'feed_eof' was called.)rk rj )r r r r �at_eof� s zStreamReader.at_eofc C sv |sd S | j j|� | j� | jd k rr| j rrt| j �d| j krry| jj� W n tk
rj d | _Y nX d| _d S )Nr T) rj �extendrq rU r8 r rh Z
pause_reading�NotImplementedError)r rR r r r rQ � s
zStreamReader.feed_datac c sV | j dk rtd| ��| jr,d| _| jj� | jj� | _ z| j E dH W dd| _ X dS )zpWait until feed_data() or feed_eof() is called.
If stream was paused, automatically resume it.
NzH%s() called while another coroutine is already waiting for incoming dataF)rl � RuntimeErrorr8 rU rr r7 rF )r Z func_namer r r �_wait_for_data� s
zStreamReader._wait_for_datac c s� d}t |�}y| j|�E dH }W n� tk
rB } z|jS d}~X nf tk
r� } zJ| jj||j�rv| jd|j| �= n
| jj� | j � t
|j d ��W Y dd}~X 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 r r rj �
startswithr$ �clearrs rg r& )r �sep�seplen�line�er r r �readline� s
zStreamReader.readlinery c c s� t |�}|dkrtd��| jdk r(| j�d}x�t | j�}|| |kr|| jj||�}|dkr\P |d | }|| jkr|td|��| jr�t| j�}| jj � t
|d��| j d�E dH q.W || jkr�td|��| jd|| � }| jd|| �= | j � 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 limitrz z2Separator is found, but chunk is longer than limit���)
r rg rm rj �findrh r rk �bytesr| r rx rs )r Z separatorr~ �offsetZbuflenZisep�chunkr r r rz � s:
zStreamReader.readuntilr c c s� | j dk r| j �|dkr dS |dk rZg }x&| j| j�E dH }|sBP |j|� q*W dj|�S | j rz| j rz| jd�E dH t| jd|� �}| jd|�= | j � |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 � �read)
rm r� rh rY rZ rj rk rx r� rs )r �nZblocks�blockrR r r r r� P s$
zStreamReader.readc c s� |dk rt d��| jdk r | j�|dkr,dS xFt| j�|k rr| jr`t| j�}| jj� t||��| jd�E dH q.W t| j�|kr�t| j�}| jj� n t| jd|� �}| jd|�= | j � |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)
rg rm r rj rk r� r| r rx rs )r r� Z
incompleterR r r r r� � s&
zStreamReader.readexactlyc C s | S )Nr )r r r r � __aiter__� s zStreamReader.__aiter__c c s | j � E d H }|dkrt�|S )Nr� )r� �StopAsyncIteration)r �valr r r � __anext__� s zStreamReader.__anext__c C s | S )Nr )r r r r r� � s )ry r� )r� )r r r! ro r r\ rd rB rq rL rs rP rt rQ r rx r� rz r� r� r
ZPY35r� r� ZPY352r r r r r V s, [ 2 * i )NN)NN)N)N)r" �__all__Zsocket�hasattrru � r r
r r r �logr ro �EOFErrorr � Exceptionr r r r r
ZProtocolr6 r r r r r r r �<module> sB
" B3GPK [vԊ�� �� & __pycache__/base_events.cpython-36.pycnu �[��� 3
\� � @ s� d Z ddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl
Z
ddlZddlZddlZddlmZ ddlmZ ddlmZ ddlmZ ddlmZ dd lmZ dd
lmZ d gZd Zd
Z e e e fZ e!e d�Z"d)Z#dd� Z$dd� Z%dd� Z&dd� Z'dd� Z(dd � Z)de j*ddd �d d �Z+e!e d ��rRd!d"� Z,nd#d"� Z,d$d%� Z-G d&d'� d'ej.�Z/G d(d � d ej0�Z1dS )*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� )�compat)�
coroutines)�events)�futures)�tasks)� coroutine)�logger�
BaseEventLoop�d g �?�AF_INET6� i c C s0 | j }tt|dd �tj�r$t|j�S t| �S d S )N�__self__)Z _callback�
isinstance�getattrr �Task�reprr �str)�handle�cb� r �+/usr/lib64/python3.6/asyncio/base_events.py�_format_handle? s
r c C s( | t jkrdS | t jkr dS t| �S d S )Nz<pipe>z<stdout>)�
subprocess�PIPE�STDOUTr )�fdr r r � _format_pipeH s
r c C sL t td�std��n4y| jtjtjd� W n tk
rF td��Y 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.)�hasattr�socket�
ValueError�
setsockopt�
SOL_SOCKETr �OSError)�sockr r r �_set_reuseportQ s
r& c C s& t td�r| d@ tjkS | tjkS d S )N�
SOCK_NONBLOCK� )r r � SOCK_STREAM)� sock_typer r r �_is_stream_socket\ s
r+ c C s& t td�r| d@ tjkS | tjkS d S )Nr' r( )r r �
SOCK_DGRAM)r* r r r �_is_dgram_socketh s
r- c C sv t td�sd S |dtjtjhks(| d kr,d S t|�r<tj}nt|�rLtj}nd S |d kr^d}nVt|t�rv|dkrvd}n>t|t�r�|dkr�d}n&y t |�}W n t
t fk
r� d S X |tj kr�tj
g}tr�|jtj� n|g}t| t�r�| jd�} d| k�r d S xp|D ]h}yJtj|| � t�r@|tjk�r@|||d| |ddffS |||d| |ffS W n tk
�rj Y nX �qW d S )N� inet_ptonr � � Zidna�%)r r � IPPROTO_TCPZ IPPROTO_UDPr+ r- r �bytesr �int� TypeErrorr! � AF_UNSPEC�AF_INET� _HAS_IPv6�appendr �decoder. r$ )�host�port�family�type�protoZafs�afr r r � _ipaddr_infop sL
rA )r= r> r? �flagsc
C sZ | d d� \}}t |||||�}|d k r@|j� } | j|g� | S |j||||||d�S d S )N� )r= r> r? rB )rA �
create_future�
set_result� getaddrinfo)
�addressr= r> r? rB �loopr; r< �info�futr r r �_ensure_resolved� s rK � TCP_NODELAYc C s> | j tjtjhkr:t| j�r:| jtjkr:| jtjtj d� d S )Nr )
r= r r7 r r+ r> r? r2 r" rL )r% r r r � _set_nodelay� s
rM c C s d S )Nr )r% r r r rM � s c C s. | j }t|t�r t|t� r d S | jj� d S )N)Z
_exceptionr �
BaseException� Exception�_loop�stop)rJ �excr r r �_run_until_complete_cb� s
rS c @ sH e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Ze d
d� �Z
dS )�Serverc C s || _ || _d| _g | _d S )Nr )rP �sockets�
_active_count�_waiters)�selfrH rU r r r �__init__� s zServer.__init__c C s d| j j| jf S )Nz<%s sockets=%r>)� __class__�__name__rU )rX r r r �__repr__� s zServer.__repr__c C s | j d k st�| jd7 _d S )Nr )rU �AssertionErrorrV )rX r r r �_attach� s zServer._attachc C s< | j dkst�| j d8 _ | j dkr8| jd kr8| j� d S )Nr r )rV r] rU �_wakeup)rX r r r �_detach� s zServer._detachc C sH | j }|d krd S d | _ x|D ]}| jj|� q W | jdkrD| j� d S )Nr )rU rP Z
_stop_servingrV r_ )rX rU r% r r r �close� s
z Server.closec C s0 | j }d | _ x |D ]}|j� s|j|� qW d S )N)rW �donerE )rX �waiters�waiterr r r r_ � s
zServer._wakeupc c s< | j d ks| jd krd S | jj� }| jj|� |E d H d S )N)rU rW rP rD r9 )rX rd r r r � wait_closed� s
zServer.wait_closedN) r[ �
__module__� __qualname__rY r\ r^ r` ra r_ r re r r r r rT � s
rT c
@ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd�d
d
d�dd�Z d�dd
d
d
d�dd�Z
d�dd�Z d�dd�Z d�dd�Z
ed�dd ��Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zed'd(� �Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zej � r�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)dMdMdMdMdN�dOdP�Z*d�dQdR�Z+ed�d
dMdMdMd
d
d
dS�dTdU��Z,ed�dVdW��Z-ed�dMdMdMd
d
d
d
dX�dYdZ��Z.ed[d\� �Z/ed�e0j1e0j2d
d]d
d
d
d^�d_d`��Z3ed
da�dbdc��Z4eddde� �Z5edfdg� �Z6dhdi� Z7ee8j9e8j9e8j9ddjdMdk�dldm��Z:ee8j9e8j9e8j9dddMdk�dndo��Z;dpdq� Z<drds� Z=dtdu� Z>dvdw� Z?dxdy� Z@dzd{� ZAd|d}� ZBd~d� ZCd�d�� ZDd�d�� ZEd�d�� ZFd
S )�r
c C s� d| _ d| _d| _tj� | _g | _d | _d| _d | _ t
j d�j | _
d | _| jtjj odttjjd��� d| _d | _d | _d| _ttd�r�t j � | _ nd | _ d| _ d S )Nr F� monotonicZPYTHONASYNCIODEBUGg�������?�get_asyncgen_hooks) �_timer_cancelled_count�_closed� _stopping� collections�deque�_ready�
_scheduled�_default_executorZ
_internal_fds�
_thread_id�timeZget_clock_infoZ
resolution�_clock_resolution�_exception_handler� set_debug�sysrB �ignore_environment�bool�os�environ�get�slow_callback_duration�_current_handle�
_task_factory�_coroutine_wrapper_setr �weakref�WeakSet�
_asyncgens�_asyncgens_shutdown_called)rX r r r rY � s(
zBaseEventLoop.__init__c C s d| j j| j� | j� | j� f S )Nz"<%s running=%s closed=%s debug=%s>)rZ r[ �
is_running� is_closed� get_debug)rX r r r r\ s zBaseEventLoop.__repr__c C s t j| d�S )z,Create a Future object attached to the loop.)rH )r ZFuture)rX r r r rD % s zBaseEventLoop.create_futurec C s@ | j � | jdkr0tj|| d�}|jr<|jd= n | j| |�}|S )zDSchedule a coroutine object.
Return a task object.
N)rH r ���)�
_check_closedr r r �_source_traceback)rX �coroZtaskr r r � create_task) s
zBaseEventLoop.create_taskc C s$ |dk rt |� rtd��|| _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 )rX �factoryr r r �set_task_factory7 s
z BaseEventLoop.set_task_factoryc C s | j S )z<Return a task factory, or None if the default one is in use.)r )rX r r r �get_task_factoryE s z BaseEventLoop.get_task_factoryN)�extra�serverc C s t �dS )zCreate socket transport.N)�NotImplementedError)rX r% �protocolrd r� r� r r r �_make_socket_transportI s z$BaseEventLoop._make_socket_transportF)� server_side�server_hostnamer� r� c C s t �dS )zCreate SSL transport.N)r� ) rX Zrawsockr� �
sslcontextrd r� r� r� r� r r r �_make_ssl_transportN s z!BaseEventLoop._make_ssl_transportc C s t �dS )zCreate datagram transport.N)r� )rX r% r� rG rd r� r r r �_make_datagram_transportT s z&BaseEventLoop._make_datagram_transportc C s t �dS )zCreate read pipe transport.N)r� )rX �piper� rd r� r r r �_make_read_pipe_transportY s z'BaseEventLoop._make_read_pipe_transportc C s t �dS )z Create write pipe transport.N)r� )rX r� r� rd r� r r r �_make_write_pipe_transport^ s z(BaseEventLoop._make_write_pipe_transportc
K s t �dS )z Create subprocess transport.N)r� )
rX r� �args�shell�stdin�stdout�stderr�bufsizer� �kwargsr r r �_make_subprocess_transportc s z(BaseEventLoop._make_subprocess_transportc C s t �dS )z�Write a byte to self-pipe, to wake up the event loop.
This may be called from a different thread.
The subclass is responsible for implementing the self-pipe.
N)r� )rX r r r �_write_to_selfj s z BaseEventLoop._write_to_selfc C s t �dS )zProcess selector events.N)r� )rX �
event_listr r r �_process_eventss s z BaseEventLoop._process_eventsc C s | j rtd��d S )NzEvent loop is closed)rk � RuntimeError)rX r r r r� w s zBaseEventLoop._check_closedc C s* | j j|� | j� s&| j| j|j� � d S )N)r� �discardr� �call_soon_threadsafer� �aclose)rX �agenr r r �_asyncgen_finalizer_hook{ s z&BaseEventLoop._asyncgen_finalizer_hookc C s, | j r tjdj|�t| d� | jj|� d S )NzNasynchronous generator {!r} was scheduled after loop.shutdown_asyncgens() call)�source)r� �warnings�warn�format�ResourceWarningr� �add)rX r� r r r �_asyncgen_firstiter_hook� s
z&BaseEventLoop._asyncgen_firstiter_hookc c s� d| _ | jdks t| j� r dS t| j�}| jj� tjdd� |D �d| d��}|E dH }x8t||�D ]*\}}t|t �rf| j
dj |�||d�� qfW dS )z,Shutdown all active asynchronous generators.TNc S s g | ] }|j � �qS r )r� )�.0Zagr r r �
<listcomp>� s z4BaseEventLoop.shutdown_asyncgens.<locals>.<listcomp>)Zreturn_exceptionsrH z?an error occurred during closing of asynchronous generator {!r})�message� exceptionZasyncgen) r� r� �len�list�clearr �gather�zipr rO �call_exception_handlerr� )rX Z
closing_agensZ
shutdown_coroZresults�resultr� r r r �shutdown_asyncgens� s"
z BaseEventLoop.shutdown_asyncgensc C s� | j � | j� rtd��tj� dk r,td��| j| j� tj� | _ | j
dk rft j � }t j
| j| jd� z$tj| � x| j� | jrtP qtW W dd| _d| _ tjd� | jd� | j
dk r�t j
|� X dS )zRun until stop() is called.z"This event loop is already runningNz7Cannot run the event loop while another loop is running)� firstiter� finalizerF)r� r� r� r Z_get_running_loop�_set_coroutine_wrapper�_debug� threading� get_identrr r� rw ri �set_asyncgen_hooksr� r� Z_set_running_loop� _run_oncerl )rX Zold_agen_hooksr r r � run_forever� s0
zBaseEventLoop.run_foreverc C s� | j � tj|� }tj|| d�}|r,d|_|jt� z>y | j� W n, |rj|j � rj|j
� rj|j � � Y nX W d|j t� X |j � s�t
d��|j� S )a\ Run until the Future is done.
If the argument is a coroutine, it is wrapped in a Task.
WARNING: It would be disastrous to call run_until_complete()
with the same coroutine twice -- it would wrap it in two
different Tasks and that can't be good.
Return the Future's result, or raise its exception.
)rH FNz+Event loop stopped before Future completed.)r� r Zisfuturer Z
ensure_futureZ_log_destroy_pendingZadd_done_callbackrS r� rb Z cancelledr� Zremove_done_callbackr� r� )rX ZfutureZnew_taskr r r �run_until_complete� s
z BaseEventLoop.run_until_completec C s
d| _ dS )z�Stop running the event loop.
Every callback already scheduled will still run. This simply informs
run_forever to stop looping after a complete iteration.
TN)rl )rX r r r rQ � s zBaseEventLoop.stopc C sj | j � rtd��| jrdS | jr,tjd| � d| _| jj� | jj� | j }|dk rfd| _ |j
dd� dS )z�Close the event loop.
This clears the queues and shuts down the executor,
but does not wait for the executor to finish.
The event loop must not be running.
z!Cannot close a running event loopNzClose %rTF)�wait) r� r� rk r� r �debugro r� rp rq Zshutdown)rX �executorr r r ra � s
zBaseEventLoop.closec C s | j S )z*Returns True if the event loop was closed.)rk )rX r r r r� s zBaseEventLoop.is_closedc C s0 | j � s,tjd| t| d� | j� s,| j� d S )Nzunclosed event loop %r)r� )r� r� r� r� r� ra )rX r r r �__del__ s
zBaseEventLoop.__del__c C s
| j dk S )z*Returns True if the event loop is running.N)rr )rX r r r r� s zBaseEventLoop.is_runningc C s t j� S )z�Return the time according to the event loop's clock.
This is a float expressed in seconds since an epoch, but the
epoch, precision, accuracy and drift are unspecified and may
differ per event loop.
)rs rh )rX r r r rs s zBaseEventLoop.timec G s, | j | j� | |f|�� }|jr(|jd= |S )a8 Arrange for a callback to be called at a given time.
Return a Handle: an opaque object with a cancel() method that
can be used to cancel the call.
The delay can be an int or float, expressed in seconds. It is
always relative to the current time.
Each callback will be called exactly once. If two callbacks
are scheduled for exactly the same time, it undefined which
will be called first.
Any positional arguments after the callback will be passed to
the callback when it is called.
r r� )�call_atrs r� )rX Zdelay�callbackr� �timerr r r �
call_later s zBaseEventLoop.call_laterc G sX | j � | jr"| j� | j|d� tj|||| �}|jr@|jd= tj| j |� d|_ |S )z|Like call_later(), but uses an absolute time.
Absolute time corresponds to the event loop's time() method.
r� r Tr� )
r� r� �
_check_thread�_check_callbackr � TimerHandler� �heapq�heappushrp )rX �whenr� r� r� r r r r� 5 s zBaseEventLoop.call_atc G s@ | j � | jr"| j� | j|d� | j||�}|jr<|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� r� �
_call_soonr� )rX r� r� r r r r r� E s
zBaseEventLoop.call_soonc C s> t j|�st j|�r"tdj|���t|�s:tdj||���d S )Nz#coroutines cannot be used with {}()z0a callable object was expected by {}(), got {!r})r Z iscoroutineZiscoroutinefunctionr5 r� r� )rX r� �methodr r r r� X s
z BaseEventLoop._check_callbackc C s, t j||| �}|jr |jd= | jj|� |S )Nr r� )r �Handler� ro r9 )rX r� r� r r r r r� c s
zBaseEventLoop._call_soonc C s, | j dkrdS tj� }|| j kr(td��dS )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)rr r� r� r� )rX Z thread_idr r r r� j s
zBaseEventLoop._check_threadc G s@ | j � | jr| j|d� | j||�}|jr4|jd= | j� |S )z"Like call_soon(), but thread-safe.r� r r� )r� r� r� r� r� r� )rX r� r� r r r r r� { s z"BaseEventLoop.call_soon_threadsafec G sZ | j � | jr| j|d� |d kr@| j}|d kr@tjj� }|| _tj|j|f|�� | d�S )N�run_in_executor)rH ) r� r� r� rq �
concurrentr ZThreadPoolExecutorZ wrap_futureZsubmit)rX r� �funcr� r r r r� � s
z BaseEventLoop.run_in_executorc C s
|| _ d S )N)rq )rX r� r r r �set_default_executor� s z"BaseEventLoop.set_default_executorc C s� d||f g}|r |j d| � |r2|j d| � |rD|j d| � |rV|j d| � dj|�}tjd|� | j� }tj||||||�} | j� | }
d||
d | f }|
| jkr�tj|� n
tj|� | S )
Nz%s:%rz family=%rztype=%rzproto=%rzflags=%rz, zGet address info %sz(Getting address info %s took %.3f ms: %rg @�@) r9 �joinr r� rs r rF r} rI ) rX r; r< r= r> r? rB �msg�t0Zaddrinfo�dtr r r �_getaddrinfo_debug� s(
z BaseEventLoop._getaddrinfo_debugr )r= r> r? rB c C s> | j r | jd | j||||||�S | jd tj||||||�S d S )N)r� r� r� r rF )rX r; r< r= r> r? rB r r r rF � s
zBaseEventLoop.getaddrinfoc C s | j d tj||�S )N)r� r � getnameinfo)rX ZsockaddrrB r r r r� � s zBaseEventLoop.getnameinfo)�sslr= r? rB r% �
local_addrr� c # s |
dk r| rt d��|
dkr2|r2|s.t d��|}
|dk sD|dk �r�|dk rTt d��t||f|tj||| d�} | g} | dk r�t| |tj||| d�}
| j|
� nd}
tj| | d�E dH | j� }|s�td��|
dk r�|
j� }|s�td��g }�x�|D �]B\}}}}}y�tj|||d�}|j d � |
dk �r�x�|D ]j\}}}}}y|j
|� P W nH tk
�r� } z*t|j d
j ||j
j� ��}|j|� W Y dd}~X nX �q.W |j� d}w�| j�r�tjd ||� | j||�E dH W n^ tk
�r } z"|dk �r�|j� |j|� W Y dd}~X q� |dk �r,|j� � Y q�X P q�W t|�d k�rR|d
�nJt|d
�� t� fdd�|D ���r~|d
�tdj djdd� |D �����n,|dk�r�t d��t|j��s�t dj |���| j||||
�E dH \}}| j�r
|jd�}tjd|||||� ||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 hostz8host/port and sock can not be specified at the same time)r= r> r? rB rH )rH z!getaddrinfo() returned empty list)r= r> r? Fz2error while attempting to bind on address {!r}: {}zconnect %r to %rr r c 3 s | ]}t |�� kV qd S )N)r )r� rR )�modelr r � <genexpr> s z2BaseEventLoop.create_connection.<locals>.<genexpr>zMultiple exceptions: {}z, c s s | ]}t |�V qd S )N)r )r� rR r r r r� # s z5host and port was not specified and no sock specifiedz&A Stream Socket was expected, got {!r}r z %r connected to %s:%r: (%r, %r)) r! rK r r) r9 r r� r� r$ � setblocking�bind�errnor� �strerror�lowerra r� r r� � sock_connectr� r �allr� r+ r> � _create_connection_transport�get_extra_info)rX �protocol_factoryr; r< r� r= r? rB r% r� r� �f1�fs�f2�infosZ laddr_infos�
exceptionsr> ZcnamerG �_ZladdrrR � transportr� r )r� r �create_connection� s�
"
z BaseEventLoop.create_connectionc
c s� |j d� |� }| j� }|rFt|t�r*d n|}| j||||||d�} n| j|||�} y|E d H W n | j� � Y nX | |fS )NF)r� r� )r� rD r ry r� r� ra )
rX r% r� r� r� r� r� rd r� r� r r r r� = s
z*BaseEventLoop._create_connection_transport)r= r? rB �
reuse_address�
reuse_port�allow_broadcastr% c # sZ |
dk r�t |
j�s tdj|
���� s@�s@|s@|s@|s@|s@|s@| r~t� �|||||| d�} djdd� | j� D ��} tdj| ���|
jd� d}
�nL� p��s�|d kr�td
��||fdff}n�tj � }x�d � fd �ffD ]�\}}|dk r�t
|t �� r�t |�d k�st
d
��t||tj||| d�E dH }|�s.td��xB|D ]:\}}}}}||f}||k�r`ddg||< ||| |< �q4W q�W � �fdd�|j� D �}|�s�td��g }|dk�r�tjdk�o�tjdk}�x|D �]\\}}\}}d}
d}
y�tj|tj|d�}
|�r|
jtjtjd � |�r t|
� | �r4|
jtjtjd � |
jd� � �rN|
j|� ��rj| j |
|�E dH |}
W n^ tk
�r� } z"|
dk �r�|
j � |j |� W Y dd}~X n" |
dk �r�|
j � � Y nX P �q�W |d �|� } | j � } | j |
| |
| �} | j!�r,� �r t"j#d� �| | � nt"j$d�| | � y| E dH W n | j � � Y nX | | fS )zCreate datagram connection.Nz#A UDP Socket was expected, got {!r})r� � remote_addrr= r? rB r� r� r z, c s s" | ]\}}|rd j ||�V qdS )z{}={}N)r� )r� �k�vr r r r� i s z9BaseEventLoop.create_datagram_endpoint.<locals>.<genexpr>zNsocket modifier keyword arguments can not be used when sock is specified. ({})Fr zunexpected address familyr rC z2-tuple is expected)r= r> r? rB rH z!getaddrinfo() returned empty listc s8 g | ]0\}}� r |d dkp*�o*|d dks||f�qS )r Nr r )r� �keyZ addr_pair)r� r r r r� � s z:BaseEventLoop.create_datagram_endpoint.<locals>.<listcomp>z can not get address information�posix�cygwin)r= r> r? z@Datagram endpoint local_addr=%r remote_addr=%r created: (%r, %r)z2Datagram endpoint remote_addr=%r created: (%r, %r))NN)%r- r> r! r� �dictr� �itemsr� rm � OrderedDictr �tupler� r] rK r r, r$ rz �namerw �platformr" r# � SO_REUSEADDRr& Z SO_BROADCASTr� r� ra r9 rD r� r� r rI r� ) rX r� r� r r= r? rB r� r� r r% ZoptsZproblemsZr_addrZaddr_pairs_infoZ
addr_infos�idxZaddrr� Zfamr� ZprorG r r� Z
local_addressZremote_addressrR r� rd r� r )r� r r �create_datagram_endpointU s�
z&BaseEventLoop.create_datagram_endpointc c s4 t ||f|tj|| d�E d H }|s0tdj|���|S )N)r= r> rB rH z%getaddrinfo({!r}) returned empty list)rK r r) r$ r� )rX r; r< r= rB r� r r r �_create_server_getaddrinfo� s
z(BaseEventLoop._create_server_getaddrinfor )r= rB r% �backlogr� r� r� c # s� t |t�rtd��|dk s$�dk �r|dk r4td��| dkrPtjdkoNtjdk} g } |dkrddg} n$t |t�s|t |t j
� r�|g} n|} � ���fdd�| D �}
t j |
d �i�E dH }t
tjj|��}d
}�z �x|D �]
}|\}}}}}ytj|||�}W n6 tjk
�r2 �j�r,tjd |||d d
� w�Y nX | j|� | �rV|jtjtjd � |
�rdt|� t�r�|tj k�r�t td��r�|jtj tj d � y|j |� W q� t!k
�r� } z t!|j"d||j#j$� f ��W Y dd}~X q�X q�W d }W d|�s x| D ]}|j%� �q�W X n2|dk�r"td��t&|j'��s<tdj(|���|g} t)�| �}x4| D ],}|j*|� |j+d
� �j,|||||� �qRW �j�r�tj-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 NoneNz8host/port and sock can not be specified at the same timer r r0 c s g | ]}�j |�� �d ��qS ))r= rB )r )r� r; )r= rB r< rX r r r� s z/BaseEventLoop.create_server.<locals>.<listcomp>rH Fz:create_server() failed to create socket.socket(%r, %r, %r)T)�exc_info� IPPROTO_IPV6z0error while attempting to bind on address %r: %sz)Neither host/port nor sock were specifiedz&A Stream Socket was expected, got {!r}z
%r is serving).r ry r5 r! rz r rw r r rm �Iterabler r� �set� itertools�chain�
from_iterabler �errorr� r �warningr9 r" r# r
r& r8 r r r Z IPV6_V6ONLYr� r$ r� r� r� ra r+ r> r� rT Zlistenr� Z_start_servingrI )rX r� r; r< r= rB r% r r� r� r� rU Zhostsr� r� Z completed�resr@ Zsocktyper? Z canonnameZsa�errr� r )r= rB r< rX r �
create_server� s�
(
zBaseEventLoop.create_server)r� c c s^ t |j�stdj|���| j|||ddd�E dH \}}| jrV|jd�}tjd|||� ||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.
z&A Stream Socket was expected, got {!r}r0 T)r� Nr z%r handled: (%r, %r)) r+ r> r! r� r� r� r� r r� )rX r� r% r� r� r� r r r �connect_accepted_socketA s
z%BaseEventLoop.connect_accepted_socketc c sd |� }| j � }| j|||�}y|E d H W n |j� � Y nX | jr\tjd|j� ||� ||fS )Nz Read pipe %r connected: (%r, %r))rD r� ra r� r r� �fileno)rX r� r� r� rd r� r r r �connect_read_pipeX s z BaseEventLoop.connect_read_pipec c sd |� }| j � }| j|||�}y|E d H W n |j� � Y nX | jr\tjd|j� ||� ||fS )Nz!Write pipe %r connected: (%r, %r))rD r� ra r� r r� r )rX r� r� r� rd r� r r r �connect_write_pipei s z BaseEventLoop.connect_write_pipec C s� |g}|d k r |j dt|� � |d k rF|tjkrF|j dt|� � n4|d k r`|j dt|� � |d k rz|j dt|� � tjdj|�� d S )Nzstdin=%szstdout=stderr=%sz stdout=%sz stderr=%s� )r9 r r r r r� r� )rX r� r� r� r� rI r r r �_log_subprocessz s z BaseEventLoop._log_subprocessT)r� r� r� �universal_newlinesr� r� c
k s� t |ttf�std��|r"td��|s.td��|dkr>td��|� }
d } | jrfd| } | j| |||� | j|
|d||||f| �E d H } | jr�| d k r�tjd| | � | |
fS ) Nzcmd must be a stringz universal_newlines must be Falsezshell must be Truer zbufsize must be 0zrun shell command %rTz%s: %r) r r3 r r! r� r# r� r rI )
rX r� �cmdr� r� r� r$ r� r� r� r� � debug_logr� r r r �subprocess_shell� s$ z BaseEventLoop.subprocess_shellc o s� |r t d��|rt d��|dkr(t d��|f| } x,| D ]$} t| ttf�s8tdt| �j ��q8W |� }
d }| jr�d| }| j||||� | j |
| d||||f|
�E d H }| jr�|d k r�t
j d||� ||
fS ) Nz universal_newlines must be Falsezshell must be Falser zbufsize must be 0z8program arguments must be a bytes or text string, not %szexecute program %rFz%s: %r) r! r r r3 r5 r> r[ r� r# r� r rI )rX r� Zprogramr� r� r� r$ r� r� r� r� Z
popen_args�argr� r& r� r r r �subprocess_exec� s,
z BaseEventLoop.subprocess_execc C s | j S )zKReturn an exception handler, or None if the default one is in use.
)ru )rX r r r �get_exception_handler� s z#BaseEventLoop.get_exception_handlerc C s* |dk r t |� r tdj|���|| _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})r� r5 r� ru )rX Zhandlerr r r �set_exception_handler� s z#BaseEventLoop.set_exception_handlerc C s |j d�}|sd}|j d�}|dk r6t|�||jf}nd}d|kr`| jdk r`| jjr`| jj|d< |g}x�t|�D ]�}|dkr~qp|| }|dkr�djtj|��}d }||j � 7 }n2|dkr�djtj|��}d
}||j � 7 }nt
|�}|j d j ||�� qpW t
jd j|�|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 loopr� NFZsource_tracebackZhandle_tracebackr0 z+Object created at (most recent call last):
z+Handle created at (most recent call last):
z{}: {}�
)r > r� r� )r| r> �
__traceback__r~ r� �sortedr� � traceback� format_list�rstripr r9 r� r r ) rX �contextr� r� r Z log_linesr �value�tbr r r �default_exception_handler� s6
z'BaseEventLoop.default_exception_handlerc C s� | j dkr>y| j|� W q� tk
r: tjddd� Y q�X nny| j | |� W n\ tk
r� } z@y| jd||d�� W n" tk
r� tjddd� Y nX W Y dd}~X nX dS )a 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;
- '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 handlerT)r z$Unhandled error in exception handler)r� r� r2 zeException in default exception handler while handling an unexpected error in custom exception handler)ru r5 rO r r )rX r2 rR r r r r� s"
z$BaseEventLoop.call_exception_handlerc C s@ t |tj�std��|jr dS t |tj� s0t�| jj|� dS )z3Add a Handle to _scheduled (TimerHandle) or _ready.zA Handle is required hereN)r r r� r] �
_cancelledr� ro r9 )rX r r r r �
_add_callback9 s
zBaseEventLoop._add_callbackc C s | j |� | j� dS )z6Like _add_callback() but called from a signal handler.N)r7 r� )rX r r r r �_add_callback_signalsafeA s
z&BaseEventLoop._add_callback_signalsafec C s |j r| jd7 _dS )z3Notification that a TimerHandle has been cancelled.r N)rp rj )rX r r r r �_timer_handle_cancelledF s z%BaseEventLoop._timer_handle_cancelledc C s� t | j�}|tkrd| j| tkrdg }x&| jD ] }|jr>d|_q,|j|� q,W tj|� || _d| _n8x6| jr�| jd jr�| jd8 _tj | j�}d|_qfW d}| j
s�| j r�d}n*| jr�| jd j }t
td|| j� �t�}| jo�|dk�r�| j� }| jj|�}| j� | }|dk�r tj} ntj} t |�}
|dk�rLtj| d|d |
� nD|
�rntj| d|d |d |
� n"|dk�r�tj| d |d |d � n | jj|�}| j|� | j� | j } xD| j�r�| jd }|j | k�r�P tj | j�}d|_| j
j|� �q�W t | j
�} x�t| �D ]|}
| j
j � }|j�r*�q| j�r�zD|| _ | j� }|j � | j� | }|| j k�rttj d
t!|�|� W dd| _ X n|j � �qW d}dS ) z�Run one full iteration of the event loop.
This calls all currently ready callbacks, polls for I/O,
schedules the resulting callbacks, and finally schedules
'call_later' callbacks.
Fr r Ng �?z poll took %.3f ms: %s eventsg @�@z$poll %.3f ms took %.3f ms: %s eventsz"poll %.3f ms took %.3f ms: timeoutz Executing %s took %.3f seconds)"r� rp � _MIN_SCHEDULED_TIMER_HANDLESrj �%_MIN_CANCELLED_TIMER_HANDLES_FRACTIONr6 r9 r� �heapify�heappopro rl Z_when�min�maxrs �MAXIMUM_SELECT_TIMEOUTr� Z _selectorZselect�logging�INFO�DEBUGr �logr� rt �range�popleftr~ Z_runr} r r )rX Z sched_countZ
new_scheduledr Ztimeoutr� r� r� r� �levelZneventZend_timeZntodo�ir r r r� K s�
zBaseEventLoop._run_oncec C s� yt j}t j}W n tk
r$ d S X t|�}| j|kr<d S tj}|� }|rz|d |fkrjtj d| t
� q�||� d| _n,|d |fkr�tj d| t
� n|d � d| _d S )Nz[loop.set_debug(True): cannot set debug coroutine wrapper; another wrapper is already set %rTzWloop.set_debug(False): cannot unset debug coroutine wrapper; another wrapper was set %rF) rw �set_coroutine_wrapper�get_coroutine_wrapper�AttributeErrorry r� r Z
debug_wrapperr� r� �RuntimeWarning)rX �enabledZ set_wrapperZ get_wrapper�wrapperZcurrent_wrapperr r r r� � s.
z$BaseEventLoop._set_coroutine_wrapperc C s | j S )N)r� )rX r r r r� � s zBaseEventLoop.get_debugc C s || _ | j� r| j|� d S )N)r� r� r� )rX rM r r r rv � s zBaseEventLoop.set_debug)N)N)NNN)NN)NN)N)r )NN)F)NN)NN)Gr[ rf rg rY r\ rD r� r� r� r� r� r� r� r� r r� r� r� r� r� r� r� r� r� rQ ra r� r ZPY34r� r� rs r� r� r� r� r� r� r� r� r� r� rF r� r� r� r r r r6 Z
AI_PASSIVEr r r r! r# r r r' r) r* r+ r5 r� r7 r8 r9 r� r� r� rv r r r r r
� s� !
%
u `
12c!i�Q )2�__doc__rm Zconcurrent.futuresr� r� �inspectr rA rz r r r� rs r/ rw r� r� r0 r r r r r r rD r �__all__r: r; �BrokenPipeError�ConnectionResetError�ConnectionAbortedErrorZ_FATAL_ERROR_IGNOREr r8 r@ r r r& r+ r- rA r) rK rM rS ZAbstractServerrT ZAbstractEventLoopr
r r r r �<module> sV
;
/PK [���� � $ __pycache__/log.cpython-36.opt-1.pycnu �[��� 3
\| � @ s d Z ddlZeje�ZdS )zLogging configuration.� N)�__doc__ZloggingZ getLogger� __package__Zlogger� r r �#/usr/lib64/python3.6/asyncio/log.py�<module> s PK [K�[ [ * __pycache__/protocols.cpython-36.opt-1.pycnu �[��� 3
\� � @ sR d Z ddddgZG dd� d�ZG dd� de�ZG dd� de�ZG dd� de�Zd S )
zAbstract Protocol class.� BaseProtocol�Protocol�DatagramProtocol�SubprocessProtocolc @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � 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 )z�Called 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.
N� )�selfZ transportr r �)/usr/lib64/python3.6/asyncio/protocols.py�connection_made s z BaseProtocol.connection_madec C s dS )z�Called 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_writing7 s zBaseProtocol.resume_writingN)�__name__�
__module__� __qualname__�__doc__r r
r r r r r r r s
c @ s e Zd ZdZdd� 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()
c C s dS )zTCalled when some data is received.
The argument is a bytes object.
Nr )r �datar r r �
data_receivedX s zProtocol.data_receivedc C s dS )z�Called 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_received^ s zProtocol.eof_receivedN)r
r r r r r r r r r r > s c @ s e Zd ZdZdd� Zdd� ZdS )r z Interface for datagram protocol.c C s dS )z&Called when some datagram is received.Nr )r r Zaddrr r r �datagram_receivedj 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 r �error_receivedm s z DatagramProtocol.error_receivedN)r
r r r r r r r r r r g s c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) r z,Interface for protocol for subprocess calls.c C s dS )z�Called 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_receivedw s z%SubprocessProtocol.pipe_data_receivedc C s dS )z�Called 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 t s N)r �__all__r r r r r r r r �<module> s 7)
PK ["4�� � ' __pycache__/queues.cpython-36.opt-2.pycnu �[��� 3
\ � @ s� d ddddgZ ddlZddlZddlmZ dd lmZ dd
lmZ dd lmZ G d d� de �Z
G d
d� de �Z G dd � d �Z G dd� de �Z
G dd� de �Zejs�e Ze jd� dS )�Queue�
PriorityQueue� LifoQueue� QueueFull�
QueueEmpty� N� )�compat)�events)�locks)� coroutinec @ s e Zd ZdS )r N)�__name__�
__module__� __qualname__� r r �&/usr/lib64/python3.6/asyncio/queues.pyr s c @ s e Zd ZdS )r N)r r
r r r r r r s c @ s� e Zd Zd(dd�dd�Zdd� Zdd � Zd
d � Zd d
� Zdd� Zdd� Z dd� Z
dd� Z e dd� �Z
dd� Zdd� Zed d � �Zd d � Zed d!� �Zd"d#� Zd$d%� Zed&d'� �ZdS ))r r N)�loopc C sb |d krt j� | _n|| _|| _tj� | _tj� | _d| _t j
| jd�| _ | j j � | j
|� d S )Nr )r )r Zget_event_loop�_loop�_maxsize� collections�deque�_getters�_putters�_unfinished_tasksr
ZEvent� _finished�set�_init)�self�maxsizer r r r �__init__( s
zQueue.__init__c C s t j� | _d S )N)r r �_queue)r r r r r r : s z Queue._initc C s
| j j� S )N)r �popleft)r r r r �_get= s z
Queue._getc C s | j j|� d S )N)r �append)r �itemr r r �_put@ s z
Queue._putc C s* x$|r$|j � }|j� s|jd � P qW d S )N)r �doneZ
set_result)r �waitersZwaiterr r r � _wakeup_nextE s
zQueue._wakeup_nextc C s dj t| �jt| �| j� �S )Nz<{} at {:#x} {}>)�format�typer �id�_format)r r r r �__repr__M s zQueue.__repr__c C s dj t| �j| j� �S )Nz<{} {}>)r( r) r r+ )r r r r �__str__Q s z
Queue.__str__c C sz dj | j�}t| dd �r,|dj t| j��7 }| jrF|dj t| j��7 }| jr`|dj t| j��7 }| jrv|dj | j�7 }|S )Nz maxsize={!r}r z _queue={!r}z
_getters[{}]z
_putters[{}]z tasks={}) r( r �getattr�listr r �lenr r )r �resultr r r r+ T s z
Queue._formatc C s
t | j�S )N)r0 r )r r r r �qsize` s z Queue.qsizec C s | j S )N)r )r r r r r d s z
Queue.maxsizec C s | j S )N)r )r r r r �emptyi s z Queue.emptyc C s | j dkrdS | j� | j kS d S )Nr F)r r2 )r r r r �fullm s
z
Queue.fullc c st xh| j � rh| jj� }| jj|� y|E d H W q |j� | j � r^|j� r^| j| j� � Y qX qW | j|�S )N) r4 r �
create_futurer r" �cancel� cancelledr' �
put_nowait)r r# Zputterr r r �putx s
z Queue.putc C s> | j � r t�| j|� | jd7 _| jj� | j| j� d S )Nr )r4 r r$ r r �clearr' r )r r# r r r r8 � s
zQueue.put_nowaitc c s� x�| j � r�| jj� }| jj|� y|E d H W q |j� y| jj|� W n tk
rb Y nX | j � r�|j� r�| j | j� � Y qX qW | j
� S )N) r3 r r5 r r" r6 �remove�
ValueErrorr7 r' �
get_nowait)r �getterr r r �get� s
z Queue.getc C s$ | j � r t�| j� }| j| j� |S )N)r3 r r! r' r )r r# r r r r= � s
zQueue.get_nowaitc C s8 | j dkrtd��| j d8 _ | j dkr4| jj� d S )Nr z!task_done() called too many timesr )r r< r r )r r r r � task_done� s
zQueue.task_donec c s | j dkr| jj� E d H d S )Nr )r r �wait)r r r r �join� s
z
Queue.join)r )r r
r r r r! r$ r' r, r- r+ r2 �propertyr r3 r4 r r9 r8 r? r= r@ rB r r r r r s$ c @ s0 e Zd Zdd� Zejfdd�Zejfdd�ZdS )r c C s
g | _ d S )N)r )r r r r r r � s zPriorityQueue._initc C s || j |� d S )N)r )r r# �heappushr r r r$ � s zPriorityQueue._putc C s
|| j �S )N)r )r �heappopr r r r! � s zPriorityQueue._getN) r r
r r �heapqrD r$ rE r! r r r r r � s c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )r c C s
g | _ d S )N)r )r r r r r r � s zLifoQueue._initc C s | j j|� d S )N)r r" )r r# r r r r$ � s zLifoQueue._putc C s
| j j� S )N)r �pop)r r r r r! � s zLifoQueue._getN)r r
r r r$ r! r r r r r � s �
JoinableQueue)�__all__r rF � r r r
Z
coroutinesr � Exceptionr r r r r ZPY35rH r" r r r r �<module> s H
PK [��yO yO # __pycache__/sslproto.cpython-36.pycnu �[��� 3
\�e �
@ s� d dl Z d dlZy d dlZW n ek
r4 dZY nX ddlmZ ddlmZ ddlmZ ddlmZ ddl m
Z
dd � Z d
d � Z d Z
d
ZdZdZG dd� de�ZG dd� dejej�ZG dd� dej�ZdS )� N� )� base_events)�compat)� protocols)�
transports)�loggerc C sj | r t d��ttd�r*tj� }|sfd|_n<tjtj�}| jtjO _| jtj O _|j
� tj |_ |S )Nz(Server side SSL needs a valid SSLContext�create_default_contextF)
�
ValueError�hasattr�sslr �check_hostnameZ
SSLContextZPROTOCOL_SSLv23ZoptionsZ OP_NO_SSLv2Z OP_NO_SSLv3Zset_default_verify_pathsZ
CERT_REQUIRED� verify_mode)� server_side�server_hostname�
sslcontext� r �(/usr/lib64/python3.6/asyncio/sslproto.py�_create_transport_context s
r c C s
t td�S )N� MemoryBIO)r
r r r r r �_is_sslproto_available% s r Z UNWRAPPEDZ DO_HANDSHAKEZWRAPPEDZSHUTDOWNc @ s~ e Zd ZdZdZd dd�Zedd� �Zed d
� �Zed d � �Z ed
d� �Z
d dd�Z d dd�Z dd� Z
d dd�Zd dd�ZdS )!�_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| _tj� | _tj� | _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 r � _incoming� _outgoing�_sslobj�
_need_ssldata�
_handshake_cb� _shutdown_cb)�self�contextr r r r r �__init__D s
z_SSLPipe.__init__c C s | j S )z*The SSL context passed to the constructor.)r )r# r r r r$ Z 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_object_ 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_ssldatag s z_SSLPipe.need_ssldatac C s
| j tkS )zj
Whether a security layer is currently in effect.
Return False during handshake.
)r �_WRAPPED)r# r r r �wrappedm s z_SSLPipe.wrappedc C sb | j tkrtd��| jj| j| j| j| jd�| _ t
| _ || _ | j ddd�\}}t
|�dks^t�|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_handshaker )r r � RuntimeErrorr Zwrap_bior r r r r �
_DO_HANDSHAKEr! � feed_ssldata�len�AssertionError)r# �callback�ssldata�appdatar r r � do_handshakev s
z_SSLPipe.do_handshakec C sj | j tkrtd��| j tkr$td��| j ttfks6t�t| _ || _| jd�\}}|g ksf|dgksft�|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- r0 r" r. )r# r1 r2 r3 r r r �shutdown� s
z_SSLPipe.shutdownc C s2 | j j� | jd�\}}|g ks.|dgks.t�dS )z�Send a potentially "ragged" EOF.
This method will raise an SSL_ERROR_EOF exception if the EOF is
unexpected.
r* N)r Z write_eofr. r0 )r# r2 r3 r r r �feed_eof� s
z_SSLPipe.feed_eofFc C s� | j tkr"|r|g}ng }g |fS d| _|r8| jj|� g }g }y�| j tkrx| jj� t| _ | j rl| j d� |rx||fS | j tkr�xn| jj
| j �}|j |� |s�P q�W nJ| j t
kr�| jj� d| _t| _ | jr�| j� n| j tkr�|j | jj
� � W nx tjtjfk
�rl } zRt|dd�tjtjtjfk�rN| j tk�rL| j �rL| j |� � |jtjk| _W Y dd}~X nX | jj�r�|j | jj
� � ||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().
FN�errno)r r r r �writer- r r4 r( r! �read�max_size�appendr5 Zunwrapr" r �SSLError�CertificateError�getattr�SSL_ERROR_WANT_READ�SSL_ERROR_WANT_WRITE�SSL_ERROR_SYSCALLr8 r �pending)r# �datar+ r3 r2 �chunk�excr r r r. � sV
z_SSLPipe.feed_ssldatar c C s, d| kot |�kn s t�| jtkrV|t |�k rF||d� g}ng }|t |�fS g }t|�}x�d| _y(|t |�k r�|| jj||d� �7 }W n\ tj k
r� } z>|j
dkr�tj |_ |j tj tj
tjfkrЂ |j tj k| _W Y dd}~X nX | jj�r
|j| jj� � |t |�k�s | jrdP qdW ||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.
r NFZPROTOCOL_IS_SHUTDOWN)r/ r0 r r �
memoryviewr r r9 r r= �reasonr@ r8 rA rB r rC r< r: )r# rD �offsetr2 ZviewrF r r r � feed_appdata� s4
z_SSLPipe.feed_appdatai )N)N)N)F)r )�__name__�
__module__� __qualname__�__doc__r; r% �propertyr$ r& r' r) r4 r6 r7 r. rJ r r r r r 0 s
Jr c @ s� e Zd Zdd� Zd dd�Zdd� Zdd � Zd
d � Zd d
� Ze j
rHdd� Z dd� Z dd� Z
d dd�Zdd� Zdd� Zdd� 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 j||�S )z#Get optional transport information.)rR �_get_extra_info)r# �name�defaultr r r �get_extra_info/ s z$_SSLProtocolTransport.get_extra_infoc C s || j _d S )N)rR �
_app_protocol)r# �protocolr r r � set_protocol3 s z"_SSLProtocolTransport.set_protocolc C s | j jS )N)rR rY )r# r r r � get_protocol6 s z"_SSLProtocolTransport.get_protocolc C s | j S )N)rS )r# r r r �
is_closing9 s z _SSLProtocolTransport.is_closingc C s d| _ | jj� 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)rS rR �_start_shutdown)r# r r r �close< s z_SSLProtocolTransport.closec C s& | j s"tjd| t| d� | j� d S )Nzunclosed transport %r)�source)rS �warnings�warn�ResourceWarningr_ )r# r r r �__del__K s z _SSLProtocolTransport.__del__c C s | j jj� dS )z�Pause the receiving end.
No data will be passed to the protocol's data_received()
method until resume_reading() is called.
N)rR �
_transport�
pause_reading)r# r r r rf Q s z#_SSLProtocolTransport.pause_readingc C s | j jj� dS )z�Resume the receiving end.
Data received will once again be passed to the protocol's
data_received() method.
N)rR re �resume_reading)r# r r r rg Y s z$_SSLProtocolTransport.resume_readingc C s | j jj||� 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)rR re �set_write_buffer_limits)r# ZhighZlowr r r rh a s z-_SSLProtocolTransport.set_write_buffer_limitsc C s | j jj� S )z,Return the current size of the write buffer.)rR re �get_write_buffer_size)r# r r r ri v s z+_SSLProtocolTransport.get_write_buffer_sizec C s< t |tttf�s$tdjt|�j���|s,dS | jj |� dS )z�Write 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 {!r}N)
�
isinstance�bytes� bytearrayrG � TypeError�format�typerK rR �_write_appdata)r# rD r r r r9 z 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 j� dS )z�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.
N)rR �_abort)r# r r r �abort� s z_SSLProtocolTransport.abort)N)NN)rK rL rM r% rX r[ r\ r] r_ r ZPY34rd rf rg rh ri r9 rq rs r r r r rP & s
rP c @ s� e Zd ZdZd(dd�Zd)dd�Zd d
� Zd d � Zd
d� Zdd� Z dd� Z
dd� Z d*dd�Z dd� Z
dd� Zdd � Zd d � Zd d � Zd+d"d#�Zd$d%� Zd&d'� ZdS ),� SSLProtocolz�SSL 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��|s t||�}|| _|r6| r6|| _nd | _|| _t|d�| _tj � | _
d| _ || _ || _
|| _t| j
| �| _d | _d| _d| _d| _d | _|| _d S )Nz stdlib ssl module not available)r r F)r r, r r r � _sslcontext�dict�_extra� collections�deque�_write_backlog�_write_buffer_size�_waiterrQ rY rP �_app_transport�_sslpipe�_session_established�
_in_handshake� _in_shutdownre �_call_connection_made)r# rT Z app_protocolr Zwaiterr r Zcall_connection_mader r r r% � s,
zSSLProtocol.__init__c C sD | j d krd S | j j� s:|d k r.| j j|� n | j jd � d | _ d S )N)r| Z cancelledZ
set_exceptionZ
set_result)r# rF r r r �_wakeup_waiter� s
zSSLProtocol._wakeup_waiterc C s& || _ t| j| j| j�| _| j� dS )zXCalled when the low-level connection is made.
Start the SSL handshake.
N)re r ru r r r~ �_start_handshake)r# � transportr r r �connection_made� s
zSSLProtocol.connection_madec C s8 | j r d| _ | jj| jj|� d| _d| _| j|� dS )z�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).
FN)r rQ � call_soonrY �connection_lostre r} r� )r# rF r r r r� � s zSSLProtocol.connection_lostc C s | j j� dS )z\Called when the low-level transport's buffer goes over
the high-water mark.
N)rY �
pause_writing)r# r r r r� � s zSSLProtocol.pause_writingc C s | j j� dS )z^Called when the low-level transport's buffer drains below
the low-water mark.
N)rY �resume_writing)r# r r r r� � s zSSLProtocol.resume_writingc C s� | j dkrdS y| j j|�\}}W nH tjk
rj } z*| jj� rTtjd| |j|j � | j
� dS d}~X nX x|D ]}| j j |� qrW x(|D ] }|r�| j
j|� q�| j� P q�W dS )zXCalled when some SSL data is received.
The argument is a bytes object.
Nz %r: SSL error %s (reason %s))r~ r. r r= rQ � get_debugr �warningr8 rH rr re r9 rY �
data_receivedr^ )r# rD r2 r3 �erE r r r r� � s"
zSSLProtocol.data_receivedc
C sT zB| j j� rtjd| � | jt� | js@| jj� }|r@tj d� W d| j
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) rQ r� r �debugr� �ConnectionResetErrorr� rY � eof_receivedr� re r_ )r# Z keep_openr r r r� s
zSSLProtocol.eof_receivedc C s4 || j kr| j | S | jd k r,| jj||�S |S d S )N)rw re rX )r# rV rW r r r rU ! s
zSSLProtocol._get_extra_infoc C s. | j r
d S | jr| j� nd| _ | jd� d S )NTr* )r� r� rr rp )r# r r r r^ ) s
zSSLProtocol._start_shutdownc C s. | j j|df� | jt|�7 _| j� d S )Nr )rz r< r{ r/ �_process_write_backlog)r# rD r r r rp 2 s zSSLProtocol._write_appdatac C sH | j j� r$tjd| � | j j� | _nd | _d| _| jjd� | j � d S )Nz%r starts SSL handshakeTr* r )r* r )
rQ r� r r� �time�_handshake_start_timer� rz r< r� )r# r r r r� 7 s
z SSLProtocol._start_handshakec C sT d| _ | jj}yF|d k r |�|j� }t| jd�sR| jrR| jjtj krRtj
|| j� W n~ t k
r� } zb| j j
� r�t|tj�r�tjd| dd� ntjd| dd� | jj� t|t�r�| j|� d S � W Y d d }~X nX | j j
� �r| j j� | j }tjd| |d � | jj||j� |j � |d � | j �r4| j j | j � | j� d| _!| j j"| j#� d S )
NFr z5%r: SSL handshake failed on verifying the certificateT)�exc_infoz%r: SSL handshake failedz %r: SSL handshake took %.1f msg @�@)�peercert�cipher� compressionr& )$r� r~ r& Z getpeercertr
ru r r
r Z CERT_NONEZmatch_hostname�
BaseExceptionrQ r� rj r> r r� re r_ � Exceptionr� r� r� r� rw �updater� r� r� rY r� r} r r� r� )r# Z
handshake_excZsslobjr� rF Zdtr r r �_on_handshake_completeC sD
z"SSLProtocol._on_handshake_completec C sJ | j d ks| jd krd S y�x�tt| j��D ]�}| jd \}}|rT| jj||�\}}n*|rl| jj| j�}d}n| jj| j �}d}x|D ]}| j j
|� q�W |t|�k r�||f| jd< | jj s�t �| j j
r�| j j� P | jd= | jt|�8 _q*W W nR tk
�rD } z4| j�r| j|� n | j|d� t|t��s4� W Y d d }~X nX d S )Nr r z Fatal error on SSL transport)re r~ �ranger/ rz rJ r4 r� r6 � _finalizer9 r' r0 Z_pausedrg r{ r� r� � _fatal_errorrj r� )r# �irD rI r2 rE rF r r r r� w s:
z"SSLProtocol._process_write_backlog�Fatal error on transportc C sX t |tj�r*| jj� rBtjd| |dd� n| jj||| j| d�� | jrT| jj |� d S )Nz%r: %sT)r� )�messageZ exceptionr� rZ )
rj r Z_FATAL_ERROR_IGNORErQ r� r r� Zcall_exception_handlerre Z _force_close)r# rF r� r r r r� � s
zSSLProtocol._fatal_errorc C s d | _ | jd k r| jj� d S )N)r~ re r_ )r# r r r r� � s
zSSLProtocol._finalizec
C s( z| j d k r| j j� W d | j� X d S )N)re rs r� )r# r r r rr � s
zSSLProtocol._abort)FNT)N)N)r� )rK rL rM rN r% r� r� r� r� r� r� r� rU r^ rp r� r� r� r� r� rr r r r r rt � s&
"
4,
rt )rx ra r � ImportError� r r r r �logr r r r r- r( r5 �objectr Z_FlowControlMixinZ TransportrP ZProtocolrt r r r r �<module> s*
wnPK [��ь� � * __pycache__/constants.cpython-36.opt-1.pycnu �[��� 3
\s � @ s d Z dZdZdZdS )z
Constants.� � �
N)�__doc__Z!LOG_THRESHOLD_FOR_CONNLOST_WRITESZACCEPT_RETRY_DELAYZDEBUG_STACK_DEPTH� r r �)/usr/lib64/python3.6/asyncio/constants.py�<module> s PK [Ea�#m m 0 __pycache__/selector_events.cpython-36.opt-2.pycnu �[��� 3
\�� �
@ s8 d gZ ddlZddlZddlZddlZddlZddlZy ddlZW n ek
rZ dZY nX ddl m
Z
ddl m Z ddl m Z ddl m
Z
ddl mZ dd l mZ dd
l mZ dd l mZ dd lmZ dd
lmZ dd� ZG dd � d e
j�ZG dd� dejej�ZG dd� de�Z G dd� de�Z G dd� de�Z dS )�BaseSelectorEventLoop� N� )� base_events)�compat)� constants)�events)�futures)� selectors)�
transports)�sslproto)� coroutine)�loggerc C s6 y| j |�}W n tk
r" dS X t|j|@ �S d S )NF)�get_key�KeyError�boolr )�selector�fdZevent�key� r �//usr/lib64/python3.6/asyncio/selector_events.py�_test_selector_event s
r c sn e Zd ZdN� fdd� ZdOddd�dd�ZdPddddd�d d
�Zddddd�d d �ZdQd
d�Z� fdd�Zdd� Z dd� Z
dd� Z dd� Z dd� Z
dd � ZdRd d �ZdSd d!�ZedTd"d#��Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Zd4d5� Zd6d7� Z d8d9� Z d:d;� Z d<d=� Z ed>d?� �Z d@dA� Z!dBdC� Z"dDdE� Z#dFdG� Z$dHdI� Z%dJdK� Z&dLdM� Z'� Z(S )Ur Nc sF t � j� |d krtj� }tjd|jj� || _| j � t
j � | _ d S )NzUsing selector: %s)
�super�__init__r ZDefaultSelectorr
�debug� __class__�__name__� _selector�_make_self_pipe�weakref�WeakValueDictionary� _transports)�selfr )r r r r 1 s
z BaseSelectorEventLoop.__init__)�extra�serverc C s t | |||||�S )N)�_SelectorSocketTransport)r! �sock�protocol�waiterr" r# r r r �_make_socket_transport; s
z,BaseSelectorEventLoop._make_socket_transportF)� server_side�server_hostnamer" r# c
C sN t j� s"| j||||||||d�S t j| |||||�} t| || ||d� | jS )N)r) r* r" r# )r" r# )r Z_is_sslproto_available�_make_legacy_ssl_transportZ SSLProtocolr$ Z_app_transport)
r! �rawsockr& �
sslcontextr' r) r* r" r# Z ssl_protocolr r r �_make_ssl_transport@ s
z)BaseSelectorEventLoop._make_ssl_transportc
C s t | ||||||||� S )N)�_SelectorSslTransport) r! r, r& r- r' r) r* r" r# r r r r+ O s
z0BaseSelectorEventLoop._make_legacy_ssl_transportc C s t | |||||�S )N)�_SelectorDatagramTransport)r! r% r& �addressr' r" r r r �_make_datagram_transportY s z.BaseSelectorEventLoop._make_datagram_transportc sL | j � rtd��| j� r d S | j� t� j� | jd k rH| jj� d | _d S )Nz!Cannot close a running event loop)Z
is_running� RuntimeError� is_closed�_close_self_piper �closer )r! )r r r r6 ^ s
zBaseSelectorEventLoop.closec C s t �d S )N)�NotImplementedError)r! r r r � _socketpairi s z!BaseSelectorEventLoop._socketpairc C sB | j | jj� � | jj� d | _| jj� d | _| jd8 _d S )Nr )�_remove_reader�_ssock�filenor6 �_csock�
_internal_fds)r! r r r r5 l s
z&BaseSelectorEventLoop._close_self_pipec C sN | j � \| _| _| jjd� | jjd� | jd7 _| j| jj� | j� d S )NFr )r8 r: r< � setblockingr= � _add_readerr; �_read_from_self)r! r r r r t s
z%BaseSelectorEventLoop._make_self_pipec C s d S )Nr )r! �datar r r �_process_self_data| s z(BaseSelectorEventLoop._process_self_datac C sV xPy | j jd�}|sP | j|� W q tk
r8 wY q tk
rL P Y qX qW d S )Ni )r: �recvrB �InterruptedError�BlockingIOError)r! rA r r r r@ s z%BaseSelectorEventLoop._read_from_selfc C sJ | j }|d k rFy|jd� W n( tk
rD | jr@tjddd� Y nX d S )N� z3Fail to write a null byte into the self-pipe socketT)�exc_info)r< �send�OSError�_debugr
r )r! Zcsockr r r �_write_to_self� s z$BaseSelectorEventLoop._write_to_self�d c C s | j |j� | j|||||� d S )N)r? r; �_accept_connection)r! �protocol_factoryr% r- r# �backlogr r r �_start_serving� s z$BaseSelectorEventLoop._start_servingc C s� x�t |�D ]�}y0|j� \}}| jr2tjd|||� |jd� W n� tttfk
rX d S t k
r� } z^| j
t
j t
j t
j
t
jfkr�| jd| |d�� | j|j� � | jtj| j|||||� n� W Y d d } ~ X q
X d|i}
| j|||
||�} | j| � q
W d S )Nz#%r got a new connection from %r: %rFz&socket.accept() out of system resource)�message� exception�socket�peername)�range�acceptrJ r
r r> rE rD �ConnectionAbortedErrorrI �errnoZEMFILEZENFILEZENOBUFSZENOMEM�call_exception_handlerr9 r; Z
call_laterr ZACCEPT_RETRY_DELAYrP �_accept_connection2Z create_task) r! rN r% r- r# rO �_�conn�addr�excr" rV r r r rM � s4
z(BaseSelectorEventLoop._accept_connectionc c s� d }d }yj|� }| j � }|r6| j||||d||d�}n| j|||||d�}y|E d H W n |j� � Y nX W n\ tk
r� } z@| jr�d| d�}
|d k r�||
d< |d k r�||
d< | j|
� W Y d d } ~ X nX d S )NT)r' r) r" r# )r' r" r# z3Error on transport creation for incoming connection)rQ rR r& � transport)�
create_futurer. r( r6 � ExceptionrJ rY ) r! rN r\ r" r- r# r& r_ r' r^ �contextr r r rZ � s4 z)BaseSelectorEventLoop._accept_connection2c C s@ y| j | }W n tk
r" Y nX |j� s<tdj||���d S )Nz.File descriptor {!r} is used by transport {!r})r r �
is_closingr3 �format)r! r r_ r r r �_ensure_fd_no_transport� s z-BaseSelectorEventLoop._ensure_fd_no_transportc
G s� | j � tj||| �}y| jj|�}W n* tk
rP | jj|tj|d f� Y n>X |j|j }\}}| jj
||tjB ||f� |d k r�|j � d S )N) �
_check_closedr �Handler r r �registerr �
EVENT_READrA �modify�cancel) r! r �callback�args�handler �mask�reader�writerr r r r? � s
z!BaseSelectorEventLoop._add_readerc
C s� | j � r dS y| jj|�}W n tk
r0 dS X |j|j }\}}|tj M }|sb| jj|� n| jj ||d |f� |d k r�|j
� dS dS d S )NFT) r4 r r r r rA r ri �
unregisterrj rk )r! r r ro rp rq r r r r9 s z$BaseSelectorEventLoop._remove_readerc
G s� | j � tj||| �}y| jj|�}W n* tk
rP | jj|tjd |f� Y n>X |j|j }\}}| jj
||tjB ||f� |d k r�|j � d S )N) rf r rg r r r rh r � EVENT_WRITErA rj rk ) r! r rl rm rn r ro rp rq r r r � _add_writer s
z!BaseSelectorEventLoop._add_writerc
C s� | j � r dS y| jj|�}W n tk
r0 dS X |j|j }\}}|tj M }|sb| jj|� n| jj |||d f� |d k r�|j
� dS dS d S )NFT) r4 r r r r rA r rs rr rj rk )r! r r ro rp rq r r r �_remove_writer, s z$BaseSelectorEventLoop._remove_writerc G s | j |� | j||f|�� S )N)re r? )r! r rl rm r r r �
add_readerC s
z BaseSelectorEventLoop.add_readerc C s | j |� | j|�S )N)re r9 )r! r r r r �
remove_readerH s
z#BaseSelectorEventLoop.remove_readerc G s | j |� | j||f|�� S )N)re rt )r! r rl rm r r r �
add_writerM s
z BaseSelectorEventLoop.add_writerc C s | j |� | j|�S )N)re ru )r! r r r r �
remove_writerR s
z#BaseSelectorEventLoop.remove_writerc C s6 | j r|j� dkrtd��| j� }| j|d ||� |S )Nr z the socket must be non-blocking)rJ �
gettimeout�
ValueErrorr` �
_sock_recv)r! r% �n�futr r r � sock_recvW s
z BaseSelectorEventLoop.sock_recvc C s� |d k r| j |� |j� r d S y|j|�}W n` ttfk
rb |j� }| j|| j||||� Y n6 tk
r� } z|j |� W Y d d }~X n X |j
|� d S )N) rw � cancelledrC rE rD r; rv r| ra �
set_exception�
set_result)r! r~ �
registered_fdr% r} rA r r^ r r r r| f s
z BaseSelectorEventLoop._sock_recvc C sF | j r|j� dkrtd��| j� }|r8| j|d ||� n
|jd � |S )Nr z the socket must be non-blocking)rJ rz r{ r` �
_sock_sendallr� )r! r% rA r~ r r r � sock_sendall{ s
z"BaseSelectorEventLoop.sock_sendallc C s� |d k r| j |� |j� r d S y|j|�}W nD ttfk
rH d}Y n* tk
rp } z|j|� d S d }~X nX |t|�kr�|jd � n.|r�||d � }|j � }| j
|| j ||||� d S )Nr ) ry r� rH rE rD ra r� �lenr� r; rx r� )r! r~ r� r% rA r} r^ r r r r r� � s"
z#BaseSelectorEventLoop._sock_sendallc c s� | j r|j� dkrtd��ttd� s2|jtjkrptj||j|j | d�}|j
� sZ|E d H |j � d \}}}}}| j � }| j
|||� |E d H S )Nr z the socket must be non-blocking�AF_UNIX)�family�proto�loop)rJ rz r{ �hasattrrS r� r� r Z_ensure_resolvedr� �done�resultr` �
_sock_connect)r! r% r1 Zresolvedr[ r~ r r r � sock_connect� s
z"BaseSelectorEventLoop.sock_connectc C s� |j � }y|j|� W nj ttfk
rV |jtj| j|�� | j|| j |||� Y n6 t
k
r� } z|j |� W Y d d }~X n X |j d � d S )N)
r; ZconnectrE rD Zadd_done_callback� functools�partial�_sock_connect_donerx �_sock_connect_cbra r� r� )r! r~ r% r1 r r^ r r r r� � s z#BaseSelectorEventLoop._sock_connectc C s | j |� d S )N)ry )r! r r~ r r r r� � s z(BaseSelectorEventLoop._sock_connect_donec C s� |j � r d S y,|jtjtj�}|dkr6t|d|f ��W nB ttfk
rP Y n6 tk
rz } z|j |� W Y d d }~X n X |j
d � d S )Nr zConnect call failed %s) r� Z
getsockoptrS Z
SOL_SOCKETZSO_ERRORrI rE rD ra r� r� )r! r~ r% r1 �errr^ r r r r� � s z&BaseSelectorEventLoop._sock_connect_cbc C s4 | j r|j� dkrtd��| j� }| j|d|� |S )Nr z the socket must be non-blockingF)rJ rz r{ r` � _sock_accept)r! r% r~ r r r � sock_accept� s
z!BaseSelectorEventLoop.sock_acceptc C s� |j � }|r| j|� |j� r"d S y|j� \}}|jd� W nV ttfk
rh | j|| j|d|� Y n: t k
r� } z|j
|� W Y d d }~X nX |j ||f� d S )NFT) r; rw r� rV r> rE rD rv r� ra r� r� )r! r~ Z
registeredr% r r\ r1 r^ r r r r� � s
z"BaseSelectorEventLoop._sock_acceptc C s� x~|D ]v\}}|j |j }\}}|tj@ rN|d k rN|jrD| j|� n
| j|� |tj@ r|d k r|jrr| j|� q| j|� qW d S )N) �fileobjrA r ri Z
_cancelledr9 Z
_add_callbackrs ru )r! Z
event_listr ro r� rp rq r r r �_process_events� s
z%BaseSelectorEventLoop._process_eventsc C s | j |j� � |j� d S )N)r9 r; r6 )r! r% r r r �
_stop_serving s z#BaseSelectorEventLoop._stop_serving)N)N)N)NNN)NNrL )NNrL )NN))r �
__module__� __qualname__r r( r. r+ r2 r6 r8 r5 r rB r@ rK rP rM r rZ re r? r9 rt ru rv rw rx ry r r| r� r� r� r� r� r� r� r� r� r� �
__classcell__r r )r r r + sR
( # c s� e Zd Zd ZeZdZd � fdd� Zdd� Zdd � Z d
d � Z
d d
� Z dd� Z dd� Z
ejr`dd� Zd!dd�Zdd� Zdd� Zdd � Zd d � Z� ZS )"�_SelectorTransport� i Nc s� t � j||� || jd< |j� | jd< d| jkrdy|j� | jd< W n tjk
rb d | jd< Y nX || _|j� | _ || _
d| _ || _ | j
� | _d| _d| _| j d k r�| j j� | |j| j < d S )NrS ZsocknamerT Tr F)r r �_extraZ getsocknameZ getpeernamerS �error�_sockr; �_sock_fd� _protocol�_protocol_connected�_server�_buffer_factory�_buffer�
_conn_lost�_closingZ_attachr )r! r� r% r& r" r# )r r r r s&
z_SelectorTransport.__init__c C s� | j jg}| jd kr |jd� n| jr0|jd� |jd| j � | jd k r�| jj� r�t| jj | jt
j �}|rz|jd� n
|jd� t| jj | jt
j �}|r�d}nd}| j
� }|jd||f � d d
j|� S ) N�closed�closingzfd=%sz read=pollingz read=idle�pollingZidlezwrite=<%s, bufsize=%s>z<%s>� )r r r� �appendr� r� �_loopr4 r r r ri rs �get_write_buffer_size�join)r! �infor� �state�bufsizer r r �__repr__2 s*
z_SelectorTransport.__repr__c C s | j d � d S )N)� _force_close)r! r r r �abortN s z_SelectorTransport.abortc C s
|| _ d S )N)r� )r! r& r r r � set_protocolQ s z _SelectorTransport.set_protocolc C s | j S )N)r� )r! r r r � get_protocolT s z _SelectorTransport.get_protocolc C s | j S )N)r� )r! r r r rc W s z _SelectorTransport.is_closingc C sT | j r
d S d| _ | jj| j� | jsP| jd7 _| jj| j� | jj| jd � d S )NTr ) r� r� r9 r� r� r� ru � call_soon�_call_connection_lost)r! r r r r6 Z s z_SelectorTransport.closec C s, | j d k r(tjd| t| d� | j j� d S )Nzunclosed transport %r)�source)r� �warnings�warn�ResourceWarningr6 )r! r r r �__del__h s
z_SelectorTransport.__del__�Fatal error on transportc C sP t |tj�r*| jj� rBtjd| |dd� n| jj||| | jd�� | j |� d S )Nz%r: %sT)rG )rQ rR r_ r& )
�
isinstancer Z_FATAL_ERROR_IGNOREr� � get_debugr
r rY r� r� )r! r^ rQ r r r � _fatal_errorn s
z _SelectorTransport._fatal_errorc C sd | j r
d S | jr(| jj� | jj| j� | jsBd| _| jj| j� | j d7 _ | jj| j |� d S )NTr )
r� r� �clearr� ru r� r� r9 r� r� )r! r^ r r r r� | s
z _SelectorTransport._force_closec C sV z| j r| jj|� W d | jj� d | _d | _d | _| j}|d k rP|j� d | _X d S )N)r� r� Zconnection_lostr� r6 r� r� Z_detach)r! r^ r# r r r r� � s
z(_SelectorTransport._call_connection_lostc C s
t | j�S )N)r� r� )r! r r r r� � s z(_SelectorTransport.get_write_buffer_sizec G s" | j r
d S | jj||f|�� d S )N)r� r� r? )r! r rl rm r r r r? � s z _SelectorTransport._add_readeri )NN)r� )r r� r� �max_size� bytearrayr� r� r r� r� r� r� rc r6 r ZPY34r� r� r� r� r� r? r� r r )r r r� s"
r� c sV e Zd Zd� fdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z dd� Z
� Z S )r$ Nc sr t � j|||||� d| _d| _tj| j� | jj| j j
| � | jj| j | j | j
� |d k rn| jjtj|d � d S )NF)r r �_eof�_pausedr Z _set_nodelayr� r� r� r� �connection_mader? r� � _read_readyr � _set_result_unless_cancelled)r! r� r% r& r' r" r# )r r r r � s
z!_SelectorSocketTransport.__init__c C s> | j s | jrd S d| _| jj| j� | jj� r:tjd| � d S )NTz%r pauses reading)r� r� r� r9 r� r� r
r )r! r r r �
pause_reading� s
z&_SelectorSocketTransport.pause_readingc C sB | j s| j rd S d| _| j| j| j� | jj� r>tjd| � d S )NFz%r resumes reading) r� r� r? r� r� r� r� r
r )r! r r r �resume_reading� s
z'_SelectorSocketTransport.resume_readingc C s� | j r
d S y| jj| j�}W nD ttfk
r4 Y n| tk
r` } z| j|d� W Y d d }~X nPX |rt| jj |� n<| j
j � r�t j
d| � | jj� }|r�| j
j| j� n| j� d S )Nz$Fatal read error on socket transportz%r received EOF)r� r� rC r� rE rD ra r� r� �
data_receivedr� r� r
r � eof_receivedr9 r� r6 )r! rA r^ � keep_openr r r r� � s
z$_SelectorSocketTransport._read_readyc C s� t |tttf�s"tdt|�j ��| jr0td��|s8d S | j rf| j t
j krTt j
d� | j d7 _ d S | js�y| jj|�}W nB ttfk
r� Y n@ tk
r� } z| j|d� d S d }~X nX ||d � }|s�d S | jj| j| j� | jj|� | j� d S )Nz1data argument must be a bytes-like object, not %rz%Cannot call write() after write_eof()z socket.send() raised exception.r z%Fatal write error on socket transport)r� �bytesr� �
memoryview� TypeError�typer r� r3 r� r �!LOG_THRESHOLD_FOR_CONNLOST_WRITESr
�warningr� r� rH rE rD ra r� r� rt r� � _write_ready�extend�_maybe_pause_protocol)r! rA r} r^ r r r �write� s4
z _SelectorSocketTransport.writec C s� | j r
d S y| jj| j�}W n\ ttfk
r4 Y n� tk
rx } z*| jj| j � | jj
� | j |d� W Y d d }~X nTX |r�| jd |�= | j � | js�| jj| j � | j
r�| jd � n| jr�| jjtj� d S )Nz%Fatal write error on socket transport)r� r� rH r� rE rD ra r� ru r� r� r� �_maybe_resume_protocolr� r� r� �shutdownrS �SHUT_WR)r! r} r^ r r r r� s&
z%_SelectorSocketTransport._write_readyc C s. | j s | jrd S d| _| js*| jjtj� d S )NT)r� r� r� r� r� rS r� )r! r r r � write_eof s
z"_SelectorSocketTransport.write_eofc C s dS )NTr )r! r r r �
can_write_eof s z&_SelectorSocketTransport.can_write_eof)NNN) r r� r� r r� r� r� r� r� r� r� r� r r )r r r$ � s #r$ c sd e Zd ZeZd� fdd� Zddd�Zdd� Zd d
� Zd d � Z d
d� Z
dd� Z dd� Z dd� Z
� ZS )r/ NFc
s� t d krtd��|s tj||�}|dd�}
|r<| r<||
d< |j|f|
�} t� j|| ||| � d| _|| _|| _ || _
d| _ | j j
|d� | jj� r�tjd| � | jj� } nd } | j| � d S )Nz stdlib ssl module not availableF)r) Zdo_handshake_on_connectr* )r- z%r starts SSL handshake)�sslr3 r Z_create_transport_contextZ wrap_socketr r r� �_server_hostname�_waiter� _sslcontextr� r� �updater� r� r
r �time�
_on_handshake)
r! r� r, r& r- r' r) r* r" r# Z wrap_kwargsZsslsock�
start_time)r r r r ( s*
z _SelectorSslTransport.__init__c C sD | j d krd S | j j� s:|d k r.| j j|� n | j jd � d | _ d S )N)r� r� r� r� )r! r^ r r r �_wakeup_waiterL s
z$_SelectorSslTransport._wakeup_waiterc " C s$ y| j j� W n� tjk
r8 | jj| j| j|� d S tjk
r` | jj | j| j|� d S t
k
r� } z`| jj � r�t j
d| dd� | jj| j� | jj| j� | j j� | j|� t|t�r�d S � W Y d d }~X nX | jj| j� | jj| j� | j j� }t| jd��s�| j�r�| jjtjk�r�ytj|| j� W nR tk
�r� } z4| jj � �rjt j
d| dd� | j j� | j|� d S d }~X nX | jj || j j � | j j � | j d� d| _ d| _ | jj| j| j!� d| _"| jj#| j$j%| � | jj#| j� | jj � �r | jj&� | }t j'd| |d � d S )
Nz%r: SSL handshake failedT)rG Zcheck_hostnamez1%r: SSL handshake failed on matching the hostname)�peercert�cipher� compressionZ
ssl_objectFz %r: SSL handshake took %.1f msg @�@)(r� Z do_handshaker� �SSLWantReadErrorr� r? r� r� �SSLWantWriteErrorrt �
BaseExceptionr� r
r� r9 ru r6 r� r� ra Z getpeercertr� r� r� Z verify_modeZ CERT_NONEZmatch_hostnamer� r� r� r� �_read_wants_write�_write_wants_readr� r� r� r� r� r� r )r! r� r^ r� Zdtr r r r� V sb
z#_SelectorSslTransport._on_handshakec C sJ | j rtd��| jr td��d| _| jj| j� | jj� rFtjd| � d S )Nz#Cannot pause_reading() when closingzAlready pausedTz%r pauses reading) r� r3 r� r� r9 r� r� r
r )r! r r r r� � s
z#_SelectorSslTransport.pause_readingc C sJ | j std��d| _ | jr d S | jj| j| j� | jj� rFtj d| � d S )Nz
Not pausedFz%r resumes reading)
r� r3 r� r� r? r� r� r� r
r )r! r r r r� � s
z$_SelectorSslTransport.resume_readingc C s" | j r
d S | jr6d| _| j� | jr6| jj| j| j� y| jj| j �}W n� t
t t j
fk
rd Y n� t jk
r� d| _| jj| j� | jj| j| j� Y n� tk
r� } z| j|d� W Y d d }~X nTX |r�| jj|� n@z4| jj� r�tjd| � | jj� }|�rtjd� W d | j� X d S )NFTz!Fatal read error on SSL transportz%r received EOFz?returning true from eof_received() has no effect when using ssl)r� r� r� r� r� rt r� r� rC r� rE rD r� r� r� r� r9 ra r� r� r� r� r
r r� r� r6 )r! rA r^ r� r r r r� � s4
z!_SelectorSslTransport._read_readyc C s( | j r
d S | jr<d| _| j� | jp(| js<| jj| j| j� | jr�y| j j
| j�}W n� t t t
jfk
rt d}Y np t
jk
r� d}| jj| j� d| _Y nD tk
r� } z(| jj| j� | jj� | j|d� d S d }~X nX |r�| jd |�= | j� | j�s$| jj| j� | j�r$| jd � d S )NFr Tz"Fatal write error on SSL transport)r� r� r� r� r� r� r? r� r� r� rH rE rD r� r� r� ru r� ra r� r� r� r� )r! r} r^ r r r r� � s8
z"_SelectorSslTransport._write_readyc C s� t |tttf�s"tdt|�j ��|s*d S | jrX| jtj krFt
j d� | jd7 _d S | j sp| j
j| j| j� | j j|� | j� d S )Nz1data argument must be a bytes-like object, not %rz socket.send() raised exception.r )r� r� r� r� r� r� r r� r r� r
r� r� r� rt r� r� r� r� )r! rA r r r r� � s
z_SelectorSslTransport.writec C s dS )NFr )r! r r r r� s z#_SelectorSslTransport.can_write_eof)NFNNN)N)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 )r0 Nc s^ t � j||||� || _| jj| jj| � | jj| j| j| j � |d k rZ| jjt
j |d � d S )N) r r �_addressr� r� r� r� r? r� r� r r� )r! r� r% r& r1 r' r" )r r r r s
z#_SelectorDatagramTransport.__init__c C s t dd� | jD ��S )Nc s s | ]\}}t |�V qd S )N)r� )�.0rA r[ r r r � <genexpr> s zC_SelectorDatagramTransport.get_write_buffer_size.<locals>.<genexpr>)�sumr� )r! r r r r� s z0_SelectorDatagramTransport.get_write_buffer_sizec C s� | j r
d S y| jj| j�\}}W np ttfk
r8 Y nh tk
rd } z| jj|� W Y d d }~X n< t k
r� } z| j
|d� W Y d d }~X nX | jj ||� d S )Nz&Fatal read error on datagram transport) r� r� Zrecvfromr� rE rD rI r� �error_receivedra r� Zdatagram_received)r! rA r] r^ r r r r� s z&_SelectorDatagramTransport._read_readyc C sT t |tttf�s"tdt|�j ��|s*d S | jrN|d | jfkrNtd| jf ��| j r�| jr�| j t
j krpt j
d� | j d7 _ d S | j�s4y&| jr�| jj|� n| jj||� d S ttfk
r� | jj| j| j� Y nZ tk
�r } z| jj|� d S d }~X n. tk
�r2 } z| j |d� d S d }~X nX | jj t|�|f� | j � d S )Nz1data argument must be a bytes-like object, not %rz#Invalid address: must be None or %sz socket.send() raised exception.r z'Fatal write error on datagram transport) r� r� r� r� r� r� r r� r{ r� r r� r
r� r� r� rH �sendtorE rD r� rt r� �
_sendto_readyrI r� r� ra r� r� r� )r! rA r] r^ r r r r� . s<
z!_SelectorDatagramTransport.sendtoc C s� x�| j r�| j j� \}}y&| jr,| jj|� n| jj||� W q ttfk
rf | j j||f� P Y q t k
r� } z| j
j |� d S d }~X q t k
r� } z| j
|d� d S d }~X qX qW | j� | j s�| jj| j� | jr�| jd � d S )Nz'Fatal write error on datagram transport)r� �popleftr� r� rH r� rE rD �
appendleftrI r� r� ra r� r� r� ru r� r� r� )r! rA r] r^ r r r r� U s* z(_SelectorDatagramTransport._sendto_ready)NNN)N) r r� r� � collections�dequer� r r� r� r� r� r� r r )r r r0 s
'r0 ) �__all__r� rX r� rS r� r r� � ImportError� r r r r r r r
r Z
coroutinesr �logr
r Z
BaseEventLoopr Z_FlowControlMixinZ Transportr� r$ r/ r0 r r r r �<module> sB
i iPK [��ь� � $ __pycache__/constants.cpython-36.pycnu �[��� 3
\s � @ s d Z dZdZdZdS )z
Constants.� � �
N)�__doc__Z!LOG_THRESHOLD_FOR_CONNLOST_WRITESZACCEPT_RETRY_DELAYZDEBUG_STACK_DEPTH� r r �)/usr/lib64/python3.6/asyncio/constants.py�<module> s PK [3'~� � - __pycache__/base_futures.cpython-36.opt-2.pycnu �[��� 3
\ � @ sr g Z d dlZd dlZddlmZ ejjjZejj Z ejj
Z
G dd� de�Z dZ dZ
dZd d
� Zd d � Zd
d� ZdS )� N� )�eventsc @ s e Zd ZdS )�InvalidStateErrorN)�__name__�
__module__� __qualname__� r r �,/usr/lib64/python3.6/asyncio/base_futures.pyr
s r ZPENDINGZ CANCELLEDZFINISHEDc C s t | jd�o| jd k S )N�_asyncio_future_blocking)�hasattr� __class__r
)�objr r r �isfuture s r c C s� t | �}|sd} dd� }|dkr.|| d �} nP|dkrTdj|| d �|| d ��} n*|dkr~dj|| d �|d || d
��} d | S ) N� c S s t j| f �S )N)r Z_format_callback_source)�callbackr r r � format_cb( s z$_format_callbacks.<locals>.format_cbr r � z{}, {}z{}, <{} more>, {}zcb=[%s]���)�len�format)�cb�sizer r r r �_format_callbacks" s r c C s� | j j� g}| j tkrP| jd k r4|jdj| j�� n tj| j�}|jdj|�� | j rf|jt
| j �� | j r�| j d }|jd|d |d f � |S )Nzexception={!r}z result={}r zcreated at %s:%sr r ) Z_state�lower� _FINISHEDZ
_exception�appendr �reprlib�reprZ_resultZ
_callbacksr Z_source_traceback)Zfuture�info�result�framer r r �_future_repr_info6 s
r! )�__all__Zconcurrent.futures._baseZ
concurrentr r r ZfuturesZ_base�ErrorZCancelledError� TimeoutErrorr Z_PENDINGZ
_CANCELLEDr r r r! r r r r �<module> s
PK [Y��� � ( __pycache__/futures.cpython-36.opt-2.pycnu �[��� 3
\ > � @ s d dddddgZ ddlZddlZddlZddlZdd lmZ dd
lmZ dd lm Z ej
Z
ej Z ej Z ej
Z
ejZejZejZejd ZG d d
� d
�ZG dd� d�ZeZdd� Zdd� Zdd� Zdd� Zdd�dd�Zy ddlZW n e k
r� Y n X ej ZZ dS )�CancelledError� TimeoutError�InvalidStateError�Future� wrap_future�isfuture� N� )� base_futures)�compat)�eventsc @ s0 e Zd ZdZdd� Zdd� Zd d
� Zd d � Zd
S )�_TracebackLogger�loop�source_traceback�exc�tbc C s |j | _|j| _|| _d | _d S )N)�_loopr
�_source_tracebackr r r )�self�futurer � r �'/usr/lib64/python3.6/asyncio/futures.py�__init__R s z_TracebackLogger.__init__c C s, | j }|d k r(d | _ tj|j||j�| _d S )N)r � traceback�format_exception� __class__�
__traceback__r )r r r r r �activateX s
z_TracebackLogger.activatec C s d | _ d | _d S )N)r r )r r r r �clear_ s z_TracebackLogger.clearc C sb | j r^d}| jr:djtj| j��}|d7 }|d|j� 7 }|dj| j �j� 7 }| jjd|i� d S )Nz*Future/Task exception was never retrieved
� z0Future/Task created at (most recent call last):
z%s
�message)r r �joinr � format_list�rstripr
�call_exception_handler)r �msg�srcr r r �__del__c s z_TracebackLogger.__del__N)r
r r r )�__name__�
__module__� __qualname__� __slots__r r r r& r r r r r s
2r c @ s� e Zd ZeZdZdZdZdZdZ dZ
dd�dd�Z e j
Zdd� ZejrNdd � Zd
d � Zd d
� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Z d d � Z ej r�e Z dS ) r NF)r
c C s@ |d krt j� | _n|| _g | _| jj� r<t jtjd��| _d S )Nr ) r �get_event_loopr �
_callbacksZ get_debug�
extract_stack�sys� _getframer )r r
r r r r � s
zFuture.__init__c C s d| j jdj| j� �f S )Nz<%s %s>� )r r' r �
_repr_info)r r r r �__repr__� s zFuture.__repr__c C sD | j s
d S | j}d| jj || d�}| jr4| j|d< | jj|� d S )Nz %s exception was never retrieved)r � exceptionr r )�_log_traceback�
_exceptionr r' r r r# )r r �contextr r r r& � s
zFuture.__del__c C s& d| _ | jtkrdS t| _| j� dS )NFT)r4 �_state�_PENDING�
_CANCELLED�_schedule_callbacks)r r r r �cancel� s
z
Future.cancelc C sD | j d d � }|sd S g | j d d �< x|D ]}| jj|| � q*W d S )N)r, r � call_soon)r Z callbacks�callbackr r r r: � s
zFuture._schedule_callbacksc C s
| j tkS )N)r7 r9 )r r r r � cancelled� s zFuture.cancelledc C s
| j tkS )N)r7 r8 )r r r r �done� s z Future.donec C s< | j tkrt�| j tkr td��d| _| jd k r6| j�| jS )NzResult is not ready.F)r7 r9 r � _FINISHEDr r4 r5 �_result)r r r r �result� s
z
Future.resultc C s, | j tkrt�| j tkr td��d| _| jS )NzException is not set.F)r7 r9 r r@ r r4 r5 )r r r r r3 � s
zFuture.exceptionc C s* | j tkr| jj|| � n | jj|� d S )N)r7 r8 r r< r, �append)r �fnr r r �add_done_callback s
zFuture.add_done_callbackc s< � fdd�| j D �}t| j �t|� }|r8|| j d d �< |S )Nc s g | ]}|� kr|�qS r r )�.0�f)rD r r �
<listcomp> s z/Future.remove_done_callback.<locals>.<listcomp>)r, �len)r rD Zfiltered_callbacksZ
removed_countr )rD r �remove_done_callback s
zFuture.remove_done_callbackc C s4 | j tkr tdj| j | ���|| _t| _ | j� d S )Nz{}: {!r})r7 r8 r �formatrA r@ r: )r rB r r r �
set_result s
zFuture.set_resultc C s� | j tkr tdj| j | ���t|t�r,|� }t|�tkr@td��|| _t | _ | j
� t j rbd| _
n t| |�| _| jj| jj� d S )Nz{}: {!r}zPStopIteration interacts badly with generators and cannot be raised into a FutureT)r7 r8 r rK �
isinstance�type�
StopIteration� TypeErrorr5 r@ r: r
�PY34r4 r Z
_tb_loggerr r< r )r r3 r r r �
set_exception, s
zFuture.set_exceptionc c s | j � sd| _| V | j� S )NT)r? �_asyncio_future_blockingrB )r r r r �__iter__D s zFuture.__iter__) r' r( r) r8 r7 rA r5 r r rS r4 r r Z_future_repr_infor1 r2 r
rQ r& r; r: r> r? rB r3 rE rJ rL rR rT ZPY35� __await__r r r r r n s2
c C s | j � r d S | j|� d S )N)r> rL )ZfutrB r r r � _set_result_unless_cancelledS s rV c C sN |j � r| j� | j� s d S |j� }|d k r8| j|� n|j� }| j|� d S )N)r> r; Z set_running_or_notify_cancelr3 rR rB rL )�
concurrent�sourcer3 rB r r r � _set_concurrent_future_stateZ s rY c C sP |j � r d S | j � r |j� n.| j� }|d k r:|j|� n| j� }|j|� d S )N)r> r; r3 rR rB rL )rX �destr3 rB r r r �_copy_future_statei s
r[ c s� t �� r"t�tjj� r"td��t �� rDt�tjj� rDtd��t ��rR�jnd �t ��rd�jnd �dd� � ���fdd�}� ���fdd�}�j|� �j|� d S ) Nz(A future is required for source argumentz-A future is required for destination argumentc S s" t | �rt|| � n
t| |� d S )N)r r[ rY )r �otherr r r �
_set_state� s z!_chain_future.<locals>._set_statec s2 | j � r.�d ks�� kr"�j� n �j�j� d S )N)r> r; �call_soon_threadsafe)� destination)� dest_looprX � source_loopr r �_call_check_cancel� s
z)_chain_future.<locals>._call_check_cancelc sJ �j � r �d k r �j� r d S �d ks,��kr8� �| � n�j� �| � d S )N)r> Z is_closedr^ )rX )r] r` r_ ra r r �_call_set_state� s z&_chain_future.<locals>._call_set_state)r rM rW Zfuturesr rP r rE )rX r_ rb rc r )r] r` r_ rX ra r �
_chain_future} s
rd )r
c C s2 t | �r | S |d kr tj� }|j� }t| |� |S )N)r r r+ Z
create_futurerd )r r
Z
new_futurer r r r � s
) �__all__Zconcurrent.futuresrW Zloggingr. r r r r
r r r r r r8 r9 r@ �DEBUGZ STACK_DEBUGr r Z _PyFuturerV rY r[ rd r Z_asyncio� ImportErrorZ_CFuturer r r r �<module> s<
P c*
PK [7� +� � ) __pycache__/__init__.cpython-36.opt-2.pycnu �[��� 3
\� � @ s> d dl Z yddlmZ W n ek
r4 d dlZY nX e jdkrnyddlmZ W n ek
rl d dlZY nX ddlT ddlT ddlT ddl T ddl
T ddl T ddl T ddl
T ddlT ddlT ddlT ejej ej e j e
j e j e j e
j ej ej ej Ze jdk�r(ddlT eej7 ZnddlT eej7 ZdS )� N� )� selectorsZwin32)� _overlapped)�*)�sys� r � ImportError�platformr Z base_eventsZ
coroutinesZeventsZfuturesZlocksZ protocolsZqueuesZstreams�
subprocessZtasksZ
transports�__all__Zwindows_eventsZ unix_events� r r �(/usr/lib64/python3.6/asyncio/__init__.py�<module> s6
: PK [ D��o? o? 0 __pycache__/proactor_events.cpython-36.opt-2.pycnu �[��� 3
\�O � @ s� d gZ ddlZddlZddlmZ ddlmZ ddlmZ ddlmZ ddlmZ dd lm Z dd
l
m Z G d d � d e j e j
�ZG d
d� dee j�ZG dd� dee j�ZG dd� de�ZG dd� deee j�ZG dd� deee j�ZG dd � d ej�ZdS )�BaseProactorEventLoop� N� )� base_events)�compat)� constants)�futures)�sslproto)�
transports)�loggerc s~ e Zd Zd� fdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z e
j rTdd� Z d dd�Z
dd� Zdd� Zdd� Z� ZS ) �_ProactorBasePipeTransportNc s� t � j||� | j|� || _|| _|| _d | _d | _d | _d| _ d| _
d| _ d| _ | jd k rh| jj
� | jj| jj| � |d k r�| jjtj|d � d S )Nr F)�super�__init__�
_set_extra�_sock� _protocol�_server�_buffer� _read_fut�
_write_fut�_pending_write�
_conn_lost�_closing� _eof_writtenZ_attach�_loop� call_soonZconnection_mader Z _set_result_unless_cancelled)�self�loop�sock�protocol�waiter�extra�server)� __class__� �//usr/lib64/python3.6/asyncio/proactor_events.pyr
s$
z#_ProactorBasePipeTransport.__init__c C s� | j jg}| jd kr |jd� n| jr0|jd� | jd k rN|jd| jj� � | jd k rh|jd| j � | jd k r�|jd| j � | jr�t | j�}|jd| � | j
r�|jd� dd j |� S )
N�closed�closingzfd=%szread=%szwrite=%rzwrite_bufsize=%sz EOF writtenz<%s>� ) r" �__name__r �appendr �filenor r r �lenr �join)r �info�bufsizer# r# r$ �__repr__/ s"
z#_ProactorBasePipeTransport.__repr__c C s || j d< d S )N�pipe)�_extra)r r r# r# r$ r B s z%_ProactorBasePipeTransport._set_extrac C s
|| _ d S )N)r )r r r# r# r$ � set_protocolE s z'_ProactorBasePipeTransport.set_protocolc C s | j S )N)r )r r# r# r$ � get_protocolH s z'_ProactorBasePipeTransport.get_protocolc C s | j S )N)r )r r# r# r$ �
is_closingK s z%_ProactorBasePipeTransport.is_closingc C s^ | j r
d S d| _ | jd7 _| j r@| jd kr@| jj| jd � | jd k rZ| jj� d | _d S )NTr ) r r r r r r �_call_connection_lostr �cancel)r r# r# r$ �closeN s
z _ProactorBasePipeTransport.closec C s* | j d k r&tjd| t| d� | j� d S )Nzunclosed transport %r)�source)r �warnings�warn�ResourceWarningr7 )r r# r# r$ �__del__] s
z"_ProactorBasePipeTransport.__del__� Fatal error on pipe transportc C sP t |tj�r*| jj� rBtjd| |dd� n| jj||| | jd�� | j |� d S )Nz%r: %sT)�exc_info)�message� exceptionZ transportr )
�
isinstancer Z_FATAL_ERROR_IGNOREr � get_debugr
�debug�call_exception_handlerr � _force_close)r �excr? r# r# r$ � _fatal_errorc s
z'_ProactorBasePipeTransport._fatal_errorc C sj | j r
d S d| _ | jd7 _| jr4| jj� d | _| jrJ| jj� d | _d| _d | _| jj| j |� d S )NTr r )
r r r r6 r r r r r r5 )r rF r# r# r$ rE p s
z'_ProactorBasePipeTransport._force_closec C s^ z| j j|� W d t| jd�r,| jjtj� | jj� d | _| j}|d k rX|j � d | _X d S )N�shutdown)
r Zconnection_lost�hasattrr rH �socketZ SHUT_RDWRr7 r Z_detach)r rF r! r# r# r$ r5 s
z0_ProactorBasePipeTransport._call_connection_lostc C s" | j }| jd k r |t| j�7 }|S )N)r r r+ )r �sizer# r# r$ �get_write_buffer_size� s
z0_ProactorBasePipeTransport.get_write_buffer_size)NNN)r= )r( �
__module__� __qualname__r
r/ r r2 r3 r4 r7 r ZPY34r< rG rE r5 rL �
__classcell__r# r# )r" r$ r s
r c s8 e Zd Zd
� fdd� Zdd� Zdd� Zd dd �Z� ZS ) �_ProactorReadPipeTransportNc s4 t � j||||||� d| _d| _| jj| j� d S )NF)r r
�_paused�_reschedule_on_resumer r �
_loop_reading)r r r r r r r! )r" r# r$ r
� s z#_ProactorReadPipeTransport.__init__c C s0 | j s | jrd S d| _| jj� r,tjd| � d S )NTz%r pauses reading)r rQ r rB r
rC )r r# r# r$ �
pause_reading� s
z(_ProactorReadPipeTransport.pause_readingc C sP | j s| j rd S d| _| jr6| jj| j| j� d| _| jj� rLtj d| � d S )NFz%r resumes reading)
r rQ rR r r rS r rB r
rC )r r# r# r$ �resume_reading� s
z)_ProactorReadPipeTransport.resume_readingc C s� | j rd| _d S d }�z"yH|d k r0d | _|j� }| jr>d }d S |dkrJd S | jjj| jd�| _W n� t k
r� } z2| js�| j
|d� n| jj � r�t j
ddd� W Y d d }~X n� tk
r� } z| j|� W Y d d }~X n^ tk
�r } z| j
|d� W Y d d }~X n0 tjk
�r& | j�s"� Y nX | jj| j� W d |�rN| jj|� n:|d k �r�| jj � �rpt j
d| � | jj� }|�s�| j� X d S )NT� i z"Fatal read error on pipe transportz*Read error on pipe transport while closing)r> z%r received EOF)rQ rR r �resultr r � _proactor�recvr �ConnectionAbortedErrorrG rB r
rC �ConnectionResetErrorrE �OSErrorr �CancelledError�add_done_callbackrS r Z
data_receivedZ eof_receivedr7 )r �fut�datarF Z keep_openr# r# r$ rS � sH
z(_ProactorReadPipeTransport._loop_reading)NNN)N)r( rM rN r
rT rU rS rO r# r# )r" r$ rP � s
rP c @ s6 e Zd Zdd� Zd dd�Zdd� Zdd � Zd
d � ZdS )
� _ProactorBaseWritePipeTransportc C s� t |tttf�s&dt|�j }t|��| jr4td��|s<d S | j rj| j t
j krXt j
d� | j d7 _ d S | jd kr�| jt|�d� n.| js�t|�| _| j� n| jj|� | j� d S )Nz3data argument must be a bytes-like object, not '%s'zwrite_eof() already calledz socket.send() raised exception.r )r` )rA �bytes� bytearray�
memoryview�typer( � TypeErrorr � RuntimeErrorr r Z!LOG_THRESHOLD_FOR_CONNLOST_WRITESr
�warningr �
_loop_writingr �_maybe_pause_protocol�extend)r r` �msgr# r# r$ �write� s(
z%_ProactorBaseWritePipeTransport.writeNc C s y�d | _ d| _|r|j� |d kr.| j}d | _|sf| jrH| jj| jd � | jr\| j j
t j � | j
� nN| jjj| j |�| _ | j j� s�t|�| _| j j| j� | j� n| j j| j� W nZ tk
r� } z| j|� W Y d d }~X n0 tk
�r } z| j|d� W Y d d }~X nX d S )Nr z#Fatal write error on pipe transport)r r rW r r r r r5 r r rH rJ �SHUT_WRZ_maybe_resume_protocolrX �send�doner+ r^ ri rj r[ rE r\ rG )r �fr` rF r# r# r$ ri
s0
z-_ProactorBaseWritePipeTransport._loop_writingc C s dS )NTr# )r r# r# r$ �
can_write_eof0 s z-_ProactorBaseWritePipeTransport.can_write_eofc C s | j � d S )N)r7 )r r# r# r$ � write_eof3 s z)_ProactorBaseWritePipeTransport.write_eofc C s | j d � d S )N)rE )r r# r# r$ �abort6 s z%_ProactorBaseWritePipeTransport.abort)NN)r( rM rN rm ri rr rs rt r# r# r# r$ ra � s
$
#ra c s$ e Zd Z� fdd�Zdd� Z� ZS )�_ProactorWritePipeTransportc s4 t � j||� | jjj| jd�| _| jj| j� d S )N� ) r r
r rX rY r r r^ � _pipe_closed)r �args�kw)r" r# r$ r
; s z$_ProactorWritePipeTransport.__init__c C s@ |j � r d S | jrd S d | _| jd k r4| jt� � n| j� d S )N)Z cancelledr r r rE �BrokenPipeErrorr7 )r r_ r# r# r$ rw @ s
z(_ProactorWritePipeTransport._pipe_closed)r( rM rN r
rw rO r# r# )r" r$ ru : s ru c @ s e Zd Zdd� Zdd� ZdS )� _ProactorDuplexPipeTransportc C s dS )NFr# )r r# r# r$ rr U s z*_ProactorDuplexPipeTransport.can_write_eofc C s t �d S )N)�NotImplementedError)r r# r# r$ rs X s z&_ProactorDuplexPipeTransport.write_eofN)r( rM rN rr rs r# r# r# r$ r{ P s r{ c s6 e Zd Zd
� fdd� Zdd� Zdd� Zdd � Z� ZS ) �_ProactorSocketTransportNc s$ t � j||||||� tj|� d S )N)r r
r Z _set_nodelay)r r r r r r r! )r" r# r$ r
a s z!_ProactorSocketTransport.__init__c C s� || j d< y|j� | j d< W n4 tjtfk
rP | jj� rLtjd|dd� Y nX d| j kr�y|j � | j d< W n4 tjtfk
r� | jj� r�tjd|dd� Y nX d S )NrJ Zsocknamezgetsockname() failed on %rT)r> �peernamezgetpeername() failed on %r)
r1 Z getsocknamerJ �error�AttributeErrorr rB r
rh Z getpeername)r r r# r# r$ r f s
z#_ProactorSocketTransport._set_extrac C s dS )NTr# )r r# r# r$ rr v s z&_ProactorSocketTransport.can_write_eofc C s2 | j s | jrd S d| _| jd kr.| jjtj� d S )NT)r r r r rH rJ rn )r r# r# r$ rs y s
z"_ProactorSocketTransport.write_eof)NNN)r( rM rN r
r rr rs rO r# r# )r" r$ r} \ s
r} c s� e Zd Z� fdd�Zd-dd�Zd.ddddd�dd �Zd/d
d �Zd0d d
�Zd1dd�Z� fdd�Z dd� Z
dd� Z dd� Z dd� Z
dd� Zd d � Zd d � Zd2d d!�Zd"d#� Zd3d%d&�Zd'd(� Zd)d*� Zd+d,� Z� ZS )4r c sH t � j� tjd|jj� || _|| _d | _i | _ |j
| � | j � d S )NzUsing proactor: %s) r r
r
rC r" r( rX � _selector�_self_reading_future�_accept_futuresZset_loop�_make_self_pipe)r Zproactor)r" r# r$ r
� s
z BaseProactorEventLoop.__init__Nc C s t | |||||�S )N)r} )r r r r r r! r# r# r$ �_make_socket_transport� s
z,BaseProactorEventLoop._make_socket_transportF)� server_side�server_hostnamer r! c
C s< t j� std��t j| |||||�} t| || ||d� | jS )NzOProactor event loop requires Python 3.5 or newer (ssl.MemoryBIO) to support SSL)r r! )r Z_is_sslproto_availabler| Z SSLProtocolr} Z_app_transport)
r Zrawsockr �
sslcontextr r� r� r r! Z ssl_protocolr# r# r$ �_make_ssl_transport� s
z)BaseProactorEventLoop._make_ssl_transportc C s t | ||||�S )N)r{ )r r r r r r# r# r$ �_make_duplex_pipe_transport� s z1BaseProactorEventLoop._make_duplex_pipe_transportc C s t | ||||�S )N)rP )r r r r r r# r# r$ �_make_read_pipe_transport� s z/BaseProactorEventLoop._make_read_pipe_transportc C s t | ||||�S )N)ru )r r r r r r# r# r$ �_make_write_pipe_transport� s z0BaseProactorEventLoop._make_write_pipe_transportc sP | j � rtd��| j� r d S | j� | j� | jj� d | _d | _t� j� d S )Nz!Cannot close a running event loop) Z
is_runningrg � is_closed�_stop_accept_futures�_close_self_piperX r7 r� r )r )r" r# r$ r7 � s
zBaseProactorEventLoop.closec C s | j j||�S )N)rX rY )r r �nr# r# r$ � sock_recv� s z BaseProactorEventLoop.sock_recvc C s | j j||�S )N)rX ro )r r r` r# r# r$ � sock_sendall� s z"BaseProactorEventLoop.sock_sendallc C s | j j||�S )N)rX Zconnect)r r Zaddressr# r# r$ � sock_connect� s z"BaseProactorEventLoop.sock_connectc C s | j j|�S )N)rX �accept)r r r# r# r$ � sock_accept� s z!BaseProactorEventLoop.sock_acceptc C s t �d S )N)r| )r r# r# r$ � _socketpair� s z!BaseProactorEventLoop._socketpairc C sL | j d k r| j j� d | _ | jj� d | _| jj� d | _| jd8 _d S )Nr )r� r6 �_ssockr7 �_csock�
_internal_fds)r r# r# r$ r� � s
z&BaseProactorEventLoop._close_self_pipec C sF | j � \| _| _| jjd� | jjd� | jd7 _| j| j� d S )NFr )r� r� r� Z setblockingr� r �_loop_self_reading)r r# r# r$ r� � s
z%BaseProactorEventLoop._make_self_pipec C s� y$|d k r|j � | jj| jd�}W nH tjk
r: d S tk
rl } z| jd|| d�� W Y d d }~X nX || _|j | j
� d S )Ni z.Error on reading from the event loop self pipe)r? r@ r ) rW rX rY r� r r] � ExceptionrD r� r^ r� )r rq rF r# r# r$ r� � s z(BaseProactorEventLoop._loop_self_readingc C s | j jd� d S )N� )r� ro )r r# r# r$ �_write_to_self� s z$BaseProactorEventLoop._write_to_self�d c s& d� �����fdd� � �j � � d S )Nc s" y�| d k rl| j � \}}�jr,tjd�||� �� }�d k rV�j||�dd|i�d� n�j||d|i�d� �j� rxd S �jj��} W n~ t k
r� } zD�j
� d kr��j d|�d�� �j � n�jr�tjd �dd
� W Y d d }~X n8 t
jk
�r �j � Y nX | �j�j
� < | j� � d S ) Nz#%r got a new connection from %r: %rTr~ )r� r r! )r r! r zAccept failed on a socket)r? r@ rJ zAccept failed on socket %r)r> ���)rW Z_debugr
rC r� r� r� rX r� r\ r* rD r7 r r] r� r^ )rq ZconnZaddrr rF )r �protocol_factoryr r! r r� r# r$ r � s>
z2BaseProactorEventLoop._start_serving.<locals>.loop)N)r )r r� r r� r! Zbacklogr# )r r� r r! r r� r$ �_start_serving� s $z$BaseProactorEventLoop._start_servingc C s d S )Nr# )r Z
event_listr# r# r$ �_process_events s z%BaseProactorEventLoop._process_eventsc C s* x| j j� D ] }|j� q W | j j� d S )N)r� �valuesr6 �clear)r Zfuturer# r# r$ r� $ s z*BaseProactorEventLoop._stop_accept_futuresc C s | j � | jj|� |j� d S )N)r� rX �
_stop_servingr7 )r r r# r# r$ r� ) s z#BaseProactorEventLoop._stop_serving)NNN)N)NN)NN)NN)N)NNr� )r( rM rN r
r� r� r� r� r� r7 r� r� r� r� r� r� r� r� r� r� r� r� r� rO r# r# )r" r$ r � s4
()�__all__rJ r9 � r r r r r r �logr
Z_FlowControlMixinZ
BaseTransportr Z
ReadTransportrP ZWriteTransportra ru Z Transportr{ r} Z
BaseEventLoopr r# r# r# r$ �<module> s0 M T
#PK [��)� # __pycache__/__init__.cpython-36.pycnu �[��� 3
\� � @ sB d Z ddlZyddlmZ W n ek
r8 ddlZY nX ejdkrryddlmZ W n ek
rp ddlZY nX ddlT ddlT ddl T ddl
T ddl T ddl T ddl
T ddlT ddlT ddlT ddlT ejej e j e
j e j e j e
j ej ej ej ej Zejdk�r,ddlT eej7 ZnddlT eej7 ZdS )z'The asyncio package, tracking PEP 3156.� N� )� selectorsZwin32)� _overlapped)�*)�__doc__�sys� r � ImportError�platformr Z base_eventsZ
coroutinesZeventsZfuturesZlocksZ protocolsZqueuesZstreams�
subprocessZtasksZ
transports�__all__Zwindows_eventsZ unix_events� r
r
�(/usr/lib64/python3.6/asyncio/__init__.py�<module> s8
: PK [P�f�# �# 0 __pycache__/base_subprocess.cpython-36.opt-1.pycnu �[��� 3
\�# � @ s� d dl Z d dlZd dlZddlmZ ddlmZ ddlmZ ddlmZ ddl m
Z
G dd � d ej �Z G d
d � d ej
�ZG d d
� d
eej�ZdS )� N� )�compat)� protocols)�
transports)� coroutine)�loggerc s� e Zd Zd0� fdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z e
j rTdd� Z dd� Z
dd� Zdd� Zdd� Zdd� Zd d � Zd d � Zed d!� �Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zed*d+� �Zd,d-� Zd.d/� Z � Z S )1�BaseSubprocessTransportNc
s& t � j|
� d| _|| _|| _d | _d | _d | _g | _t j
� | _ i | _ d| _
|tjkr`d | j d< |tjkrtd | j d< |tjkr�d | j d< y"| jf ||||||d�| �� W n | j� � Y nX | jj| _| j| jd< | jj� �rt|ttf�r�|} n|d } tjd| | j� | jj| j| �� d S )NFr r � )�args�shell�stdin�stdout�stderr�bufsize�
subprocesszprocess %r created: pid %s) �super�__init__�_closed� _protocol�_loop�_proc�_pid� _returncode�
_exit_waiters� collections�deque�_pending_calls�_pipes� _finishedr �PIPE�_start�close�pidZ_extra� get_debug�
isinstance�bytes�strr �debugZ create_task�_connect_pipes)
�self�loop�protocolr
r r r
r r �waiterZextra�kwargsZprogram)� __class__� �//usr/lib64/python3.6/asyncio/base_subprocess.pyr s@
z BaseSubprocessTransport.__init__c C s | j jg}| jr|jd� | jd k r4|jd| j � | jd k rP|jd| j � n | jd k rf|jd� n
|jd� | jjd�}|d k r�|jd|j � | jjd�}| jjd �}|d k r�||kr�|jd
|j � n0|d k r�|jd |j � |d k r�|jd |j � d
dj |� S )N�closedzpid=%sz
returncode=%sZrunningz not startedr zstdin=%sr r zstdout=stderr=%sz stdout=%sz stderr=%sz<%s>� )
r. �__name__r �appendr r r �get�pipe�join)r) �infor r
r r/ r/ r0 �__repr__9 s,
z BaseSubprocessTransport.__repr__c K s t �d S )N)�NotImplementedError)r) r
r r r
r r r- r/ r/ r0 r V s z BaseSubprocessTransport._startc C s
|| _ d S )N)r )r) r+ r/ r/ r0 � set_protocolY s z$BaseSubprocessTransport.set_protocolc C s | j S )N)r )r) r/ r/ r0 � get_protocol\ s z$BaseSubprocessTransport.get_protocolc C s | j S )N)r )r) r/ r/ r0 �
is_closing_ s z"BaseSubprocessTransport.is_closingc C s� | j r
d S d| _ x&| jj� D ]}|d kr*q |jj� q W | jd k r�| jd kr�| jj� d kr�| jj � rpt
j d| � y| jj � W n t
k
r� Y nX d S )NTz$Close running child process: kill %r)r r �valuesr6 r! r r Zpollr r# r Zwarning�kill�ProcessLookupError)r) �protor/ r/ r0 r! b s
z BaseSubprocessTransport.closec C s& | j s"tjd| t| d� | j� d S )Nzunclosed transport %r)�source)r �warnings�warn�ResourceWarningr! )r) r/ r/ r0 �__del__� s z BaseSubprocessTransport.__del__c C s | j S )N)r )r) r/ r/ r0 �get_pid� s z BaseSubprocessTransport.get_pidc C s | j S )N)r )r) r/ r/ r0 �get_returncode� s z&BaseSubprocessTransport.get_returncodec C s || j kr| j | jS d S d S )N)r r6 )r) �fdr/ r/ r0 �get_pipe_transport� s
z*BaseSubprocessTransport.get_pipe_transportc C s | j d krt� �d S )N)r r@ )r) r/ r/ r0 � _check_proc� s
z#BaseSubprocessTransport._check_procc C s | j � | jj|� d S )N)rK r � send_signal)r) �signalr/ r/ r0 rL � s z#BaseSubprocessTransport.send_signalc C s | j � | jj� d S )N)rK r � terminate)r) r/ r/ r0 rN � s z!BaseSubprocessTransport.terminatec C s | j � | jj� d S )N)rK r r? )r) r/ r/ r0 r? � s z BaseSubprocessTransport.killc # sP y� j }� j}|jd k rB|j� fdd�|j�E d H \}}|� jd< |jd k rv|j� fdd�|j�E d H \}}|� jd< |jd k r�|j� fdd�|j�E d H \}}|� jd< |j� j j
� � x"� j D ]\}}|j|f|�� q�W d � _ W nD t k
�r* } z&|d k �r|j
� �r|j|� W Y d d }~X n"X |d k �rL|j
� �rL|jd � d S )Nc s
t � d�S )Nr )�WriteSubprocessPipeProtor/ )r) r/ r0 �<lambda>� s z8BaseSubprocessTransport._connect_pipes.<locals>.<lambda>r c s
t � d�S )Nr )�ReadSubprocessPipeProtor/ )r) r/ r0 rP � s r c s
t � d�S )Nr )rQ r/ )r) r/ r0 rP � s r )r r r Zconnect_write_piper r
Zconnect_read_piper � call_soonr �connection_mader � Exception� cancelledZ
set_exception�
set_result) r) r, �procr* �_r6 �callback�data�excr/ )r) r0 r( � s6
z&BaseSubprocessTransport._connect_pipesc G s2 | j d k r | j j||f� n| jj|f|�� d S )N)r r4 r rR )r) �cbrZ r/ r/ r0 �_call� s
z BaseSubprocessTransport._callc C s | j | jj||� | j� d S )N)r] r Zpipe_connection_lost� _try_finish)r) rI r[ r/ r/ r0 �_pipe_connection_lost� s z-BaseSubprocessTransport._pipe_connection_lostc C s | j | jj||� d S )N)r] r Zpipe_data_received)r) rI rZ r/ r/ r0 �_pipe_data_received� s z+BaseSubprocessTransport._pipe_data_receivedc C st | j j� rtjd| |� || _| jjd kr2|| j_| j| jj � | j
� x | j D ]}|j � sP|j
|� qPW d | _ d S )Nz %r exited with return code %r)r r# r r8 r r �
returncoder] r Zprocess_exitedr^ r rU rV )r) ra r, r/ r/ r0 �_process_exited� s
z'BaseSubprocessTransport._process_exitedc c s0 | j dk r| j S | jj� }| jj|� |E dH S )zdWait until the process exit and return the process return code.
This method is a coroutine.N)r r Z
create_futurer r4 )r) r, r/ r/ r0 �_wait� s
z BaseSubprocessTransport._waitc C s> | j d krd S tdd� | jj� D ��r:d| _| j| jd � d S )Nc s s | ]}|d k o|j V qd S )N)� disconnected)�.0�pr/ r/ r0 � <genexpr>� s z6BaseSubprocessTransport._try_finish.<locals>.<genexpr>T)r �allr r> r r] �_call_connection_lost)r) r/ r/ r0 r^ � s
z#BaseSubprocessTransport._try_finishc C s* z| j j|� W d d | _d | _d | _ X d S )N)r �connection_lostr r )r) r[ r/ r/ r0 ri � s
z-BaseSubprocessTransport._call_connection_lost)NN) r3 �
__module__� __qualname__r r9 r r; r< r= r! r ZPY34rF rG rH rJ rK rL rN r? r r( r] r_ r` rb rc r^ ri �
__classcell__r/ r/ )r. r0 r s0 ) % r c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
S )rO c C s || _ || _d | _d| _d S )NF)rW rI r6 rd )r) rW rI r/ r/ r0 r s z!WriteSubprocessPipeProto.__init__c C s
|| _ d S )N)r6 )r) Z transportr/ r/ r0 rS s z(WriteSubprocessPipeProto.connection_madec C s d| j j| j| jf S )Nz<%s fd=%s pipe=%r>)r. r3 rI r6 )r) r/ r/ r0 r9 s z!WriteSubprocessPipeProto.__repr__c C s d| _ | jj| j|� d | _d S )NT)rd rW r_ rI )r) r[ r/ r/ r0 rj s z(WriteSubprocessPipeProto.connection_lostc C s | j jj� d S )N)rW r �
pause_writing)r) r/ r/ r0 rn s z&WriteSubprocessPipeProto.pause_writingc C s | j jj� d S )N)rW r �resume_writing)r) r/ r/ r0 ro s z'WriteSubprocessPipeProto.resume_writingN) r3 rk rl r rS r9 rj rn ro r/ r/ r/ r0 rO s rO c @ s e Zd Zdd� ZdS )rQ c C s | j j| j|� d S )N)rW r` rI )r) rZ r/ r/ r0 �
data_received$ s z%ReadSubprocessPipeProto.data_receivedN)r3 rk rl rp r/ r/ r/ r0 rQ ! s rQ )r r rC � r r r Z
coroutinesr �logr ZSubprocessTransportr Z BaseProtocolrO ZProtocolrQ r/ r/ r/ r0 �<module> s { PK [VWX�E E % __pycache__/test_utils.cpython-36.pycnu �[��� 3
\�: �
@ s d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl
Z
ddlZddl
mZ ddlmZ ddlmZmZ y ddlZW n ek
r� dZY nX ddlmZ ddlmZ dd lmZ dd
lmZ dd lm Z dd lm Z dd
l m Z ddl m!Z! ddl"m#Z# e j$dk�rHddl%m&Z& n ddlm&Z& dd� Z'e'd�Z(e'd�Z)dd� Z*dd� Z+dRdd �Z,d d � Z-G d d � d e�Z.G d!d"� d"e�Z/G d#d$� d$�Z0G d%d&� d&e0e/�Z1d'd(�d)d*�Z2e3ed+��rZG d,d-� d-ej4e�Z5G d.d/� d/e5e�Z6G d0d1� d1e6�Z7G d2d3� d3e0e7�Z8d4d5� Z9ej:d6d7� �Z;ej:d'd(�d8d9��Z<ej:d:dd'd;�d<d=��Z=d>d?� Z>G d@dA� dAe j?�Z@G dBdC� dCejA�ZBdDdE� ZCG dFdG� dGeD�ZEdHdI� ZFG dJdK� dKe
jG�ZGej:dLdM� �ZHejIejJejKfdNdO�ZLdPdQ� ZMdS )SzUtilities shared by tests.� N)�mock)�
HTTPServer)�WSGIRequestHandler�
WSGIServer� )� base_events)�compat)�events)�futures)� selectors)�tasks)� coroutine)�logger)�supportZwin32)�
socketpairc C s` t td�r*tjjtj| �}tjj|�r*|S tjjtjjtj�d| �}tjj|�rT|S t | ��d S )N�
TEST_HOME_DIR�test)
�hasattrr �os�path�joinr �isfile�dirname�__file__�FileNotFoundError)�filename�fullname� r �*/usr/lib64/python3.6/asyncio/test_utils.py� data_file- s
r z ssl_cert.pemz ssl_key.pemc C s t d kr d S t jt j�S d S )N)�ssl�
SSLContextZPROTOCOL_SSLv23r r r r �dummy_ssl_context< s r" c
C s@ t dd� �}|� }| j|�}d|_z| j|� W d |j� X d S )Nc S s d S )Nr r r r r �onceD s zrun_briefly.<locals>.onceF)r
Z create_taskZ_log_destroy_pending�run_until_complete�close)�loopr# �gen�tr r r � run_brieflyC s
r) � c C sT t j � | }xB|� sN|d k r8|t j � }|dkr8tj� �| jtjd| d�� qW d S )Nr g����MbP?)r& )�timer
� TimeoutErrorr$ r Zsleep)r& Zpred�timeoutZdeadliner r r � run_untilR s r. c C s | j | j� | j� dS )z�Legacy API to run once through the event loop.
This is the recommended pattern for test code. It will poll the
selector once and run all callbacks scheduled in response to I/O
events.
N)Z call_soon�stopZ run_forever)r& r r r �run_once\ s r0 c @ s e Zd Zdd� Zdd� ZdS )�SilentWSGIRequestHandlerc C s t j� S )N)�io�StringIO)�selfr r r �
get_stderri s z#SilentWSGIRequestHandler.get_stderrc G s d S )Nr )r4 �format�argsr r r � log_messagel s z$SilentWSGIRequestHandler.log_messageN)�__name__�
__module__� __qualname__r5 r8 r r r r r1 g s r1 c s( e Zd ZdZ� fdd�Zdd� Z� ZS )�SilentWSGIServer� c s" t � j� \}}|j| j� ||fS )N)�super� get_request�
settimeout�request_timeout)r4 �request� client_addr)� __class__r r r? t s z SilentWSGIServer.get_requestc C s d S )Nr )r4 rB �client_addressr r r � handle_errory s z SilentWSGIServer.handle_error)r9 r: r; rA r? rF �
__classcell__r r )rD r r< p s r< c @ s e Zd Zdd� ZdS )�SSLWSGIServerMixinc C s^ t }t}tj� }|j||� |j|dd�}y| j||| � |j� W n tk
rX Y nX d S )NT)Z server_side) �ONLYKEY�ONLYCERTr r! Zload_cert_chainZ wrap_socketZRequestHandlerClassr% �OSError)r4 rB rE ZkeyfileZcertfile�contextZssockr r r �finish_request s z!SSLWSGIServerMixin.finish_requestN)r9 r: r; rM r r r r rH } s rH c @ s e Zd ZdS )�
SSLWSGIServerN)r9 r: r; r r r r rN � s rN F)�use_sslc
# sv dd� }|r|n|}|| t �� � j|� � j� _tj� fdd�d�}|j� z
� V W d � j� � j� |j � X d S )Nc S s d}dg}|||� dgS )Nz200 OK� Content-type�
text/plains Test message)rP rQ r )�environZstart_responseZstatusZheadersr r r �app� s
z _run_test_server.<locals>.appc s � j dd�S )Ng�������?)Z
poll_interval)Z
serve_foreverr )�httpdr r �<lambda>� s z"_run_test_server.<locals>.<lambda>)�target)
r1 Zset_appZserver_address�address� threadingZThread�start�shutdownZ server_closer )rW rO �
server_cls�server_ssl_clsrS Z server_classZ
server_threadr )rT r �_run_test_server� s
r] ZAF_UNIXc @ s e Zd Zdd� ZdS )�UnixHTTPServerc C s t jj| � d| _d| _d S )Nz 127.0.0.1�P )� socketserver�UnixStreamServer� server_bindZ server_nameZ server_port)r4 r r r rb � s zUnixHTTPServer.server_bindN)r9 r: r; rb r r r r r^ � s r^ c s( e Zd ZdZdd� Z� fdd�Z� ZS )�UnixWSGIServerr= c C s t j| � | j� d S )N)r^ rb Z
setup_environ)r4 r r r rb � s
zUnixWSGIServer.server_bindc s" t � j� \}}|j| j� |dfS )N� 127.0.0.1� )rd re )r> r? r@ rA )r4 rB rC )rD r r r? � s zUnixWSGIServer.get_request)r9 r: r; rA rb r? rG r r )rD r rc � s rc c @ s e Zd Zdd� ZdS )�SilentUnixWSGIServerc C s d S )Nr )r4 rB rE r r r rF � s z!SilentUnixWSGIServer.handle_errorN)r9 r: r; rF r r r r rf � s rf c @ s e Zd ZdS )�UnixSSLWSGIServerN)r9 r: r; r r r r rg � s rg c C s t j� �} | jS Q R X d S )N)�tempfileZNamedTemporaryFile�name)�filer r r �gen_unix_socket_path� s
rk c c s< t � } z
| V W d ytj| � W n tk
r4 Y nX X d S )N)rk r �unlinkrK )r r r r �unix_socket_path� s
rm c
c s, t � � }t|| ttd�E d H W d Q R X d S )N)rW rO r[ r\ )rm r] rf rg )rO r r r r �run_test_unix_server� s rn z 127.0.0.1)�host�portrO c c s t | |f|ttd�E d H d S )N)rW rO r[ r\ )r] r< rN )ro rp rO r r r �run_test_server� s
rq c C sP i }x4t | �D ](}|jd�r(|jd�r(qtd d�||< qW td| f| j |�� S )N�__)� return_valueZ TestProtocol)�dir�
startswith�endswith� MockCallback�type� __bases__)�baseZdctri r r r �make_test_protocol� s r{ c @ s6 e Zd Zdd� Zd dd�Zdd� Zdd � Zd
d � ZdS )
� TestSelectorc C s
i | _ d S )N)�keys)r4 r r r �__init__ s zTestSelector.__init__Nc C s t j|d||�}|| j|< |S )Nr )r Z SelectorKeyr} )r4 �fileobjr �data�keyr r r �register s
zTestSelector.registerc C s | j j|�S )N)r} �pop)r4 r r r r �
unregister s zTestSelector.unregisterc C s g S )Nr )r4 r- r r r �select s zTestSelector.selectc C s | j S )N)r} )r4 r r r �get_map s zTestSelector.get_map)N)r9 r: r; r~ r� r� r� r� r r r r r| s
r| c s� e Zd ZdZd-� fdd� Zdd� Zdd� Z� fd d
�Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Z� fd%d&�Z� fd'd(�Zd)d*� Zd+d,� Z� ZS ).�TestLoopa� Loop for unittests.
It manages self time directly.
If something scheduled to be executed later then
on next loop iteration after all ready handlers done
generator passed to __init__ is calling.
Generator should be like this:
def gen():
...
when = yield ...
... = yield time_advance
Value returned by yield is absolute time of next scheduled handler.
Value passed to yield is time advance to move loop's time forward.
Nc sv t � j� |d kr"dd� }d| _nd| _|� | _t| j� d| _d| _g | _t� | _ i | _
i | _ | j � t
j� | _d S )Nc s s
d V d S )Nr r r r r r' , s z TestLoop.__init__.<locals>.genFTr g��&� .>)r> r~ �_check_on_close�_gen�next�_timeZ_clock_resolution�_timersr| Z _selector�readers�writers�reset_counters�weakref�WeakValueDictionary� _transports)r4 r' )rD r r r~ ( s
zTestLoop.__init__c C s | j S )N)r� )r4 r r r r+ ? s z
TestLoop.timec C s |r| j |7 _ dS )zMove test time forward.N)r� )r4 �advancer r r � advance_timeB s zTestLoop.advance_timec sB t � j� | jr>y| jjd� W n tk
r4 Y n
X td��d S )Nr z Time generator is not finished)r> r% r� r� �send�
StopIteration�AssertionError)r4 )rD r r r% G s
zTestLoop.closec G s t j||| �| j|< d S )N)r �Handler� )r4 �fd�callbackr7 r r r � _add_readerQ s zTestLoop._add_readerc C s0 | j | d7 < || jkr(| j|= dS dS d S )Nr TF)�remove_reader_countr� )r4 r� r r r �_remove_readerT s
zTestLoop._remove_readerc G sh || j krtd|� d���| j | }|j|krDtd|j� d|� ���|j|krdtd|j� d|� ���d S )Nzfd z is not registeredzunexpected callback: z != zunexpected callback args: )r� r� � _callback�_args)r4 r� r� r7 �handler r r �
assert_reader\ s
zTestLoop.assert_readerc C s || j krtd|� d���d S )Nzfd z is registered)r� r� )r4 r� r r r �assert_no_readerg s
zTestLoop.assert_no_readerc G s t j||| �| j|< d S )N)r r� r� )r4 r� r� r7 r r r � _add_writerk s zTestLoop._add_writerc C s0 | j | d7 < || jkr(| j|= dS dS d S )Nr TF)�remove_writer_countr� )r4 r� r r r �_remove_writern s
zTestLoop._remove_writerc G s^ || j kstdj|���| j | }|j|ks>tdj|j|���|j|ksZtdj|j|���d S )Nzfd {} is not registeredz {!r} != {!r})r� r� r6 r� r� )r4 r� r� r7 r� r r r �
assert_writerv s
zTestLoop.assert_writerc C s8 y| j | }W n tk
r" Y nX tdj||���d S )Nz.File descriptor {!r} is used by transport {!r})r� �KeyError� RuntimeErrorr6 )r4 r� Z transportr r r �_ensure_fd_no_transport~ s z TestLoop._ensure_fd_no_transportc G s | j |� | j||f|�� S )zAdd a reader callback.)r� r� )r4 r� r� r7 r r r �
add_reader� s
zTestLoop.add_readerc C s | j |� | j|�S )zRemove a reader callback.)r� r� )r4 r� r r r �
remove_reader� s
zTestLoop.remove_readerc G s | j |� | j||f|�� S )zAdd a writer callback..)r� r� )r4 r� r� r7 r r r �
add_writer� s
zTestLoop.add_writerc C s | j |� | j|�S )zRemove a writer callback.)r� r� )r4 r� r r r �
remove_writer� s
zTestLoop.remove_writerc C s t jt�| _t jt�| _d S )N)� collections� defaultdict�intr� r� )r4 r r r r� � s zTestLoop.reset_countersc s: t � j� x$| jD ]}| jj|�}| j|� qW g | _d S )N)r> � _run_oncer� r� r� r� )r4 �whenr� )rD r r r� � s
zTestLoop._run_oncec s | j j|� t� j||f|�� S )N)r� �appendr> �call_at)r4 r� r� r7 )rD r r r� � s zTestLoop.call_atc C s d S )Nr )r4 Z
event_listr r r �_process_events� s zTestLoop._process_eventsc C s d S )Nr )r4 r r r �_write_to_self� s zTestLoop._write_to_self)N)r9 r: r; �__doc__r~ r+ r� r% r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rG r r )rD r r� s,
r� c K s t jf ddgi| ��S )N�spec�__call__)r ZMock)�kwargsr r r rw � s rw c @ s e Zd ZdZdd� ZdS )� MockPatternz�A regex based str with a fuzzy __eq__.
Use this helper with 'mock.assert_called_with', or anywhere
where a regex comparison between strings is needed.
For instance:
mock_call.assert_called_with(MockPattern('spam.*ham'))
c C s t tjt| �|tj��S )N)�bool�re�search�str�S)r4 �otherr r r �__eq__� s zMockPattern.__eq__N)r9 r: r; r� r� r r r r r� � s r� c C s$ t j| �}|d kr td| f ��|S )Nz unable to get the source of %r)r Z_get_function_source�
ValueError)�func�sourcer r r �get_function_source� s
r� c @ sV e Zd Zedd� �Zdd�dd�Zddd �Zd
d � Zd d
� Zdd� Z e
j sRdd� Z dS )�TestCasec C s& | j }|d k r|jdd� | j� d S )NT)�wait)Z_default_executorrZ r% )r& Zexecutorr r r �
close_loop� s zTestCase.close_loopT)�cleanupc C s, |d k s t �tjd � |r(| j| j|� d S )N)r� r �set_event_loopZ
addCleanupr� )r4 r& r� r r r r� � s
zTestCase.set_event_loopNc C s t |�}| j|� |S )N)r� r� )r4 r' r& r r r �
new_test_loop� s
zTestCase.new_test_loopc C s | j t_ d S )N)�_get_running_loopr )r4 r r r �unpatch_get_running_loop� s z!TestCase.unpatch_get_running_loopc C s t j| _dd� t _tj� | _d S )Nc S s d S )Nr r r r r rU � s z TestCase.setUp.<locals>.<lambda>)r r� r Zthreading_setup�_thread_cleanup)r4 r r r �setUp� s
zTestCase.setUpc C sB | j � tjd � | jtj� d� | j� tj| j � tj
� d S )N)NNN) r� r r� Z assertEqual�sys�exc_infoZ
doCleanupsr Zthreading_cleanupr� Z
reap_children)r4 r r r �tearDown� s
zTestCase.tearDownc O s G dd� d�}|� S )Nc @ s e Zd Zdd� Zdd� ZdS )z!TestCase.subTest.<locals>.EmptyCMc S s d S )Nr )r4 r r r � __enter__� s z+TestCase.subTest.<locals>.EmptyCM.__enter__c W s d S )Nr )r4 �excr r r �__exit__� s z*TestCase.subTest.<locals>.EmptyCM.__exit__N)r9 r: r; r� r� r r r r �EmptyCM� s r� r )r4 r7 r� r� r r r �subTest� s zTestCase.subTest)N)
r9 r: r; � staticmethodr� r� r� r� r� r� r ZPY34r� r r r r r� � s
r� c c s2 t j} zt jtjd � dV W dt j| � X dS )zrContext manager to disable asyncio logger.
For example, it can be used to ignore warnings in debug mode.
r N)r �levelZsetLevel�loggingZCRITICAL)Z old_levelr r r �disable_logger� s
r� c C s* t jtj�}| |_||_||_d|j_|S )z'Create a mock of a non-blocking socket.g )r Z MagicMock�socket�protorx �familyZ
gettimeoutrs )r� rx r� Zsockr r r �mock_nonblocking_socket s r� c C s t jddd�S )Nz'asyncio.sslproto._is_sslproto_availableF)rs )r Zpatchr r r r �force_legacy_ssl_support s r� )r* )Nr� r� �
contextlibr2 r� r r� r� r` r� rh rX r+ Zunittestr� r Z http.serverr Zwsgiref.simple_serverr r r � ImportErrorre r r r r
r r Z
coroutinesr
�logr r r �platformZ
windows_utilsr r rJ rI r" r) r. r0 r1 r< rH rN r] r ra r^ rc rf rg rk �contextmanagerrm rn rq r{ Z BaseSelectorr| Z
BaseEventLoopr� rw r� r� r� r� r� Z IPPROTO_TCPZ SOCK_STREAMZAF_INETr� r� r r r r �<module> s�
4
PK [�;�.4 .4 ( __pycache__/streams.cpython-36.opt-2.pycnu �[��� 3
\�_ � @ sH d ddddddgZ ddlZeed �r2e jd
d g� d d
lmZ d dlmZ d dlmZ d dlmZ d dlm Z d dl
m Z d!Z G dd� de
�ZG dd� de�Ze d"de d�dd��Ze d#de d�dd��Zeed ��re d$de d�dd
��Ze d%de d�dd ��ZG d d � d ej�ZG d d� deej�ZG d d� d�ZG d d � d �ZdS )&� StreamReader� StreamWriter�StreamReaderProtocol�open_connection� start_server�IncompleteReadError�LimitOverrunError� NZAF_UNIX�open_unix_connection�start_unix_server� )�
coroutines)�compat)�events)� protocols)� coroutine)�logger� � c s$ e Zd Z� fdd�Zdd� Z� ZS )r c s( t � jdt|�|f � || _|| _d S )Nz-%d bytes read on a total of %r expected bytes)�super�__init__�len�partial�expected)�selfr r )� __class__� �'/usr/lib64/python3.6/asyncio/streams.pyr s z IncompleteReadError.__init__c C s t | �| j| jffS )N)�typer r )r r r r �
__reduce__& s z IncompleteReadError.__reduce__)�__name__�
__module__� __qualname__r r �
__classcell__r r )r r r s c s$ e Zd Z� fdd�Zdd� Z� ZS )r c s t � j|� || _d S )N)r r �consumed)r �messager# )r r r r 0 s zLimitOverrunError.__init__c C s t | �| jd | jffS )Nr )r �argsr# )r r r r r 4 s z LimitOverrunError.__reduce__)r r r! r r r" r r )r r r * s )�loop�limitc + sb |d krt j� }t||d�}t||d�� |j� fdd�| |f|�E d H \}}t|� ||�}||fS )N)r' r& )r& c s � S )Nr r )�protocolr r �<lambda>Q s z!open_connection.<locals>.<lambda>)r �get_event_loopr r Zcreate_connectionr ) �host�portr& r' �kwds�reader� transport�_�writerr )r( r r 8 s c + s8 �d krt j� �� ��fdd�}�j|||f|�E d H S )Nc s t ��d�} t| � �d�}|S )N)r' r& )r& )r r )r. r( )�client_connected_cbr' r& r r �factoryq s z start_server.<locals>.factory)r r* Z
create_server)r2 r+ r, r& r' r- r3 r )r2 r' r& r r V s c + s` |d krt j� }t||d�}t||d�� |j� fdd�| f|�E d H \}}t|� ||�}||fS )N)r' r& )r& c s � S )Nr r )r( r r r) � s z&open_unix_connection.<locals>.<lambda>)r r* r r Zcreate_unix_connectionr )�pathr& r' r- r. r/ r0 r1 r )r( r r } s c + s6 �d krt j� �� ��fdd�}�j||f|�E d H S )Nc s t ��d�} t| � �d�}|S )N)r' r& )r& )r r )r. r( )r2 r' r& r r r3 � s z"start_unix_server.<locals>.factory)r r* Zcreate_unix_server)r2 r4 r& r' r- r3 r )r2 r' r& r r
� s c @ s: e Zd Zd dd�Zdd� Zdd� Zdd � Zed
d � �ZdS )
�FlowControlMixinNc C s0 |d krt j� | _n|| _d| _d | _d| _d S )NF)r r* �_loop�_paused�
_drain_waiter�_connection_lost)r r& r r r r � s zFlowControlMixin.__init__c C s d| _ | jj� r tjd| � d S )NTz%r pauses writing)r7 r6 � get_debugr �debug)r r r r �
pause_writing� s
z FlowControlMixin.pause_writingc C sF d| _ | jj� r tjd| � | j}|d k rBd | _|j� sB|jd � d S )NFz%r resumes writing)r7 r6 r: r r; r8 �done�
set_result)r �waiterr r r �resume_writing� s
z FlowControlMixin.resume_writingc C sV d| _ | jsd S | j}|d kr"d S d | _|j� r4d S |d krH|jd � n
|j|� d S )NT)r9 r7 r8 r= r> �
set_exception)r �excr? r r r �connection_lost� s z FlowControlMixin.connection_lostc c s< | j rtd��| jsd S | j}| jj� }|| _|E d H d S )NzConnection lost)r9 �ConnectionResetErrorr7 r8 r6 �
create_future)r r? r r r �
_drain_helper� s
z FlowControlMixin._drain_helper)N) r r r! r r< r@ rC r rF r r r r r5 � s
r5 c sB e Zd Zd � fdd� Zdd� Z� fdd�Zdd � Zd
d � Z� ZS )
r Nc s* t � j|d� || _d | _|| _d| _d S )N)r& F)r r �_stream_reader�_stream_writer�_client_connected_cb� _over_ssl)r Z
stream_readerr2 r& )r r r r � s
z StreamReaderProtocol.__init__c C sd | j j|� |jd�d k | _| jd k r`t|| | j | j�| _| j| j | j�}tj |�r`| jj
|� d S )NZ
sslcontext) rG �
set_transport�get_extra_inforJ rI r r6 rH r Z iscoroutineZ create_task)r r/ �resr r r �connection_made� s
z$StreamReaderProtocol.connection_madec sF | j d k r*|d kr | j j� n | j j|� t� j|� d | _ d | _d S )N)rG �feed_eofrA r rC rH )r rB )r r r rC � s
z$StreamReaderProtocol.connection_lostc C s | j j|� d S )N)rG � feed_data)r �datar r r �
data_received s z"StreamReaderProtocol.data_receivedc C s | j j� | jrdS dS )NFT)rG rO rJ )r r r r � eof_received s
z!StreamReaderProtocol.eof_received)NN) r r r! r rN rC rR rS r" r r )r r r � s
c @ sf e Zd Zdd� Zdd� Zedd� �Zdd� Zd d
� Zd d � Z d
d� Z
dd� Z ddd�Z e
dd� �ZdS )r c C s || _ || _|| _|| _d S )N)�
_transport� _protocol�_readerr6 )r r/ r( r. r& r r r r s zStreamWriter.__init__c C s: | j jd| j g}| jd k r,|jd| j � ddj|� S )Nz transport=%rz reader=%rz<%s>� )r r rT rV �append�join)r �infor r r �__repr__! s
zStreamWriter.__repr__c C s | j S )N)rT )r r r r r/ ' s zStreamWriter.transportc C s | j j|� d S )N)rT �write)r rQ r r r r\ + s zStreamWriter.writec C s | j j|� d S )N)rT �
writelines)r rQ r r r r] . s zStreamWriter.writelinesc C s
| j j� S )N)rT � write_eof)r r r r r^ 1 s zStreamWriter.write_eofc C s
| j j� S )N)rT �
can_write_eof)r r r r r_ 4 s zStreamWriter.can_write_eofc C s
| j j� S )N)rT �close)r r r r r` 7 s zStreamWriter.closeNc C s | j j||�S )N)rT rL )r �name�defaultr r r rL : s zStreamWriter.get_extra_infoc c sN | j d k r | j j� }|d k r |�| jd k r:| jj� r:d V | jj� E d H d S )N)rV � exceptionrT Z
is_closingrU rF )r rB r r r �drain= s
zStreamWriter.drain)N)r r r! r r[ �propertyr/ r\ r] r^ r_ r` rL r rd r r r r r s
c @ s� e Zd Zedfdd�Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
edd� �Zedd� �Zed'dd ��Zed)d d ��Zed d!� �Zejr�ed"d#� �Zed$d%� �Zejr�d&d#� ZdS )*r Nc C sZ |dkrt d��|| _|d kr*tj� | _n|| _t� | _d| _d | _d | _ d | _
d| _ d S )Nr zLimit cannot be <= 0F) �
ValueError�_limitr r* r6 � bytearray�_buffer�_eof�_waiter�
_exceptionrT r7 )r r' r& r r r r X s zStreamReader.__init__c C s� dg}| j r |jdt| j � � | jr0|jd� | jtkrJ|jd| j � | jr`|jd| j � | jrv|jd| j � | jr�|jd| j � | j r�|jd� d d
j
|� S ) Nr z%d bytes�eofzl=%dzw=%rze=%rzt=%rZpausedz<%s>rW ) ri rX r rj rg �_DEFAULT_LIMITrk rl rT r7 rY )r rZ r r r r[ k s
zStreamReader.__repr__c C s | j S )N)rl )r r r r rc } s zStreamReader.exceptionc C s0 || _ | j}|d k r,d | _|j� s,|j|� d S )N)rl rk � cancelledrA )r rB r? r r r rA � s zStreamReader.set_exceptionc C s* | j }|d k r&d | _ |j� s&|jd � d S )N)rk ro r> )r r? r r r �_wakeup_waiter� s
zStreamReader._wakeup_waiterc C s
|| _ d S )N)rT )r r/ r r r rK � s zStreamReader.set_transportc C s* | j r&t| j�| jkr&d| _ | jj� d S )NF)r7 r ri rg rT �resume_reading)r r r r �_maybe_resume_transport� s z$StreamReader._maybe_resume_transportc C s d| _ | j� d S )NT)rj rp )r r r r rO � s zStreamReader.feed_eofc C s | j o | j S )N)rj ri )r r r r �at_eof� s zStreamReader.at_eofc C sv |sd S | j j|� | j� | jd k rr| j rrt| j �d| j krry| jj� W n tk
rj d | _Y nX d| _d S )Nr T) ri �extendrp rT r7 r rg Z
pause_reading�NotImplementedError)r rQ r r r rP � s
zStreamReader.feed_datac c sV | j d k rtd| ��| jr,d| _| jj� | jj� | _ z| j E d H W d d | _ X d S )NzH%s() called while another coroutine is already waiting for incoming dataF)rk � RuntimeErrorr7 rT rq r6 rE )r Z func_namer r r �_wait_for_data� s
zStreamReader._wait_for_datac c s� d}t |�}y| j|�E d H }W n� tk
rB } z|jS d }~X nf tk
r� } zJ| jj||j�rv| jd |j| �= n
| jj� | j � t
|j d ��W Y d d }~X nX |S )N�
r ) r � readuntilr r r ri �
startswithr# �clearrr rf r% )r �sep�seplen�line�er r r �readline� s
zStreamReader.readlinerx c c s� t |�}|dkrtd��| jd k r(| j�d}x�t | j�}|| |kr|| jj||�}|dkr\P |d | }|| jkr|td|��| jr�t| j�}| jj � t
|d ��| j d�E d H q.W || jkr�td|��| jd || � }| jd || �= | j � t|�S )Nr z,Separator should be at least one-byte stringr z2Separator is not found, and chunk exceed the limitry z2Separator is found, but chunk is longer than limit���)
r rf rl ri �findrg r rj �bytesr{ r rw rr )r Z separatorr} �offsetZbuflenZisep�chunkr r r ry � s:
zStreamReader.readuntilr c c s� | j d k r| j �|dkr dS |dk rZg }x&| j| j�E d H }|sBP |j|� q*W dj|�S | j rz| j rz| jd�E d H t| jd |� �}| jd |�= | j � |S )Nr � �read)
rl r� rg rX rY ri rj rw r� rr )r �nZblocks�blockrQ r r r r� P s$
zStreamReader.readc c s� |dk rt d��| jd k r | j�|dkr,dS xFt| j�|k rr| jr`t| j�}| jj� t||��| jd�E d H q.W t| j�|kr�t| j�}| jj� n t| jd |� �}| jd |�= | j � |S )Nr z*readexactly size can not be less than zeror� � readexactly)
rf rl r ri rj r� r{ r rw rr )r r� Z
incompleterQ r r r r� � s&
zStreamReader.readexactlyc C s | S )Nr )r r r r � __aiter__� s zStreamReader.__aiter__c c s | j � E d H }|dkrt�|S )Nr� )r� �StopAsyncIteration)r �valr r r � __anext__� s zStreamReader.__anext__c C s | S )Nr )r r r r r� � s )rx r� )r� )r r r! rn r r[ rc rA rp rK rr rO rs rP r rw r� ry r� r� r
ZPY35r� r� ZPY352r r r r r V s, [ 2 * i )NN)NN)N)N)�__all__Zsocket�hasattrrt � r r
r r r �logr rn �EOFErrorr � Exceptionr r r r r
ZProtocolr5 r r r r r r r �<module> s@
" B3GPK [�`�� � * __pycache__/protocols.cpython-36.opt-2.pycnu �[��� 3
\� � @ sN d dddgZ G dd � d �ZG dd� de�ZG dd� de�ZG dd� de�ZdS ) � BaseProtocol�Protocol�DatagramProtocol�SubprocessProtocolc @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S )
r c C s d S )N� )�selfZ transportr r �)/usr/lib64/python3.6/asyncio/protocols.py�connection_made s z BaseProtocol.connection_madec C s d S )Nr )r �excr r r �connection_lost s z BaseProtocol.connection_lostc C s d S )Nr )r r r r �
pause_writing! s zBaseProtocol.pause_writingc C s d S )Nr )r r r r �resume_writing7 s zBaseProtocol.resume_writingN)�__name__�
__module__� __qualname__r r
r r r r r r r s
c @ s e Zd Zdd� Zdd� ZdS )r c C s d S )Nr )r �datar r r �
data_receivedX s zProtocol.data_receivedc C s d S )Nr )r r r r � eof_received^ s zProtocol.eof_receivedN)r
r r r r r r r r r > s c @ s e Zd Zdd� Zdd� ZdS )r c C s d S )Nr )r r Zaddrr r r �datagram_receivedj s z"DatagramProtocol.datagram_receivedc C s d S )Nr )r r r r r �error_receivedm s z DatagramProtocol.error_receivedN)r
r r r r r r r r r g s c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )r c C s d S )Nr )r �fdr r r r �pipe_data_receivedw s z%SubprocessProtocol.pipe_data_receivedc C s d S )Nr )r r r r r r �pipe_connection_lost~ s z'SubprocessProtocol.pipe_connection_lostc C s d S )Nr )r r r r �process_exited� s z!SubprocessProtocol.process_exitedN)r
r r r r r r r r r r t s N)�__all__r r r r r r r r �<module> s
7)
PK [��t�Gs Gs 0 __pycache__/selector_events.cpython-36.opt-1.pycnu �[��� 3
\�� �
@ s< d Z dgZddlZddlZddlZddlZddlZddlZy ddlZW n e k
r^ dZY nX ddl
m Z ddl
m Z ddl
m
Z
ddl
mZ dd l
mZ dd
l
mZ dd l
mZ dd l
mZ dd
lmZ ddlmZ dd� ZG dd� de j�ZG dd� dejej�Z G dd� de �Z G dd� de �Z G dd� de �Z dS )z�Event 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)�compat)� constants)�events)�futures)� selectors)�
transports)�sslproto)� coroutine)�loggerc C s6 y| j |�}W n tk
r" dS X t|j|@ �S d S )NF)�get_key�KeyError�boolr )�selector�fdZevent�key� r �//usr/lib64/python3.6/asyncio/selector_events.py�_test_selector_event s
r c sr e Zd ZdZdO� fdd� ZdPddd�dd�ZdQddddd �d
d �Zddddd �d d
�ZdRdd�Z� fdd�Z dd� Z
dd� Z dd� Z dd� Z
dd� Zd d � ZdSd d �ZdTd!d"�ZedUd#d$��Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Zd5d6� Z d7d8� Z d9d:� Z d;d<� Z d=d>� Z ed?d@� �Z!dAdB� Z"dCdD� Z#dEdF� Z$dGdH� Z%dIdJ� Z&dKdL� Z'dMdN� Z(� Z)S )Vr zJSelector event loop.
See events.EventLoop for API specification.
Nc sF t � j� |d krtj� }tjd|jj� || _| j � t
j � | _ d S )NzUsing selector: %s)
�super�__init__r ZDefaultSelectorr
�debug� __class__�__name__� _selector�_make_self_pipe�weakref�WeakValueDictionary� _transports)�selfr )r r r r 1 s
z BaseSelectorEventLoop.__init__)�extra�serverc C s t | |||||�S )N)�_SelectorSocketTransport)r! �sock�protocol�waiterr" r# r r r �_make_socket_transport; s
z,BaseSelectorEventLoop._make_socket_transportF)� server_side�server_hostnamer" r# c
C sN t j� s"| j||||||||d�S t j| |||||�} t| || ||d� | jS )N)r) r* r" r# )r" r# )r Z_is_sslproto_available�_make_legacy_ssl_transportZ SSLProtocolr$ Z_app_transport)
r! �rawsockr& �
sslcontextr' r) r* r" r# Z ssl_protocolr r r �_make_ssl_transport@ s
z)BaseSelectorEventLoop._make_ssl_transportc
C s t | ||||||||� S )N)�_SelectorSslTransport) r! r, r& r- r' r) r* r" r# r r r r+ O s
z0BaseSelectorEventLoop._make_legacy_ssl_transportc C s t | |||||�S )N)�_SelectorDatagramTransport)r! r% r& �addressr' r" r r r �_make_datagram_transportY s z.BaseSelectorEventLoop._make_datagram_transportc sL | j � rtd��| j� r d S | j� t� j� | jd k rH| jj� d | _d S )Nz!Cannot close a running event loop)Z
is_running� RuntimeError� is_closed�_close_self_piper �closer )r! )r r r r6 ^ s
zBaseSelectorEventLoop.closec C s t �d S )N)�NotImplementedError)r! r r r � _socketpairi s z!BaseSelectorEventLoop._socketpairc C sB | j | jj� � | jj� d | _| jj� d | _| jd8 _d S )Nr )�_remove_reader�_ssock�filenor6 �_csock�
_internal_fds)r! r r r r5 l s
z&BaseSelectorEventLoop._close_self_pipec C sN | j � \| _| _| jjd� | jjd� | jd7 _| j| jj� | j� d S )NFr )r8 r: r< � setblockingr= � _add_readerr; �_read_from_self)r! r r r r t s
z%BaseSelectorEventLoop._make_self_pipec C s d S )Nr )r! �datar r r �_process_self_data| s z(BaseSelectorEventLoop._process_self_datac C sV xPy | j jd�}|sP | j|� W q tk
r8 wY q tk
rL P Y qX qW d S )Ni )r: �recvrB �InterruptedError�BlockingIOError)r! rA r r r r@ s z%BaseSelectorEventLoop._read_from_selfc C sJ | j }|d k rFy|jd� W n( tk
rD | jr@tjddd� Y nX d S )N� z3Fail to write a null byte into the self-pipe socketT)�exc_info)r< �send�OSError�_debugr
r )r! Zcsockr r r �_write_to_self� s z$BaseSelectorEventLoop._write_to_self�d c C s | j |j� | j|||||� d S )N)r? r; �_accept_connection)r! �protocol_factoryr% r- r# �backlogr r r �_start_serving� s z$BaseSelectorEventLoop._start_servingc C s� x�t |�D ]�}y0|j� \}}| jr2tjd|||� |jd� W n� tttfk
rX d S t k
r� } z^| j
t
j t
j t
j
t
jfkr�| jd| |d�� | j|j� � | jtj| j|||||� n� W Y d d } ~ X q
X d|i}
| j|||
||�} | j| � q
W d S )Nz#%r got a new connection from %r: %rFz&socket.accept() out of system resource)�message� exception�socket�peername)�range�acceptrJ r
r r> rE rD �ConnectionAbortedErrorrI �errnoZEMFILEZENFILEZENOBUFSZENOMEM�call_exception_handlerr9 r; Z
call_laterr ZACCEPT_RETRY_DELAYrP �_accept_connection2Z create_task) r! rN r% r- r# rO �_�conn�addr�excr" rV r r r rM � s4
z(BaseSelectorEventLoop._accept_connectionc c s� d }d }yj|� }| j � }|r6| j||||d||d�}n| j|||||d�}y|E d H W n |j� � Y nX W n\ tk
r� } z@| jr�d| d�}
|d k r�||
d< |d k r�||
d< | j|
� W Y d d } ~ X nX d S )NT)r' r) r" r# )r' r" r# z3Error on transport creation for incoming connection)rQ rR r& � transport)�
create_futurer. r( r6 � ExceptionrJ rY ) r! rN r\ r" r- r# r& r_ r' r^ �contextr r r rZ � s4 z)BaseSelectorEventLoop._accept_connection2c C s@ y| j | }W n tk
r" Y nX |j� s<tdj||���d S )Nz.File descriptor {!r} is used by transport {!r})r r �
is_closingr3 �format)r! r r_ r r r �_ensure_fd_no_transport� s z-BaseSelectorEventLoop._ensure_fd_no_transportc
G s� | j � tj||| �}y| jj|�}W n* tk
rP | jj|tj|d f� Y n>X |j|j }\}}| jj
||tjB ||f� |d k r�|j � d S )N) �
_check_closedr �Handler r r �registerr �
EVENT_READrA �modify�cancel) r! r �callback�args�handler �mask�reader�writerr r r r? � s
z!BaseSelectorEventLoop._add_readerc
C s� | j � r dS y| jj|�}W n tk
r0 dS X |j|j }\}}|tj M }|sb| jj|� n| jj ||d |f� |d k r�|j
� dS dS d S )NFT) r4 r r r r rA r ri �
unregisterrj rk )r! r r ro rp rq r r r r9 s z$BaseSelectorEventLoop._remove_readerc
G s� | j � tj||| �}y| jj|�}W n* tk
rP | jj|tjd |f� Y n>X |j|j }\}}| jj
||tjB ||f� |d k r�|j � d S )N) rf r rg r r r rh r � EVENT_WRITErA rj rk ) r! r rl rm rn r ro rp rq r r r � _add_writer s
z!BaseSelectorEventLoop._add_writerc
C s� | j � r dS y| jj|�}W n tk
r0 dS X |j|j }\}}|tj M }|sb| jj|� n| jj |||df� |dk r�|j
� dS dS dS )zRemove a writer callback.FNT) r4 r r r r rA r rs rr rj rk )r! r r ro rp rq r r r �_remove_writer, s z$BaseSelectorEventLoop._remove_writerc G s | j |� | j||f|�� S )zAdd a reader callback.)re r? )r! r rl rm r r r �
add_readerC s
z BaseSelectorEventLoop.add_readerc C s | j |� | j|�S )zRemove a reader callback.)re r9 )r! r r r r �
remove_readerH s
z#BaseSelectorEventLoop.remove_readerc G s | j |� | j||f|�� S )zAdd a writer callback..)re rt )r! r rl rm r r r �
add_writerM s
z BaseSelectorEventLoop.add_writerc C s | j |� | j|�S )zRemove a writer callback.)re ru )r! r r r r �
remove_writerR s
z#BaseSelectorEventLoop.remove_writerc C s6 | j r|j� dkrtd��| j� }| j|d||� |S )z�Receive 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.
This method is a coroutine.
r z the socket must be non-blockingN)rJ �
gettimeout�
ValueErrorr` �
_sock_recv)r! r% �n�futr r r � sock_recvW s
z BaseSelectorEventLoop.sock_recvc C s� |d k r| j |� |j� r d S y|j|�}W n` ttfk
rb |j� }| j|| j||||� Y n6 tk
r� } z|j |� W Y d d }~X n X |j
|� d S )N) rw � cancelledrC rE rD r; rv r| ra �
set_exception�
set_result)r! r~ �
registered_fdr% r} rA r r^ r r r r| f s
z BaseSelectorEventLoop._sock_recvc C sF | j r|j� dkrtd��| j� }|r8| j|d||� n
|jd� |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.
This method is a coroutine.
r z the socket must be non-blockingN)rJ rz r{ r` �
_sock_sendallr� )r! r% rA r~ r r r � sock_sendall{ s
z"BaseSelectorEventLoop.sock_sendallc C s� |d k r| j |� |j� r d S y|j|�}W nD ttfk
rH d}Y n* tk
rp } z|j|� d S d }~X nX |t|�kr�|jd � n.|r�||d � }|j � }| j
|| j ||||� d S )Nr ) ry r� rH rE rD ra r� �lenr� r; rx r� )r! r~ r� r% rA r} r^ r r r r r� � s"
z#BaseSelectorEventLoop._sock_sendallc c s� | j r|j� dkrtd��ttd� s2|jtjkrptj||j|j | d�}|j
� sZ|E dH |j � d \}}}}}| j � }| j
|||� |E dH S )zTConnect to a remote socket at address.
This method is a coroutine.
r z the socket must be non-blocking�AF_UNIX)�family�proto�loopN)rJ rz r{ �hasattrrS r� r� r Z_ensure_resolvedr� �done�resultr` �
_sock_connect)r! r% r1 Zresolvedr[ r~ r r r � sock_connect� s
z"BaseSelectorEventLoop.sock_connectc C s� |j � }y|j|� W nj ttfk
rV |jtj| j|�� | j|| j |||� Y n6 t
k
r� } z|j |� W Y d d }~X n X |j d � d S )N)
r; ZconnectrE rD Zadd_done_callback� functools�partial�_sock_connect_donerx �_sock_connect_cbra r� r� )r! r~ r% r1 r r^ r r r r� � s z#BaseSelectorEventLoop._sock_connectc C s | j |� d S )N)ry )r! r r~ r r r r� � s z(BaseSelectorEventLoop._sock_connect_donec C s� |j � r d S y,|jtjtj�}|dkr6t|d|f ��W nB ttfk
rP Y n6 tk
rz } z|j |� W Y d d }~X n X |j
d � d S )Nr zConnect call failed %s) r� Z
getsockoptrS Z
SOL_SOCKETZSO_ERRORrI rE rD ra r� r� )r! r~ r% r1 �errr^ r r r r� � s z&BaseSelectorEventLoop._sock_connect_cbc C s4 | j r|j� dkrtd��| j� }| j|d|� |S )a| 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.
This method is a coroutine.
r z the socket must be non-blockingF)rJ rz r{ r` � _sock_accept)r! r% r~ r r r � sock_accept� s
z!BaseSelectorEventLoop.sock_acceptc C s� |j � }|r| j|� |j� r"d S y|j� \}}|jd� W nV ttfk
rh | j|| j|d|� Y n: t k
r� } z|j
|� W Y d d }~X nX |j ||f� d S )NFT) r; rw r� rV r> rE rD rv r� ra r� r� )r! r~ Z
registeredr% r r\ r1 r^ r r r r� � s
z"BaseSelectorEventLoop._sock_acceptc C s� x~|D ]v\}}|j |j }\}}|tj@ rN|d k rN|jrD| j|� n
| j|� |tj@ r|d k r|jrr| j|� q| j|� qW d S )N) �fileobjrA r ri Z
_cancelledr9 Z
_add_callbackrs ru )r! Z
event_listr ro r� rp rq r r r �_process_events� s
z%BaseSelectorEventLoop._process_eventsc C s | j |j� � |j� d S )N)r9 r; r6 )r! r% r r r �
_stop_serving s z#BaseSelectorEventLoop._stop_serving)N)N)N)NNN)NNrL )NNrL )NN)*r �
__module__� __qualname__�__doc__r r( r. r+ r2 r6 r8 r5 r rB r@ rK rP rM r rZ re r? r9 rt ru rv rw rx ry r r| r� r� r� r� r� r� r� r� r� r� �
__classcell__r r )r r r + sT
( # c s� e Zd Zd ZeZdZd � fdd� Zdd� Zdd � Z d
d � Z
d d
� Z dd� Z dd� Z
ejr`dd� Zd!dd�Zdd� Zdd� Zdd � Zd d � Z� ZS )"�_SelectorTransport� i Nc s� t � j||� || jd< |j� | jd< d| jkrdy|j� | jd< W n tjk
rb d | jd< Y nX || _|j� | _ || _
d| _ || _ | j
� | _d| _d| _| j d k r�| j j� | |j| j < d S )NrS ZsocknamerT Tr F)r r �_extraZ getsocknameZ getpeernamerS �error�_sockr; �_sock_fd� _protocol�_protocol_connected�_server�_buffer_factory�_buffer�
_conn_lost�_closingZ_attachr )r! r� r% r& r" r# )r r r r s&
z_SelectorTransport.__init__c C s� | j jg}| jd kr |jd� n| jr0|jd� |jd| j � | jd k r�| jj� r�t| jj | jt
j �}|rz|jd� n
|jd� t| jj | jt
j �}|r�d}nd}| j
� }|jd||f � d d
j|� S ) N�closed�closingzfd=%sz read=pollingz read=idle�pollingZidlezwrite=<%s, bufsize=%s>z<%s>� )r r r� �appendr� r� �_loopr4 r r r ri rs �get_write_buffer_size�join)r! �infor� �state�bufsizer r r �__repr__2 s*
z_SelectorTransport.__repr__c C s | j d � d S )N)� _force_close)r! r r r �abortN s z_SelectorTransport.abortc C s
|| _ d S )N)r� )r! r& r r r � set_protocolQ s z _SelectorTransport.set_protocolc C s | j S )N)r� )r! r r r � get_protocolT s z _SelectorTransport.get_protocolc C s | j S )N)r� )r! r r r rc W s z _SelectorTransport.is_closingc C sT | j r
d S d| _ | jj| j� | jsP| jd7 _| jj| j� | jj| jd � d S )NTr ) r� r� r9 r� r� r� ru � call_soon�_call_connection_lost)r! r r r r6 Z s z_SelectorTransport.closec C s, | j d k r(tjd| t| d� | j j� d S )Nzunclosed transport %r)�source)r� �warnings�warn�ResourceWarningr6 )r! r r r �__del__h s
z_SelectorTransport.__del__�Fatal error on transportc C sP t |tj�r*| jj� rBtjd| |dd� n| jj||| | jd�� | j |� d S )Nz%r: %sT)rG )rQ rR r_ r& )
�
isinstancer Z_FATAL_ERROR_IGNOREr� � get_debugr
r rY r� r� )r! r^ rQ r r r � _fatal_errorn s
z _SelectorTransport._fatal_errorc C sd | j r
d S | jr(| jj� | jj| j� | jsBd| _| jj| j� | j d7 _ | jj| j |� d S )NTr )
r� r� �clearr� ru r� r� r9 r� r� )r! r^ r r r r� | s
z _SelectorTransport._force_closec C sV z| j r| jj|� W d | jj� d | _d | _d | _| j}|d k rP|j� d | _X d S )N)r� r� Zconnection_lostr� r6 r� r� Z_detach)r! r^ r# r r r r� � s
z(_SelectorTransport._call_connection_lostc C s
t | j�S )N)r� r� )r! r r r r� � s z(_SelectorTransport.get_write_buffer_sizec G s" | j r
d S | jj||f|�� d S )N)r� r� r? )r! r rl rm r r r r? � s z _SelectorTransport._add_readeri )NN)r� )r r� r� �max_size� bytearrayr� r� r r� r� r� r� rc r6 r ZPY34r� r� r� r� r� r? r� r r )r r r� s"
r� c sV e Zd Zd� fdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z dd� Z
� Z S )r$ Nc sr t � j|||||� d| _d| _tj| j� | jj| j j
| � | jj| j | j | j
� |d k rn| jjtj|d � d S )NF)r r �_eof�_pausedr Z _set_nodelayr� r� r� r� �connection_mader? r� � _read_readyr � _set_result_unless_cancelled)r! r� r% r& r' r" r# )r r r r � s
z!_SelectorSocketTransport.__init__c C s> | j s | jrd S d| _| jj| j� | jj� r:tjd| � d S )NTz%r pauses reading)r� r� r� r9 r� r� r
r )r! r r r �
pause_reading� s
z&_SelectorSocketTransport.pause_readingc C sB | j s| j rd S d| _| j| j| j� | jj� r>tjd| � d S )NFz%r resumes reading) r� r� r? r� r� r� r� r
r )r! r r r �resume_reading� s
z'_SelectorSocketTransport.resume_readingc C s� | j r
d S y| jj| j�}W nD ttfk
r4 Y n| tk
r` } z| j|d� W Y d d }~X nPX |rt| jj |� n<| j
j � r�t j
d| � | jj� }|r�| j
j| j� n| j� d S )Nz$Fatal read error on socket transportz%r received EOF)r� r� rC r� rE rD ra r� r� �
data_receivedr� r� r
r � eof_receivedr9 r� r6 )r! rA r^ � keep_openr r r r� � s
z$_SelectorSocketTransport._read_readyc C s� t |tttf�s"tdt|�j ��| jr0td��|s8d S | j rf| j t
j krTt j
d� | j d7 _ d S | js�y| jj|�}W nB ttfk
r� Y n@ tk
r� } z| j|d� d S d }~X nX ||d � }|s�d S | jj| j| j� | jj|� | j� d S )Nz1data argument must be a bytes-like object, not %rz%Cannot call write() after write_eof()z socket.send() raised exception.r z%Fatal write error on socket transport)r� �bytesr� �
memoryview� TypeError�typer r� r3 r� r �!LOG_THRESHOLD_FOR_CONNLOST_WRITESr
�warningr� r� rH rE rD ra r� r� rt r� � _write_ready�extend�_maybe_pause_protocol)r! rA r} r^ r r r �write� s4
z _SelectorSocketTransport.writec C s� | j r
d S y| jj| j�}W n\ ttfk
r4 Y n� tk
rx } z*| jj| j � | jj
� | j |d� W Y d d }~X nTX |r�| jd |�= | j � | js�| jj| j � | j
r�| jd � n| jr�| jjtj� d S )Nz%Fatal write error on socket transport)r� r� rH r� rE rD ra r� ru r� r� r� �_maybe_resume_protocolr� r� r� �shutdownrS �SHUT_WR)r! r} r^ r r r r� s&
z%_SelectorSocketTransport._write_readyc C s. | j s | jrd S d| _| js*| jjtj� d S )NT)r� r� r� r� r� rS r� )r! r r r � write_eof s
z"_SelectorSocketTransport.write_eofc C s dS )NTr )r! r r r �
can_write_eof s z&_SelectorSocketTransport.can_write_eof)NNN) r r� r� r r� r� r� r� r� r� r� r� r r )r r r$ � s #r$ c sd e Zd ZeZd� fdd� Zddd�Zdd� Zd d
� Zd d � Z d
d� Z
dd� Z dd� Z dd� Z
� ZS )r/ NFc
s� t d krtd��|s tj||�}|dd�}
|r<| r<||
d< |j|f|
�} t� j|| ||| � d| _|| _|| _ || _
d| _ | j j
|d� | jj� r�tjd| � | jj� } nd } | j| � d S )Nz stdlib ssl module not availableF)r) Zdo_handshake_on_connectr* )r- z%r starts SSL handshake)�sslr3 r Z_create_transport_contextZ wrap_socketr r r� �_server_hostname�_waiter� _sslcontextr� r� �updater� r� r
r �time�
_on_handshake)
r! r� r, r& r- r' r) r* r" r# Z wrap_kwargsZsslsock�
start_time)r r r r ( s*
z _SelectorSslTransport.__init__c C sD | j d krd S | j j� s:|d k r.| j j|� n | j jd � d | _ d S )N)r� r� r� r� )r! r^ r r r �_wakeup_waiterL s
z$_SelectorSslTransport._wakeup_waiterc " C s$ y| j j� W n� tjk
r8 | jj| j| j|� d S tjk
r` | jj | j| j|� d S t
k
r� } z`| jj � r�t j
d| dd� | jj| j� | jj| j� | j j� | j|� t|t�r�d S � W Y d d }~X nX | jj| j� | jj| j� | j j� }t| jd��s�| j�r�| jjtjk�r�ytj|| j� W nR tk
�r� } z4| jj � �rjt j
d| dd� | j j� | j|� d S d }~X nX | jj || j j � | j j � | j d� d| _ d| _ | jj| j| j!� d| _"| jj#| j$j%| � | jj#| j� | jj � �r | jj&� | }t j'd| |d � d S )
Nz%r: SSL handshake failedT)rG Zcheck_hostnamez1%r: SSL handshake failed on matching the hostname)�peercert�cipher� compressionZ
ssl_objectFz %r: SSL handshake took %.1f msg @�@)(r� Z do_handshaker� �SSLWantReadErrorr� r? r� r� �SSLWantWriteErrorrt �
BaseExceptionr� r
r� r9 ru r6 r� r� ra Z getpeercertr� r� r� Z verify_modeZ CERT_NONEZmatch_hostnamer� r� r� r� �_read_wants_write�_write_wants_readr� r� r� r� r� r� r )r! r� r^ r� Zdtr r r r� V sb
z#_SelectorSslTransport._on_handshakec C sJ | j rtd��| jr td��d| _| jj| j� | jj� rFtjd| � d S )Nz#Cannot pause_reading() when closingzAlready pausedTz%r pauses reading) r� r3 r� r� r9 r� r� r
r )r! r r r r� � s
z#_SelectorSslTransport.pause_readingc C sJ | j std��d| _ | jr d S | jj| j| j� | jj� rFtj d| � d S )Nz
Not pausedFz%r resumes reading)
r� r3 r� r� r? r� r� r� r
r )r! r r r r� � s
z$_SelectorSslTransport.resume_readingc C s" | j r
d S | jr6d| _| j� | jr6| jj| j| j� y| jj| j �}W n� t
t t j
fk
rd Y n� t jk
r� d| _| jj| j� | jj| j| j� Y n� tk
r� } z| j|d� W Y d d }~X nTX |r�| jj|� n@z4| jj� r�tjd| � | jj� }|�rtjd� W d | j� X d S )NFTz!Fatal read error on SSL transportz%r received EOFz?returning true from eof_received() has no effect when using ssl)r� r� r� r� r� rt r� r� rC r� rE rD r� r� r� r� r9 ra r� r� r� r� r
r r� r� r6 )r! rA r^ r� r r r r� � s4
z!_SelectorSslTransport._read_readyc C s( | j r
d S | jr<d| _| j� | jp(| js<| jj| j| j� | jr�y| j j
| j�}W n� t t t
jfk
rt d}Y np t
jk
r� d}| jj| j� d| _Y nD tk
r� } z(| jj| j� | jj� | j|d� d S d }~X nX |r�| jd |�= | j� | j�s$| jj| j� | j�r$| jd � d S )NFr Tz"Fatal write error on SSL transport)r� r� r� r� r� r� r? r� r� r� rH rE rD r� r� r� ru r� ra r� r� r� r� )r! r} r^ r r r r� � s8
z"_SelectorSslTransport._write_readyc C s� t |tttf�s"tdt|�j ��|s*d S | jrX| jtj krFt
j d� | jd7 _d S | j sp| j
j| j| j� | j j|� | j� d S )Nz1data argument must be a bytes-like object, not %rz socket.send() raised exception.r )r� r� r� r� r� r� r r� r r� r
r� r� r� rt r� r� r� r� )r! rA r r r r� � s
z_SelectorSslTransport.writec C s dS )NFr )r! r r r r� s z#_SelectorSslTransport.can_write_eof)NFNNN)N)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 )r0 Nc s^ t � j||||� || _| jj| jj| � | jj| j| j| j � |d k rZ| jjt
j |d � d S )N) r r �_addressr� r� r� r� r? r� r� r r� )r! r� r% r& r1 r' r" )r r r r s
z#_SelectorDatagramTransport.__init__c C s t dd� | jD ��S )Nc s s | ]\}}t |�V qd S )N)r� )�.0rA r[ r r r � <genexpr> s zC_SelectorDatagramTransport.get_write_buffer_size.<locals>.<genexpr>)�sumr� )r! r r r r� s z0_SelectorDatagramTransport.get_write_buffer_sizec C s� | j r
d S y| jj| j�\}}W np ttfk
r8 Y nh tk
rd } z| jj|� W Y d d }~X n< t k
r� } z| j
|d� W Y d d }~X nX | jj ||� d S )Nz&Fatal read error on datagram transport) r� r� Zrecvfromr� rE rD rI r� �error_receivedra r� Zdatagram_received)r! rA r] r^ r r r r� s z&_SelectorDatagramTransport._read_readyc C sT t |tttf�s"tdt|�j ��|s*d S | jrN|d | jfkrNtd| jf ��| j r�| jr�| j t
j krpt j
d� | j d7 _ d S | j�s4y&| jr�| jj|� n| jj||� d S ttfk
r� | jj| j| j� Y nZ tk
�r } z| jj|� d S d }~X n. tk
�r2 } z| j |d� d S d }~X nX | jj t|�|f� | j � d S )Nz1data argument must be a bytes-like object, not %rz#Invalid address: must be None or %sz socket.send() raised exception.r z'Fatal write error on datagram transport) r� r� r� r� r� r� r r� r{ r� r r� r
r� r� r� rH �sendtorE rD r� rt r� �
_sendto_readyrI r� r� ra r� r� r� )r! rA r] r^ r r r r� . s<
z!_SelectorDatagramTransport.sendtoc C s� x�| j r�| j j� \}}y&| jr,| jj|� n| jj||� W q ttfk
rf | j j||f� P Y q t k
r� } z| j
j |� d S d }~X q t k
r� } z| j
|d� d S d }~X qX qW | j� | j s�| jj| j� | jr�| jd � d S )Nz'Fatal write error on datagram transport)r� �popleftr� r� rH r� rE rD �
appendleftrI r� r� ra r� r� r� ru r� r� r� )r! rA r] r^ r r r r� U s* z(_SelectorDatagramTransport._sendto_ready)NNN)N) r r� r� � collections�dequer� r r� r� r� r� r� r r )r r r0 s
'r0 ) r� �__all__r� rX r� rS r� r r� � ImportError� r r r r r r r
r Z
coroutinesr �logr
r Z
BaseEventLoopr Z_FlowControlMixinZ Transportr� r$ r/ r0 r r r r �<module> sD
i iPK [����j# j# 0 __pycache__/base_subprocess.cpython-36.opt-2.pycnu �[��� 3
\�# � @ s� d dl Z d dlZd dlZddlmZ ddlmZ ddlmZ ddlmZ ddl m
Z
G dd � d ej �Z G d
d � d ej
�ZG d d
� d
eej�ZdS )� N� )�compat)� protocols)�
transports)� coroutine)�loggerc s� e Zd Zd0� fdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z e
j rTdd� Z dd� Z
dd� Zdd� Zdd� Zdd� Zd d � Zd d � Zed d!� �Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zed*d+� �Zd,d-� Zd.d/� Z � Z S )1�BaseSubprocessTransportNc
s& t � j|
� d| _|| _|| _d | _d | _d | _g | _t j
� | _ i | _ d| _
|tjkr`d | j d< |tjkrtd | j d< |tjkr�d | j d< y"| jf ||||||d�| �� W n | j� � Y nX | jj| _| j| jd< | jj� �rt|ttf�r�|} n|d } tjd| | j� | jj| j| �� d S )NFr r � )�args�shell�stdin�stdout�stderr�bufsize�
subprocesszprocess %r created: pid %s) �super�__init__�_closed� _protocol�_loop�_proc�_pid� _returncode�
_exit_waiters� collections�deque�_pending_calls�_pipes� _finishedr �PIPE�_start�close�pidZ_extra� get_debug�
isinstance�bytes�strr �debugZ create_task�_connect_pipes)
�self�loop�protocolr
r r r
r r �waiterZextra�kwargsZprogram)� __class__� �//usr/lib64/python3.6/asyncio/base_subprocess.pyr s@
z BaseSubprocessTransport.__init__c C s | j jg}| jr|jd� | jd k r4|jd| j � | jd k rP|jd| j � n | jd k rf|jd� n
|jd� | jjd�}|d k r�|jd|j � | jjd�}| jjd �}|d k r�||kr�|jd
|j � n0|d k r�|jd |j � |d k r�|jd |j � d
dj |� S )N�closedzpid=%sz
returncode=%sZrunningz not startedr zstdin=%sr r zstdout=stderr=%sz stdout=%sz stderr=%sz<%s>� )
r. �__name__r �appendr r r �get�pipe�join)r) �infor r
r r/ r/ r0 �__repr__9 s,
z BaseSubprocessTransport.__repr__c K s t �d S )N)�NotImplementedError)r) r
r r r
r r r- r/ r/ r0 r V s z BaseSubprocessTransport._startc C s
|| _ d S )N)r )r) r+ r/ r/ r0 � set_protocolY s z$BaseSubprocessTransport.set_protocolc C s | j S )N)r )r) r/ r/ r0 � get_protocol\ s z$BaseSubprocessTransport.get_protocolc C s | j S )N)r )r) r/ r/ r0 �
is_closing_ s z"BaseSubprocessTransport.is_closingc C s� | j r
d S d| _ x&| jj� D ]}|d kr*q |jj� q W | jd k r�| jd kr�| jj� d kr�| jj � rpt
j d| � y| jj � W n t
k
r� Y nX d S )NTz$Close running child process: kill %r)r r �valuesr6 r! r r Zpollr r# r Zwarning�kill�ProcessLookupError)r) �protor/ r/ r0 r! b s
z BaseSubprocessTransport.closec C s& | j s"tjd| t| d� | j� d S )Nzunclosed transport %r)�source)r �warnings�warn�ResourceWarningr! )r) r/ r/ r0 �__del__� s z BaseSubprocessTransport.__del__c C s | j S )N)r )r) r/ r/ r0 �get_pid� s z BaseSubprocessTransport.get_pidc C s | j S )N)r )r) r/ r/ r0 �get_returncode� s z&BaseSubprocessTransport.get_returncodec C s || j kr| j | jS d S d S )N)r r6 )r) �fdr/ r/ r0 �get_pipe_transport� s
z*BaseSubprocessTransport.get_pipe_transportc C s | j d krt� �d S )N)r r@ )r) r/ r/ r0 � _check_proc� s
z#BaseSubprocessTransport._check_procc C s | j � | jj|� d S )N)rK r � send_signal)r) �signalr/ r/ r0 rL � s z#BaseSubprocessTransport.send_signalc C s | j � | jj� d S )N)rK r � terminate)r) r/ r/ r0 rN � s z!BaseSubprocessTransport.terminatec C s | j � | jj� d S )N)rK r r? )r) r/ r/ r0 r? � s z BaseSubprocessTransport.killc # sP y� j }� j}|jd k rB|j� fdd�|j�E d H \}}|� jd< |jd k rv|j� fdd�|j�E d H \}}|� jd< |jd k r�|j� fdd�|j�E d H \}}|� jd< |j� j j
� � x"� j D ]\}}|j|f|�� q�W d � _ W nD t k
�r* } z&|d k �r|j
� �r|j|� W Y d d }~X n"X |d k �rL|j
� �rL|jd � d S )Nc s
t � d�S )Nr )�WriteSubprocessPipeProtor/ )r) r/ r0 �<lambda>� s z8BaseSubprocessTransport._connect_pipes.<locals>.<lambda>r c s
t � d�S )Nr )�ReadSubprocessPipeProtor/ )r) r/ r0 rP � s r c s
t � d�S )Nr )rQ r/ )r) r/ r0 rP � s r )r r r Zconnect_write_piper r
Zconnect_read_piper � call_soonr �connection_mader � Exception� cancelledZ
set_exception�
set_result) r) r, �procr* �_r6 �callback�data�excr/ )r) r0 r( � s6
z&BaseSubprocessTransport._connect_pipesc G s2 | j d k r | j j||f� n| jj|f|�� d S )N)r r4 r rR )r) �cbrZ r/ r/ r0 �_call� s
z BaseSubprocessTransport._callc C s | j | jj||� | j� d S )N)r] r Zpipe_connection_lost� _try_finish)r) rI r[ r/ r/ r0 �_pipe_connection_lost� s z-BaseSubprocessTransport._pipe_connection_lostc C s | j | jj||� d S )N)r] r Zpipe_data_received)r) rI rZ r/ r/ r0 �_pipe_data_received� s z+BaseSubprocessTransport._pipe_data_receivedc C st | j j� rtjd| |� || _| jjd kr2|| j_| j| jj � | j
� x | j D ]}|j � sP|j
|� qPW d | _ d S )Nz %r exited with return code %r)r r# r r8 r r �
returncoder] r Zprocess_exitedr^ r rU rV )r) ra r, r/ r/ r0 �_process_exited� s
z'BaseSubprocessTransport._process_exitedc c s0 | j d k r| j S | jj� }| jj|� |E d H S )N)r r Z
create_futurer r4 )r) r, r/ r/ r0 �_wait� s
z BaseSubprocessTransport._waitc C s> | j d krd S tdd� | jj� D ��r:d| _| j| jd � d S )Nc s s | ]}|d k o|j V qd S )N)� disconnected)�.0�pr/ r/ r0 � <genexpr>� s z6BaseSubprocessTransport._try_finish.<locals>.<genexpr>T)r �allr r> r r] �_call_connection_lost)r) r/ r/ r0 r^ � s
z#BaseSubprocessTransport._try_finishc C s* z| j j|� W d d | _d | _d | _ X d S )N)r �connection_lostr r )r) r[ r/ r/ r0 ri � s
z-BaseSubprocessTransport._call_connection_lost)NN) r3 �
__module__� __qualname__r r9 r r; r< r= r! r ZPY34rF rG rH rJ rK rL rN r? r r( r] r_ r` rb rc r^ ri �
__classcell__r/ r/ )r. r0 r s0 ) % r c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
S )rO c C s || _ || _d | _d| _d S )NF)rW rI r6 rd )r) rW rI r/ r/ r0 r s z!WriteSubprocessPipeProto.__init__c C s
|| _ d S )N)r6 )r) Z transportr/ r/ r0 rS s z(WriteSubprocessPipeProto.connection_madec C s d| j j| j| jf S )Nz<%s fd=%s pipe=%r>)r. r3 rI r6 )r) r/ r/ r0 r9 s z!WriteSubprocessPipeProto.__repr__c C s d| _ | jj| j|� d | _d S )NT)rd rW r_ rI )r) r[ r/ r/ r0 rj s z(WriteSubprocessPipeProto.connection_lostc C s | j jj� d S )N)rW r �
pause_writing)r) r/ r/ r0 rn s z&WriteSubprocessPipeProto.pause_writingc C s | j jj� d S )N)rW r �resume_writing)r) r/ r/ r0 ro s z'WriteSubprocessPipeProto.resume_writingN) r3 rk rl r rS r9 rj rn ro r/ r/ r/ r0 rO s rO c @ s e Zd Zdd� ZdS )rQ c C s | j j| j|� d S )N)rW r` rI )r) rZ r/ r/ r0 �
data_received$ s z%ReadSubprocessPipeProto.data_receivedN)r3 rk rl rp r/ r/ r/ r0 rQ ! s rQ )r r rC � r r r Z
coroutinesr �logr ZSubprocessTransportr Z BaseProtocolrO ZProtocolrQ r/ r/ r/ r0 �<module> s { PK [�#�~� � ! __pycache__/queues.cpython-36.pycnu �[��� 3
\ � @ s� d Z dddddgZddlZddlZdd lmZ dd
lmZ dd lmZ dd lm Z G d
d� de
�Z G dd� de
�Z G dd� d�Z
G dd� de
�ZG dd� de
�Zejs�e
Zejd� dS )ZQueues�Queue�
PriorityQueue� LifoQueue� QueueFull�
QueueEmpty� N� )�compat)�events)�locks)� coroutinec @ s e Zd ZdZdS )r z]Exception raised when Queue.get_nowait() is called on a Queue object
which is empty.
N)�__name__�
__module__� __qualname__�__doc__� r r �&/usr/lib64/python3.6/asyncio/queues.pyr s c @ s e Zd ZdZdS )r zgException raised when the Queue.put_nowait() method is called on a Queue
object which is full.
N)r r
r r r r r r r s c @ s� e Zd ZdZd)dd�dd�Zdd� Zd d
� Zd d � Zd
d� Zdd� Z dd� Z
dd� Z dd� Z e
dd� �Zdd� Zdd � Zed d � �Zd d � Zed!d"� �Zd#d$� Zd%d&� Zed'd(� �ZdS )*r a A queue, useful for coordinating producer and consumer coroutines.
If maxsize is less than or equal to zero, the queue size is infinite. If it
is an integer greater than 0, then "yield from put()" will block when the
queue reaches maxsize, until an item is removed by get().
Unlike the standard library Queue, you can reliably know this Queue's size
with qsize(), since your single-threaded asyncio application won't be
interrupted between calling qsize() and doing an operation on the Queue.
r N)�loopc C sb |d krt j� | _n|| _|| _tj� | _tj� | _d| _t j
| jd�| _ | j j � | j
|� d S )Nr )r )r Zget_event_loop�_loop�_maxsize� collections�deque�_getters�_putters�_unfinished_tasksr
ZEvent� _finished�set�_init)�self�maxsizer r r r �__init__( s
zQueue.__init__c C s t j� | _d S )N)r r �_queue)r r r r r r : s z Queue._initc C s
| j j� S )N)r �popleft)r r r r �_get= s z
Queue._getc C s | j j|� d S )N)r �append)r �itemr r r �_put@ s z
Queue._putc C s* x$|r$|j � }|j� s|jd � P qW d S )N)r! �doneZ
set_result)r �waitersZwaiterr r r � _wakeup_nextE s
zQueue._wakeup_nextc C s dj t| �jt| �| j� �S )Nz<{} at {:#x} {}>)�format�typer �id�_format)r r r r �__repr__M s zQueue.__repr__c C s dj t| �j| j� �S )Nz<{} {}>)r) r* r r, )r r r r �__str__Q s z
Queue.__str__c C sz dj | j�}t| dd �r,|dj t| j��7 }| jrF|dj t| j��7 }| jr`|dj t| j��7 }| jrv|dj | j�7 }|S )Nz maxsize={!r}r z _queue={!r}z
_getters[{}]z
_putters[{}]z tasks={}) r) r �getattr�listr r �lenr r )r �resultr r r r, T s z
Queue._formatc C s
t | j�S )z Number of items in the queue.)r1 r )r r r r �qsize` s z Queue.qsizec C s | j S )z%Number of items allowed in the queue.)r )r r r r r d s z
Queue.maxsizec C s | j S )z3Return True if the queue is empty, False otherwise.)r )r r r r �emptyi s z Queue.emptyc C s | j dkrdS | j� | j kS dS )z�Return True if there are maxsize items in the queue.
Note: if the Queue was initialized with maxsize=0 (the default),
then full() is never True.
r FN)r r3 )r r r r �fullm s
z
Queue.fullc c st xh| j � rh| jj� }| jj|� y|E dH W q |j� | j � r^|j� r^| j| j� � Y qX qW | j|�S )z�Put an item into the queue.
Put an item into the queue. If the queue is full, wait until a free
slot is available before adding item.
This method is a coroutine.
N) r5 r �
create_futurer r# �cancel� cancelledr( �
put_nowait)r r$ Zputterr r r �putx s
z Queue.putc C s> | j � r t�| j|� | jd7 _| jj� | j| j� dS )zyPut an item into the queue without blocking.
If no free slot is immediately available, raise QueueFull.
r N)r5 r r% r r �clearr( r )r r$ r r r r9 � s
zQueue.put_nowaitc c s� x�| j � r�| jj� }| jj|� y|E dH W q |j� y| jj|� W n tk
rb Y nX | j � r�|j� r�| j | j� � Y qX qW | j
� S )z�Remove and return an item from the queue.
If queue is empty, wait until an item is available.
This method is a coroutine.
N) r4 r r6 r r# r7 �remove�
ValueErrorr8 r( �
get_nowait)r �getterr r r �get� s
z Queue.getc C s$ | j � r t�| j� }| j| j� |S )z�Remove and return an item from the queue.
Return an item if one is immediately available, else raise QueueEmpty.
)r4 r r" r( r )r r$ r r r r> � s
zQueue.get_nowaitc C s8 | j dkrtd��| j d8 _ | j dkr4| jj� dS )a$ Indicate that a formerly enqueued task is complete.
Used by queue consumers. For each get() used to fetch a task,
a subsequent call to task_done() tells the queue that the processing
on the task is complete.
If a join() is currently blocking, it will resume when all items have
been processed (meaning that a task_done() call was received for every
item that had been put() into the queue).
Raises ValueError if called more times than there were items placed in
the queue.
r z!task_done() called too many timesr N)r r= r r )r r r r � task_done� s
zQueue.task_donec c s | j dkr| jj� E dH dS )a Block until all items in the queue have been gotten and processed.
The count of unfinished tasks goes up whenever an item is added to the
queue. The count goes down whenever a consumer calls task_done() to
indicate that the item was retrieved and all work on it is complete.
When the count of unfinished tasks drops to zero, join() unblocks.
r N)r r �wait)r r r r �join� s
z
Queue.join)r )r r
r r r r r" r% r( r- r. r, r3 �propertyr r4 r5 r r: r9 r@ r> rA rC r r r r r s&
c @ s4 e Zd ZdZdd� Zejfdd�Zejfdd�Z dS ) r z�A subclass of Queue; retrieves entries in priority order (lowest first).
Entries are typically tuples of the form: (priority number, data).
c C s
g | _ d S )N)r )r r r r r r � s zPriorityQueue._initc C s || j |� d S )N)r )r r$ �heappushr r r r% � s zPriorityQueue._putc C s
|| j �S )N)r )r �heappopr r r r" � s zPriorityQueue._getN)
r r
r r r �heapqrE r% rF r" r r r r r � s c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) r zEA subclass of Queue that retrieves most recently added entries first.c C s
g | _ d S )N)r )r r r r r r � s zLifoQueue._initc C s | j j|� d S )N)r r# )r r$ r r r r% � s zLifoQueue._putc C s
| j j� S )N)r �pop)r r r r r" � s zLifoQueue._getN)r r
r r r r% r" r r r r r � s �
JoinableQueue)r �__all__r rG � r r r
Z
coroutinesr � Exceptionr r r r r ZPY35rI r# r r r r �<module> s H
PK [1<���J �J __pycache__/tasks.cpython-36.pycnu �[��� 3
\�a �
@ s� d Z ddddddddd d
d d d
g
ZddlZddlZddlZddlZddlZddlm Z ddlm
Z
ddlm Z ddlm Z ddlm
Z
ddl mZ G dd� de
j�ZeZy ddlZW n ek
r� Y n X ej ZZej
jZej
jZej
jZedded�dd��Zdd� Zedd �d d��Zed d � �Zddd �d!d�Z ed/dd �d"d��Z dd �d#d$�Z e e � d < d e _ [ dd �d%d �Z!ed&d'� �Z"G d(d)� d)e
j�Z#dd*d+�d,d
�Z$dd �d-d �Z%d.d
� Z&dS )0z0Support for tasks, coroutines and the scheduler.�Task�FIRST_COMPLETED�FIRST_EXCEPTION�
ALL_COMPLETED�wait�wait_for� as_completed�sleep�async�gather�shield�
ensure_future�run_coroutine_threadsafe� N� )�
base_tasks)�compat)�
coroutines)�events)�futures)� coroutinec s� e Zd ZdZej� Zi ZdZe ddd��Z
e d dd��Z dd�� fd d
�
Z e
jrXd d � Zd
d� Zdd�dd�Zddd�dd�Zdd� Zd � fdd� Zdd� Z� ZS ) r z A coroutine wrapped in a Future.TNc C s |dkrt j� }| jj|�S )z�Return 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.
N)r �get_event_loop�_current_tasks�get)�cls�loop� r �%/usr/lib64/python3.6/asyncio/tasks.py� current_task. s zTask.current_taskc s$ � dkrt j� � � fdd�| jD �S )z|Return a set of all tasks for an event loop.
By default all tasks for the current event loop are returned.
Nc s h | ]}|j � kr|�qS r )�_loop)�.0�t)r r r � <setcomp>B s z!Task.all_tasks.<locals>.<setcomp>)r r �
_all_tasks)r r r )r r � all_tasks: s zTask.all_tasks)r c sd t j|�stt|���t� j|d� | jr2| jd= || _d | _d| _ | j
j | j � | j
jj| � d S )N)r r F���)r � iscoroutine�AssertionError�repr�super�__init__�_source_traceback�_coro� _fut_waiter� _must_cancelr � call_soon�_step� __class__r" �add)�self�coror )r0 r r r) D s z
Task.__init__c C sH | j tjkr8| jr8| dd�}| jr,| j|d< | jj|� tjj| � d S )Nz%Task was destroyed but it is pending!)�task�messageZsource_traceback) Z_stater Z_PENDING�_log_destroy_pendingr* r Zcall_exception_handler�Future�__del__)r2 �contextr r r r8 S s
z Task.__del__c C s
t j| �S )N)r Z_task_repr_info)r2 r r r �
_repr_info^ s zTask._repr_info)�limitc C s t j| |�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)r2 r; r r r � get_stacka s zTask.get_stack)r; �filec C s t j| ||�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)r2 r; r= r r r � print_stackx s zTask.print_stackc C s4 d| _ | j� rdS | jdk r*| jj� 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_traceback�doner, �cancelr- )r2 r r r r@ � s
z Task.cancelc s� | j � stdj| |���| jr:t|tj�s4tj� }d| _| j}d | _| | j j
| j < �zy"|d krn|j d �}n
|j
|�}W n� tk
r� } z.| jr�d| _| jtj� � n | j|j� W Y d d }~X �n� tjk
r� t� j� Y �n~ tk
�r } z| j|� W Y d d }~X �nP tk
�rD } z| j|� � W Y d d }~X �n X t|dd �}|d k �r|j | j k �r�| j j| jtdj| |��� n||�r�|| k�r�| j j| jtdj| ��� n2d|_|j| j � || _| j�r| jj� �rd| _n | j j| jtdj| |��� n^|d k�r | j j| j� nDt j |��rJ| j j| jtdj| |��� n| j j| jtdj|��� W d | j j
j | j � d } X d S ) Nz!_step(): already done: {!r}, {!r}F�_asyncio_future_blockingz6Task {!r} got Future {!r} attached to a different loopz!Task cannot await on itself: {!r}z;yield was used instead of yield from in task {!r} with {!r}zIyield was used instead of yield from for generator in task {!r} with {!r}zTask got bad yield: {!r}) r? r& �formatr- �
isinstancer �CancelledErrorr+ r, r0 r r �send�throw�
StopIteration�
set_exception�
set_result�valuer( r@ � Exception�
BaseException�getattrr. r/ � RuntimeErrorrA �add_done_callback�_wakeup�inspectZ isgenerator�pop)r2 �excr3 �resultZblocking)r0 r r r/ � s�
z
Task._stepc C sJ y |j � W n, tk
r8 } z| j|� W Y d d }~X n
X | j� d } d S )N)rT rK r/ )r2 �futurerS r r r rP � s z Task._wakeup)N)N)N)�__name__�
__module__� __qualname__�__doc__�weakref�WeakSetr" r r6 � classmethodr r# r) r ZPY34r8 r: r< r> r@ r/ rP �
__classcell__r r )r0 r r s" !T)r �timeout� return_whenc # s� t j| �stj| �r&tdt| �j ��| s2td��|tt t
fkrNtdj |���� dkr^t j
� � � fdd�t| �D �} t| ||� �E dH S )a� Wait for the Futures and coroutines given by fs to complete.
The sequence futures must not be empty.
Coroutines will be wrapped in Tasks.
Returns two sets of Future: (done, pending).
Usage:
done, pending = yield from 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 %sz#Set of coroutines/Futures is empty.z Invalid return_when value: {}Nc s h | ]}t |� d ��qS ))r )r )r �f)r r r r! 7 s zwait.<locals>.<setcomp>)r �isfuturer r% � TypeError�typerV �
ValueErrorr r r rB r r �set�_wait)�fsr r^ r_ r )r r r s c G s | j � s| jd � d S )N)r? rI )�waiter�argsr r r �_release_waiter< s rj )r c c s� |dkrt j� }|dkr"| E dH S |j� }|j|t|�}tjt|�}t| |d�} | j|� zhy|E dH W n* t j
k
r� | j |� | j � � Y nX | j
� r�| j� S | j |� | j � t j� �W d|j � 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.
N)r )r r �
create_future�
call_laterrj � functools�partialr rO r rD �remove_done_callbackr@ r? rT � TimeoutError)�futr^ r rh �timeout_handle�cbr r r r A s,
c # s� | s t d��|j� �d�|dk r.|j|t���t| �� � ���fdd�}x| D ]}|j|� qNW z�E dH W d�dk r��j� X t� t� }}x4| D ],}|j|� |j � r�|j
|� q�|j
|� q�W ||fS )zeInternal helper for wait() and wait_for().
The fs argument must be a collection of Futures.
zSet of Futures is empty.Nc s\ � d8 � � dks6�t ks6�tkrX| j� rX| j� d k rX�d k rF�j� �j� sX�jd � d S )Nr r )r r � cancelled� exceptionr@ r? rI )r` )�counterr_ rr rh r r �_on_completion| s z _wait.<locals>._on_completion) r& rk rl rj �lenrO r@ re ro r? r1 )rg r^ r_ r rw r` r? �pendingr )rv r_ rr rh r rf o s(
rf )r r^ c # s� t j| �stj| �r&tdt| �j ���dk r2�ntj� ��fdd�t | �D ��ddl
m } |�d��d�� ��fdd �}���fd
d �� t �fd d
��}x�D ]}|j
� � q�W �r�|dk rʈj||��x tt���D ] }|� V q�W dS )am Return an iterator whose values are coroutines.
When waiting for the yielded coroutines you'll get the results (or
exceptions!) of the original Futures (or coroutines), in the order
in which and as soon as they complete.
This differs from PEP 3148; the proper way to use this is:
for f in as_completed(fs):
result = yield from f # The 'yield from' may raise.
# Use result.
If a timeout is specified, the 'yield from' will raise
TimeoutError when the timeout occurs before all Futures are done.
Note: The futures 'f' are not necessarily members of fs.
z expect a list of futures, not %sNc s h | ]}t |� d ��qS ))r )r )r r` )r r r r! � s z as_completed.<locals>.<setcomp>r )�Queue)r c s. x �D ]} | j � � �jd � qW �j� d S )N)ro �
put_nowait�clear)r` )rw r? �todor r � _on_timeout� s
z!as_completed.<locals>._on_timeoutc s6 �sd S �j | � � j| � � r2�d k r2�j� d S )N)�remover{ r@ )r` )r? rr r} r r rw � s
z$as_completed.<locals>._on_completionc 3 s$ � j � E d H } | d kr tj�| j� S )N)r r rp rT )r` )r? r r �
_wait_for_one� s z#as_completed.<locals>._wait_for_one)r ra r r% rb rc rV r r re Zqueuesrz r rO rl �rangerx )rg r r^ rz r~ r� r` �_r )rw r? r rr r} r r � s
c
c sX | dkrdV |S |dkr"t j� }|j� }|jj| tj||�}z
|E dH S |j� X dS )z9Coroutine that completes after a given time (in seconds).r N)r r rk r rl r Z _set_result_unless_cancelledr@ )ZdelayrT r rU �hr r r r � s
c C s t jdtdd� t| |d�S )z�Wrap a coroutine in a future.
If the argument is a Future, it is returned directly.
This function is deprecated in 3.5. Use asyncio.ensure_future() instead.
z;asyncio.async() function is deprecated, use ensure_future()� )�
stacklevel)r )�warnings�warn�DeprecationWarningr )�coro_or_futurer r r r �async_� s r� c C s� t j| �r(|dk r$|| jk r$td��| S tj| �r^|dkrBtj� }|j| �}|j rZ|j d= |S t
j r~t j
| �r~tt| �|d�S td��dS )zmWrap a coroutine or an awaitable in a future.
If the argument is a Future, it is returned directly.
Nz$loop argument must agree with Futurer )r z:An asyncio.Future, a coroutine or an awaitable is requiredr$ )r ra r rd r r% r r Z create_taskr* r ZPY35rQ Z isawaitabler �_wrap_awaitablerb )r� r r4 r r r r � s
c c s | j � E dH S )z�Helper 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 )�_GatheringFuturez�Helper for gather().
This overrides cancel() to cancel all the children and act more
like Task.cancel(), which doesn't immediately mark itself as
cancelled.
N)r c s t � j|d� || _d| _d S )N)r F)r( r) � _children�_cancel_requested)r2 �childrenr )r0 r r r) $ s z_GatheringFuture.__init__c C s: | j � r dS d}x| jD ]}|j� rd}qW |r6d| _|S )NFT)r? r� r@ r� )r2 ZretZchildr r r r@ ) s z_GatheringFuture.cancel)rV rW rX rY r) r@ r] r r )r0 r r� s r� F)r �return_exceptionsc s |s*| dkrt j� } | j� ��jg � �S i � xjt|�D ]^}tj|�sht|| d�}| dkr`|j} d|_ n&|}| dkr||j} n|j| k r�t
d��|� |< q8W � fdd�|D �}t |��t || d��d�dg� ������fdd �}x&t
|�D ]\}}|jtj||�� q�W �S )
a7 Return a future aggregating results from the given coroutines
or 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.)
N)r Fz)futures are tied to different event loopsc s g | ] }� | �qS r r )r �arg)�
arg_to_futr r �
<listcomp>h s zgather.<locals>.<listcomp>r c s� �j � r |j� s|j� d S |j� r@tj� }�sl�j|� d S n,|jd k rf|j� }�sl�j|� d S n|j}|�| < �d7 ��� kr��jr��jtj� � n
�j �� d S )Nr )
r? rt ru r rD rH Z
_exceptionZ_resultr� rI )�irq �res)� nchildren� nfinished�outer�resultsr� r r �_done_callbackn s*
z gather.<locals>._done_callback)r r rk rI re r ra r r r6 rd rx r� � enumeraterO rm rn )r r� Zcoros_or_futuresr� rq r� r� r� r )r� r� r� r� r� r� r r
8 s8
c s@ t | |d�}|j� r|S |j}|j� � � fdd�}|j|� � S )a= Wait for a future, shielding it from cancellation.
The statement
res = yield from shield(something())
is exactly equivalent to the statement
res = yield from 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 = yield from shield(something())
except CancelledError:
res = None
)r c s\ � j � r | j � s| j� d S | j � r.� j� n*| j� }|d k rJ� j|� n� j| j� � d S )N)rt ru r@ rH rI rT )�innerrS )r� r r r� � s
z shield.<locals>._done_callback)r r? r rk rO )r� r r� r� r )r� r r � s
c s: t j� �std��tjj� �� ��fdd�}�j|� �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 sT yt jt� �d��� W n6 tk
rN } z�j� r<�j| � � W Y d d } ~ X nX d S )N)r )r Z
_chain_futurer rK Z set_running_or_notify_cancelrH )rS )r3 rU r r r �callback� s
z*run_coroutine_threadsafe.<locals>.callback)r r% rb �
concurrentr r7 Zcall_soon_threadsafe)r3 r r� r )r3 rU r r r
� s
)N)'rY �__all__Zconcurrent.futuresr� rm rQ r� rZ � r r r r r r r7 r Z_PyTaskZ_asyncio� ImportErrorZ_CTaskr r r r rj r rf r r r� �globalsrV r r� r� r
r r
r r r r �<module> sZ
s
- -8
W5PK [ϤУ ' __pycache__/base_futures.cpython-36.pycnu �[��� 3
\ � @ sr g Z d dlZd dlZddlmZ ejjjZejj Z ejj
Z
G dd� de�Z dZ dZ
dZd d
� Zd d � Zd
d� ZdS )� N� )�eventsc @ s e Zd ZdZdS )�InvalidStateErrorz+The operation is not allowed in this state.N)�__name__�
__module__� __qualname__�__doc__� r r �,/usr/lib64/python3.6/asyncio/base_futures.pyr
s r ZPENDINGZ CANCELLEDZFINISHEDc C s t | jd�o| jdk S )z�Check for a Future.
This returns True when obj is a Future instance or is advertising
itself as duck-type compatible by setting _asyncio_future_blocking.
See comment in Future for more details.
�_asyncio_future_blockingN)�hasattr� __class__r )�objr r r
�isfuture s r c C s� t | �}|sd} dd� }|dkr.|| d �} nP|dkrTdj|| d �|| d ��} n*|dkr~dj|| d �|d || d
��} d | S ) z#helper function for Future.__repr__� c S s t j| f �S )N)r Z_format_callback_source)�callbackr r r
� format_cb( s z$_format_callbacks.<locals>.format_cbr r � z{}, {}z{}, <{} more>, {}zcb=[%s]���)�len�format)�cb�sizer r r r
�_format_callbacks" s r c C s� | j j� g}| j tkrP| jdk r4|jdj| j�� n tj| j�}|jdj|�� | j rf|jt
| j �� | j r�| j d }|jd|d |d f � |S )z#helper function for Future.__repr__Nzexception={!r}z result={}r zcreated at %s:%sr r ) Z_state�lower� _FINISHEDZ
_exception�appendr �reprlib�reprZ_resultZ
_callbacksr Z_source_traceback)Zfuture�info�result�framer r r
�_future_repr_info6 s
r" )�__all__Zconcurrent.futures._baseZ
concurrentr r r ZfuturesZ_base�ErrorZCancelledError� TimeoutErrorr Z_PENDINGZ
_CANCELLEDr r r r" r r r r
�<module> s
PK [�pä�b �b ! __pycache__/events.cpython-36.pycnu �[��� 3
\�[ � @ s� d Z ddddddddd d
d d d
dgZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl m Z ddl m
Z
dd� Zdd� Zd3dd�Zdd � Zd4d d �ZG d d� d�ZG d d� de�ZG d!d� d�ZG d"d� d�ZG d#d� d�ZG d$d%� d%e�Zdae j� ZG d&d'� d'e j �Z e � Z d(d� Z d)d
� Z d*d+� Z!d,d� Z"d-d� Z#d.d� Z$d/d � Z%d0d
� Z&d1d � Z'd2d � Z(dS )5z!Event loop and event loop policy.�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� N� )�compat)� constantsc C st t jrtj| �} nt| d�r"| j} tj| �r>| j}|j|j fS t
| t j �rTt
| j�S t jrpt
| t j�rpt
| j�S d S )N� __wrapped__)r ZPY34�inspectZunwrap�hasattrr Z
isfunction�__code__� co_filename�co_firstlineno�
isinstance� functools�partial�_get_function_source�func�
partialmethod)r �code� r �&/usr/lib64/python3.6/asyncio/events.pyr s
r c C sJ g }| r |j dd� | D �� |r8|j dd� |j� D �� ddj|� d S )z�Format function arguments and keyword arguments.
Special case for a single parameter: ('hello',) is formatted as ('hello').
c s s | ]}t j|�V qd S )N)�reprlib�repr)�.0�argr r r! � <genexpr>1 s z*_format_args_and_kwargs.<locals>.<genexpr>c s s$ | ] \}}d j |tj|��V qdS )z{}={}N)�formatr" r# )r$ �k�vr r r! r& 3 s �(z, �))�extend�items�join)�args�kwargsr- r r r! �_format_args_and_kwargs) s
r1 � c C s� t | tj�r.t||�| }t| j| j| j|�S t| d�rF| j rF| j }n t| d�r^| j
r^| j
}nt | �}|t||�7 }|r�||7 }|S )N� __qualname__�__name__) r r r r1 �_format_callbackr r/ �keywordsr r3 r4 r# )r r/ r0 �suffix� func_reprr r r! r5 8 s r5 c C s( t | |d �}t| �}|r$|d| 7 }|S )Nz at %s:%s)r5 r )r r/ r8 �sourcer r r! �_format_callback_sourceI s
r: c C sD | dkrt j� j} |dkr tj}tjjtj| �|dd�}|j � |S )zlReplacement for traceback.extract_stack() that only does the
necessary work for asyncio debug mode.
NF)�limit� lookup_lines)
�sys� _getframe�f_backr ZDEBUG_STACK_DEPTH� traceback� StackSummary�extract�
walk_stack�reverse)�fr; �stackr r r! �
extract_stackQ s
rG c @ s< e Zd ZdZdZd d
� Zd d � Zd
d� Zdd� Zdd� Z dS )r z1Object returned by callback registration methods.� _callback�_args�
_cancelled�_loop�_source_traceback�_repr� __weakref__c C sD || _ || _|| _d| _d | _| j j� r:ttjd��| _ nd | _ d S )NFr )
rK rH rI rJ rM � get_debugrG r= r> rL )�self�callbackr/ �loopr r r! �__init__h s
zHandle.__init__c C sf | j jg}| jr|jd� | jd k r8|jt| j| j�� | jrb| jd }|jd|d |d f � |S )NZ cancelledr zcreated at %s:%sr ���)� __class__r4 rJ �appendrH r: rI rL )rP �info�framer r r! �
_repr_infos s
zHandle._repr_infoc C s& | j d k r| j S | j� }ddj|� S )Nz<%s>� )rM rY r. )rP rW r r r! �__repr__~ s
zHandle.__repr__c C s0 | j s,d| _ | jj� r t| �| _d | _d | _d S )NT)rJ rK rO r# rM rH rI )rP r r r! �cancel� s
z
Handle.cancelc C s| y| j | j� W nb tk
rr } zFt| j | j�}dj|�}||| d�}| jrV| j|d< | jj|� W Y d d }~X nX d } d S )NzException in callback {})�messageZ exception�handleZsource_traceback)rH rI � Exceptionr: r' rL rK �call_exception_handler)rP �exc�cb�msg�contextr r r! �_run� s
z Handle._runN)rH rI rJ rK rL rM rN )
r4 �
__module__r3 �__doc__� __slots__rS rY r[ r\ re r r r r! r b s c sx e Zd ZdZddgZ� fdd�Z� fdd�Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
� fdd�Z� ZS )r z7Object returned by timed callback registration methods.�
_scheduled�_whenc s: |d k s t �t� j|||� | jr*| jd= || _d| _d S )Nr FrT )�AssertionError�superrS rL rj ri )rP �whenrQ r/ rR )rU r r! rS � s zTimerHandle.__init__c s. t � j� }| jrdnd}|j|d| j � |S )N� r zwhen=%s)rl rY rJ �insertrj )rP rW �pos)rU r r! rY � s
zTimerHandle._repr_infoc C s
t | j�S )N)�hashrj )rP r r r! �__hash__� s zTimerHandle.__hash__c C s | j |j k S )N)rj )rP �otherr r r! �__lt__� s zTimerHandle.__lt__c C s | j |j k rdS | j|�S )NT)rj �__eq__)rP rs r r r! �__le__� s zTimerHandle.__le__c C s | j |j kS )N)rj )rP rs r r r! �__gt__� s zTimerHandle.__gt__c C s | j |j krdS | j|�S )NT)rj ru )rP rs r r r! �__ge__� s zTimerHandle.__ge__c C s> t |t�r:| j|jko8| j|jko8| j|jko8| j|jkS tS )N)r r rj rH rI rJ �NotImplemented)rP rs r r r! ru � s
zTimerHandle.__eq__c C s | j |�}|tkrtS | S )N)ru ry )rP rs Zequalr r r! �__ne__� s
zTimerHandle.__ne__c s | j s| jj| � t� j� d S )N)rJ rK �_timer_handle_cancelledrl r\ )rP )rU r r! r\ � s zTimerHandle.cancel)r4 rf r3 rg rh rS rY rr rt rv rw rx ru rz r\ �
__classcell__r r )rU r! r � s c @ s e Zd ZdZdd� Zdd� ZdS )r z,Abstract server returned by create_server().c C s t S )z5Stop serving. This leaves existing connections open.)ry )rP r r r! �close� s zAbstractServer.closec C s t S )z*Coroutine to wait until service is closed.)ry )rP r r r! � wait_closed� s zAbstractServer.wait_closedN)r4 rf r3 rg r} r~ r r r r! r � s c @ s e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d$d$d$d%�d&d'�Zdhd(d)�Zdid*d$d$d$d*d*d*d+�d,d-�Zdjejejd*d.d*d*d*d/�d0d1�Zd*d*d*d2�d3d4�Z d*d.d*d5�d6d7�Z dkd$d$d$d*d*d*d*d8�d9d:�Z d;d<� Z d=d>� Z e!j"e!j"e!j"d?�d@dA�Z#e!j"e!j"e!j"d?�dBdC�Z$dDdE� Z%dFdG� Z&dHdI� Z'dJdK� Z(dLdM� Z)dNdO� Z*dPdQ� Z+dRdS� Z,dTdU� Z-dVdW� Z.dXdY� Z/dZd[� Z0d\d]� Z1d^d_� Z2d`da� Z3dbdc� Z4ddde� Z5dfdg� Z6d*S )lr zAbstract event loop.c C s t �dS )z*Run the event loop until stop() is called.N)�NotImplementedError)rP 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.
N)r )rP Zfuturer r r! �run_until_complete� s z$AbstractEventLoop.run_until_completec C s t �dS )z�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.
N)r )rP r r r! �stop� s zAbstractEventLoop.stopc C s t �dS )z3Return whether the event loop is currently running.N)r )rP r r r! �
is_running� s z AbstractEventLoop.is_runningc C s t �dS )z*Returns True if the event loop was closed.N)r )rP r r r! � is_closed s zAbstractEventLoop.is_closedc C s t �dS )z�Close the loop.
The loop should not be running.
This is idempotent and irreversible.
No other methods should be called after this one.
N)r )rP r r r! r} s zAbstractEventLoop.closec C s t �dS )z,Shutdown all active asynchronous generators.N)r )rP r r r! �shutdown_asyncgens s z$AbstractEventLoop.shutdown_asyncgensc C s t �dS )z3Notification that a TimerHandle has been cancelled.N)r )rP r^ r r r! r{ s z)AbstractEventLoop._timer_handle_cancelledc G s | j d|f|�� S )Nr )�
call_later)rP rQ r/ r r r! � call_soon s zAbstractEventLoop.call_soonc G s t �d S )N)r )rP ZdelayrQ r/ r r r! r� s z AbstractEventLoop.call_laterc G s t �d S )N)r )rP rm rQ r/ r r r! �call_at s zAbstractEventLoop.call_atc C s t �d S )N)r )rP r r r! �time" s zAbstractEventLoop.timec C s t �d S )N)r )rP r r r! �
create_future% s z AbstractEventLoop.create_futurec C s t �d S )N)r )rP �coror r r! � create_task* s z AbstractEventLoop.create_taskc G s t �d S )N)r )rP rQ r/ r r r! �call_soon_threadsafe/ s z&AbstractEventLoop.call_soon_threadsafec G s t �d S )N)r )rP �executorr r/ r r r! �run_in_executor2 s z!AbstractEventLoop.run_in_executorc C s t �d S )N)r )rP r� r r r! �set_default_executor5 s z&AbstractEventLoop.set_default_executorr )�family�type�proto�flagsc C s t �d S )N)r )rP �host�portr� r� r� r� r r r! � getaddrinfo: s z AbstractEventLoop.getaddrinfoc C s t �d S )N)r )rP Zsockaddrr� r r r! � getnameinfo= s z AbstractEventLoop.getnameinfoN)�sslr� r� r� �sock�
local_addr�server_hostnamec C s t �d S )N)r ) rP �protocol_factoryr� r� r� r� r� r� r� r� r� r r r! �create_connection@ s z#AbstractEventLoop.create_connection�d )r� r� r� �backlogr� �
reuse_address�
reuse_portc C s t �dS )a� 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.
N)r ) rP r� r� r� r� r� r� r� r� r� r� r r r! �
create_serverE s 'z AbstractEventLoop.create_server)r� r� r� c C s t �d S )N)r )rP r� �pathr� r� r� r r r! �create_unix_connectionn s z(AbstractEventLoop.create_unix_connection)r� r� r� c 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.
N)r )rP r� r� r� r� r� r r r! �create_unix_servers s z$AbstractEventLoop.create_unix_server)r� r� r� r� r� �allow_broadcastr� c 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 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.
N)r ) rP r� r� Z remote_addrr� r� r� r� r� r� r� r r r! �create_datagram_endpoint� s !z*AbstractEventLoop.create_datagram_endpointc C 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.N)r )rP r� �piper r r! �connect_read_pipe� s z#AbstractEventLoop.connect_read_pipec C 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.N)r )rP r� r� r r r! �connect_write_pipe� s z$AbstractEventLoop.connect_write_pipe)�stdin�stdout�stderrc K s t �d S )N)r )rP r� �cmdr� r� r� r0 r r r! �subprocess_shell� s z"AbstractEventLoop.subprocess_shellc O s t �d S )N)r )rP r� r� r� r� r/ r0 r r r! �subprocess_exec� s z!AbstractEventLoop.subprocess_execc G s t �d S )N)r )rP �fdrQ r/ r r r! �
add_reader� s z AbstractEventLoop.add_readerc C s t �d S )N)r )rP r� r r r! �
remove_reader� s z AbstractEventLoop.remove_readerc G s t �d S )N)r )rP r� rQ r/ r r r! �
add_writer� s z AbstractEventLoop.add_writerc C s t �d S )N)r )rP r� r r r! �
remove_writer� s z AbstractEventLoop.remove_writerc C s t �d S )N)r )rP r� �nbytesr r r! � sock_recv� s zAbstractEventLoop.sock_recvc C s t �d S )N)r )rP r� �datar r r! � sock_sendall� s z AbstractEventLoop.sock_sendallc C s t �d S )N)r )rP r� Zaddressr r r! � sock_connect� s z AbstractEventLoop.sock_connectc C s t �d S )N)r )rP r� r r r! � sock_accept� s z AbstractEventLoop.sock_acceptc G s t �d S )N)r )rP �sigrQ r/ r r r! �add_signal_handler� s z$AbstractEventLoop.add_signal_handlerc C s t �d S )N)r )rP r� r r r! �remove_signal_handler� s z'AbstractEventLoop.remove_signal_handlerc C s t �d S )N)r )rP �factoryr r r! �set_task_factory� s z"AbstractEventLoop.set_task_factoryc C s t �d S )N)r )rP r r r! �get_task_factory� s z"AbstractEventLoop.get_task_factoryc C s t �d S )N)r )rP r r r! �get_exception_handler s z'AbstractEventLoop.get_exception_handlerc C s t �d S )N)r )rP Zhandlerr r r! �set_exception_handler s z'AbstractEventLoop.set_exception_handlerc C s t �d S )N)r )rP rd r r r! �default_exception_handler s z+AbstractEventLoop.default_exception_handlerc C s t �d S )N)r )rP rd r r r! r` s z(AbstractEventLoop.call_exception_handlerc C s t �d S )N)r )rP r r r! rO s zAbstractEventLoop.get_debugc C s t �d S )N)r )rP Zenabledr r r! � set_debug s zAbstractEventLoop.set_debug)r )NN)NN)NN)7r4 rf r3 rg r� r� r� r� r� r} r� r{ r� r� r� r� r� r� r� r� r� r� r� r� �socketZ AF_UNSPECZ
AI_PASSIVEr� r� r� r� r� r� �
subprocess�PIPEr� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r` rO r� r r r r! r � st
'!
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.N)r )rP r r r! r s z&AbstractEventLoopPolicy.get_event_loopc C s t �dS )z3Set the event loop for the current context to loop.N)r )rP rR r r r! r $ s z&AbstractEventLoopPolicy.set_event_loopc C s t �dS )z�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.N)r )rP r r r! r
( s z&AbstractEventLoopPolicy.new_event_loopc C s t �dS )z$Get the watcher for child processes.N)r )rP r r r! r 0 s z)AbstractEventLoopPolicy.get_child_watcherc C s t �dS )z$Set the watcher for child processes.N)r )rP �watcherr r r! r 4 s z)AbstractEventLoopPolicy.set_child_watcherN) r4 rf r3 rg r r r
r r r r r r! r s
c @ sF e Zd ZdZdZG dd� dej�Zdd� 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)r4 rf r3 rK � _set_calledr r r r! �_LocalH s r� c C s | j � | _d S )N)r� �_local)rP r r r! rS L s z#BaseDefaultEventLoopPolicy.__init__c C sZ | j jdkr4| j j r4ttj� tj�r4| j| j� � | j jdkrRt dtj� j
��| j jS )zSGet the event loop.
This may be None or an instance of EventLoop.
Nz,There is no current event loop in thread %r.) r� rK r� r � threadingZcurrent_threadZ _MainThreadr r
� RuntimeError�name)rP r r r! r O s
z)BaseDefaultEventLoopPolicy.get_event_loopc C s* d| j _|dks t|t�s t�|| j _dS )zSet the event loop.TN)r� r� r r rk rK )rP rR r r r! r ] s z)BaseDefaultEventLoopPolicy.set_event_loopc C s | j � S )zvCreate a new event loop.
You must call set_event_loop() to make this the current event
loop.
)�
_loop_factory)rP r r r! r
c s z)BaseDefaultEventLoopPolicy.new_event_loop) r4 rf r3 rg r� r� �localr� rS r r r
r r r r! r� 9 s r� c @ s e Zd ZdZdS )� _RunningLoopN)NN)r4 rf r3 �loop_pidr r r r! r� w s r� c C s& t j\} }| dk r"|tj� kr"| S dS )z�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.
N)�
_running_loopr� �os�getpid)Z running_loop�pidr r r! r ~ s
c C s | t j� ft_dS )z�Set 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� )rR r r r! r
� s c C s. t � td kr ddlm} | � aW d Q R X d S )Nr )�DefaultEventLoopPolicy)�_lock�_event_loop_policyr2 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 c C s | dkst | t�st�| adS )zZSet the current event loop policy.
If policy is None, the default policy is restored.N)r r rk r� )Zpolicyr r r! r � s c C s t � } | dk r| S t� j� 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 c C s t � j| � dS )zCEquivalent to calling get_event_loop_policy().set_event_loop(loop).N)r r )rR r r r! r � s c C s
t � j� S )z?Equivalent to calling get_event_loop_policy().new_event_loop().)r r
r r r r! r
� s c C s
t � j� S )zBEquivalent to calling get_event_loop_policy().get_child_watcher().)r r r r r r! r � s c C s t � j| �S )zMEquivalent to calling
get_event_loop_policy().set_child_watcher(watcher).)r r )r� r r r! r � s )r2 )NN))rg �__all__r r r� r" r� r� r= r� r@ r2 r r r r1 r5 r: rG r r r r r r� r� ZLockr� r� r� r� r r
r� r r r r r
r r r r r r! �<module> sZ
>8 5"7 PK [�ny�0$ 0$ * __pycache__/base_subprocess.cpython-36.pycnu �[��� 3
\�# � @ s� d dl Z d dlZd dlZddlmZ ddlmZ ddlmZ ddlmZ ddl m
Z
G dd � d ej �Z G d
d � d ej
�ZG d d
� d
eej�ZdS )� N� )�compat)� protocols)�
transports)� coroutine)�loggerc s� e Zd Zd0� fdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z e
j rTdd� Z dd� Z
dd� Zdd� Zdd� Zdd� Zd d � Zd d � Zed d!� �Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zed*d+� �Zd,d-� Zd.d/� Z � Z S )1�BaseSubprocessTransportNc
s& t � j|
� d| _|| _|| _d | _d | _d | _g | _t j
� | _ i | _ d| _
|tjkr`d | j d< |tjkrtd | j d< |tjkr�d | j d< y"| jf ||||||d�| �� W n | j� � Y nX | jj| _| j| jd< | jj� �rt|ttf�r�|} n|d } tjd| | j� | jj| j| �� d S )NFr r � )�args�shell�stdin�stdout�stderr�bufsize�
subprocesszprocess %r created: pid %s) �super�__init__�_closed� _protocol�_loop�_proc�_pid� _returncode�
_exit_waiters� collections�deque�_pending_calls�_pipes� _finishedr �PIPE�_start�close�pidZ_extra� get_debug�
isinstance�bytes�strr �debugZ create_task�_connect_pipes)
�self�loop�protocolr
r r r
r r �waiterZextra�kwargsZprogram)� __class__� �//usr/lib64/python3.6/asyncio/base_subprocess.pyr s@
z BaseSubprocessTransport.__init__c C s | j jg}| jr|jd� | jd k r4|jd| j � | jd k rP|jd| j � n | jd k rf|jd� n
|jd� | jjd�}|d k r�|jd|j � | jjd�}| jjd �}|d k r�||kr�|jd
|j � n0|d k r�|jd |j � |d k r�|jd |j � d
dj |� S )N�closedzpid=%sz
returncode=%sZrunningz not startedr zstdin=%sr r zstdout=stderr=%sz stdout=%sz stderr=%sz<%s>� )
r. �__name__r �appendr r r �get�pipe�join)r) �infor r
r r/ r/ r0 �__repr__9 s,
z BaseSubprocessTransport.__repr__c K s t �d S )N)�NotImplementedError)r) r
r r r
r r r- r/ r/ r0 r V s z BaseSubprocessTransport._startc C s
|| _ d S )N)r )r) r+ r/ r/ r0 � set_protocolY s z$BaseSubprocessTransport.set_protocolc C s | j S )N)r )r) r/ r/ r0 � get_protocol\ s z$BaseSubprocessTransport.get_protocolc C s | j S )N)r )r) r/ r/ r0 �
is_closing_ s z"BaseSubprocessTransport.is_closingc C s� | j r
d S d| _ x&| jj� D ]}|d kr*q |jj� q W | jd k r�| jd kr�| jj� d kr�| jj � rpt
j d| � y| jj � W n t
k
r� Y nX d S )NTz$Close running child process: kill %r)r r �valuesr6 r! r r Zpollr r# r Zwarning�kill�ProcessLookupError)r) �protor/ r/ r0 r! b s
z BaseSubprocessTransport.closec C s& | j s"tjd| t| d� | j� d S )Nzunclosed transport %r)�source)r �warnings�warn�ResourceWarningr! )r) r/ r/ r0 �__del__� s z BaseSubprocessTransport.__del__c C s | j S )N)r )r) r/ r/ r0 �get_pid� s z BaseSubprocessTransport.get_pidc C s | j S )N)r )r) r/ r/ r0 �get_returncode� s z&BaseSubprocessTransport.get_returncodec C s || j kr| j | jS d S d S )N)r r6 )r) �fdr/ r/ r0 �get_pipe_transport� s
z*BaseSubprocessTransport.get_pipe_transportc C s | j d krt� �d S )N)r r@ )r) r/ r/ r0 � _check_proc� s
z#BaseSubprocessTransport._check_procc C s | j � | jj|� d S )N)rK r � send_signal)r) �signalr/ r/ r0 rL � s z#BaseSubprocessTransport.send_signalc C s | j � | jj� d S )N)rK r � terminate)r) r/ r/ r0 rN � s z!BaseSubprocessTransport.terminatec C s | j � | jj� d S )N)rK r r? )r) r/ r/ r0 r? � s z BaseSubprocessTransport.killc # s^ y� j }� j}|jd k rB|j� fdd�|j�E d H \}}|� jd< |jd k rv|j� fdd�|j�E d H \}}|� jd< |jd k r�|j� fdd�|j�E d H \}}|� jd< � jd k s�t �|j
� j j � � x"� jD ]\}}|j
|f|�� q�W d � _W nD t
k
�r8 } z&|d k �r(|j� �r(|j|� W Y d d }~X n"X |d k �rZ|j� �rZ|jd � d S )Nc s
t � d�S )Nr )�WriteSubprocessPipeProtor/ )r) r/ r0 �<lambda>� s z8BaseSubprocessTransport._connect_pipes.<locals>.<lambda>r c s
t � d�S )Nr )�ReadSubprocessPipeProtor/ )r) r/ r0 rP � s r c s
t � d�S )Nr )rQ r/ )r) r/ r0 rP � s r )r r r Zconnect_write_piper r
Zconnect_read_piper r �AssertionError� call_soonr �connection_made� Exception� cancelledZ
set_exception�
set_result) r) r, �procr* �_r6 �callback�data�excr/ )r) r0 r( � s8
z&BaseSubprocessTransport._connect_pipesc G s2 | j d k r | j j||f� n| jj|f|�� d S )N)r r4 r rS )r) �cbr[ r/ r/ r0 �_call� s
z BaseSubprocessTransport._callc C s | j | jj||� | j� d S )N)r^ r Zpipe_connection_lost� _try_finish)r) rI r\ r/ r/ r0 �_pipe_connection_lost� s z-BaseSubprocessTransport._pipe_connection_lostc C s | j | jj||� d S )N)r^ r Zpipe_data_received)r) rI r[ r/ r/ r0 �_pipe_data_received� s z+BaseSubprocessTransport._pipe_data_receivedc C s� |d k st |��| jd ks$t | j��| jj� r<tjd| |� || _| jjd krV|| j_| j| j j
� | j � x | j D ]}|j
� st|j|� qtW d | _ d S )Nz %r exited with return code %r)rR r r r# r r8 r �
returncoder^ r Zprocess_exitedr_ r rV rW )r) rb r, r/ r/ r0 �_process_exited� s
z'BaseSubprocessTransport._process_exitedc c s0 | j dk r| j S | jj� }| jj|� |E dH S )zdWait until the process exit and return the process return code.
This method is a coroutine.N)r r Z
create_futurer r4 )r) r, r/ r/ r0 �_wait� s
z BaseSubprocessTransport._waitc C sJ | j s t�| jd krd S tdd� | jj� D ��rFd| _ | j| jd � d S )Nc s s | ]}|d k o|j V qd S )N)� disconnected)�.0�pr/ r/ r0 � <genexpr>� s z6BaseSubprocessTransport._try_finish.<locals>.<genexpr>T)r rR r �allr r> r^ �_call_connection_lost)r) r/ r/ r0 r_ � s
z#BaseSubprocessTransport._try_finishc C s* z| j j|� W d d | _d | _d | _ X d S )N)r �connection_lostr r )r) r\ r/ r/ r0 rj � s
z-BaseSubprocessTransport._call_connection_lost)NN) r3 �
__module__� __qualname__r r9 r r; r< r= r! r ZPY34rF rG rH rJ rK rL rN r? r r( r^ r` ra rc rd r_ rj �
__classcell__r/ r/ )r. r0 r s0 ) % r c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
S )rO c C s || _ || _d | _d| _d S )NF)rX rI r6 re )r) rX rI r/ r/ r0 r s z!WriteSubprocessPipeProto.__init__c C s
|| _ d S )N)r6 )r) Z transportr/ r/ r0 rT s z(WriteSubprocessPipeProto.connection_madec C s d| j j| j| jf S )Nz<%s fd=%s pipe=%r>)r. r3 rI r6 )r) r/ r/ r0 r9 s z!WriteSubprocessPipeProto.__repr__c C s d| _ | jj| j|� d | _d S )NT)re rX r` rI )r) r\ r/ r/ r0 rk s z(WriteSubprocessPipeProto.connection_lostc C s | j jj� d S )N)rX r �
pause_writing)r) r/ r/ r0 ro s z&WriteSubprocessPipeProto.pause_writingc C s | j jj� d S )N)rX r �resume_writing)r) r/ r/ r0 rp s z'WriteSubprocessPipeProto.resume_writingN) r3 rl rm r rT r9 rk ro rp r/ r/ r/ r0 rO s rO c @ s e Zd Zdd� ZdS )rQ c C s | j j| j|� d S )N)rX ra rI )r) r[ r/ r/ r0 �
data_received$ s z%ReadSubprocessPipeProto.data_receivedN)r3 rl rm rq r/ r/ r/ r0 rQ ! s rQ )r r rC � r r r Z
coroutinesr �logr ZSubprocessTransportr Z BaseProtocolrO ZProtocolrQ r/ r/ r/ r0 �<module> s { PK [h8�"� � . __pycache__/windows_utils.cpython-36.opt-1.pycnu �[��� 3
\� � @ s� d Z ddlZejdkr ed��ddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddddd gZ d
Z
e jZe jZej� Zeed�r�ejZnejejdfd d�Zd de
d�dd�ZG dd � d �ZG dd� de j�ZdS )z*
Various Windows specific bits and pieces
� NZwin32z
win32 only�
socketpair�pipe�Popen�PIPE�
PipeHandlei c
C s | t jkrd}n| t jkr d}ntd��|t jkr:td��|dkrJtd��t j | ||�}z�|j|df� |jd� |j� dd � \}}t j | ||�}yP|jd
� y|j ||f� W n t
t fk
r� Y nX |jd � |j � \}} W n |j
� � Y nX W d|j
� X ||fS ) z�A socket pair usable as a self-pipe, for Windows.
Origin: https://gist.github.com/4325783, by Geert Jansen.
Public domain.
z 127.0.0.1z::1z?Only AF_INET and AF_INET6 socket address families are supportedz)Only SOCK_STREAM socket type is supportedr z Only protocol zero is supported� N� FT)�socket�AF_INETZAF_INET6�
ValueError� SOCK_STREAMZbindZlistenZ getsocknameZ setblockingZconnect�BlockingIOError�InterruptedErrorZaccept�close)
Zfamily�type�proto�hostZlsockZaddrZportZcsockZssock�_� r �-/usr/lib64/python3.6/asyncio/windows_utils.pyr % s8
FT)�duplex�
overlapped�bufsizec C s" t jdtj� tt�f d�}| r>tj}tjtj B }|| }}ntj
}tj }d| }}|tj O }|d rp|tj O }|d r�tj }nd}d } }
yZtj
||tjd||tjtj�} tj||dtjtj|tj�}
tj| dd�} | jd� | |
fS | dk �rtj| � |
dk �rtj|
� � Y nX dS )zELike os.pipe() but with overlapped support and using handles not fds.z\\.\pipe\python-pipe-%d-%d-)�prefixr r NT)r )�tempfileZmktemp�os�getpid�next�
_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 ZaddressZopenmode�accessZobsizeZibsizeZflags_and_attribsZh1Zh2Zovr r r r S s@
c @ s\ e Zd ZdZdd� Zdd� Zedd� �Zdd � Ze j
d
�d d �Z d
d� Z dd� Z
dd� ZdS )r z�Wrapper 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)�_handle)�self�handler r r �__init__� s zPipeHandle.__init__c C s* | j d k rd| j }nd}d| jj|f S )Nz handle=%r�closedz<%s %s>)r" � __class__�__name__)r# r$ r r r �__repr__� s
zPipeHandle.__repr__c C s | j S )N)r" )r# r r r r$ � s zPipeHandle.handlec C s | j d krtd��| j S )Nz I/O operatioon on closed pipe)r" r )r# r r r �fileno� s
zPipeHandle.fileno)r c C s | j d k r|| j � d | _ d S )N)r" )r# r r r r r � s
zPipeHandle.closec C s* | j d k r&tjd| t| d� | j� d S )Nz unclosed %r)�source)r" �warnings�warn�ResourceWarningr )r# r r r �__del__� s
zPipeHandle.__del__c C s | S )Nr )r# r r r � __enter__� s zPipeHandle.__enter__c C s | j � d S )N)r )r# �t�v�tbr r r �__exit__� s zPipeHandle.__exit__N)r( �
__module__� __qualname__�__doc__r% r) �propertyr$ r* r r r r/ r0 r4 r r r r r � s c s" e Zd ZdZd� fdd� Z� ZS )r z�Replacement for subprocess.Popen using overlapped pipe handles.
The stdin, stdout, stderr are None or instances of PipeHandle.
Nc s| d } }}d } }
} |t kr@tddd�\} } tj| tj�}n|}|t krhtdd�\}
}
tj|
d�}n|}|t kr�td d�\} }tj|d�}n|tkr�|}n|}z�y t� j|f|||d�|�� W n4 x$| |
| fD ]}|d k r�t j
|� q�W � Y n>X | d k �rt | �| _ |
d k �r"t |
�| _
| d k �r6t | �| _W d |t k�rNtj|� |t k�rbtj|� |t k�rvtj|� X d S )
NFT)r r )r r )�stdin�stdout�stderr)FT)TF)TF)r r �msvcrtZopen_osfhandler �O_RDONLY�STDOUT�superr% r r r r9 r: r; r )r# �argsr9 r: r; �kwdsZ stdin_rfdZ
stdout_wfdZ
stderr_wfdZstdin_whZ stdout_rhZ stderr_rhZstdin_rhZ stdout_whZ stderr_wh�h)r' r r r% � sH
zPopen.__init__)NNN)r( r5 r6 r7 r% �
__classcell__r r )r' r r � s )TT)r7 �sys�platform� ImportErrorr � itertoolsr< r r �
subprocessr r, �__all__ZBUFSIZEr r> �countr �hasattrr r
r r r r r r r r �<module> s,
.0-PK [4]�j! j! % __pycache__/coroutines.cpython-36.pycnu �[��� 3
\+ � @ s� d ddgZ ddlZddlZddlZddlZddlZddlZddlZddlm Z ddlm
Z
ddlm Z dd lm Z dd
l
mZ ejd Zejj o�eejjd ��ZyejZejZW n ek
r� dZdZY nX y
ej Z W n ek
r� d
d� Z Y nX yddl m Z m!Z" W n e#k
�r* d Z Z"Y nX dd� Z$e$� Z%[$dd� Z&G dd� d�Z'dd � Ze(� Z)dd� Z ej*e'fZ+e dk �r�e+e f7 Z+edk �r�efe+ Z+dd� Z,dd� Z-dS )� coroutine�iscoroutinefunction� iscoroutine� N� )�compat)� constants)�events)� base_futures)�loggerZ
YIELD_FROMZPYTHONASYNCIODEBUGc C s dS )NF� )�funcr r �*/usr/lib64/python3.6/asyncio/coroutines.py�<lambda>/ s r )� Coroutine� Awaitablec C sF G dd� d�} dd� }d}| � }||�}t |� |j|� |j|fkS ) Nc @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S )
z!has_yield_from_bug.<locals>.MyGenc S s
d | _ d S )N)� send_args)�selfr r r
�__init__; s z*has_yield_from_bug.<locals>.MyGen.__init__c S s | S )Nr )r r r r
�__iter__= s z*has_yield_from_bug.<locals>.MyGen.__iter__c S s dS )N�* r )r r r r
�__next__? s z*has_yield_from_bug.<locals>.MyGen.__next__c W s
|| _ d S )N)r )r Zwhatr r r
�sendA s z&has_yield_from_bug.<locals>.MyGen.sendN)�__name__�
__module__� __qualname__r r r r r r r r
�MyGen: s r c s s | E d H d S )Nr )�genr r r
�yield_from_genD s z*has_yield_from_bug.<locals>.yield_from_genr � � )r r r )�nextr r )r r �valuer �coror r r
�has_yield_from_bug9 s
r# c C s
t | d �S )N)� CoroWrapper)r r r r
�
debug_wrapperP s r% c @ s� e Zd Zd%dd�Zdd� Zdd� Zdd � Zer8d
d � Znd d � Zd&d
d�Z dd� Z
e dd� �Z e dd� �Z
e dd� �Zejr�dd� Ze dd� �Ze dd � �Ze d d � �Ze d d � �Ze d!d"� �Zd#d$� ZdS )'r$ Nc C sZ t j|�s t j|�s t|��|| _|| _tjtj d��| _
t |dd �| _ t |dd �| _
d S )Nr r r )�inspect� isgeneratorr �AssertionErrorr r r �
extract_stack�sys� _getframe�_source_traceback�getattrr r )r r r r r r
r [ s zCoroWrapper.__init__c C s@ t | �}| jr0| jd }|d|d |d f 7 }d| jj|f S )Nr z, created at %s:%sr z<%s %s>���)�_format_coroutiner, � __class__r )r � coro_repr�framer r r
�__repr__c s
zCoroWrapper.__repr__c C s | S )Nr )r r r r
r j s zCoroWrapper.__iter__c C s | j jd �S )N)r r )r r r r
r m s zCoroWrapper.__next__c G sB t j� }|j}|jdks t�|jj|j tkr6|d }| jj |�S )Nr )
r* r+ �f_back�f_lastir( �f_code�co_code� _YIELD_FROMr r )r r! r2 Zcallerr r r
r u s zCoroWrapper.sendc C s | j j|�S )N)r r )r r! r r r
r } s c C s | j j|||�S )N)r �throw)r �typer! � tracebackr r r
r9 � s zCoroWrapper.throwc C s
| j j� S )N)r �close)r r r r
r< � s zCoroWrapper.closec C s | j jS )N)r �gi_frame)r r r r
r= � s zCoroWrapper.gi_framec C s | j jS )N)r �
gi_running)r r r r
r> � s zCoroWrapper.gi_runningc C s | j jS )N)r �gi_code)r r r r
r? � s zCoroWrapper.gi_codec C s, t | jdd �}|d k r(tdj| j|���| S )N�cr_awaitz;Cannot await on coroutine {!r} while it's awaiting for {!r})r- r � RuntimeError�format)r r@ r r r
� __await__� s zCoroWrapper.__await__c C s | j jS )N)r � gi_yieldfrom)r r r r
rD � s zCoroWrapper.gi_yieldfromc C s | j jS )N)r r@ )r r r r
r@ � s zCoroWrapper.cr_awaitc C s | j jS )N)r �
cr_running)r r r r
rE � s zCoroWrapper.cr_runningc C s | j jS )N)r �cr_code)r r r r
rF � s zCoroWrapper.cr_codec C s | j jS )N)r �cr_frame)r r r r
rG � s zCoroWrapper.cr_framec C s� t | dd �}t |dd �}|d kr,t |dd �}|d k r�|jd
kr�d| }t | df �}|r�djtj|��}|dtj� d �7 }||j� 7 }tj |� d S ) Nr r= rG r z%r was never yielded fromr, � zB
Coroutine object created at (most recent call last, truncated to z last lines):
r. )
r- r5 �joinr; � format_listr ZDEBUG_STACK_DEPTH�rstripr
�error)r r r2 �msg�tbr r r
�__del__� s zCoroWrapper.__del__)N)NN)r r r r r3 r r �_YIELD_FROM_BUGr r9 r< �propertyr= r> r? r ZPY35rC rD r@ rE rF rG rO r r r r
r$ X s(
r$ c sp t ��r �S tj��r �� ntj���fdd��� tsNtdkrD� }qft� �}ntj��� �fdd��}t|_|S )z�Decorator to mark coroutines.
If the coroutine is not yielded from before it is destroyed,
an error message is logged.
c ? sv � | |�}t j|�s(tj|�s(t|t�r4|E d H }n>td k rry
|j}W n tk
rZ Y nX t|t�rr|� E d H }|S )N) r Zisfuturer& r' �
isinstancer$ �
_AwaitableABCrC �AttributeError)�args�kw�resZ
await_meth)r r r
r" � s
zcoroutine.<locals>.coroNc s@ t � | |��d�}|jr |jd= t�dd �|_t�dd �|_|S )N)r r r r r. )r$ r, r- r r )rU �kwds�w)r" r r r
�wrapper� s zcoroutine.<locals>.wrapper)� _inspect_iscoroutinefunctionr& �isgeneratorfunction� functools�wraps�_DEBUG�_types_coroutine�
_is_coroutine)r rZ r )r" r r
r � s
c C s t | dd�tkpt| �S )z6Return True if func is a decorated coroutine function.ra N)r- ra r[ )r r r r
r � s c C s
t | t�S )z)Return True if obj is a coroutine object.)rR �_COROUTINE_TYPES)�objr r r
r s c
C s& t | �s t�t| d� r�t| d� r�t| dt| dt| �j��}dj|�}d}y
| j}W n4 tk
r� y
| j }W n tk
r� Y nX Y nX |r�dj|�S |S d }t
| t �r�| j }| j
}|d k r�dj|�}n| }|d kr�tj|f i �}d }t| d�o�| j�r| j}nt| d��r | j�r | j}d }t| d��r>| j�r>| j}nt| d ��rX| j�rX| j}d
}|�rp|j�rp|j}d }|}t
| t ��r�tj| j � �r�| j d k �r�tj| j �} | d k �r�| \}}|d k�r�d |||f }nd
|||f }n:|d k �r|j}d|||f }n|�r"|j}d |||f }|S )NrF r? r r z{}()Fz
{} runningrG r= z<empty co_filename>r z%s done, defined at %s:%sz %s running, defined at %s:%sz%s running at %s:%s)r r( �hasattrr- r: r rB rE rT r> rR r$ r r r Z_format_callbackrF r? rG r= � co_filenamer& r\ Z_get_function_source�f_lineno�co_firstlineno)
r" Z coro_nameZrunningr Z coro_codeZ
coro_frame�filename�linenor1 �sourcer r r
r/ sz
r/ ).�__all__r] r& Zopcode�osr* r; �typesrH r r r r �logr
Zopmapr8 �flags�ignore_environment�bool�environ�getr_ r r` �
CoroutineTypeZ_types_CoroutineTyperT r r[ �collections.abcr Z
_CoroutineABCr rS � ImportErrorr# rP r% r$ �objectra �
GeneratorTyperb r r/ r r r r
�<module> sZ
j:
PK [{fU�� � * __pycache__/constants.cpython-36.opt-2.pycnu �[��� 3
\s � @ s d Z dZdZdS )� � �
N)Z!LOG_THRESHOLD_FOR_CONNLOST_WRITESZACCEPT_RETRY_DELAYZDEBUG_STACK_DEPTH� r r �)/usr/lib64/python3.6/asyncio/constants.py�<module> s PK [�>B� + __pycache__/transports.cpython-36.opt-2.pycnu �[��� 3
\R' � @ s� d dl mZ ddddddgZG dd� d�ZG d d� de�ZG d
d� de�ZG d d� dee�ZG d d� de�ZG d
d� de�ZG dd� de�Z dS )� )�compat�
BaseTransport�
ReadTransport�WriteTransport� Transport�DatagramTransport�SubprocessTransportc @ s@ e Zd Zddd�Zddd�Zdd� Zdd � Zd
d � Zd d
� ZdS )r Nc C s |d kr i }|| _ d S )N)�_extra)�self�extra� r �*/usr/lib64/python3.6/asyncio/transports.py�__init__
s zBaseTransport.__init__c C s | j j||�S )N)r �get)r
�name�defaultr r r
�get_extra_info s z BaseTransport.get_extra_infoc C s t �d S )N)�NotImplementedError)r
r r r
�
is_closing s zBaseTransport.is_closingc C s t �d S )N)r )r
r r r
�close s zBaseTransport.closec C s t �d S )N)r )r
�protocolr r r
� set_protocol$ s zBaseTransport.set_protocolc C s t �d S )N)r )r
r r r
� get_protocol( s zBaseTransport.get_protocol)N)N) �__name__�
__module__� __qualname__r r r r r r r r r r
r
s
c @ s e Zd Zdd� Zdd� ZdS )r c C s t �d S )N)r )r
r r r
�
pause_reading0 s zReadTransport.pause_readingc C s t �d S )N)r )r
r r r
�resume_reading8 s z ReadTransport.resume_readingN)r r r r r r r r r
r - s c @ sF e Zd Zddd�Zdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z dS )r Nc C s t �d S )N)r )r
�high�lowr r r
�set_write_buffer_limitsD s z&WriteTransport.set_write_buffer_limitsc C s t �d S )N)r )r
r r r
�get_write_buffer_sizeY s z$WriteTransport.get_write_buffer_sizec C s t �d S )N)r )r
�datar r r
�write] s zWriteTransport.writec C s t j|�}| j|� d S )N)r Zflatten_list_bytesr# )r
Z list_of_datar" r r r
�
writelinese s
zWriteTransport.writelinesc C s t �d S )N)r )r
r r r
� write_eofn s zWriteTransport.write_eofc C s t �d S )N)r )r
r r r
�
can_write_eofw s z WriteTransport.can_write_eofc C s t �d S )N)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 A s
c @ s e Zd ZdS )r N)r r r r r r r
r � s c @ s e Zd Zddd�Zdd� ZdS )r Nc C s t �d S )N)r )r
r" Zaddrr r r
�sendto� s zDatagramTransport.sendtoc C s t �d S )N)r )r
r r r
r' � s zDatagramTransport.abort)N)r r r r( r' r r r r
r � s
c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
S )r c C s t �d S )N)r )r
r r r
�get_pid� s zSubprocessTransport.get_pidc C s t �d S )N)r )r
r r r
�get_returncode� s z"SubprocessTransport.get_returncodec C s t �d S )N)r )r
�fdr r r
�get_pipe_transport� s z&SubprocessTransport.get_pipe_transportc C s t �d S )N)r )r
�signalr r r
� send_signal� s z SubprocessTransport.send_signalc C s t �d S )N)r )r
r r r
� terminate� s z SubprocessTransport.terminatec C s t �d S )N)r )r
r r r
�kill� s zSubprocessTransport.killN) r r r r) r* r, r. r/ r0 r r r r
r � s c sR e Zd Zd� fdd� Zdd� Zdd� Zdd � Zdd
d �Zdd d
�Zdd� Z � Z
S )�_FlowControlMixinNc s$ t � j|� || _d| _| j� d S )NF)�superr �_loop�_protocol_paused�_set_write_buffer_limits)r
r Zloop)� __class__r r
r � s z_FlowControlMixin.__init__c C sp | j � }|| jkrd S | jsld| _y| jj� W n: tk
rj } z | jjd|| | jd�� W Y d d }~X nX d S )NTz protocol.pause_writing() failed)�message� exception� transportr )r! � _high_waterr4 � _protocolZ
pause_writing� Exceptionr3 �call_exception_handler)r
�size�excr r r
�_maybe_pause_protocol� s
z'_FlowControlMixin._maybe_pause_protocolc C sh | j rd| j� | jkrdd| _ y| jj� W n: tk
rb } z | jjd|| | jd�� W Y d d }~X nX d S )NFz protocol.resume_writing() failed)r7 r8 r9 r )r4 r! �
_low_waterr; Zresume_writingr< r3 r= )r
r? r r r
�_maybe_resume_protocol s z(_FlowControlMixin._maybe_resume_protocolc C s | j | jfS )N)rA r: )r
r r r
�get_write_buffer_limits s z)_FlowControlMixin.get_write_buffer_limitsc C sf |d kr |d krd}nd| }|d kr.|d }|| ko@dkn sVt d||f ��|| _|| _d S )N�@ i � r z*high (%r) must be >= low (%r) must be >= 0i )�
ValueErrorr: rA )r
r r r r r
r5 s z*_FlowControlMixin._set_write_buffer_limitsc C s | j ||d� | j� d S )N)r r )r5 r@ )r
r r r r r
r - s z)_FlowControlMixin.set_write_buffer_limitsc C s t �d S )N)r )r
r r r
r! 1 s z'_FlowControlMixin.get_write_buffer_size)NN)NN)NN) r r r r r@ rB rC r5 r r! �
__classcell__r r )r6 r
r1 � s
r1 N)
Zasyncior �__all__r r r r r r r1 r r r r
�<module> s
#D4PK [���� � ! __pycache__/compat.cpython-36.pycnu �[��� 3
\ � @ s6 d Z ddlZejd kZejd
kZejd kZdd� ZdS ) z8Compatibility helpers for the different Python versions.� N� � � � c C s t sdd� | D �} dj| �S )z-Concatenate a sequence of bytes-like objects.c s s$ | ] }t |t�rt|�n|V qd S )N)�
isinstance�
memoryview�bytes)�.0�data� r �&/usr/lib64/python3.6/asyncio/compat.py� <genexpr> s z%flatten_list_bytes.<locals>.<genexpr>� )�PY34�join)Z list_of_datar r r �flatten_list_bytes
s r )r r )r r )r r r )�__doc__�sys� version_infor ZPY35ZPY352r r r r r �<module> s
PK [C�s / / + __pycache__/transports.cpython-36.opt-1.pycnu �[��� 3
\R' � @ s� d Z ddlmZ ddddddgZG d d� d�ZG d
d� de�ZG d d� de�ZG d d� dee�ZG d
d� de�ZG dd� de�Z G dd� de�Z
dS )zAbstract Transport class.� )�compat�
BaseTransport�
ReadTransport�WriteTransport� Transport�DatagramTransport�SubprocessTransportc @ sD e Zd ZdZddd�Zddd�Zdd� Zd d
� Zd d � Zd
d� Z dS )r zBase class for transports.Nc C s |d kr i }|| _ d S )N)�_extra)�self�extra� r �*/usr/lib64/python3.6/asyncio/transports.py�__init__
s zBaseTransport.__init__c C s | j j||�S )z#Get optional transport information.)r �get)r
�name�defaultr r r
�get_extra_info s z BaseTransport.get_extra_infoc C s t �dS )z2Return True if the transport is closing or closed.N)�NotImplementedError)r
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) called
with None as its argument.
N)r )r
r r r
�close s zBaseTransport.closec C s t �dS )zSet a new protocol.N)r )r
�protocolr r r
� set_protocol$ s zBaseTransport.set_protocolc C s t �dS )z Return the current protocol.N)r )r
r r r
� get_protocol( s zBaseTransport.get_protocol)N)N)
�__name__�
__module__� __qualname__�__doc__r r r r r r r r r r
r
s
c @ s e Zd ZdZdd� Zdd� ZdS )r z#Interface for read-only transports.c C s t �dS )z�Pause the receiving end.
No data will be passed to the protocol's data_received()
method until resume_reading() is called.
N)r )r
r r r
�
pause_reading0 s zReadTransport.pause_readingc C s t �dS )z�Resume the receiving end.
Data received will once again be passed to the protocol's
data_received() method.
N)r )r
r r r
�resume_reading8 s z ReadTransport.resume_readingN)r r r r r r r r r r
r - s c @ sJ e Zd ZdZddd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dS )r z$Interface for write-only transports.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.
N)r )r
�high�lowr r r
�set_write_buffer_limitsD s z&WriteTransport.set_write_buffer_limitsc C s t �dS )z,Return the current size of the write buffer.N)r )r
r r r
�get_write_buffer_sizeY s z$WriteTransport.get_write_buffer_sizec C s t �dS )z�Write some data bytes to the transport.
This does not block; it buffers the data and arranges for it
to be sent out asynchronously.
N)r )r
�datar r r
�write] s zWriteTransport.writec C s t j|�}| j|� dS )z�Write a list (or any iterable) of data bytes to the transport.
The default implementation concatenates the arguments and
calls write() on the result.
N)r Zflatten_list_bytesr$ )r
Z list_of_datar# r r r
�
writelinese s
zWriteTransport.writelinesc C s t �dS )z�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.
N)r )r
r r r
� write_eofn s zWriteTransport.write_eofc C s t �dS )zAReturn True if this transport supports write_eof(), False if not.N)r )r
r r r
�
can_write_eofw s z WriteTransport.can_write_eofc C s t �dS )z�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.
N)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 A s
c @ s e Zd ZdZdS )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.
N)r r r r r r r r
r � s c @ s" e Zd ZdZddd�Zdd� ZdS )r z(Interface for datagram (UDP) transports.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.
N)r )r
r# Zaddrr r r
�sendto� s zDatagramTransport.sendtoc C s t �dS )z�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.
N)r )r
r r r
r( � s zDatagramTransport.abort)N)r r r r r) r( r r r r
r � s
c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
S )r c C s t �dS )zGet subprocess id.N)r )r
r r r
�get_pid� s zSubprocessTransport.get_pidc C s t �dS )z�Get subprocess returncode.
See also
http://docs.python.org/3/library/subprocess#subprocess.Popen.returncode
N)r )r
r r r
�get_returncode� s z"SubprocessTransport.get_returncodec C s t �dS )z&Get transport for pipe with number fd.N)r )r
�fdr r r
�get_pipe_transport� s z&SubprocessTransport.get_pipe_transportc C s t �dS )z�Send signal to subprocess.
See also:
docs.python.org/3/library/subprocess#subprocess.Popen.send_signal
N)r )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
N)r )r
r r r
� terminate� s z SubprocessTransport.terminatec C s t �dS )z�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
N)r )r
r r r
�kill� s zSubprocessTransport.killN) r r r r* r+ r- r/ r0 r1 r r r r
r � s c sV e Zd ZdZd� fdd� Zdd� Zdd� Zd d
� Zdd d �Zdd
d�Z 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.
Nc s$ t � j|� || _d| _| j� d S )NF)�superr �_loop�_protocol_paused�_set_write_buffer_limits)r
r Zloop)� __class__r r
r � s z_FlowControlMixin.__init__c C sp | j � }|| jkrd S | jsld| _y| jj� W n: tk
rj } z | jjd|| | jd�� W Y d d }~X nX d S )NTz protocol.pause_writing() failed)�message� exception� transportr )r" � _high_waterr5 � _protocolZ
pause_writing� Exceptionr4 �call_exception_handler)r
�size�excr r r
�_maybe_pause_protocol� s
z'_FlowControlMixin._maybe_pause_protocolc C sh | j rd| j� | jkrdd| _ y| jj� W n: tk
rb } z | jjd|| | jd�� W Y d d }~X nX d S )NFz protocol.resume_writing() failed)r8 r9 r: r )r5 r" �
_low_waterr< Zresume_writingr= r4 r> )r
r@ r r r
�_maybe_resume_protocol s z(_FlowControlMixin._maybe_resume_protocolc C s | j | jfS )N)rB r; )r
r r r
�get_write_buffer_limits s z)_FlowControlMixin.get_write_buffer_limitsc C sf |d kr |d krd}nd| }|d kr.|d }|| ko@dkn sVt d||f ��|| _|| _d S )N�@ i � r z*high (%r) must be >= low (%r) must be >= 0i )�
ValueErrorr; rB )r
r r r r r
r6 s z*_FlowControlMixin._set_write_buffer_limitsc C s | j ||d� | j� d S )N)r r )r6 rA )r
r r r r r
r! - s z)_FlowControlMixin.set_write_buffer_limitsc C s t �d S )N)r )r
r r r
r" 1 s z'_FlowControlMixin.get_write_buffer_size)NN)NN)NN) r r r r r rA rC rD r6 r! r" �
__classcell__r r )r7 r
r2 � s
r2 N) r Zasyncior �__all__r r r r r r r2 r r r r
�<module> s
#D4PK [G��4G G % __pycache__/base_tasks.cpython-36.pycnu �[��� 3
\� � @ sD d dl Z d dlZddlmZ ddlmZ dd� Zdd� Zd d
� ZdS ) � N� )� base_futures)�
coroutinesc C sT t j| �}| jrd|d< tj| j�}|jdd| � | jd k rP|jdd| j � |S )NZ
cancellingr r z coro=<%s>� z wait_for=%r)r Z_future_repr_infoZ _must_cancelr Z_format_coroutine�_coro�insertZ _fut_waiter)�task�info�coro� r �*/usr/lib64/python3.6/asyncio/base_tasks.py�_task_repr_info s
r
c C s� g }y | j j}W n tk
r, | j j}Y nX |d k rxx6|d k rl|d k rZ|dkrRP |d8 }|j|� |j}q8W |j� nL| jd k r�| jj}x8|d k r�|d k r�|dkr�P |d8 }|j|j � |j
}q�W |S )Nr r ) r �cr_frame�AttributeError�gi_frame�append�f_back�reverse�
_exception�
__traceback__�tb_frame�tb_next)r �limitZframes�f�tbr r r �_task_get_stack s0
r c C s� g }t � }xj| j|d�D ]Z}|j}|j}|j}|j} ||krP|j|� tj|� tj |||j
�}
|j ||| |
f� qW | j } |s�t
d| |d� n*| d k r�t
d| |d� nt
d| |d� tj||d� | d k r�x$tj| j| �D ]}
t
|
|dd� q�W d S )N)r zNo stack for %r)�filez)Traceback for %r (most recent call last):z%Stack for %r (most recent call last):� )r �end)�setZ get_stack�f_lineno�f_code� co_filename�co_name�add� linecache�
checkcache�getline� f_globalsr r �print� traceback�
print_list�format_exception_only� __class__) r r r �extracted_listZcheckedr �lineno�co�filename�name�line�excr r r �_task_print_stack3 s0
r5 )r% r* r r r r
r r5 r r r r �<module> s PK [ϤУ - __pycache__/base_futures.cpython-36.opt-1.pycnu �[��� 3
\ � @ sr g Z d dlZd dlZddlmZ ejjjZejj Z ejj
Z
G dd� de�Z dZ dZ
dZd d
� Zd d � Zd
d� ZdS )� N� )�eventsc @ s e Zd ZdZdS )�InvalidStateErrorz+The operation is not allowed in this state.N)�__name__�
__module__� __qualname__�__doc__� r r �,/usr/lib64/python3.6/asyncio/base_futures.pyr
s r ZPENDINGZ CANCELLEDZFINISHEDc C s t | jd�o| jdk S )z�Check for a Future.
This returns True when obj is a Future instance or is advertising
itself as duck-type compatible by setting _asyncio_future_blocking.
See comment in Future for more details.
�_asyncio_future_blockingN)�hasattr� __class__r )�objr r r
�isfuture s r c C s� t | �}|sd} dd� }|dkr.|| d �} nP|dkrTdj|| d �|| d ��} n*|dkr~dj|| d �|d || d
��} d | S ) z#helper function for Future.__repr__� c S s t j| f �S )N)r Z_format_callback_source)�callbackr r r
� format_cb( s z$_format_callbacks.<locals>.format_cbr r � z{}, {}z{}, <{} more>, {}zcb=[%s]���)�len�format)�cb�sizer r r r
�_format_callbacks" s r c C s� | j j� g}| j tkrP| jdk r4|jdj| j�� n tj| j�}|jdj|�� | j rf|jt
| j �� | j r�| j d }|jd|d |d f � |S )z#helper function for Future.__repr__Nzexception={!r}z result={}r zcreated at %s:%sr r ) Z_state�lower� _FINISHEDZ
_exception�appendr �reprlib�reprZ_resultZ
_callbacksr Z_source_traceback)Zfuture�info�result�framer r r
�_future_repr_info6 s
r" )�__all__Zconcurrent.futures._baseZ
concurrentr r r ZfuturesZ_base�ErrorZCancelledError� TimeoutErrorr Z_PENDINGZ
_CANCELLEDr r r r" r r r r
�<module> s
PK [/F\: ( __pycache__/windows_utils.cpython-36.pycnu �[��� 3
\� � @ s� d Z ddlZejdkr ed��ddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddddd gZ d
Z
e jZe jZej� Zeed�r�ejZnejejdfd d�Zd de
d�dd�ZG dd � d �ZG dd� de j�ZdS )z*
Various Windows specific bits and pieces
� NZwin32z
win32 only�
socketpair�pipe�Popen�PIPE�
PipeHandlei c
C s | t jkrd}n| t jkr d}ntd��|t jkr:td��|dkrJtd��t j | ||�}z�|j|df� |jd� |j� dd � \}}t j | ||�}yP|jd
� y|j ||f� W n t
t fk
r� Y nX |jd � |j � \}} W n |j
� � Y nX W d|j
� X ||fS ) z�A socket pair usable as a self-pipe, for Windows.
Origin: https://gist.github.com/4325783, by Geert Jansen.
Public domain.
z 127.0.0.1z::1z?Only AF_INET and AF_INET6 socket address families are supportedz)Only SOCK_STREAM socket type is supportedr z Only protocol zero is supported� N� FT)�socket�AF_INETZAF_INET6�
ValueError� SOCK_STREAMZbindZlistenZ getsocknameZ setblockingZconnect�BlockingIOError�InterruptedErrorZaccept�close)
Zfamily�type�proto�hostZlsockZaddrZportZcsockZssock�_� r �-/usr/lib64/python3.6/asyncio/windows_utils.pyr % s8
FT)�duplex�
overlapped�bufsizec C s" t jdtj� tt�f d�}| r>tj}tjtj B }|| }}ntj
}tj }d| }}|tj O }|d rp|tj O }|d r�tj }nd}d } }
yZtj
||tjd||tjtj�} tj||dtjtj|tj�}
tj| dd�} | jd� | |
fS | dk �rtj| � |
dk �rtj|
� � Y nX dS )zELike os.pipe() but with overlapped support and using handles not fds.z\\.\pipe\python-pipe-%d-%d-)�prefixr r NT)r )�tempfileZmktemp�os�getpid�next�
_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 ZaddressZopenmode�accessZobsizeZibsizeZflags_and_attribsZh1Zh2Zovr r r r S s@
c @ s\ e Zd ZdZdd� Zdd� Zedd� �Zdd � Ze j
d
�d d �Z d
d� Z dd� Z
dd� ZdS )r z�Wrapper 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)�_handle)�self�handler r r �__init__� s zPipeHandle.__init__c C s* | j d k rd| j }nd}d| jj|f S )Nz handle=%r�closedz<%s %s>)r" � __class__�__name__)r# r$ r r r �__repr__� s
zPipeHandle.__repr__c C s | j S )N)r" )r# r r r r$ � s zPipeHandle.handlec C s | j d krtd��| j S )Nz I/O operatioon on closed pipe)r" r )r# r r r �fileno� s
zPipeHandle.fileno)r c C s | j d k r|| j � d | _ d S )N)r" )r# r r r r r � s
zPipeHandle.closec C s* | j d k r&tjd| t| d� | j� d S )Nz unclosed %r)�source)r" �warnings�warn�ResourceWarningr )r# r r r �__del__� s
zPipeHandle.__del__c C s | S )Nr )r# r r r � __enter__� s zPipeHandle.__enter__c C s | j � d S )N)r )r# �t�v�tbr r r �__exit__� s zPipeHandle.__exit__N)r( �
__module__� __qualname__�__doc__r% r) �propertyr$ r* r r r r/ r0 r4 r r r r r � s c s" e Zd ZdZd� fdd� Z� ZS )r z�Replacement for subprocess.Popen using overlapped pipe handles.
The stdin, stdout, stderr are None or instances of PipeHandle.
Nc s� |j d� st�|j dd�dks$t�d } }}d } }
} |tkrdtd dd�\} } tj| tj�}n|}|tkr�td
d�\}
}
tj|
d�}n|}|tkr�td d�\} }tj|d�}n|tkr�|}n|}z�y t � j
|f|||d�|�� W n8 x(| |
| fD ]}|d k � r�t j |� � q�W � Y n>X | d k �r6t
| �| _|
d k �rJt
|
�| _| d k �r^t
| �| _W d |tk�rvtj|� |tk�r�tj|� |tk�r�tj|� X d S ) NZuniversal_newlinesr r FT)r r )r )�stdin�stdout�stderr)FT)TF)TF)�get�AssertionErrorr r �msvcrtZopen_osfhandler �O_RDONLY�STDOUT�superr% r r r r9 r: r; r )r# �argsr9 r: r; �kwdsZ stdin_rfdZ
stdout_wfdZ
stderr_wfdZstdin_whZ stdout_rhZ stderr_rhZstdin_rhZ stdout_whZ stderr_wh�h)r' r r r% � sL
zPopen.__init__)NNN)r( r5 r6 r7 r% �
__classcell__r r )r' r r � s )TT)r7 �sys�platform� ImportErrorr � itertoolsr> r r �
subprocessr r, �__all__ZBUFSIZEr r@ �countr �hasattrr r
r r r r r r r r �<module> s,
.0-PK [ ��z�4 �4 ( __pycache__/futures.cpython-36.opt-1.pycnu �[��� 3
\ > � @ s
d Z ddddddgZddlZddlZddlZddlZd d
lmZ d d lm Z d d lm
Z
ej Z ej Z ej
Z
ejZejZejZejZejd ZG d
d� d�ZG dd� d�ZeZdd� Zdd� Zdd� Zdd� Zdd�dd�Zy ddl Z W n e k
r� Y n X e j ZZ dS )z.A Future class similar to the one in PEP 3148.�CancelledError� TimeoutError�InvalidStateError�Future� wrap_future�isfuture� N� )� base_futures)�compat)�eventsc @ s4 e Zd ZdZdZdd� Zdd � Zd
d � Zd d
� ZdS )�_TracebackLoggera
Helper to log a traceback upon destruction if not cleared.
This solves a nasty problem with Futures and Tasks that have an
exception set: if nobody asks for the exception, the exception is
never logged. This violates the Zen of Python: 'Errors should
never pass silently. Unless explicitly silenced.'
However, we don't want to log the exception as soon as
set_exception() is called: if the calling code is written
properly, it will get the exception and handle it properly. But
we *do* want to log it if result() or exception() was never called
-- otherwise developers waste a lot of time wondering why their
buggy code fails silently.
An earlier attempt added a __del__() method to the Future class
itself, but this backfired because the presence of __del__()
prevents garbage collection from breaking cycles. A way out of
this catch-22 is to avoid having a __del__() method on the Future
class itself, but instead to have a reference to a helper object
with a __del__() method that logs the traceback, where we ensure
that the helper object doesn't participate in cycles, and only the
Future has a reference to it.
The helper object is added when set_exception() is called. When
the Future is collected, and the helper is present, the helper
object is also collected, and its __del__() method will log the
traceback. When the Future's result() or exception() method is
called (and a helper object is present), it removes the helper
object, after calling its clear() method to prevent it from
logging.
One downside is that we do a fair amount of work to extract the
traceback from the exception, even when it is never logged. It
would seem cheaper to just store the exception object, but that
references the traceback, which references stack frames, which may
reference the Future, which references the _TracebackLogger, and
then the _TracebackLogger would be included in a cycle, which is
what we're trying to avoid! As an optimization, we don't
immediately format the exception; we only do the work when
activate() is called, which call is delayed until after all the
Future's callbacks have run. Since usually a Future has at least
one callback (typically set by 'yield from') and usually that
callback extracts the callback, thereby removing the need to
format the exception.
PS. I don't claim credit for this solution. I first heard of it
in a discussion about closing files when they are collected.
�loop�source_traceback�exc�tbc C s |j | _|j| _|| _d | _d S )N)�_loopr
�_source_tracebackr r r )�self�futurer � r �'/usr/lib64/python3.6/asyncio/futures.py�__init__R s z_TracebackLogger.__init__c C s, | j }|d k r(d | _ tj|j||j�| _d S )N)r � traceback�format_exception� __class__�
__traceback__r )r r r r r �activateX s
z_TracebackLogger.activatec C s d | _ d | _d S )N)r r )r r r r �clear_ s z_TracebackLogger.clearc C sb | j r^d}| jr:djtj| j��}|d7 }|d|j� 7 }|dj| j �j� 7 }| jjd|i� d S )Nz*Future/Task exception was never retrieved
� z0Future/Task created at (most recent call last):
z%s
�message)r r �joinr � format_list�rstripr
�call_exception_handler)r �msg�srcr r r �__del__c s z_TracebackLogger.__del__N)r
r r r ) �__name__�
__module__� __qualname__�__doc__� __slots__r r r r& r r r r r s 0r c @ s� e Zd ZdZeZdZdZdZdZ dZ
dZ dd�dd�Z e
jZdd� ZejrRd d
� Zd d � Zd
d� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd � Z d d � Z d d � Z ej r�e Z dS )!r a, This class is *almost* compatible with concurrent.futures.Future.
Differences:
- This class is not thread-safe.
- result() and exception() do not take a timeout argument and
raise an exception when the future isn't done yet.
- Callbacks registered with add_done_callback() are always called
via the event loop's call_soon().
- This class is not compatible with the wait() and as_completed()
methods in the concurrent.futures package.
(In Python 3.4 or later we may be able to unify the implementations.)
NF)r
c C s@ |dkrt j� | _n|| _g | _| jj� r<t jtjd��| _dS )z�Initialize the future.
The optional event_loop argument allows explicitly setting the event
loop object used by the future. If it's not provided, the future uses
the default event loop.
Nr ) r �get_event_loopr �
_callbacksZ get_debug�
extract_stack�sys� _getframer )r r
r r r r � s
zFuture.__init__c C s d| j jdj| j� �f S )Nz<%s %s>� )r r' r �
_repr_info)r r r r �__repr__� s zFuture.__repr__c C sD | j s
d S | j}d| jj || d�}| jr4| j|d< | jj|� d S )Nz %s exception was never retrieved)r � exceptionr r )�_log_traceback�
_exceptionr r' r r r# )r r �contextr r r r& � s
zFuture.__del__c C s& d| _ | jtkrdS t| _| j� dS )z�Cancel the future and schedule callbacks.
If the future is already done or cancelled, return False. Otherwise,
change the future's state to cancelled, schedule the callbacks and
return True.
FT)r5 �_state�_PENDING�
_CANCELLED�_schedule_callbacks)r r r r �cancel� s
z
Future.cancelc C sD | j dd� }|sdS g | j dd�< x|D ]}| jj|| � q*W dS )z�Internal: Ask the event loop to call all callbacks.
The callbacks are scheduled to be called as soon as possible. Also
clears the callback list.
N)r- r � call_soon)r Z callbacks�callbackr r r r; � s
zFuture._schedule_callbacksc C s
| j tkS )z(Return True if the future was cancelled.)r8 r: )r r r r � cancelled� s zFuture.cancelledc C s
| j tkS )z�Return True if the future is done.
Done means either that a result / exception are available, or that the
future was cancelled.
)r8 r9 )r r r r �done� s z Future.donec C s< | j tkrt�| j tkr td��d| _| jdk r6| j�| jS )a Return the result this future represents.
If the future has been cancelled, raises CancelledError. If the
future's result isn't yet available, raises InvalidStateError. If
the future is done and has an exception set, this exception is raised.
zResult is not ready.FN)r8 r: r � _FINISHEDr r5 r6 �_result)r r r r �result� s
z
Future.resultc C s, | j tkrt�| j tkr td��d| _| jS )a& Return the exception that was set on this future.
The exception (or None if no exception was set) is returned only if
the future is done. If the future has been cancelled, raises
CancelledError. If the future isn't done yet, raises
InvalidStateError.
zException is not set.F)r8 r: r rA r r5 r6 )r r r r r4 � s
zFuture.exceptionc C s* | j tkr| jj|| � n | jj|� dS )z�Add a callback to be run when the future becomes done.
The callback is called with a single argument - the future object. If
the future is already done when this is called, the callback is
scheduled with call_soon.
N)r8 r9 r r= r- �append)r �fnr r r �add_done_callback s
zFuture.add_done_callbackc s< � fdd�| j D �}t| j �t|� }|r8|| j dd�< |S )z}Remove all instances of a callback from the "call when done" list.
Returns the number of callbacks removed.
c s g | ]}|� kr|�qS r r )�.0�f)rE r r �
<listcomp> s z/Future.remove_done_callback.<locals>.<listcomp>N)r- �len)r rE Zfiltered_callbacksZ
removed_countr )rE r �remove_done_callback s
zFuture.remove_done_callbackc C s4 | j tkr tdj| j | ���|| _t| _ | j� dS )z�Mark the future done and set its result.
If the future is already done when this method is called, raises
InvalidStateError.
z{}: {!r}N)r8 r9 r �formatrB rA r; )r rC r r r �
set_result s
zFuture.set_resultc C s� | j tkr tdj| j | ���t|t�r,|� }t|�tkr@td��|| _t | _ | j
� t j rbd| _
n t| |�| _| jj| jj� dS )z�Mark the future done and set an exception.
If the future is already done when this method is called, raises
InvalidStateError.
z{}: {!r}zPStopIteration interacts badly with generators and cannot be raised into a FutureTN)r8 r9 r rL �
isinstance�type�
StopIteration� TypeErrorr6 rA r; r
�PY34r5 r Z
_tb_loggerr r= r )r r4 r r r �
set_exception, s
zFuture.set_exceptionc c s | j � sd| _| V | j� S )NT)r@ �_asyncio_future_blockingrC )r r r r �__iter__D s zFuture.__iter__)!r' r( r) r* r9 r8 rB r6 r r rT r5 r r Z_future_repr_infor2 r3 r
rR r& r< r; r? r@ rC r4 rF rK rM rS rU ZPY35� __await__r r r r r n s4
c C s | j � r dS | j|� dS )z?Helper setting the result only if the future was not cancelled.N)r? rM )ZfutrC r r r � _set_result_unless_cancelledS s rW c C sN |j � r| j� | j� s dS |j� }|dk r8| j|� n|j� }| j|� dS )z8Copy state from a future to a concurrent.futures.Future.N)r? r< Z set_running_or_notify_cancelr4 rS rC rM )�
concurrent�sourcer4 rC r r r � _set_concurrent_future_stateZ s rZ c C sP |j � r dS | j � r |j� n.| j� }|dk r:|j|� n| j� }|j|� dS )zqInternal helper to copy state from another Future.
The other Future may be a concurrent.futures.Future.
N)r? r< r4 rS rC rM )rY �destr4 rC r r r �_copy_future_statei s
r\ c s� t �� r"t�tjj� r"td��t �� rDt�tjj� rDtd��t ��rR�jnd�t ��rd�jnd�dd� � ���fdd�}� ���fdd �}�j|� �j|� dS )
a Chain two futures so that when one completes, so does the other.
The result (or exception) of source will be copied to destination.
If destination is cancelled, source gets cancelled too.
Compatible with both asyncio.Future and concurrent.futures.Future.
z(A future is required for source argumentz-A future is required for destination argumentNc S s" t | �rt|| � n
t| |� d S )N)r r\ rZ )r �otherr r r �
_set_state� s z!_chain_future.<locals>._set_statec s2 | j � r.�d ks�� kr"�j� n �j�j� d S )N)r? r< �call_soon_threadsafe)� destination)� dest_looprY � source_loopr r �_call_check_cancel� s
z)_chain_future.<locals>._call_check_cancelc sJ �j � r �d k r �j� r d S �d ks,��kr8� �| � n�j� �| � d S )N)r? Z is_closedr_ )rY )r^ ra r` rb r r �_call_set_state� s z&_chain_future.<locals>._call_set_state)r rN rX Zfuturesr rQ r rF )rY r` rc rd r )r^ ra r` rY rb r �
_chain_future} s
re )r
c C s2 t | �r | S |dkr tj� }|j� }t| |� |S )z&Wrap concurrent.futures.Future object.N)r r r, Z
create_futurere )r r
Z
new_futurer r r r � s
) r* �__all__Zconcurrent.futuresrX Zloggingr/ r r r r
r r r r r r9 r: rA �DEBUGZ STACK_DEBUGr r Z _PyFuturerW rZ r\ re r Z_asyncio� ImportErrorZ_CFuturer r r r �<module> s>
P c*
PK [�� � � + __pycache__/coroutines.cpython-36.opt-1.pycnu �[��� 3
\+ � @ s� d ddgZ ddlZddlZddlZddlZddlZddlZddlZddlm Z ddlm
Z
ddlm Z dd lm Z dd
l
mZ ejd Zejj o�eejjd ��ZyejZejZW n ek
r� dZdZY nX y
ej Z W n ek
r� d
d� Z Y nX yddl m Z m!Z" W n e#k
�r* d Z Z"Y nX dd� Z$e$� Z%[$dd� Z&G dd� d�Z'dd � Ze(� Z)dd� Z ej*e'fZ+e dk �r�e+e f7 Z+edk �r�efe+ Z+dd� Z,dd� Z-dS )� coroutine�iscoroutinefunction� iscoroutine� N� )�compat)� constants)�events)� base_futures)�loggerZ
YIELD_FROMZPYTHONASYNCIODEBUGc C s dS )NF� )�funcr r �*/usr/lib64/python3.6/asyncio/coroutines.py�<lambda>/ s r )� Coroutine� Awaitablec C sF G dd� d�} dd� }d}| � }||�}t |� |j|� |j|fkS ) Nc @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S )
z!has_yield_from_bug.<locals>.MyGenc S s
d | _ d S )N)� send_args)�selfr r r
�__init__; s z*has_yield_from_bug.<locals>.MyGen.__init__c S s | S )Nr )r r r r
�__iter__= s z*has_yield_from_bug.<locals>.MyGen.__iter__c S s dS )N�* r )r r r r
�__next__? s z*has_yield_from_bug.<locals>.MyGen.__next__c W s
|| _ d S )N)r )r Zwhatr r r
�sendA s z&has_yield_from_bug.<locals>.MyGen.sendN)�__name__�
__module__� __qualname__r r r r r r r r
�MyGen: s r c s s | E d H d S )Nr )�genr r r
�yield_from_genD s z*has_yield_from_bug.<locals>.yield_from_genr � � )r r r )�nextr r )r r �valuer �coror r r
�has_yield_from_bug9 s
r# c C s
t | d �S )N)� CoroWrapper)r r r r
�
debug_wrapperP s r% c @ s� e Zd Zd%dd�Zdd� Zdd� Zdd � Zer8d
d � Znd d � Zd&d
d�Z dd� Z
e dd� �Z e dd� �Z
e dd� �Zejr�dd� Ze dd� �Ze dd � �Ze d d � �Ze d d � �Ze d!d"� �Zd#d$� ZdS )'r$ Nc C s> || _ || _tjtjd��| _t|dd �| _t|dd �| _ d S )Nr r r )
r r r �
extract_stack�sys� _getframe�_source_traceback�getattrr r )r r r r r r
r [ s
zCoroWrapper.__init__c C s@ t | �}| jr0| jd }|d|d |d f 7 }d| jj|f S )Nr z, created at %s:%sr z<%s %s>���)�_format_coroutiner) � __class__r )r � coro_repr�framer r r
�__repr__c s
zCoroWrapper.__repr__c C s | S )Nr )r r r r
r j s zCoroWrapper.__iter__c C s | j jd �S )N)r r )r r r r
r m s zCoroWrapper.__next__c G s4 t j� }|j}|jj|j tkr(|d }| jj|�S )Nr ) r' r( �f_back�f_code�co_code�f_lasti� _YIELD_FROMr r )r r! r/ Zcallerr r r
r u s
zCoroWrapper.sendc C s | j j|�S )N)r r )r r! r r r
r } s c C s | j j|||�S )N)r �throw)r �typer! � tracebackr r r
r6 � s zCoroWrapper.throwc C s
| j j� S )N)r �close)r r r r
r9 � s zCoroWrapper.closec C s | j jS )N)r �gi_frame)r r r r
r: � s zCoroWrapper.gi_framec C s | j jS )N)r �
gi_running)r r r r
r; � s zCoroWrapper.gi_runningc C s | j jS )N)r �gi_code)r r r r
r< � s zCoroWrapper.gi_codec C s, t | jdd �}|d k r(tdj| j|���| S )N�cr_awaitz;Cannot await on coroutine {!r} while it's awaiting for {!r})r* r � RuntimeError�format)r r= r r r
� __await__� s zCoroWrapper.__await__c C s | j jS )N)r � gi_yieldfrom)r r r r
rA � s zCoroWrapper.gi_yieldfromc C s | j jS )N)r r= )r r r r
r= � s zCoroWrapper.cr_awaitc C s | j jS )N)r �
cr_running)r r r r
rB � s zCoroWrapper.cr_runningc C s | j jS )N)r �cr_code)r r r r
rC � s zCoroWrapper.cr_codec C s | j jS )N)r �cr_frame)r r r r
rD � s zCoroWrapper.cr_framec C s� t | dd �}t |dd �}|d kr,t |dd �}|d k r�|jd
kr�d| }t | df �}|r�djtj|��}|dtj� d �7 }||j� 7 }tj |� d S ) Nr r: rD r z%r was never yielded fromr) � zB
Coroutine object created at (most recent call last, truncated to z last lines):
r+ )
r* r4 �joinr8 � format_listr ZDEBUG_STACK_DEPTH�rstripr
�error)r r r/ �msg�tbr r r
�__del__� s zCoroWrapper.__del__)N)NN)r r r r r0 r r �_YIELD_FROM_BUGr r6 r9 �propertyr: r; r< r ZPY35r@ rA r= rB rC rD rL r r r r
r$ X s(
r$ c sp t ��r �S tj��r �� ntj���fdd��� tsNtdkrD� }qft� �}ntj��� �fdd��}t|_|S )z�Decorator to mark coroutines.
If the coroutine is not yielded from before it is destroyed,
an error message is logged.
c ? sv � | |�}t j|�s(tj|�s(t|t�r4|E d H }n>td k rry
|j}W n tk
rZ Y nX t|t�rr|� E d H }|S )N) r Zisfuture�inspectZ isgenerator�
isinstancer$ �
_AwaitableABCr@ �AttributeError)�args�kw�resZ
await_meth)r r r
r" � s
zcoroutine.<locals>.coroNc s@ t � | |��d�}|jr |jd= t�dd �|_t�dd �|_|S )N)r r r r r+ )r$ r) r* r r )rS �kwds�w)r" r r r
�wrapper� s zcoroutine.<locals>.wrapper)� _inspect_iscoroutinefunctionrO �isgeneratorfunction� functools�wraps�_DEBUG�_types_coroutine�
_is_coroutine)r rX r )r" r r
r � s
c C s t | dd�tkpt| �S )z6Return True if func is a decorated coroutine function.r_ N)r* r_ rY )r r r r
r � s c C s
t | t�S )z)Return True if obj is a coroutine object.)rP �_COROUTINE_TYPES)�objr r r
r s c
C s t | d� r�t | d� r�t| dt| dt| �j��}dj|�}d}y
| j}W n4 tk
r~ y
| j}W n tk
rx Y nX Y nX |r�dj|�S |S d }t| t �r�| j
}| j }|d k r�dj|�}n| }|d kr�t j
|f i �}d }t | d�r�| jr�| j}nt | d��r| j�r| j}d }t | d��r0| j�r0| j}nt | d ��rJ| j�rJ| j}d
}|�rb|j�rb|j}d }|}t| t ��r�tj| j
� �r�| j
d k �r�t j| j
�} | d k �r�| \}}|d k�r�d |||f }nd
|||f }n:|d k �r�|j}d|||f }n|�r|j}d |||f }|S )NrC r< r r z{}()Fz
{} runningrD r: z<empty co_filename>r z%s done, defined at %s:%sz %s running, defined at %s:%sz%s running at %s:%s)�hasattrr* r7 r r? rB rR r; rP r$ r r r Z_format_callbackrC r< rD r: � co_filenamerO rZ Z_get_function_source�f_lineno�co_firstlineno)
r" Z coro_nameZrunningr Z coro_codeZ
coro_frame�filename�linenor. �sourcer r r
r, sx
r, ).�__all__r[ rO Zopcode�osr' r8 �typesrE r r r r �logr
Zopmapr5 �flags�ignore_environment�bool�environ�getr] r r^ �
CoroutineTypeZ_types_CoroutineTyperR r rY �collections.abcr Z
_CoroutineABCr rQ � ImportErrorr# rM r% r$ �objectr_ �
GeneratorTyper` r r, r r r r
�<module> sZ
j:
PK [5 �h�@ �@ 0 __pycache__/proactor_events.cpython-36.opt-1.pycnu �[��� 3
\�O � @ s� d Z dgZddlZddlZddlmZ ddlmZ ddlmZ ddlmZ dd lm Z dd
lm
Z
dd l m Z G d d
� d
e
j
e
j�ZG dd� dee
j�ZG dd� dee
j�ZG dd� de�ZG dd� deee
j�ZG dd� deee
j�ZG dd� dej�ZdS )z�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.
�BaseProactorEventLoop� N� )� base_events)�compat)� constants)�futures)�sslproto)�
transports)�loggerc s� e Zd ZdZd � fdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
e j rXdd� Z
d dd�Zdd� Zdd� Zdd� Z� ZS ) �_ProactorBasePipeTransportz*Base class for pipe and socket transports.Nc s� t � j||� | j|� || _|| _|| _d | _d | _d | _d| _ d| _
d| _ d| _ | jd k rh| jj
� | jj| jj| � |d k r�| jjtj|d � d S )Nr F)�super�__init__�
_set_extra�_sock� _protocol�_server�_buffer� _read_fut�
_write_fut�_pending_write�
_conn_lost�_closing� _eof_writtenZ_attach�_loop� call_soonZconnection_mader Z _set_result_unless_cancelled)�self�loop�sock�protocol�waiter�extra�server)� __class__� �//usr/lib64/python3.6/asyncio/proactor_events.pyr
s$
z#_ProactorBasePipeTransport.__init__c C s� | j jg}| jd kr |jd� n| jr0|jd� | jd k rN|jd| jj� � | jd k rh|jd| j � | jd k r�|jd| j � | jr�t | j�}|jd| � | j
r�|jd� dd j |� S )
N�closed�closingzfd=%szread=%szwrite=%rzwrite_bufsize=%sz EOF writtenz<%s>� ) r" �__name__r �appendr �filenor r r �lenr �join)r �info�bufsizer# r# r$ �__repr__/ s"
z#_ProactorBasePipeTransport.__repr__c C s || j d< d S )N�pipe)�_extra)r r r# r# r$ r B s z%_ProactorBasePipeTransport._set_extrac C s
|| _ d S )N)r )r r r# r# r$ � set_protocolE s z'_ProactorBasePipeTransport.set_protocolc C s | j S )N)r )r r# r# r$ � get_protocolH s z'_ProactorBasePipeTransport.get_protocolc C s | j S )N)r )r r# r# r$ �
is_closingK s z%_ProactorBasePipeTransport.is_closingc C s^ | j r
d S d| _ | jd7 _| j r@| jd kr@| jj| jd � | jd k rZ| jj� d | _d S )NTr ) r r r r r r �_call_connection_lostr �cancel)r r# r# r$ �closeN s
z _ProactorBasePipeTransport.closec C s* | j d k r&tjd| t| d� | j� d S )Nzunclosed transport %r)�source)r �warnings�warn�ResourceWarningr7 )r r# r# r$ �__del__] s
z"_ProactorBasePipeTransport.__del__� Fatal error on pipe transportc C sP t |tj�r*| jj� rBtjd| |dd� n| jj||| | jd�� | j |� d S )Nz%r: %sT)�exc_info)�message� exceptionZ transportr )
�
isinstancer Z_FATAL_ERROR_IGNOREr � get_debugr
�debug�call_exception_handlerr � _force_close)r �excr? r# r# r$ � _fatal_errorc s
z'_ProactorBasePipeTransport._fatal_errorc C sj | j r
d S d| _ | jd7 _| jr4| jj� d | _| jrJ| jj� d | _d| _d | _| jj| j |� d S )NTr r )
r r r r6 r r r r r r5 )r rF r# r# r$ rE p s
z'_ProactorBasePipeTransport._force_closec C s^ z| j j|� W d t| jd�r,| jjtj� | jj� d | _| j}|d k rX|j � d | _X d S )N�shutdown)
r Zconnection_lost�hasattrr rH �socketZ SHUT_RDWRr7 r Z_detach)r rF r! r# r# r$ r5 s
z0_ProactorBasePipeTransport._call_connection_lostc C s" | j }| jd k r |t| j�7 }|S )N)r r r+ )r �sizer# r# r$ �get_write_buffer_size� s
z0_ProactorBasePipeTransport.get_write_buffer_size)NNN)r= )r( �
__module__� __qualname__�__doc__r
r/ r r2 r3 r4 r7 r ZPY34r< rG rE r5 rL �
__classcell__r# r# )r" r$ r s
r c s< e Zd ZdZd � fdd� Zdd� Zdd� Zd d d
�Z� ZS )
�_ProactorReadPipeTransportzTransport for read pipes.Nc s4 t � j||||||� d| _d| _| jj| j� d S )NF)r r
�_paused�_reschedule_on_resumer r �
_loop_reading)r r r r r r r! )r" r# r$ r
� s z#_ProactorReadPipeTransport.__init__c C s0 | j s | jrd S d| _| jj� r,tjd| � d S )NTz%r pauses reading)r rR r rB r
rC )r r# r# r$ �
pause_reading� s
z(_ProactorReadPipeTransport.pause_readingc C sP | j s| j rd S d| _| jr6| jj| j| j� d| _| jj� rLtj d| � d S )NFz%r resumes reading)
r rR rS r r rT r rB r
rC )r r# r# r$ �resume_reading� s
z)_ProactorReadPipeTransport.resume_readingc C s� | j rd| _d S d }�z"yH|d k r0d | _|j� }| jr>d }d S |dkrJd S | jjj| jd�| _W n� t k
r� } z2| js�| j
|d� n| jj � r�t j
ddd� W Y d d }~X n� tk
r� } z| j|� W Y d d }~X n^ tk
�r } z| j
|d� W Y d d }~X n0 tjk
�r& | j�s"� Y nX | jj| j� W d |�rN| jj|� n:|d k �r�| jj � �rpt j
d| � | jj� }|�s�| j� X d S )NT� i z"Fatal read error on pipe transportz*Read error on pipe transport while closing)r> z%r received EOF)rR rS r �resultr r � _proactor�recvr �ConnectionAbortedErrorrG rB r
rC �ConnectionResetErrorrE �OSErrorr �CancelledError�add_done_callbackrT r Z
data_receivedZ eof_receivedr7 )r �fut�datarF Z keep_openr# r# r$ rT � sH
z(_ProactorReadPipeTransport._loop_reading)NNN)N) r( rM rN rO r
rU rV rT rP r# r# )r" r$ rQ � s
rQ c @ s: e Zd ZdZdd� Zd
dd�Zdd� Zd d
� Zd d � ZdS )� _ProactorBaseWritePipeTransportzTransport for write pipes.c C s� t |tttf�s&dt|�j }t|��| jr4td��|s<d S | j rj| j t
j krXt j
d� | j d7 _ d S | jd kr�| jt|�d� n.| js�t|�| _| j� n| jj|� | j� d S )Nz3data argument must be a bytes-like object, not '%s'zwrite_eof() already calledz socket.send() raised exception.r )ra )rA �bytes� bytearray�
memoryview�typer( � TypeErrorr � RuntimeErrorr r Z!LOG_THRESHOLD_FOR_CONNLOST_WRITESr
�warningr �
_loop_writingr �_maybe_pause_protocol�extend)r ra �msgr# r# r$ �write� s(
z%_ProactorBaseWritePipeTransport.writeNc C s y�d | _ d| _|r|j� |d kr.| j}d | _|sf| jrH| jj| jd � | jr\| j j
t j � | j
� nN| jjj| j |�| _ | j j� s�t|�| _| j j| j� | j� n| j j| j� W nZ tk
r� } z| j|� W Y d d }~X n0 tk
�r } z| j|d� W Y d d }~X nX d S )Nr z#Fatal write error on pipe transport)r r rX r r r r r5 r r rH rJ �SHUT_WRZ_maybe_resume_protocolrY �send�doner+ r_ rj rk r\ rE r] rG )r �fra rF r# r# r$ rj
s0
z-_ProactorBaseWritePipeTransport._loop_writingc C s dS )NTr# )r r# r# r$ �
can_write_eof0 s z-_ProactorBaseWritePipeTransport.can_write_eofc C s | j � d S )N)r7 )r r# r# r$ � write_eof3 s z)_ProactorBaseWritePipeTransport.write_eofc C s | j d � d S )N)rE )r r# r# r$ �abort6 s z%_ProactorBaseWritePipeTransport.abort)NN) r( rM rN rO rn rj rs rt ru r# r# r# r$ rb � s $
#rb c s$ e Zd Z� fdd�Zdd� Z� ZS )�_ProactorWritePipeTransportc s4 t � j||� | jjj| jd�| _| jj| j� d S )N� ) r r
r rY rZ r r r_ � _pipe_closed)r �args�kw)r" r# r$ r
; s z$_ProactorWritePipeTransport.__init__c C s@ |j � r d S | jrd S d | _| jd k r4| jt� � n| j� d S )N)Z cancelledr r r rE �BrokenPipeErrorr7 )r r` r# r# r$ rx @ s
z(_ProactorWritePipeTransport._pipe_closed)r( rM rN r
rx rP r# r# )r" r$ rv : s rv c @ s e Zd ZdZdd� Zdd� ZdS )� _ProactorDuplexPipeTransportzTransport for duplex pipes.c C s dS )NFr# )r r# r# r$ rs U s z*_ProactorDuplexPipeTransport.can_write_eofc C s t �d S )N)�NotImplementedError)r r# r# r$ rt X s z&_ProactorDuplexPipeTransport.write_eofN)r( rM rN rO rs rt r# r# r# r$ r| P s r| c s: e Zd ZdZd � fdd� Zdd� Zdd� Zd d
� Z� ZS ) �_ProactorSocketTransportz Transport for connected sockets.Nc s$ t � j||||||� tj|� d S )N)r r
r Z _set_nodelay)r r r r r r r! )r" r# r$ r
a s z!_ProactorSocketTransport.__init__c C s� || j d< y|j� | j d< W n4 tjtfk
rP | jj� rLtjd|dd� Y nX d| j kr�y|j � | j d< W n4 tjtfk
r� | jj� r�tjd|dd� Y nX d S )NrJ Zsocknamezgetsockname() failed on %rT)r> �peernamezgetpeername() failed on %r)
r1 Z getsocknamerJ �error�AttributeErrorr rB r
ri Z getpeername)r r r# r# r$ r f s
z#_ProactorSocketTransport._set_extrac C s dS )NTr# )r r# r# r$ rs v s z&_ProactorSocketTransport.can_write_eofc C s2 | j s | jrd S d| _| jd kr.| jjtj� d S )NT)r r r r rH rJ ro )r r# r# r$ rt y s
z"_ProactorSocketTransport.write_eof)NNN) r( rM rN rO r
r rs rt rP r# r# )r" r$ r~ \ s r~ c s� e Zd Z� fdd�Zd-dd�Zd.ddddd�dd �Zd/d
d �Zd0d d
�Zd1dd�Z� fdd�Z dd� Z
dd� Z dd� Z dd� Z
dd� Zd d � Zd d � Zd2d d!�Zd"d#� Zd3d%d&�Zd'd(� Zd)d*� Zd+d,� Z� ZS )4r c sH t � j� tjd|jj� || _|| _d | _i | _ |j
| � | j � d S )NzUsing proactor: %s) r r
r
rC r" r( rY � _selector�_self_reading_future�_accept_futuresZset_loop�_make_self_pipe)r Zproactor)r" r# r$ r
� s
z BaseProactorEventLoop.__init__Nc C s t | |||||�S )N)r~ )r r r r r r! r# r# r$ �_make_socket_transport� s
z,BaseProactorEventLoop._make_socket_transportF)� server_side�server_hostnamer r! c
C s< t j� std��t j| |||||�} t| || ||d� | jS )NzOProactor event loop requires Python 3.5 or newer (ssl.MemoryBIO) to support SSL)r r! )r Z_is_sslproto_availabler} Z SSLProtocolr~ Z_app_transport)
r Zrawsockr �
sslcontextr r� r� r r! Z ssl_protocolr# r# r$ �_make_ssl_transport� s
z)BaseProactorEventLoop._make_ssl_transportc C s t | ||||�S )N)r| )r r r r r r# r# r$ �_make_duplex_pipe_transport� s z1BaseProactorEventLoop._make_duplex_pipe_transportc C s t | ||||�S )N)rQ )r r r r r r# r# r$ �_make_read_pipe_transport� s z/BaseProactorEventLoop._make_read_pipe_transportc C s t | ||||�S )N)rv )r r r r r r# r# r$ �_make_write_pipe_transport� s z0BaseProactorEventLoop._make_write_pipe_transportc sP | j � rtd��| j� r d S | j� | j� | jj� d | _d | _t� j� d S )Nz!Cannot close a running event loop) Z
is_runningrh � is_closed�_stop_accept_futures�_close_self_piperY r7 r� r )r )r" r# r$ r7 � s
zBaseProactorEventLoop.closec C s | j j||�S )N)rY rZ )r r �nr# r# r$ � sock_recv� s z BaseProactorEventLoop.sock_recvc C s | j j||�S )N)rY rp )r r ra r# r# r$ � sock_sendall� s z"BaseProactorEventLoop.sock_sendallc C s | j j||�S )N)rY Zconnect)r r Zaddressr# r# r$ � sock_connect� s z"BaseProactorEventLoop.sock_connectc C s | j j|�S )N)rY �accept)r r r# r# r$ � sock_accept� s z!BaseProactorEventLoop.sock_acceptc C s t �d S )N)r} )r r# r# r$ � _socketpair� s z!BaseProactorEventLoop._socketpairc C sL | j d k r| j j� d | _ | jj� d | _| jj� d | _| jd8 _d S )Nr )r� r6 �_ssockr7 �_csock�
_internal_fds)r r# r# r$ r� � s
z&BaseProactorEventLoop._close_self_pipec C sF | j � \| _| _| jjd� | jjd� | jd7 _| j| j� d S )NFr )r� r� r� Z setblockingr� r �_loop_self_reading)r r# r# r$ r� � s
z%BaseProactorEventLoop._make_self_pipec C s� y$|d k r|j � | jj| jd�}W nH tjk
r: d S tk
rl } z| jd|| d�� W Y d d }~X nX || _|j | j
� d S )Ni z.Error on reading from the event loop self pipe)r? r@ r ) rX rY rZ r� r r^ � ExceptionrD r� r_ r� )r rr rF r# r# r$ r� � s z(BaseProactorEventLoop._loop_self_readingc C s | j jd� d S )N� )r� rp )r r# r# r$ �_write_to_self� s z$BaseProactorEventLoop._write_to_self�d c s& d� �����fdd� � �j � � d S )Nc s" y�| d k rl| j � \}}�jr,tjd�||� �� }�d k rV�j||�dd|i�d� n�j||d|i�d� �j� rxd S �jj��} W n~ t k
r� } zD�j
� d kr��j d|�d�� �j � n�jr�tjd �dd
� W Y d d }~X n8 t
jk
�r �j � Y nX | �j�j
� < | j� � d S ) Nz#%r got a new connection from %r: %rTr )r� r r! )r r! r zAccept failed on a socket)r? r@ rJ zAccept failed on socket %r)r> ���)rX Z_debugr
rC r� r� r� rY r� r] r* rD r7 r r^ r� r_ )rr ZconnZaddrr rF )r �protocol_factoryr r! r r� r# r$ r � s>
z2BaseProactorEventLoop._start_serving.<locals>.loop)N)r )r r� r r� r! Zbacklogr# )r r� r r! r r� r$ �_start_serving� s $z$BaseProactorEventLoop._start_servingc C s d S )Nr# )r Z
event_listr# r# r$ �_process_events s z%BaseProactorEventLoop._process_eventsc C s* x| j j� D ] }|j� q W | j j� d S )N)r� �valuesr6 �clear)r Zfuturer# r# r$ r� $ s z*BaseProactorEventLoop._stop_accept_futuresc C s | j � | jj|� |j� d S )N)r� rY �
_stop_servingr7 )r r r# r# r$ r� ) s z#BaseProactorEventLoop._stop_serving)NNN)N)NN)NN)NN)N)NNr� )r( rM rN r
r� r� r� r� r� r7 r� r� r� r� r� r� r� r� r� r� r� r� r� rP r# r# )r" r$ r � s4
()rO �__all__rJ r9 � r r r r r r �logr
Z_FlowControlMixinZ
BaseTransportr Z
ReadTransportrQ ZWriteTransportrb rv Z Transportr| r~ Z
BaseEventLoopr r# r# r# r$ �<module> s2 M T
#PK [ ��� � $ __pycache__/log.cpython-36.opt-2.pycnu �[��� 3
\| � @ s d dl Z e je�ZdS )� N)ZloggingZ getLogger� __package__Zlogger� r r �#/usr/lib64/python3.6/asyncio/log.py�<module> s PK [�%�O�S �S / __pycache__/windows_events.cpython-36.opt-1.pycnu �[��� 3
\�l � @ s� d Z ddlZddlZddlZddlZddlZddlZddlmZ ddlm Z ddlm
Z
ddlm Z ddlm Z dd lm
Z
dd
lmZ dd lmZ dd lmZ dd
lmZ ddddgZdZdZdZdZdZdZG dd� de
j�Z G dd� de
j�Z G dd � d e �Z G d d � d e �Z G d d � d e �Z!G d!d"� d"e j"�Z#G d#d� de j$�Z%G d$d� d�Z&G d%d&� d&e j'�Z(e#Z)G d'd(� d(ej*�Z+e+Z,dS ))z.Selector and proactor event loops for Windows.� N� )�events)�base_subprocess)�futures)�proactor_events)�selector_events)�tasks)�
windows_utils)� _overlapped)� coroutine)�logger�SelectorEventLoop�ProactorEventLoop� IocpProactor�DefaultEventLoopPolicyl �� i� i� g����MbP?g�������?c s^ e Zd ZdZdd�� fdd�
Z� fdd�Zdd � Z� fd
d �Z� fd d
�Z� fdd�Z � Z
S )�_OverlappedFuturez�Subclass of Future which represents an overlapped operation.
Cancelling it will immediately cancel the overlapped operation.
N)�loopc s& t � j|d� | jr | jd= || _d S )N)r r ���)�super�__init__�_source_traceback�_ov)�self�ovr )� __class__� �./usr/lib64/python3.6/asyncio/windows_events.pyr - s z_OverlappedFuture.__init__c s@ t � j� }| jd k r<| jjr dnd}|jdd|| jjf � |S )N�pendingZ completedr zoverlapped=<%s, %#x>)r �
_repr_infor r �insert�address)r �info�state)r r r r 3 s
z _OverlappedFuture._repr_infoc C sr | j d krd S y| j j� W nJ tk
rf } z.d|| d�}| jrJ| j|d< | jj|� W Y d d }~X nX d | _ d S )Nz&Cancelling an overlapped future failed)�message� exception�future�source_traceback)r �cancel�OSErrorr �_loop�call_exception_handler)r �exc�contextr r r �_cancel_overlapped: s
z$_OverlappedFuture._cancel_overlappedc s | j � t� j� S )N)r- r r' )r )r r r r' J s z_OverlappedFuture.cancelc s t � j|� | j� d S )N)r �
set_exceptionr- )r r$ )r r r r. N s z _OverlappedFuture.set_exceptionc s t � j|� d | _d S )N)r �
set_resultr )r �result)r r r r/ R s z _OverlappedFuture.set_result) �__name__�
__module__� __qualname__�__doc__r r r- r' r. r/ �
__classcell__r r )r r r ' s r c sn e Zd ZdZdd�� fdd�
Zdd� Z� fdd �Zd
d � Zd d
� Z� fdd�Z � fdd�Z
� fdd�Z � Z S )�_BaseWaitHandleFuturez2Subclass of Future which represents a wait handle.N)r c s8 t � j|d� | jr | jd= || _|| _|| _d| _d S )N)r r Tr )r r r r �_handle� _wait_handle� _registered)r r �handle� wait_handler )r r r r Z s z _BaseWaitHandleFuture.__init__c C s t j| jd�t jkS )Nr )�_winapiZWaitForSingleObjectr7 Z
WAIT_OBJECT_0)r r r r �_pollh s z_BaseWaitHandleFuture._pollc s\ t � j� }|jd| j � | jd k r>| j� r0dnd}|j|� | jd k rX|jd| j � |S )Nz
handle=%#xZsignaledZwaitingzwait_handle=%#x)r r �appendr7 r= r8 )r r! r" )r r r r m s
z _BaseWaitHandleFuture._repr_infoc C s
d | _ d S )N)r )r �futr r r �_unregister_wait_cbw s z)_BaseWaitHandleFuture._unregister_wait_cbc C s� | j s
d S d| _ | j}d | _ytj|� W nZ tk
r� } z>|jtjkrtd|| d�}| jrd| j|d< | jj |� d S W Y d d }~X nX | j
d � d S )NFz$Failed to unregister the wait handle)r# r$ r% r& ) r9 r8 r
ZUnregisterWaitr( �winerror�ERROR_IO_PENDINGr r) r* r@ )r r; r+ r, r r r �_unregister_wait| s"
z&_BaseWaitHandleFuture._unregister_waitc s | j � t� j� S )N)rC r r' )r )r r r r' � s z _BaseWaitHandleFuture.cancelc s | j � t� j|� d S )N)rC r r. )r r$ )r r r r. � s z#_BaseWaitHandleFuture.set_exceptionc s | j � t� j|� d S )N)rC r r/ )r r0 )r r r r/ � s z _BaseWaitHandleFuture.set_result)
r1 r2 r3 r4 r r= r r@ rC r' r. r/ r5 r r )r r r6 W s
r6 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.
N)r c s t � j||||d� d | _d S )N)r )r r �_done_callback)r r �eventr; r )r r r r � s z_WaitCancelFuture.__init__c C s t d��d S )Nz'_WaitCancelFuture must not be cancelled)� RuntimeError)r r r r r' � s z_WaitCancelFuture.cancelc s$ t � j|� | jd k r | j| � d S )N)r r/ rE )r r0 )r r r r/ � s
z _WaitCancelFuture.set_resultc s$ t � j|� | jd k r | j| � d S )N)r r. rE )r r$ )r r r r. � s
z _WaitCancelFuture.set_exception) r1 r2 r3 r4 r r' r/ r. r5 r r )r r rD � s
rD c s6 e Zd Zdd�� fdd�
Z� fdd�Zdd� Z� ZS ) �_WaitHandleFutureN)r c s< t � j||||d� || _d| _tjd ddd �| _d | _d S )N)r TF)r r � _proactorZ_unregister_proactorr
Z CreateEvent�_event�
_event_fut)r r r: r; �proactorr )r r r r � s
z_WaitHandleFuture.__init__c sF | j d k r"tj| j � d | _ d | _| jj| j� d | _t� j|� d S )N) rJ r< � CloseHandlerK rI � _unregisterr r r@ )r r? )r r r r@ � s
z%_WaitHandleFuture._unregister_wait_cbc C s� | j s
d S d| _ | j}d | _ytj|| j� W nZ tk
r� } z>|jtjkrxd|| d�}| jrh| j|d< | j j
|� d S W Y d d }~X nX | j j | j| j
�| _d S )NFz$Failed to unregister the wait handle)r# r$ r% r& )r9 r8 r
ZUnregisterWaitExrJ r( rA rB r r) r* rI � _wait_cancelr@ rK )r r; r+ r, r r r rC � s$
z"_WaitHandleFuture._unregister_wait)r1 r2 r3 r r@ rC r5 r r )r r rH � s rH 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, || _ tj� | _d | _d | _| jd�| _d S )NT)�_address�weakref�WeakSet�_free_instances�_pipe�_accept_pipe_future�_server_pipe_handle)r r r r r r � s
zPipeServer.__init__c C s | j | jd� }| _ |S )NF)rU rW )r �tmpr r r �_get_unconnected_pipe� s z PipeServer._get_unconnected_pipec C sr | j � r d S tjtjB }|r&|tjO }tj| j|tjtjB tj B tj
t j t j tj
tj�}t j|�}| jj|� |S )N)�closedr< ZPIPE_ACCESS_DUPLEXZFILE_FLAG_OVERLAPPEDZ FILE_FLAG_FIRST_PIPE_INSTANCEZCreateNamedPiperQ ZPIPE_TYPE_MESSAGEZPIPE_READMODE_MESSAGEZ PIPE_WAITZPIPE_UNLIMITED_INSTANCESr ZBUFSIZEZNMPWAIT_WAIT_FOREVER�NULL�
PipeHandlerT �add)r �first�flags�h�piper r r rW s
z PipeServer._server_pipe_handlec C s
| j d kS )N)rQ )r r r r rZ s zPipeServer.closedc C sV | j d k r| j j� d | _ | jd k rRx| jD ] }|j� q,W d | _d | _| jj� d S )N)rV r' rQ rT �closerU �clear)r ra r r r rb s
zPipeServer.closeN)
r1 r2 r3 r4 r rY rW rZ rb �__del__r r r r rP � s
rP c @ s e Zd ZdZdd� ZdS )�_WindowsSelectorEventLoopz'Windows version of selector event loop.c C s t j� S )N)r �
socketpair)r r r r � _socketpair+ s z%_WindowsSelectorEventLoop._socketpairN)r1 r2 r3 r4 rg r r r r re ( s re c sP e Zd ZdZd
� fdd� Zdd� Zedd� �Zed d
� �Zedd d ��Z � Z
S )r z2Windows version of proactor event loop using IOCP.Nc s |d krt � }t� j|� d S )N)r r r )r rL )r r r r 2 s zProactorEventLoop.__init__c C s t j� S )N)r rf )r r r r rg 7 s z ProactorEventLoop._socketpairc c s8 | j j|�}|E d H }|� }| j||d|id�}||fS )N�addr)�extra)rI � connect_pipe�_make_duplex_pipe_transport)r �protocol_factoryr �fra �protocol�transr r r �create_pipe_connection: s
z(ProactorEventLoop.create_pipe_connectionc s. t � ��d� ����fdd� ��j�� �gS )Nc s d }yj| rL| j � }�jj|� �j� r2|j� d S �� }�j||d� id� �j� }|d kr`d S �jj|�} W n� t k
r� } zH|r�|j
� d kr��j d||d�� |j� n�j r�t
jd|dd� W Y d d }~X n2 tjk
r� |r�|j� Y nX | �_| j�� d S )
Nrh )ri r zPipe accept failed)r# r$ ra z Accept pipe failed on pipe %rT)�exc_infor )r0 rT �discardrZ rb rk rY rI � accept_piper( �filenor* Z_debugr Zwarningr �CancelledErrorrV �add_done_callback)rm ra rn r+ )r �loop_accept_piperl r �serverr r rw G s<
z>ProactorEventLoop.start_serving_pipe.<locals>.loop_accept_pipe)N)rP Z call_soon)r rl r r )r rw rl r rx r �start_serving_pipeC s (
z$ProactorEventLoop.start_serving_pipec k s� | j � }
t| |||||||f|
|d�| ��} y|
E d H W n& tk
r` } z
| }
W Y d d } ~ X nX d }
|
d k r�| j� | j� E d H |
�| S )N)�waiterri )�
create_future�_WindowsSubprocessTransport� Exceptionrb Z_wait)r rn �args�shell�stdin�stdout�stderr�bufsizeri �kwargsrz Ztranspr+ �errr r r �_make_subprocess_transportr s
z,ProactorEventLoop._make_subprocess_transport)N)N) r1 r2 r3 r4 r rg r rp ry r� r5 r r )r r r / s /c @ s� e Zd ZdZd1dd�Zdd� Zdd� Zd2d
d �Zd d
� Zd3dd�Z d4dd�Z
dd� Z dd� Z dd� Z
edd� �Zd5dd �Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd6d)d*�Zd+d,� Zd-d.� Zd/d0� Zd S )7r z#Proactor implementation using IOCP.� �� c C sD d | _ g | _tjtjtd|�| _i | _tj � | _
g | _ tj � | _ d S )Nr )
r) �_resultsr
�CreateIoCompletionPort�INVALID_HANDLE_VALUEr[ �_iocp�_cacherR rS r9 �
_unregistered�_stopped_serving)r Z concurrencyr r r r � s
zIocpProactor.__init__c C s d| j jt| j�t| j�f S )Nz <%s overlapped#=%s result#=%s>)r r1 �lenr� r� )r r r r �__repr__� s zIocpProactor.__repr__c C s
|| _ d S )N)r) )r r r r r �set_loop� s zIocpProactor.set_loopNc C s | j s| j|� | j }g | _ |S )N)r� r= )r �timeoutrX r r r �select� s
zIocpProactor.selectc C s | j j� }|j|� |S )N)r) r{ r/ )r �valuer? r r r �_result� s
zIocpProactor._resultr c C sz | j |� tjt�}y4t|tj�r6|j|j� ||� n|j|j� |� W n t k
rb | j
d�S X dd� }| j |||�S )N� c S sJ y|j � S tk
rD } z |jtjkr2t|j� �n� W Y d d }~X nX d S )N)� getresultr( rA r
�ERROR_NETNAME_DELETED�ConnectionResetErrorr~ )ro �keyr r+ r r r � finish_recv� s z&IocpProactor.recv.<locals>.finish_recv) �_register_with_iocpr
�
Overlappedr[ �
isinstance�socketZWSARecvrt ZReadFile�BrokenPipeErrorr� � _register)r �conn�nbytesr_ r r� r r r �recv� s
zIocpProactor.recvc C sZ | j |� tjt�}t|tj�r4|j|j� ||� n|j|j� |� dd� }| j |||�S )Nc S sJ y|j � S tk
rD } z |jtjkr2t|j� �n� W Y d d }~X nX d S )N)r� r( rA r
r� r� r~ )ro r� r r+ r r r � finish_send� s z&IocpProactor.send.<locals>.finish_send)
r� r
r� r[ r� r� ZWSASendrt Z WriteFiler� )r r� �bufr_ r r� r r r �send� s
zIocpProactor.sendc sz | j �� | j�j�� tjt�}|j�j� � j� � � �fdd�}tdd� �}| j |�|�}||� �}t
j || j d� |S )Nc sD |j � tjd�j� �}� jtjtj|� � j �j
� � � � j � fS )Nz@P) r� �structZpackrt �
setsockoptr� �
SOL_SOCKETr
ZSO_UPDATE_ACCEPT_CONTEXT�
settimeoutZ
gettimeoutZ getpeername)ro r� r r� )r� �listenerr r �
finish_accept� s
z*IocpProactor.accept.<locals>.finish_acceptc s s4 y| E d H W n t jk
r. |j� � Y nX d S )N)r ru rb )r% r� r r r � accept_coro� s
z(IocpProactor.accept.<locals>.accept_coro)r )
r� �_get_accept_socket�familyr
r� r[ ZAcceptExrt r r� r Z
ensure_futurer) )r r� r r� r� r% �coror )r� r� r �accept� s
zIocpProactor.acceptc s� | j � � ytj� j� � j� W nB tk
rb } z&|jtjkr@� � j � d dkrR� W Y d d }~X nX tj
t �}|j � j� |� � fdd�}| j
|� |�S )Nr r c s |j � � jtjtjd� � S )Nr )r� r� r� r� r
ZSO_UPDATE_CONNECT_CONTEXT)ro r� r )r� r r �finish_connect s
z,IocpProactor.connect.<locals>.finish_connect)r� r
Z BindLocalrt r� r( rA �errnoZ WSAEINVALZ getsocknamer� r[ Z ConnectExr� )r r� r �er r� r )r� r �connect� s
zIocpProactor.connectc sJ | j � � tjt�}|j� j� �}|r0| j� �S � fdd�}| j|� |�S )Nc s |j � � S )N)r� )ro r� r )ra r r �finish_accept_pipe s z4IocpProactor.accept_pipe.<locals>.finish_accept_pipe)r� r
r� r[ ZConnectNamedPipert r� r� )r ra r Z connectedr� r )ra r rs
s
zIocpProactor.accept_pipec c sz t }xjytj|�}P W n0 tk
rF } z|jtjkr6� W Y d d }~X nX t|d t�}tj || j
d�E d H qW t j |�S )N� )r )
�CONNECT_PIPE_INIT_DELAYr
Z ConnectPiper( rA ZERROR_PIPE_BUSY�min�CONNECT_PIPE_MAX_DELAYr Zsleepr) r r\ )r r Zdelayr: r+ r r r rj s
zIocpProactor.connect_pipec C s | j ||d�S )z�Wait 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 r: r� r r r �wait_for_handle/ s z IocpProactor.wait_for_handlec C s | j |d d�}||_|S )NT)r� rE )r rF Z
done_callbackr? r r r rO 7 s zIocpProactor._wait_cancelc s� |d krt j}ntj|d �}tjt�}tj|| j|j |�}|rTt
|||| j d�� nt |||| | j d�� � j
rv� j
d= � fdd�}� |d|f| j|j < � S )Ng @�@)r r c s � j � S )N)r= )ro r� r )rm r r �finish_wait_for_handleR s z=IocpProactor._wait_for_handle.<locals>.finish_wait_for_handler r )r< �INFINITE�math�ceilr
r� r[ ZRegisterWaitWithQueuer� r rD r) rH r r� )r r: r� Z
_is_cancel�msr r; r� r )rm r r� > s
z IocpProactor._wait_for_handlec C s0 || j kr,| j j|� tj|j� | jdd� d S )Nr )r9 r] r
r� rt r� )r �objr r r r� ^ s
z IocpProactor._register_with_iocpc C s� t || jd�}|jr |jd= |jsjy|d d |�}W n, tk
r^ } z|j|� W Y d d }~X n X |j|� ||||f| j|j< |S )N)r r r ) r r) r r r( r. r/ r� r )r r r� �callbackrm r� r� r r r r� h s
zIocpProactor._registerc C s | j 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> )r r r r r rN � s zIocpProactor._unregisterc C s t j |�}|jd� |S )Nr )r� r� )r r� �sr r r r� � s
z IocpProactor._get_accept_socketc C s� |d krt }n0|dk r td��n tj|d �}|t kr>td���xtj| j|�}|d krZP d}|\}}}}y| jj|�\}} }
} W nV t k
r� | j
j � r�| j
j dd||||f d�� |dtj
fkr�tj|� wBY nX |
| jkr�|j� qB|j� sBy| ||| �} W n: tk
�r@ }
z |j|
� | jj|� W Y d d }
~
X qBX |j| � | jj|� qBW x | jD ]} | jj| jd � �qdW | jj� d S )Nr znegative timeoutg @�@ztimeout too bigz8GetQueuedCompletionStatus() returned an unexpected eventz)err=%s transferred=%s key=%#x address=%#x)r# �status)r� �
ValueErrorr� r� r
ZGetQueuedCompletionStatusr� r� �pop�KeyErrorr) Z get_debugr* r� r< rM r� r' �doner( r. r� r> r/ r� r rc )r r� r� r� r� Z transferredr� r rm r r� r� r� r� r r r r= � sJ
zIocpProactor._pollc C s | j j|� d S )N)r� r] )r r� r r r �
_stop_serving� s zIocpProactor._stop_servingc C s� x�t | jj� �D ]�\}\}}}}|j� r*qt|t�r6qy |j� W q tk
r� } z8| jd k r�d||d�}|j rz|j |d< | jj
|� W Y d d }~X qX qW x | jr�| j d�s�t j
d� q�W g | _| jd k r�tj| j� d | _d S )NzCancelling a future failed)r# r$ r% r& r z"taking long time to close proactor)�listr� �itemsZ cancelledr� rD r' r( r) r r* r= r �debugr� r� r< rM )r r r? r r� r� r+ r, r r r rb � s,
"
zIocpProactor.closec C s | j � d S )N)rb )r r r r rd � s zIocpProactor.__del__)r� )N)r )r )N)N)r1 r2 r3 r4 r r� r� r� r� r� r� r� r� rs r rj r� rO r� r� r� rN r� r= r� rb rd r r r r r � s.
7 c @ s e Zd Zdd� ZdS )r| c
sP t j|f|||||d�|��� _� fdd�}� jjjt� jj��} | j|� d S )N)r r� r� r� r� c s � j j� }� j|� d S )N)�_procZpollZ_process_exited)rm �
returncode)r r r r� � s
z4_WindowsSubprocessTransport._start.<locals>.callback) r �Popenr� r) rI r� �intr7 rv )
r r~ r r� r� r� r� r� r� rm r )r r �_start� s z"_WindowsSubprocessTransport._startN)r1 r2 r3 r� r r r r r| � s r| c @ s e Zd ZeZdS )� _WindowsDefaultEventLoopPolicyN)r1 r2 r3 r
Z
_loop_factoryr r r r r� s r� )-r4 r< r� r� r� r� rR � r r r r r r r r
Z
coroutinesr �logr �__all__r[ r� ZERROR_CONNECTION_REFUSEDZERROR_CONNECTION_ABORTEDr� r� ZFuturer r6 rD rH �objectrP ZBaseSelectorEventLoopre ZBaseProactorEventLoopr r ZBaseSubprocessTransportr| r
ZBaseDefaultEventLoopPolicyr� r r r r r �<module> sL 0J4;] kPK [�gғg �g , __pycache__/unix_events.cpython-36.opt-2.pycnu �[��� 3
\�� �
@ s d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlZddl m
Z
ddl m Z ddl m Z ddl m
Z
ddl mZ ddl mZ dd l mZ dd
l mZ dd l mZ dd l mZ dd
lmZ ddlmZ dddddgZejdkr�ed��dd� Zy
ejZ W n e k
�r( dd� Z Y nX G dd� dej �Z e ed ��rRd d � Z!nd dl"Z"d d � Z!G d d!� d!ej#�Z$G d"d#� d#ej%ej&�Z'e ed$��r�ej(Z)nd dl"Z"d%d&� Z)G d'd(� d(e j*�Z+G d)d� d�Z,G d*d+� d+e,�Z-G d,d� de-�Z.G d-d� de-�Z/G d.d/� d/ej0�Z1e Z2e1Z3dS )0� N� )� base_events)�base_subprocess)�compat)� constants)�
coroutines)�events)�futures)�selector_events)� selectors)�
transports)� coroutine)�logger�SelectorEventLoop�AbstractChildWatcher�SafeChildWatcher�FastChildWatcher�DefaultEventLoopPolicyZwin32z+Signals are not really supported on Windowsc C s d S )N� )�signum�framer r �+/usr/lib64/python3.6/asyncio/unix_events.py�_sighandler_noop% s r c C s | S )Nr )�pathr r r �<lambda>. s r c s� e Zd Zd!� fdd� Zdd� Z� fdd�Zdd � Zd
d � Zd d
� Zdd� Z dd� Z
d"dd�Z d#dd�Z e
d$dd��Zdd� Ze
dddd�dd ��Ze
d%dd dd �d d ��Z� ZS )&�_UnixSelectorEventLoopNc s t � j|� i | _d S )N)�super�__init__�_signal_handlers)�self�selector)� __class__r r r 7 s z _UnixSelectorEventLoop.__init__c C s t j� S )N)�socketZ
socketpair)r r r r � _socketpair; s z"_UnixSelectorEventLoop._socketpairc s^ t � j� tj� s2xFt| j�D ]}| j|� q W n(| jrZtjd| �d�t | d� | jj
� d S )NzClosing the loop z@ on interpreter shutdown stage, skipping signal handlers removal)�source) r �close�sys�
is_finalizing�listr �remove_signal_handler�warnings�warn�ResourceWarning�clear)r �sig)r! r r r% > s
z _UnixSelectorEventLoop.closec C s" x |D ]}|sq| j |� qW d S )N)�_handle_signal)r �datar r r r �_process_self_dataL s
z)_UnixSelectorEventLoop._process_self_datac + G sH t j|�st j|�r td��| j|� | j� ytj| jj � � W n2 t
t fk
rt } zt t
|���W Y d d }~X nX tj||| �}|| j|< y tj|t� tj|d� W n� t k
�rB } zz| j|= | j�sytjd� W n4 t
t fk
�r } ztjd|� W Y d d }~X nX |jtjk�r0t dj|���n� W Y d d }~X nX d S )Nz3coroutines cannot be used with add_signal_handler()Fr z set_wakeup_fd(-1) failed: %szsig {} cannot be caught���)r Z iscoroutineZiscoroutinefunction� TypeError�
_check_signalZ
_check_closed�signal�
set_wakeup_fdZ_csock�fileno�
ValueError�OSError� RuntimeError�strr ZHandler r � siginterruptr �info�errno�EINVAL�format)r r. �callback�args�exc�handleZnexcr r r �add_signal_handlerS s0
z)_UnixSelectorEventLoop.add_signal_handlerc C s8 | j j|�}|d krd S |jr*| j|� n
| j|� d S )N)r �getZ
_cancelledr) Z_add_callback_signalsafe)r r. rD r r r r/ � s z%_UnixSelectorEventLoop._handle_signalc & C s� | j |� y | j|= W n tk
r* dS X |tjkr>tj}ntj}ytj||� W n@ tk
r� } z$|jtj kr�t
dj |���n� W Y d d }~X nX | js�ytj d� W n2 t
tfk
r� } ztjd|� W Y d d }~X nX dS )NFzsig {} cannot be caughtr z set_wakeup_fd(-1) failed: %sTr2 )r4 r �KeyErrorr5 �SIGINT�default_int_handler�SIG_DFLr9 r> r? r: r@ r6 r8 r r= )r r. ZhandlerrC r r r r) � s(
z,_UnixSelectorEventLoop.remove_signal_handlerc C sH t |t�stdj|���d| ko,tjk n sDtdj|tj���d S )Nz sig must be an int, not {!r}r zsig {} out of range(1, {}))�
isinstance�intr3 r@ r5 �NSIGr8 )r r. r r r r4 � s
z$_UnixSelectorEventLoop._check_signalc C s t | ||||�S )N)�_UnixReadPipeTransport)r �pipe�protocol�waiter�extrar r r �_make_read_pipe_transport� s z0_UnixSelectorEventLoop._make_read_pipe_transportc C s t | ||||�S )N)�_UnixWritePipeTransport)r rO rP rQ rR r r r �_make_write_pipe_transport� s z1_UnixSelectorEventLoop._make_write_pipe_transportc k s� t j� ��}
| j� } t| |||||||f| |d�| ��} |
j| j� | j| � y| E d H W n& tk
r~ }
z
|
}W Y d d }
~
X nX d }|d k r�| j� | j � E d H |�W d Q R X | S )N)rQ rR )
r �get_child_watcherZ
create_future�_UnixSubprocessTransport�add_child_handlerZget_pid�_child_watcher_callback� Exceptionr% Z_wait)r rP rB �shell�stdin�stdout�stderr�bufsizerR �kwargs�watcherrQ �transprC �errr r r �_make_subprocess_transport� s$
z1_UnixSelectorEventLoop._make_subprocess_transportc C s | j |j|� d S )N)Zcall_soon_threadsafeZ_process_exited)r �pid�
returncoderb r r r rY � s z._UnixSelectorEventLoop._child_watcher_callback)�ssl�sock�server_hostnamec c s� |r|d kr&t d��n|d k r&t d��|d k r�|d k r>t d��tjtjtjd�}y |jd� | j||�E d H W q� |j� � Y q�X nB|d kr�t d��|jtjks�tj |j
� r�t dj |���|jd� | j ||||�E d H \}}||fS )Nz/you have to pass server_hostname when using sslz+server_hostname is only meaningful with sslz3path and sock can not be specified at the same timer Fz no path and sock were specifiedz2A UNIX Domain Stream Socket was expected, got {!r})
r8 r" �AF_UNIX� SOCK_STREAM� setblockingZ sock_connectr% �familyr �_is_stream_socket�typer@ Z _create_connection_transport)r �protocol_factoryr rg rh ri � transportrP r r r �create_unix_connection� s8
z-_UnixSelectorEventLoop.create_unix_connection�d )rh �backlogrg c
! C s� t |t�rtd��|d k �r0|d k r,td��t|�}tjtjtj�}|d d
kr�y tj t
j|�j �rnt
j |� W nB t
k
r� Y n0 tk
r� } ztjd||� W Y d d }~X nX y|j|� W nj tk
�r } z8|j� |jtjk�rdj|�}ttj|�d �n� W Y d d }~X n |j� � Y nX n>|d k�rBtd��|jtjk�s`tj|j� �rntdj|���tj| |g�} |j|� |j d � | j |||| � | S ) Nz*ssl argument must be an SSLContext or Nonez3path and sock can not be specified at the same timer � z2Unable to check or remove stale UNIX socket %r: %rz Address {!r} is already in usez-path was not specified, and no sock specifiedz2A UNIX Domain Stream Socket was expected, got {!r}F)r ru ) rK �boolr3 r8 �_fspathr" rj rk �stat�S_ISSOCK�os�st_mode�remove�FileNotFoundErrorr9 r �errorZbindr% r> Z
EADDRINUSEr@ rm r rn ro ZServerZlistenrl Z_start_serving)
r rp r rh rt rg rc rC �msgZserverr r r �create_unix_server sP
z)_UnixSelectorEventLoop.create_unix_server)N)NN)NN)N)N)�__name__�
__module__� __qualname__r r# r% r1 rE r/ r) r4 rS rU r
rd rY rr r� �
__classcell__r r )r! r r 1 s* -
%r � set_blockingc C s t j| d� d S )NF)rz r� )�fdr r r �_set_nonblockingB s r� c C s, t j | t j�}|tjB }t j | t j|� d S )N)�fcntlZF_GETFLrz �
O_NONBLOCKZF_SETFL)r� �flagsr r r r� G s
c s� e Zd Zd Zd � fdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z dd� Z
dd� Z dd� Z e
jrhdd� Zd!dd�Zdd � Zd d � Z� ZS )"rN � i Nc s� t � j|� || jd< || _|| _|j� | _|| _d| _t j
| j�j }t j
|�pbt j|�pbt j|�s~d | _d | _d | _td��t| j� | jj| jj| � | jj| jj| j| j� |d k r�| jjtj|d � d S )NrO Fz)Pipe transport is for pipes/sockets only.)r r �_extra�_loop�_piper7 �_fileno� _protocol�_closingrz �fstatr{ rx �S_ISFIFOry �S_ISCHRr8 r� � call_soon�connection_made� _add_reader� _read_readyr � _set_result_unless_cancelled)r �looprO rP rQ rR �mode)r! r r r Q s,
z _UnixReadPipeTransport.__init__c C s� | j jg}| jd kr |jd� n| jr0|jd� |jd| j � t| jdd �}| jd k r�|d k r�tj || jt
j �}|r�|jd� q�|jd� n | jd k r�|jd� n
|jd� dd j |� S )
N�closed�closingzfd=%s� _selector�polling�idle�openz<%s>� )
r! r� r� �appendr� r� �getattrr� r
�_test_selector_eventr Z
EVENT_READ�join)r r= r r� r r r �__repr__n s$
z _UnixReadPipeTransport.__repr__c C s� yt j| j| j�}W nD ttfk
r, Y n� tk
rX } z| j|d� W Y d d }~X n^X |rl| jj |� nJ| j
j � r�t j
d| � d| _| j
j| j� | j
j| jj� | j
j| jd � d S )Nz"Fatal read error on pipe transportz%r was closed by peerT)rz �readr� �max_size�BlockingIOError�InterruptedErrorr9 � _fatal_errorr� Z
data_receivedr� � get_debugr r= r� �_remove_readerr� Z eof_received�_call_connection_lost)r r0 rC r r r r� � s
z"_UnixReadPipeTransport._read_readyc C s | j j| j� d S )N)r� r� r� )r r r r �
pause_reading� s z$_UnixReadPipeTransport.pause_readingc C s | j j| j| j� d S )N)r� r� r� r� )r r r r �resume_reading� s z%_UnixReadPipeTransport.resume_readingc C s
|| _ d S )N)r� )r rP r r r � set_protocol� s z#_UnixReadPipeTransport.set_protocolc C s | j S )N)r� )r r r r � get_protocol� s z#_UnixReadPipeTransport.get_protocolc C s | j S )N)r� )r r r r �
is_closing� s z!_UnixReadPipeTransport.is_closingc C s | j s| jd � d S )N)r� �_close)r r r r r% � s z _UnixReadPipeTransport.closec C s, | j d k r(tjd| t| d� | j j� d S )Nzunclosed transport %r)r$ )r� r* r+ r, r% )r r r r �__del__� s
z _UnixReadPipeTransport.__del__� Fatal error on pipe transportc C sZ t |t�r4|jtjkr4| jj� rLtjd| |dd� n| jj||| | j d�� | j
|� d S )Nz%r: %sT)�exc_info)�message� exceptionrq rP ) rK r9 r> ZEIOr� r� r �debug�call_exception_handlerr� r� )r rC r� r r r r� � s
z#_UnixReadPipeTransport._fatal_errorc C s( d| _ | jj| j� | jj| j|� d S )NT)r� r� r� r� r� r� )r rC r r r r� � s z _UnixReadPipeTransport._closec C s4 z| j j|� W d | jj� d | _d | _ d | _X d S )N)r� �connection_lostr� r% r� )r rC r r r r� � s
z,_UnixReadPipeTransport._call_connection_losti )NN)r� )r� r� r� r� r r� r� r� r� r� r� r� r% r �PY34r� r� r� r� r� r r )r! r rN M s
rN c s� e Zd Zd%� fdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zejr|dd� Zd d � Zd&d d �Zd'd!d"�Zd#d$� Z� ZS )(rT Nc
s� t � j||� || jd< || _|j� | _|| _t� | _d| _ d| _
t j | j�j
}tj|�}tj|�}tj|�} |px|px| s�d | _d | _d | _td��t| j� | jj| jj| � | s�|r�tjjd� r�| jj| jj| j| j� |d k r�| jjt j |d � d S )NrO r Fz?Pipe transport is only for pipes, sockets and character devices�aix) r r r� r� r7 r� r� � bytearray�_buffer�
_conn_lostr� rz r� r{ rx r� r� ry r8 r� r� r� r� r& �platform�
startswithr� r� r r� )
r r� rO rP rQ rR r� Zis_charZis_fifoZ is_socket)r! r r r � s2
z _UnixWritePipeTransport.__init__c C s� | j jg}| jd kr |jd� n| jr0|jd� |jd| j � t| jdd �}| jd k r�|d k r�tj || jt
j �}|r�|jd� n
|jd� | j � }|jd| � n | jd k r�|jd� n
|jd� d d
j
|� S ) Nr� r� zfd=%sr� r� r� z
bufsize=%sr� z<%s>r� )r! r� r� r� r� r� r� r� r
r� r Z EVENT_WRITE�get_write_buffer_sizer� )r r= r r� r_ r r r r� � s(
z _UnixWritePipeTransport.__repr__c C s
t | j�S )N)�lenr� )r r r r r� s z-_UnixWritePipeTransport.get_write_buffer_sizec C s6 | j j� rtjd| � | jr*| jt� � n| j� d S )Nz%r was closed by peer)r� r� r r= r� r� �BrokenPipeError)r r r r r� s
z#_UnixWritePipeTransport._read_readyc C s t |t�rt|�}|sd S | js&| jrN| jtjkr<tjd� | jd7 _d S | j � s�yt
j | j |�}W nT t
tfk
r� d}Y n: tk
r� } z | jd7 _| j|d� d S d }~X nX |t|�kr�d S |dkr�t|�|d � }| jj| j | j� | j |7 _ | j� d S )Nz=pipe closed by peer or os.write(pipe, data) raised exception.r r z#Fatal write error on pipe transport)rK r� �
memoryviewr� r� r Z!LOG_THRESHOLD_FOR_CONNLOST_WRITESr �warningr� rz �writer� r� r� rZ r� r� r� Z _add_writer� _write_readyZ_maybe_pause_protocol)r r0 �nrC r r r r� s2
z _UnixWritePipeTransport.writec C s� yt j| j| j�}W nj ttfk
r, Y n� tk
r~ } z8| jj� | jd7 _| j j
| j� | j |d� W Y d d }~X nfX |t | j�kr�| jj� | j j
| j� | j
� | jr�| j j| j� | jd � d S |dkr�| jd |�= d S )Nr z#Fatal write error on pipe transportr )rz r� r� r� r� r� rZ r- r� r� �_remove_writerr� r� Z_maybe_resume_protocolr� r� r� )r r� rC r r r r� > s&
z$_UnixWritePipeTransport._write_readyc C s dS )NTr )r r r r �
can_write_eofX s z%_UnixWritePipeTransport.can_write_eofc C s8 | j r
d S d| _ | js4| jj| j� | jj| jd � d S )NT)r� r� r� r� r� r� r� )r r r r � write_eof[ s z!_UnixWritePipeTransport.write_eofc C s
|| _ d S )N)r� )r rP r r r r� d s z$_UnixWritePipeTransport.set_protocolc C s | j S )N)r� )r r r r r� g s z$_UnixWritePipeTransport.get_protocolc C s | j S )N)r� )r r r r r� j s z"_UnixWritePipeTransport.is_closingc C s | j d k r| j r| j� d S )N)r� r� r� )r r r r r% m s z _UnixWritePipeTransport.closec C s, | j d k r(tjd| t| d� | j j� d S )Nzunclosed transport %r)r$ )r� r* r+ r, r% )r r r r r� v s
z _UnixWritePipeTransport.__del__c C s | j d � d S )N)r� )r r r r �abort| s z _UnixWritePipeTransport.abort� Fatal error on pipe transportc C sP t |tj�r*| jj� rBtjd| |dd� n| jj||| | jd�� | j |� d S )Nz%r: %sT)r� )r� r� rq rP )
rK r Z_FATAL_ERROR_IGNOREr� r� r r� r� r� r� )r rC r� r r r r� s
z$_UnixWritePipeTransport._fatal_errorc C sF d| _ | jr| jj| j� | jj� | jj| j� | jj| j|� d S )NT) r� r� r� r� r� r- r� r� r� )r rC r r r r� � s
z _UnixWritePipeTransport._closec C s4 z| j j|� W d | jj� d | _d | _ d | _X d S )N)r� r� r� r% r� )r rC 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 rT � s$ % !
rT �set_inheritablec C sN t tdd�}tj| tj�}|s4tj| tj||B � ntj| tj|| @ � d S )NZ
FD_CLOEXECr )r� r� ZF_GETFDZF_SETFD)r� Z inheritableZ cloexec_flag�oldr r r �_set_inheritable� s
r� c @ s e Zd Zdd� ZdS )rW c K sv d }|t jkr*| jj� \}}t|j� d� t j|f||||d|d�|��| _|d k rr|j� t |j
� d|d�| j_ d S )NF)r[ r\ r] r^ Zuniversal_newlinesr_ �wb)� buffering) �
subprocess�PIPEr� r# r� r7 �Popen�_procr% r� �detachr\ ) r rB r[ r\ r] r^ r_ r` Zstdin_wr r r �_start� s
z _UnixSubprocessTransport._startN)r� r� r� r� r r r r rW � s rW c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
S )r c G s
t � �d S )N)�NotImplementedError)r re rA rB r r r rX � s z&AbstractChildWatcher.add_child_handlerc C s
t � �d S )N)r� )r re r r r �remove_child_handler� s z)AbstractChildWatcher.remove_child_handlerc C s
t � �d S )N)r� )r r� r r r � attach_loop� s z AbstractChildWatcher.attach_loopc C s
t � �d S )N)r� )r r r r r% � s zAbstractChildWatcher.closec C s
t � �d S )N)r� )r r r r � __enter__ s z AbstractChildWatcher.__enter__c C s
t � �d S )N)r� )r �a�b�cr r r �__exit__ s z AbstractChildWatcher.__exit__N) r� r� r� rX r� r� r% r� r� r r r r r � s
c @ sD e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dS )�BaseChildWatcherc C s d | _ i | _d S )N)r� �
_callbacks)r r r r r s zBaseChildWatcher.__init__c C s | j d � d S )N)r� )r r r r r% s zBaseChildWatcher.closec C s
t � �d S )N)r� )r � expected_pidr r r � _do_waitpid s z BaseChildWatcher._do_waitpidc C s
t � �d S )N)r� )r r r r �_do_waitpid_all s z BaseChildWatcher._do_waitpid_allc C sf | j d k r$|d kr$| jr$tjdt� | j d k r<| j jtj� || _ |d k rb|jtj| j � | j
� d S )NzCA loop is being detached from a child watcher with pending handlers) r� r� r* r+ �RuntimeWarningr) r5 �SIGCHLDrE � _sig_chldr� )r r� r r r r� s
z BaseChildWatcher.attach_loopc C sF y | j � W n4 tk
r@ } z| jjd|d�� W Y d d }~X nX d S )Nz$Unknown exception in SIGCHLD handler)r� r� )r� rZ r� r� )r rC r r r r� 1 s zBaseChildWatcher._sig_chldc C s2 t j|�rt j|� S t j|�r*t j|�S |S d S )N)rz � WIFSIGNALED�WTERMSIG� WIFEXITED� WEXITSTATUS)r �statusr r r �_compute_returncode= s
z$BaseChildWatcher._compute_returncodeN)
r� r� r� r r% r� r� r� r� r� r r r r r� s r� c sL e Zd Z� fdd�Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z � Z
S )r c s | j j� t� j� d S )N)r� r- r r% )r )r! r r r% V s
zSafeChildWatcher.closec C s | S )Nr )r r r r r� Z s zSafeChildWatcher.__enter__c C s d S )Nr )r r� r� r� r r r r� ] s zSafeChildWatcher.__exit__c G s. | j d krtd��||f| j|< | j|� d S )NzICannot add child handler, the child watcher does not have a loop attached)r� r: r� r� )r re rA rB r r r rX ` s
z"SafeChildWatcher.add_child_handlerc C s& y | j |= dS tk
r dS X d S )NTF)r� rG )r re r r r r� k s
z%SafeChildWatcher.remove_child_handlerc C s" x t | j�D ]}| j|� q W d S )N)r( r� r� )r re r r r r� r s z SafeChildWatcher._do_waitpid_allc C s� yt j|t j�\}}W n( tk
r> |}d}tjd|� Y n0X |dkrLd S | j|�}| jj� rntj d||� y| j
j |�\}}W n. t k
r� | jj� r�tjd|dd� Y nX |||f|�� d S )N� z8Unknown child process pid %d, will report returncode 255r z$process %s exited with returncode %sz'Child watcher got an unexpected pid: %rT)r� )
rz �waitpid�WNOHANG�ChildProcessErrorr r� r� r� r� r� r� �poprG )r r� re r� rf rA rB r r r r� w s*
z SafeChildWatcher._do_waitpid) r� r� r� r% r� r� rX r� r� r� r� r r )r! r r K s c sP e Zd Z� fdd�Z� fdd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z � Z
S )r c s$ t � j� tj� | _i | _d| _d S )Nr )r r � threadingZLock�_lock�_zombies�_forks)r )r! r r r � s
zFastChildWatcher.__init__c s" | j j� | jj� t� j� d S )N)r� r- r� r r% )r )r! r r r% � s
zFastChildWatcher.closec
C s$ | j � | jd7 _| S Q R X d S )Nr )r� r� )r r r r r� � s zFastChildWatcher.__enter__c
C sV | j �: | jd8 _| js$| j r(d S t| j�}| jj� W d Q R X tjd|� 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 sl | j d krtd��| j�: y| jj|�}W n" tk
rL ||f| j|< d S X W d Q R X |||f|�� d S )NzICannot add child handler, the child watcher does not have a loop attached)r� r: r� r� r� rG r� )r re rA rB rf r r r rX � s
z"FastChildWatcher.add_child_handlerc C s& y | j |= dS tk
r dS X d S )NTF)r� rG )r re r r r r� � s
z%FastChildWatcher.remove_child_handlerc C s� x�yt jdt j�\}}W n tk
r, d S X |dkr:d S | j|�}| j�v y| jj|�\}}W nB tk
r� | j r�|| j
|< | j j � r�t
jd||� wd }Y nX | j j � r�t
jd||� W d Q R X |d kr�t
jd||� q|||f|�� qW d S )Nr r z,unknown process %s exited with returncode %sz$process %s exited with returncode %sz8Caught subprocess termination from unknown pid: %d -> %dr2 )rz r� r� r� r� r� r� r� rG r� r� r� r� r r� r� )r re r� rf rA rB r r r r� � s6
z FastChildWatcher._do_waitpid_all) r� r� r� r r% r� r� rX r� r� r� r r )r! r r � s
c sD e Zd ZeZ� fdd�Zdd� Z� fdd�Zdd� Zd d
� Z � Z
S ) �_UnixDefaultEventLoopPolicyc s t � j� d | _d S )N)r r �_watcher)r )r! r r r s
z$_UnixDefaultEventLoopPolicy.__init__c
C sH t j�8 | jd kr:t� | _ttj� tj�r:| jj| j j
� W d Q R X d S )N) r r� r� r rK r� �current_thread� _MainThreadr� �_localr� )r r r r �
_init_watcher s
z)_UnixDefaultEventLoopPolicy._init_watcherc s6 t � j|� | jd k r2ttj� tj�r2| jj|� d S )N)r �set_event_loopr� rK r� r� r� r� )r r� )r! r r r s
z*_UnixDefaultEventLoopPolicy.set_event_loopc C s | j d kr| j� | j S )N)r� r )r r r r rV & s
z-_UnixDefaultEventLoopPolicy.get_child_watcherc C s | j d k r| j j� || _ d S )N)r� r% )r ra r r r �set_child_watcher0 s
z-_UnixDefaultEventLoopPolicy.set_child_watcher) r� r� r� r Z
_loop_factoryr r r rV r r� r r )r! r r� s
r� )4r> rz r5 r" rx r� r& r� r* � r r r r r r r r
r r r
�logr �__all__r� � ImportErrorr �fspathrw �AttributeErrorZBaseSelectorEventLoopr �hasattrr� r� Z
ReadTransportrN Z_FlowControlMixinZWriteTransportrT r� r� ZBaseSubprocessTransportrW r r� r r ZBaseDefaultEventLoopPolicyr� r r r r r r �<module> sl
O
F=On2PK [����M �M " __pycache__/streams.cpython-36.pycnu �[��� 3
\�_ � @ sL d Z dddddddgZdd lZeed
�r6ejd d g� d
dlmZ d
dlmZ d
dlmZ d
dlm Z d
dlm
Z
d
dl m Z d"Z
G dd� de�ZG dd� de�Ze
d#d e
d�dd��Ze
d$d e
d�dd��Zeed
��re
d%d e
d�dd ��Ze
d&d e
d�d d ��ZG d d � d e j�ZG d d� dee j�ZG d d� d�ZG d!d� d�Zd S )'zStream-related things.� StreamReader� StreamWriter�StreamReaderProtocol�open_connection� start_server�IncompleteReadError�LimitOverrunError� NZAF_UNIX�open_unix_connection�start_unix_server� )�
coroutines)�compat)�events)� protocols)� coroutine)�logger� � c s( e Zd ZdZ� fdd�Zdd� 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( t � jdt|�|f � || _|| _d S )Nz-%d bytes read on a total of %r expected bytes)�super�__init__�len�partial�expected)�selfr r )� __class__� �'/usr/lib64/python3.6/asyncio/streams.pyr s z IncompleteReadError.__init__c C s t | �| j| jffS )N)�typer r )r r r r �
__reduce__& s z IncompleteReadError.__reduce__)�__name__�
__module__� __qualname__�__doc__r r �
__classcell__r r )r r r s c s( e Zd ZdZ� fdd�Zdd� Z� ZS )r z�Reached the buffer limit while looking for a separator.
Attributes:
- consumed: total number of to be consumed bytes.
c s t � j|� || _d S )N)r r �consumed)r �messager$ )r r r r 0 s zLimitOverrunError.__init__c C s t | �| jd | jffS )Nr )r �argsr$ )r r r r r 4 s z LimitOverrunError.__reduce__)r r r! r" r r r# r r )r r r * s )�loop�limitc + sb |dkrt j� }t||d�}t||d�� |j� fdd�| |f|�E 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)r( r' )r' c s � S )Nr r )�protocolr r �<lambda>Q s z!open_connection.<locals>.<lambda>)r �get_event_loopr r Zcreate_connectionr ) �host�portr' r( �kwds�reader� transport�_�writerr )r) r r 8 s c + s8 �dkrt j� �� ��fdd�}�j|||f|�E 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.
Nc s t ��d�} t| � �d�}|S )N)r( r' )r' )r r )r/ r) )�client_connected_cbr( r' r r �factoryq s z start_server.<locals>.factory)r r+ Z
create_server)r3 r, r- r' r( r. r4 r )r3 r( r' r r V s c + s` |dkrt j� }t||d�}t||d�� |j� fdd�| f|�E dH \}}t|� ||�}||fS )z@Similar to `open_connection` but works with UNIX Domain Sockets.N)r( r' )r' c s � S )Nr r )r) r r r* � s z&open_unix_connection.<locals>.<lambda>)r r+ r r Zcreate_unix_connectionr )�pathr' r( r. r/ r0 r1 r2 r )r) r r } s c + s6 �dkrt j� �� ��fdd�}�j||f|�E dH S )z=Similar to `start_server` but works with UNIX Domain Sockets.Nc s t ��d�} t| � �d�}|S )N)r( r' )r' )r r )r/ r) )r3 r( r' r r r4 � s z"start_unix_server.<locals>.factory)r r+ Zcreate_unix_server)r3 r5 r' r( r. r4 r )r3 r( r' r r
� s c @ s> e Zd ZdZd
dd�Zdd� Zdd� Zd d
� Zed d � �Z dS )�FlowControlMixina) Reusable flow control logic for StreamWriter.drain().
This implements the protocol methods pause_writing(),
resume_reading() 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 j� | _n|| _d| _d | _d| _d S )NF)r r+ �_loop�_paused�
_drain_waiter�_connection_lost)r r' r r r r � s zFlowControlMixin.__init__c C s, | j s t�d| _ | jj� r(tjd| � d S )NTz%r pauses writing)r8 �AssertionErrorr7 � get_debugr �debug)r r r r �
pause_writing� s
z FlowControlMixin.pause_writingc C sP | j s
t�d| _ | jj� r&tjd| � | j}|d k rLd | _|j� sL|jd � d S )NFz%r resumes writing) r8 r; r7 r< r r= r9 �done�
set_result)r �waiterr r r �resume_writing� s
z FlowControlMixin.resume_writingc C sV d| _ | jsd S | j}|d kr"d S d | _|j� r4d S |d krH|jd � n
|j|� d S )NT)r: r8 r9 r? r@ �
set_exception)r �excrA r r r �connection_lost� s z FlowControlMixin.connection_lostc c sP | j rtd��| jsd S | j}|d ks2|j� s2t�| jj� }|| _|E d H d S )NzConnection lost)r: �ConnectionResetErrorr8 r9 � cancelledr; r7 �
create_future)r rA r r r �
_drain_helper� s
z FlowControlMixin._drain_helper)N)
r r r! r" r r> rB rE r rI r r r r r6 � s
r6 c sF e Zd ZdZd
� fdd� Zdd� Z� fdd�Zd d
� Zd d � Z� Z S )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 s* t � j|d� || _d | _|| _d| _d S )N)r' F)r r �_stream_reader�_stream_writer�_client_connected_cb� _over_ssl)r Z
stream_readerr3 r' )r r r r � s
z StreamReaderProtocol.__init__c C sd | j j|� |jd�d k | _| jd k r`t|| | j | j�| _| j| j | j�}tj |�r`| jj
|� d S )NZ
sslcontext) rJ �
set_transport�get_extra_inforM rL r r7 rK r Z iscoroutineZ create_task)r r0 �resr r r �connection_made� s
z$StreamReaderProtocol.connection_madec sF | j d k r*|d kr | j j� n | j j|� t� j|� d | _ d | _d S )N)rJ �feed_eofrC r rE rK )r rD )r r r rE � s
z$StreamReaderProtocol.connection_lostc C s | j j|� d S )N)rJ � feed_data)r �datar r r �
data_received s z"StreamReaderProtocol.data_receivedc C s | j j� | jrdS dS )NFT)rJ rR rM )r r r r � eof_received s
z!StreamReaderProtocol.eof_received)NN)
r r r! r" r rQ rE rU rV r# r r )r r r � s
c @ sj e Zd ZdZdd� Zdd� Zedd� �Zdd � Zd
d � Z d d
� Z
dd� Z dd� Z ddd�Z
edd� �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 s2 || _ || _|d ks"t|t�s"t�|| _|| _d S )N)�
_transport� _protocol�
isinstancer r; �_readerr7 )r r0 r) r/ r' r r r r s
zStreamWriter.__init__c C s: | j jd| j g}| jd k r,|jd| j � ddj|� S )Nz transport=%rz reader=%rz<%s>� )r r rW rZ �append�join)r �infor r r �__repr__! s
zStreamWriter.__repr__c C s | j S )N)rW )r r r r r0 ' s zStreamWriter.transportc C s | j j|� d S )N)rW �write)r rT r r r r` + s zStreamWriter.writec C s | j j|� d S )N)rW �
writelines)r rT r r r ra . s zStreamWriter.writelinesc C s
| j j� S )N)rW � write_eof)r r r r rb 1 s zStreamWriter.write_eofc C s
| j j� S )N)rW �
can_write_eof)r r r r rc 4 s zStreamWriter.can_write_eofc C s
| j j� S )N)rW �close)r r r r rd 7 s zStreamWriter.closeNc C s | j j||�S )N)rW rO )r �name�defaultr r r rO : s zStreamWriter.get_extra_infoc c sN | j dk r | j j� }|dk r |�| jdk r:| jj� r:dV | jj� E dH dS )z~Flush the write buffer.
The intended use is to write
w.write(data)
yield from w.drain()
N)rZ � exceptionrW Z
is_closingrX rI )r rD r r r �drain= s
zStreamWriter.drain)N)r r r! r" r r_ �propertyr0 r` ra rb rc rd rO r rh r r r r r s
c @ s� e Zd Zedfdd�Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
edd� �Zedd� �Zed'dd ��Zed)d d ��Zed d!� �Zejr�ed"d#� �Zed$d%� �Zejr�d&d#� ZdS )*r Nc C sZ |dkrt d��|| _|d kr*tj� | _n|| _t� | _d| _d | _d | _ d | _
d| _ d S )Nr zLimit cannot be <= 0F) �
ValueError�_limitr r+ r7 � bytearray�_buffer�_eof�_waiter�
_exceptionrW r8 )r r( r' r r r r X s zStreamReader.__init__c C s� dg}| j r |jdt| j � � | jr0|jd� | jtkrJ|jd| j � | jr`|jd| j � | jrv|jd| j � | jr�|jd| j � | j r�|jd� d d
j
|� S ) Nr z%d bytes�eofzl=%dzw=%rze=%rzt=%rZpausedz<%s>r[ ) rm r\ r rn rk �_DEFAULT_LIMITro rp rW r8 r] )r r^ r r r r_ k s
zStreamReader.__repr__c C s | j S )N)rp )r r r r rg } s zStreamReader.exceptionc C s0 || _ | j}|d k r,d | _|j� s,|j|� d S )N)rp ro rG rC )r rD rA r r r rC � s zStreamReader.set_exceptionc C s* | j }|dk r&d| _ |j� s&|jd� dS )z1Wakeup read*() functions waiting for data or EOF.N)ro rG r@ )r rA r r r �_wakeup_waiter� s
zStreamReader._wakeup_waiterc C s | j d kstd��|| _ d S )NzTransport already set)rW r; )r r0 r r r rN � s zStreamReader.set_transportc C s* | j r&t| j�| jkr&d| _ | jj� d S )NF)r8 r rm rk rW �resume_reading)r r r r �_maybe_resume_transport� s z$StreamReader._maybe_resume_transportc C s d| _ | j� d S )NT)rn rs )r r r r rR � s zStreamReader.feed_eofc C s | j o | j S )z=Return True if the buffer is empty and 'feed_eof' was called.)rn rm )r r r r �at_eof� s zStreamReader.at_eofc C s� | j std��|sd S | jj|� | j� | jd k r�| j r�t| j�d| j kr�y| jj � W n t
k
rz d | _Y nX d| _d S )Nzfeed_data after feed_eofr T) rn r; rm �extendrs rW r8 r rk Z
pause_reading�NotImplementedError)r rT r r r rS � s
zStreamReader.feed_datac c sf | j dk rtd| ��| j s&td��| jr<d| _| jj� | jj� | _ z| j E dH W dd| _ X dS )zpWait until feed_data() or feed_eof() is called.
If stream was paused, automatically resume it.
NzH%s() called while another coroutine is already waiting for incoming dataz_wait_for_data after EOFF) ro � RuntimeErrorrn r; r8 rW rt r7 rH )r Z func_namer r r �_wait_for_data� s
zStreamReader._wait_for_datac c s� d}t |�}y| j|�E dH }W n� tk
rB } z|jS d}~X nf tk
r� } zJ| jj||j�rv| jd|j| �= n
| jj� | j � t
|j d ��W Y dd}~X 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 r r rm �
startswithr$ �clearru rj r& )r �sep�seplen�line�er r r �readline� s
zStreamReader.readliner{ c c s� t |�}|dkrtd��| jdk r(| j�d}x�t | j�}|| |kr|| jj||�}|dkr\P |d | }|| jkr|td|��| jr�t| j�}| jj � t
|d��| j d�E dH q.W || jkr�td|��| jd|| � }| jd|| �= | j � 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 rj rp rm �findrk r rn �bytesr~ r rz ru )r Z separatorr� �offsetZbuflenZisep�chunkr r r r| � s:
zStreamReader.readuntilr c c s� | j dk r| j �|dkr dS |dk rZg }x&| j| j�E dH }|sBP |j|� q*W dj|�S | j rz| j rz| jd�E dH t| jd|� �}| jd|�= | j � |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 � �read)
rp r� rk r\ r] rm rn rz r� ru )r �nZblocks�blockrT r r r r� P s$
zStreamReader.readc c s� |dk rt d��| jdk r | j�|dkr,dS xFt| j�|k rr| jr`t| j�}| jj� t||��| jd�E dH q.W t| j�|kr�t| j�}| jj� n t| jd|� �}| jd|�= | j � |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)
rj rp r rm rn r� r~ r rz ru )r r� Z
incompleterT r r r r� � s&
zStreamReader.readexactlyc C s | S )Nr )r r r r � __aiter__� s zStreamReader.__aiter__c c s | j � E d H }|dkrt�|S )Nr� )r� �StopAsyncIteration)r �valr r r � __anext__� s zStreamReader.__anext__c C s | S )Nr )r r r r r� � s )r{ r� )r� )r r r! rr r r_ rg rC rs rN ru rR rv rS r rz r� r| r� r� r
ZPY35r� r� ZPY352r r r r r V s, [ 2 * i )NN)NN)N)N)r" �__all__Zsocket�hasattrrw � r r
r r r �logr rr �EOFErrorr � Exceptionr r r r r
ZProtocolr6 r r r r r r r �<module> sB
" B3GPK [G��4G G + __pycache__/base_tasks.cpython-36.opt-1.pycnu �[��� 3
\� � @ sD d dl Z d dlZddlmZ ddlmZ dd� Zdd� Zd d
� ZdS ) � N� )� base_futures)�
coroutinesc C sT t j| �}| jrd|d< tj| j�}|jdd| � | jd k rP|jdd| j � |S )NZ
cancellingr r z coro=<%s>� z wait_for=%r)r Z_future_repr_infoZ _must_cancelr Z_format_coroutine�_coro�insertZ _fut_waiter)�task�info�coro� r �*/usr/lib64/python3.6/asyncio/base_tasks.py�_task_repr_info s
r
c C s� g }y | j j}W n tk
r, | j j}Y nX |d k rxx6|d k rl|d k rZ|dkrRP |d8 }|j|� |j}q8W |j� nL| jd k r�| jj}x8|d k r�|d k r�|dkr�P |d8 }|j|j � |j
}q�W |S )Nr r ) r �cr_frame�AttributeError�gi_frame�append�f_back�reverse�
_exception�
__traceback__�tb_frame�tb_next)r �limitZframes�f�tbr r r �_task_get_stack s0
r c C s� g }t � }xj| j|d�D ]Z}|j}|j}|j}|j} ||krP|j|� tj|� tj |||j
�}
|j ||| |
f� qW | j } |s�t
d| |d� n*| d k r�t
d| |d� nt
d| |d� tj||d� | d k r�x$tj| j| �D ]}
t
|
|dd� q�W d S )N)r zNo stack for %r)�filez)Traceback for %r (most recent call last):z%Stack for %r (most recent call last):� )r �end)�setZ get_stack�f_lineno�f_code� co_filename�co_name�add� linecache�
checkcache�getline� f_globalsr r �print� traceback�
print_list�format_exception_only� __class__) r r r �extracted_listZcheckedr �lineno�co�filename�name�line�excr r r �_task_print_stack3 s0
r5 )r% r* r r r r
r r5 r r r r �<module> s PK [�a��Z< Z< __pycache__/locks.cpython-36.pycnu �[��� 3
\�< � @ s� d Z dddddgZddlZdd lmZ dd
lmZ dd lmZ dd lmZ G d
d� d�Z G dd� d�Z
G dd� de
�Z G dd� d�Z G dd� de
�Z
G dd� de
�ZG dd� de�ZdS )zSynchronization primitives.�Lock�Event� Condition� Semaphore�BoundedSemaphore� N� )�compat)�events)�futures)� coroutinec @ 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):
<block>
while failing loudly when accidentally using:
with lock:
<block>
c C s
|| _ d S )N)�_lock)�self�lock� r �%/usr/lib64/python3.6/asyncio/locks.py�__init__ s z_ContextManager.__init__c C s d S )Nr )r r r r � __enter__ s z_ContextManager.__enter__c G s z| j j� W d d | _ X d S )N)r
�release)r �argsr r r �__exit__$ s z_ContextManager.__exit__N)�__name__�
__module__� __qualname__�__doc__r r r r r r r r
s
r c @ sN e Zd Zdd� Zdd� Zedd� �ZejrJdd� Z ed d
� �Z
ed d � �Z d
S )�_ContextManagerMixinc C s t d��d S )Nz9"yield from" should be used as context manager expression)� RuntimeError)r r r r r , s z _ContextManagerMixin.__enter__c G s d S )Nr )r r r r r r 0 s z _ContextManagerMixin.__exit__c c s | j � E d H t| �S )N)�acquirer )r r r r �__iter__5 s z _ContextManagerMixin.__iter__c c s | j � E d H t| �S )N)r r )r r r r � __await__H s z _ContextManagerMixin.__await__c c s | j � E d H d S )N)r )r r r r �
__aenter__M s z _ContextManagerMixin.__aenter__c C s | j � d S )N)r )r �exc_type�exc�tbr r r � __aexit__T s z _ContextManagerMixin.__aexit__N) r r r r r r r r ZPY35r r r$ r r r r r + s r c sR e Zd ZdZdd�dd�Z� fdd�Zdd � Zed
d � �Zd d
� Z dd� 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 'yield from'.
Locks also support the context management protocol. '(yield from lock)'
should be used as the context manager expression.
Usage:
lock = Lock()
...
yield from lock
try:
...
finally:
lock.release()
Context manager usage:
lock = Lock()
...
with (yield from lock):
...
Lock objects can be tested for locking state:
if not lock.locked():
yield from lock
else:
# lock is acquired
...
N)�loopc C s. t j� | _d| _|d k r || _n
tj� | _d S )NF)� collections�deque�_waiters�_locked�_loopr �get_event_loop)r r% r r r r � s
z
Lock.__init__c sD t � j� }| jrdnd}| jr0dj|t| j��}dj|dd� |�S )N�locked�unlockedz
{},waiters:{}z <{} [{}]>r ���)�super�__repr__r) r( �format�len)r �res�extra)� __class__r r r0 � s
z
Lock.__repr__c C s | j S )z Return True if lock is acquired.)r) )r r r r r, � s z Lock.lockedc c s� | j r&tdd� | jD ��r&d| _ dS | jj� }| jj|� y"z|E dH W d| jj|� X W n& tjk
r� | j s~| j � � Y nX d| _ dS )z�Acquire a lock.
This method blocks until the lock is unlocked, then sets it to
locked and returns True.
c s s | ]}|j � V qd S )N)� cancelled)�.0�wr r r � <genexpr>� s z Lock.acquire.<locals>.<genexpr>TN)
r) �allr( r* �
create_future�append�remover
�CancelledError�_wake_up_first)r �futr r r r � s
z Lock.acquirec C s" | j rd| _ | j� ntd��dS )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)r) r? r )r r r r r � s
z Lock.releasec C s> yt t| j��}W n tk
r& dS X |j� s:|jd� dS )z*Wake up the first waiter if it isn't done.NT)�next�iterr( �
StopIteration�done�
set_result)r r@ r r r r? � s zLock._wake_up_first) r r r r r r0 r, r r r r? �
__classcell__r r )r5 r r Y s 4 c sR e Zd ZdZdd�dd�Z� fdd�Zdd � Zd
d � Zd d
� Ze dd� �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.
N)r% c C s. t j� | _d| _|d k r || _n
tj� | _d S )NF)r& r' r( �_valuer* r r+ )r r% r r r r � s
zEvent.__init__c sD t � j� }| jrdnd}| jr0dj|t| j��}dj|dd� |�S )N�setZunsetz
{},waiters:{}z <{} [{}]>r r. )r/ r0 rG r( r1 r2 )r r3 r4 )r5 r r r0 � s
zEvent.__repr__c C s | j S )z5Return True if and only if the internal flag is true.)rG )r r r r �is_set� s z Event.is_setc C s2 | j s.d| _ x | jD ]}|j� s|jd� qW dS )z�Set 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)rG r( rD rE )r r@ r r r rH � s
z Event.setc C s
d| _ dS )z�Reset the internal flag to false. Subsequently, coroutines calling
wait() will block until set() is called to set the internal flag
to true again.FN)rG )r r r r �clear s z Event.clearc c sB | j r
dS | jj� }| jj|� z|E dH dS | jj|� X dS )z�Block 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)rG r* r; r( r< r= )r r@ r r r �wait
s
z
Event.wait) r r r r r r0 rI rH rJ r rK rF r r )r5 r r � s c sZ e Zd ZdZddd�dd�Z� fdd�Zedd � �Zed
d � �Zdd
d�Z dd� 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.
N)r% c C sp |d k r|| _ n
tj� | _ |d kr0t| j d�}n|j | j k rDtd��|| _|j| _|j| _|j| _t j
� | _ d S )N)r% z"loop argument must agree with lock) r* r r+ r �
ValueErrorr
r, r r r& r' r( )r r r% r r r r + s
zCondition.__init__c sF t � j� }| j� rdnd}| jr2dj|t| j��}dj|dd� |�S )Nr, r- z
{},waiters:{}z <{} [{}]>r r. )r/ r0 r, r( r1 r2 )r r3 r4 )r5 r r r0 > s
zCondition.__repr__c c s� | j � std��| j� z8| jj� }| jj|� z|E dH dS | jj|� X W dd}x4y| j� E dH P W qX t j
k
r� d}Y qXX qXW |r�t j
�X 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 lockNTF) r, r r r* r; r( r< r= r r
r> )r r@ r6 r r r rK E s&
zCondition.waitc c s( |� }x |s"| j � E dH |� }qW |S )z�Wait 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)rK )r Z predicate�resultr r r �wait_fork s
zCondition.wait_forr c C sL | j � std��d}x2| jD ](}||kr*P |j� s |d7 }|jd� q W dS )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 r( rD rE )r �n�idxr@ r r r �notifyy s zCondition.notifyc C s | j 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)rQ r2 r( )r r r r �
notify_all� s zCondition.notify_all)N)r ) r r r r r r0 r rK rN rQ rR rF r r )r5 r r ! s &
c sT e Zd ZdZddd�dd�Z� fdd�Zd d
� Zd d � Zed
d� �Z dd� 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 N)r% c C s> |dk rt d��|| _tj� | _|d k r0|| _n
tj� | _d S )Nr z$Semaphore initial value must be >= 0)rL rG r& r' r( r* r r+ )r �valuer% r r r r � s
zSemaphore.__init__c sN t � j� }| j� rdn
dj| j�}| jr:dj|t| j��}dj|dd� |�S )Nr, zunlocked,value:{}z
{},waiters:{}z <{} [{}]>r r. )r/ r0 r, r1 rG r( r2 )r r3 r4 )r5 r r r0 � s
zSemaphore.__repr__c C s0 x*| j r*| j j� }|j� s|jd � d S qW d S )N)r( �popleftrD rE )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 )rG )r r r r r, � s zSemaphore.lockedc c sz xf| j dkrf| jj� }| jj|� y|E dH W q |j� | j dkr\|j� r\| j� � Y qX qW | 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)rG r* r; r( r< Zcancelr6 rU )r r@ r r r r � s
zSemaphore.acquirec C s | j d7 _ | j� dS )z�Release 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)rG rU )r r r r r � s zSemaphore.release)r ) r r r r r r0 rU r, r r r rF r r )r5 r r � s
c s4 e Zd ZdZd dd�� fdd� Z� fdd�Z� ZS )
r z�A bounded semaphore implementation.
This raises ValueError in release() if it would increase the value
above the initial value.
r N)r% c s || _ t� j||d� d S )N)r% )� _bound_valuer/ r )r rS r% )r5 r r r � s zBoundedSemaphore.__init__c s" | j | jkrtd��t� j� d S )Nz(BoundedSemaphore released too many times)rG rV rL r/ r )r )r5 r r r � s zBoundedSemaphore.release)r )r r r r r r rF r r )r5 r r � s )r �__all__r& � r r r
Z
coroutinesr r r r r r r r r r r r �<module> s . ByMPK [�x�mD mD + __pycache__/test_utils.cpython-36.opt-1.pycnu �[��� 3
\�: �
@ s d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl
Z
ddlZddl
mZ ddlmZ ddlmZmZ y ddlZW n ek
r� dZY nX ddlmZ ddlmZ dd lmZ dd
lmZ dd lm Z dd lm Z dd
l m Z ddl m!Z! ddl"m#Z# e j$dk�rHddl%m&Z& n ddlm&Z& dd� Z'e'd�Z(e'd�Z)dd� Z*dd� Z+dRdd �Z,d d � Z-G d d � d e�Z.G d!d"� d"e�Z/G d#d$� d$�Z0G d%d&� d&e0e/�Z1d'd(�d)d*�Z2e3ed+��rZG d,d-� d-ej4e�Z5G d.d/� d/e5e�Z6G d0d1� d1e6�Z7G d2d3� d3e0e7�Z8d4d5� Z9ej:d6d7� �Z;ej:d'd(�d8d9��Z<ej:d:dd'd;�d<d=��Z=d>d?� Z>G d@dA� dAe j?�Z@G dBdC� dCejA�ZBdDdE� ZCG dFdG� dGeD�ZEdHdI� ZFG dJdK� dKe
jG�ZGej:dLdM� �ZHejIejJejKfdNdO�ZLdPdQ� ZMdS )SzUtilities shared by tests.� N)�mock)�
HTTPServer)�WSGIRequestHandler�
WSGIServer� )� base_events)�compat)�events)�futures)� selectors)�tasks)� coroutine)�logger)�supportZwin32)�
socketpairc C s` t td�r*tjjtj| �}tjj|�r*|S tjjtjjtj�d| �}tjj|�rT|S t | ��d S )N�
TEST_HOME_DIR�test)
�hasattrr �os�path�joinr �isfile�dirname�__file__�FileNotFoundError)�filename�fullname� r �*/usr/lib64/python3.6/asyncio/test_utils.py� data_file- s
r z ssl_cert.pemz ssl_key.pemc C s t d kr d S t jt j�S d S )N)�ssl�
SSLContextZPROTOCOL_SSLv23r r r r �dummy_ssl_context< s r" c
C s@ t dd� �}|� }| j|�}d|_z| j|� W d |j� X d S )Nc S s d S )Nr r r r r �onceD s zrun_briefly.<locals>.onceF)r
Z create_taskZ_log_destroy_pending�run_until_complete�close)�loopr# �gen�tr r r � run_brieflyC s
r) � c C sT t j � | }xB|� sN|d k r8|t j � }|dkr8tj� �| jtjd| d�� qW d S )Nr g����MbP?)r& )�timer
� TimeoutErrorr$ r Zsleep)r& Zpred�timeoutZdeadliner r r � run_untilR s r. c C s | j | j� | j� dS )z�Legacy API to run once through the event loop.
This is the recommended pattern for test code. It will poll the
selector once and run all callbacks scheduled in response to I/O
events.
N)Z call_soon�stopZ run_forever)r& r r r �run_once\ s r0 c @ s e Zd Zdd� Zdd� ZdS )�SilentWSGIRequestHandlerc C s t j� S )N)�io�StringIO)�selfr r r �
get_stderri s z#SilentWSGIRequestHandler.get_stderrc G s d S )Nr )r4 �format�argsr r r � log_messagel s z$SilentWSGIRequestHandler.log_messageN)�__name__�
__module__� __qualname__r5 r8 r r r r r1 g s r1 c s( e Zd ZdZ� fdd�Zdd� Z� ZS )�SilentWSGIServer� c s" t � j� \}}|j| j� ||fS )N)�super� get_request�
settimeout�request_timeout)r4 �request� client_addr)� __class__r r r? t s z SilentWSGIServer.get_requestc C s d S )Nr )r4 rB �client_addressr r r � handle_errory s z SilentWSGIServer.handle_error)r9 r: r; rA r? rF �
__classcell__r r )rD r r< p s r< c @ s e Zd Zdd� ZdS )�SSLWSGIServerMixinc C s^ t }t}tj� }|j||� |j|dd�}y| j||| � |j� W n tk
rX Y nX d S )NT)Z server_side) �ONLYKEY�ONLYCERTr r! Zload_cert_chainZ wrap_socketZRequestHandlerClassr% �OSError)r4 rB rE ZkeyfileZcertfile�contextZssockr r r �finish_request s z!SSLWSGIServerMixin.finish_requestN)r9 r: r; rM r r r r rH } s rH c @ s e Zd ZdS )�
SSLWSGIServerN)r9 r: r; r r r r rN � s rN F)�use_sslc
# sv dd� }|r|n|}|| t �� � j|� � j� _tj� fdd�d�}|j� z
� V W d � j� � j� |j � X d S )Nc S s d}dg}|||� dgS )Nz200 OK� Content-type�
text/plains Test message)rP rQ r )�environZstart_responseZstatusZheadersr r r �app� s
z _run_test_server.<locals>.appc s � j dd�S )Ng�������?)Z
poll_interval)Z
serve_foreverr )�httpdr r �<lambda>� s z"_run_test_server.<locals>.<lambda>)�target)
r1 Zset_appZserver_address�address� threadingZThread�start�shutdownZ server_closer )rW rO �
server_cls�server_ssl_clsrS Z server_classZ
server_threadr )rT r �_run_test_server� s
r] ZAF_UNIXc @ s e Zd Zdd� ZdS )�UnixHTTPServerc C s t jj| � d| _d| _d S )Nz 127.0.0.1�P )� socketserver�UnixStreamServer� server_bindZ server_nameZ server_port)r4 r r r rb � s zUnixHTTPServer.server_bindN)r9 r: r; rb r r r r r^ � s r^ c s( e Zd ZdZdd� Z� fdd�Z� ZS )�UnixWSGIServerr= c C s t j| � | j� d S )N)r^ rb Z
setup_environ)r4 r r r rb � s
zUnixWSGIServer.server_bindc s" t � j� \}}|j| j� |dfS )N� 127.0.0.1� )rd re )r> r? r@ rA )r4 rB rC )rD r r r? � s zUnixWSGIServer.get_request)r9 r: r; rA rb r? rG r r )rD r rc � s rc c @ s e Zd Zdd� ZdS )�SilentUnixWSGIServerc C s d S )Nr )r4 rB rE r r r rF � s z!SilentUnixWSGIServer.handle_errorN)r9 r: r; rF r r r r rf � s rf c @ s e Zd ZdS )�UnixSSLWSGIServerN)r9 r: r; r r r r rg � s rg c C s t j� �} | jS Q R X d S )N)�tempfileZNamedTemporaryFile�name)�filer r r �gen_unix_socket_path� s
rk c c s< t � } z
| V W d ytj| � W n tk
r4 Y nX X d S )N)rk r �unlinkrK )r r r r �unix_socket_path� s
rm c
c s, t � � }t|| ttd�E d H W d Q R X d S )N)rW rO r[ r\ )rm r] rf rg )rO r r r r �run_test_unix_server� s rn z 127.0.0.1)�host�portrO c c s t | |f|ttd�E d H d S )N)rW rO r[ r\ )r] r< rN )ro rp rO r r r �run_test_server� s
rq c C sP i }x4t | �D ](}|jd�r(|jd�r(qtd d�||< qW td| f| j |�� S )N�__)� return_valueZ TestProtocol)�dir�
startswith�endswith� MockCallback�type� __bases__)�baseZdctri r r r �make_test_protocol� s r{ c @ s6 e Zd Zdd� Zd dd�Zdd� Zdd � Zd
d � ZdS )
� TestSelectorc C s
i | _ d S )N)�keys)r4 r r r �__init__ s zTestSelector.__init__Nc C s t j|d||�}|| j|< |S )Nr )r Z SelectorKeyr} )r4 �fileobjr �data�keyr r r �register s
zTestSelector.registerc C s | j j|�S )N)r} �pop)r4 r r r r �
unregister s zTestSelector.unregisterc C s g S )Nr )r4 r- r r r �select s zTestSelector.selectc C s | j S )N)r} )r4 r r r �get_map s zTestSelector.get_map)N)r9 r: r; r~ r� r� r� r� r r r r r| s
r| c s� e Zd ZdZd-� fdd� Zdd� Zdd� Z� fd d
�Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Z� fd%d&�Z� fd'd(�Zd)d*� Zd+d,� Z� ZS ).�TestLoopa� Loop for unittests.
It manages self time directly.
If something scheduled to be executed later then
on next loop iteration after all ready handlers done
generator passed to __init__ is calling.
Generator should be like this:
def gen():
...
when = yield ...
... = yield time_advance
Value returned by yield is absolute time of next scheduled handler.
Value passed to yield is time advance to move loop's time forward.
Nc sv t � j� |d kr"dd� }d| _nd| _|� | _t| j� d| _d| _g | _t� | _ i | _
i | _ | j � t
j� | _d S )Nc s s
d V d S )Nr r r r r r' , s z TestLoop.__init__.<locals>.genFTr g��&� .>)r> r~ �_check_on_close�_gen�next�_timeZ_clock_resolution�_timersr| Z _selector�readers�writers�reset_counters�weakref�WeakValueDictionary� _transports)r4 r' )rD r r r~ ( s
zTestLoop.__init__c C s | j S )N)r� )r4 r r r r+ ? s z
TestLoop.timec C s |r| j |7 _ dS )zMove test time forward.N)r� )r4 �advancer r r � advance_timeB s zTestLoop.advance_timec sB t � j� | jr>y| jjd� W n tk
r4 Y n
X td��d S )Nr z Time generator is not finished)r> r% r� r� �send�
StopIteration�AssertionError)r4 )rD r r r% G s
zTestLoop.closec G s t j||| �| j|< d S )N)r �Handler� )r4 �fd�callbackr7 r r r � _add_readerQ s zTestLoop._add_readerc C s0 | j | d7 < || jkr(| j|= dS dS d S )Nr TF)�remove_reader_countr� )r4 r� r r r �_remove_readerT s
zTestLoop._remove_readerc G sh || j krtd|� d���| j | }|j|krDtd|j� d|� ���|j|krdtd|j� d|� ���d S )Nzfd z is not registeredzunexpected callback: z != zunexpected callback args: )r� r� Z _callbackZ_args)r4 r� r� r7 �handler r r �
assert_reader\ s
zTestLoop.assert_readerc C s || j krtd|� d���d S )Nzfd z is registered)r� r� )r4 r� r r r �assert_no_readerg s
zTestLoop.assert_no_readerc G s t j||| �| j|< d S )N)r r� r� )r4 r� r� r7 r r r � _add_writerk s zTestLoop._add_writerc C s0 | j | d7 < || jkr(| j|= dS dS d S )Nr TF)�remove_writer_countr� )r4 r� r r r �_remove_writern s
zTestLoop._remove_writerc G s | j | }d S )N)r� )r4 r� r� r7 r� r r r �
assert_writerv s
zTestLoop.assert_writerc C s8 y| j | }W n tk
r" Y nX tdj||���d S )Nz.File descriptor {!r} is used by transport {!r})r� �KeyError� RuntimeErrorr6 )r4 r� Z transportr r r �_ensure_fd_no_transport~ s z TestLoop._ensure_fd_no_transportc G s | j |� | j||f|�� S )zAdd a reader callback.)r� r� )r4 r� r� r7 r r r �
add_reader� s
zTestLoop.add_readerc C s | j |� | j|�S )zRemove a reader callback.)r� r� )r4 r� r r r �
remove_reader� s
zTestLoop.remove_readerc G s | j |� | j||f|�� S )zAdd a writer callback..)r� r� )r4 r� r� r7 r r r �
add_writer� s
zTestLoop.add_writerc C s | j |� | j|�S )zRemove a writer callback.)r� r� )r4 r� r r r �
remove_writer� s
zTestLoop.remove_writerc C s t jt�| _t jt�| _d S )N)� collections� defaultdict�intr� r� )r4 r r r r� � s zTestLoop.reset_countersc s: t � j� x$| jD ]}| jj|�}| j|� qW g | _d S )N)r> � _run_oncer� r� r� r� )r4 �whenr� )rD r r r� � s
zTestLoop._run_oncec s | j j|� t� j||f|�� S )N)r� �appendr> �call_at)r4 r� r� r7 )rD r r r� � s zTestLoop.call_atc C s d S )Nr )r4 Z
event_listr r r �_process_events� s zTestLoop._process_eventsc C s d S )Nr )r4 r r r �_write_to_self� s zTestLoop._write_to_self)N)r9 r: r; �__doc__r~ r+ r� r% r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rG r r )rD r r� s,
r� c K s t jf ddgi| ��S )N�spec�__call__)r ZMock)�kwargsr r r rw � s rw c @ s e Zd ZdZdd� ZdS )� MockPatternz�A regex based str with a fuzzy __eq__.
Use this helper with 'mock.assert_called_with', or anywhere
where a regex comparison between strings is needed.
For instance:
mock_call.assert_called_with(MockPattern('spam.*ham'))
c C s t tjt| �|tj��S )N)�bool�re�search�str�S)r4 �otherr r r �__eq__� s zMockPattern.__eq__N)r9 r: r; r� r� r r r r r� � s r� c C s$ t j| �}|d kr td| f ��|S )Nz unable to get the source of %r)r Z_get_function_source�
ValueError)�func�sourcer r r �get_function_source� s
r� c @ sV e Zd Zedd� �Zdd�dd�Zddd �Zd
d � Zd d
� Zdd� Z e
j sRdd� Z dS )�TestCasec C s& | j }|d k r|jdd� | j� d S )NT)�wait)Z_default_executorrZ r% )r& Zexecutorr r r �
close_loop� s zTestCase.close_loopT)�cleanupc C s t jd � |r | j| j|� d S )N)r �set_event_loopZ
addCleanupr� )r4 r& r� r r r r� � s
zTestCase.set_event_loopNc C s t |�}| j|� |S )N)r� r� )r4 r' r& r r r �
new_test_loop� s
zTestCase.new_test_loopc C s | j t_ d S )N)�_get_running_loopr )r4 r r r �unpatch_get_running_loop� s z!TestCase.unpatch_get_running_loopc C s t j| _dd� t _tj� | _d S )Nc S s d S )Nr r r r r rU � s z TestCase.setUp.<locals>.<lambda>)r r� r Zthreading_setup�_thread_cleanup)r4 r r r �setUp� s
zTestCase.setUpc C sB | j � tjd � | jtj� d� | j� tj| j � tj
� d S )N)NNN) r� r r� Z assertEqual�sys�exc_infoZ
doCleanupsr Zthreading_cleanupr� Z
reap_children)r4 r r r �tearDown� s
zTestCase.tearDownc O s G dd� d�}|� S )Nc @ s e Zd Zdd� Zdd� ZdS )z!TestCase.subTest.<locals>.EmptyCMc S s d S )Nr )r4 r r r � __enter__� s z+TestCase.subTest.<locals>.EmptyCM.__enter__c W s d S )Nr )r4 �excr r r �__exit__� s z*TestCase.subTest.<locals>.EmptyCM.__exit__N)r9 r: r; r� r� r r r r �EmptyCM� s r� r )r4 r7 r� r� r r r �subTest� s zTestCase.subTest)N)
r9 r: r; � staticmethodr� r� r� r� r� r� r ZPY34r� r r r r r� � s
r� c c s2 t j} zt jtjd � dV W dt j| � X dS )zrContext manager to disable asyncio logger.
For example, it can be used to ignore warnings in debug mode.
r N)r �levelZsetLevel�loggingZCRITICAL)Z old_levelr r r �disable_logger� s
r� c C s* t jtj�}| |_||_||_d|j_|S )z'Create a mock of a non-blocking socket.g )r Z MagicMock�socket�protorx �familyZ
gettimeoutrs )r� rx r� Zsockr r r �mock_nonblocking_socket s r� c C s t jddd�S )Nz'asyncio.sslproto._is_sslproto_availableF)rs )r Zpatchr r r r �force_legacy_ssl_support s r� )r* )Nr� r� �
contextlibr2 r� r r� r� r` r� rh rX r+ Zunittestr� r Z http.serverr Zwsgiref.simple_serverr r r � ImportErrorre r r r r
r r Z
coroutinesr
�logr r r �platformZ
windows_utilsr r rJ rI r" r) r. r0 r1 r< rH rN r] r ra r^ rc rf rg rk �contextmanagerrm rn rq r{ Z BaseSelectorr| Z
BaseEventLoopr� rw r� r� r� r� r� Z IPPROTO_TCPZ SOCK_STREAMZAF_INETr� r� r r r r �<module> s�
4
PK [�E(�g g ' __pycache__/compat.cpython-36.opt-2.pycnu �[��� 3
\ � @ s2 d dl Z e jdkZe jd kZe jd
kZdd� ZdS ) � N� � � � c C s t sdd� | D �} dj| �S )Nc s s$ | ] }t |t�rt|�n|V qd S )N)�
isinstance�
memoryview�bytes)�.0�data� r �&/usr/lib64/python3.6/asyncio/compat.py� <genexpr> s z%flatten_list_bytes.<locals>.<genexpr>� )�PY34�join)Z list_of_datar r r �flatten_list_bytes
s r )r r )r r )r r r )�sys� version_infor ZPY35ZPY352r r r r r �<module> s
PK [#���]w ]w & __pycache__/unix_events.cpython-36.pycnu �[��� 3
\�� �
@ 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 l
mZ dd
l
mZ ddlmZ ddlmZ dddddgZejdkr�ed��dd� Zy
ej Z W n e k
�r, dd� Z Y nX G dd � d ej �Z e!ed ��rVd d � Z"nddl#Z#d d � Z"G d!d"� d"ej$�Z%G d#d$� d$ej&ej'�Z(e!ed%��r�ej)Z*nddl#Z#d&d'� Z*G d(d)� d)e j+�Z,G d*d� d�Z-G d+d,� d,e-�Z.G d-d� de.�Z/G d.d� de.�Z0G d/d0� d0ej1�Z2e Z3e2Z4dS )1z2Selector event loop for Unix with signal handling.� N� )� base_events)�base_subprocess)�compat)� constants)�
coroutines)�events)�futures)�selector_events)� selectors)�
transports)� coroutine)�logger�SelectorEventLoop�AbstractChildWatcher�SafeChildWatcher�FastChildWatcher�DefaultEventLoopPolicyZwin32z+Signals are not really supported on Windowsc C s dS )zDummy signal handler.N� )�signum�framer r �+/usr/lib64/python3.6/asyncio/unix_events.py�_sighandler_noop% s r c C s | S )Nr )�pathr r r �<lambda>. s r c s� e Zd ZdZd"� fdd� Zdd� Z� fdd�Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z d#dd�Z d$dd�Z
ed%dd��Zdd� Zedddd�d d ��Zed&dd dd �d d!��Z� ZS )'�_UnixSelectorEventLoopzdUnix event loop.
Adds signal handling and UNIX Domain Socket support to SelectorEventLoop.
Nc s t � j|� i | _d S )N)�super�__init__�_signal_handlers)�self�selector)� __class__r r r 7 s z _UnixSelectorEventLoop.__init__c C s t j� S )N)�socketZ
socketpair)r r r r � _socketpair; s z"_UnixSelectorEventLoop._socketpairc s^ t � j� tj� s2xFt| j�D ]}| j|� q W n(| jrZtjd| �d�t | d� | jj
� d S )NzClosing the loop z@ on interpreter shutdown stage, skipping signal handlers removal)�source) r �close�sys�
is_finalizing�listr �remove_signal_handler�warnings�warn�ResourceWarning�clear)r �sig)r! r r r% > s
z _UnixSelectorEventLoop.closec C s" x |D ]}|sq| j |� qW d S )N)�_handle_signal)r �datar r r r �_process_self_dataL s
z)_UnixSelectorEventLoop._process_self_datac + G sH t j|�st j|�r td��| j|� | j� ytj| jj � � W n2 t
t fk
rt } zt t
|���W Y dd}~X nX tj||| �}|| j|< y tj|t� tj|d� W n� t k
�rB } zz| j|= | j�sytjd� W n4 t
t fk
�r } ztjd|� W Y dd}~X nX |jtjk�r0t dj|���n� W Y dd}~X nX dS )z�Add 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()NFr z set_wakeup_fd(-1) failed: %szsig {} cannot be caught���)r Z iscoroutineZiscoroutinefunction� TypeError�
_check_signalZ
_check_closed�signal�
set_wakeup_fdZ_csock�fileno�
ValueError�OSError� RuntimeError�strr ZHandler r � siginterruptr �info�errno�EINVAL�format)r r. �callback�args�exc�handleZnexcr r r �add_signal_handlerS s0
z)_UnixSelectorEventLoop.add_signal_handlerc C s8 | j j|�}|dkrdS |jr*| j|� n
| j|� dS )z2Internal helper that is the actual signal handler.N)r �getZ
_cancelledr) Z_add_callback_signalsafe)r r. rD r r r r/ � s z%_UnixSelectorEventLoop._handle_signalc & C s� | j |� y | j|= W n tk
r* dS X |tjkr>tj}ntj}ytj||� W n@ tk
r� } z$|jtj kr�t
dj |���n� W Y dd}~X nX | js�ytj d� W n2 t
tfk
r� } ztjd|� W Y dd}~X nX dS )zwRemove a handler for a signal. UNIX only.
Return True if a signal handler was removed, False if not.
Fzsig {} cannot be caughtNr z set_wakeup_fd(-1) failed: %sTr2 )r4 r �KeyErrorr5 �SIGINT�default_int_handler�SIG_DFLr9 r> r? r: r@ r6 r8 r r= )r r. ZhandlerrC r r r r) � s(
z,_UnixSelectorEventLoop.remove_signal_handlerc C sH t |t�stdj|���d| ko,tjk n sDtdj|tj���dS )z�Internal 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.
z sig must be an int, not {!r}r zsig {} out of range(1, {})N)�
isinstance�intr3 r@ r5 �NSIGr8 )r r. r r r r4 � s
z$_UnixSelectorEventLoop._check_signalc C s t | ||||�S )N)�_UnixReadPipeTransport)r �pipe�protocol�waiter�extrar r r �_make_read_pipe_transport� s z0_UnixSelectorEventLoop._make_read_pipe_transportc C s t | ||||�S )N)�_UnixWritePipeTransport)r rO rP rQ rR r r r �_make_write_pipe_transport� s z1_UnixSelectorEventLoop._make_write_pipe_transportc k s� t j� ��}
| j� } t| |||||||f| |d�| ��} |
j| j� | j| � y| E d H W n& tk
r~ }
z
|
}W Y d d }
~
X nX d }|d k r�| j� | j � E d H |�W d Q R X | S )N)rQ rR )
r �get_child_watcherZ
create_future�_UnixSubprocessTransport�add_child_handlerZget_pid�_child_watcher_callback� Exceptionr% Z_wait)r rP rB �shell�stdin�stdout�stderr�bufsizerR �kwargs�watcherrQ �transprC �errr r r �_make_subprocess_transport� s$
z1_UnixSelectorEventLoop._make_subprocess_transportc C s | j |j|� d S )N)Zcall_soon_threadsafeZ_process_exited)r �pid�
returncoderb r r r rY � s z._UnixSelectorEventLoop._child_watcher_callback)�ssl�sock�server_hostnamec c s |d kst |t�st�|r,|d kr<td��n|d k r<td��|d k r�|d k rTtd��tjtjtjd�}y |jd� | j||�E d H W q� |j � � Y q�X nB|d kr�td��|j
tjks�t j |j
� r�tdj|���|jd� | j||||�E d H \}}||fS )Nz/you have to pass server_hostname when using sslz+server_hostname is only meaningful with sslz3path and sock can not be specified at the same timer Fz no path and sock were specifiedz2A UNIX Domain Stream Socket was expected, got {!r})rK r; �AssertionErrorr8 r" �AF_UNIX� SOCK_STREAM� setblockingZ sock_connectr% �familyr �_is_stream_socket�typer@ Z _create_connection_transport)r �protocol_factoryr rg rh ri � transportrP r r r �create_unix_connection� s:
z-_UnixSelectorEventLoop.create_unix_connection�d )rh �backlogrg c
! C s� t |t�rtd��|d k �r0|d k r,td��t|�}tjtjtj�}|d d
kr�y tj t
j|�j �rnt
j |� W nB t
k
r� Y n0 tk
r� } ztjd||� W Y d d }~X nX y|j|� W nj tk
�r } z8|j� |jtjk�rdj|�}ttj|�d �n� W Y d d }~X n |j� � Y nX n>|d k�rBtd��|jtjk�s`tj|j� �rntdj|���tj| |g�} |j|� |j d � | j |||| � | S ) Nz*ssl argument must be an SSLContext or Nonez3path and sock can not be specified at the same timer � z2Unable to check or remove stale UNIX socket %r: %rz Address {!r} is already in usez-path was not specified, and no sock specifiedz2A UNIX Domain Stream Socket was expected, got {!r}F)r rv ) rK �boolr3 r8 �_fspathr" rk rl �stat�S_ISSOCK�os�st_mode�remove�FileNotFoundErrorr9 r �errorZbindr% r> Z
EADDRINUSEr@ rn r ro rp ZServerZlistenrm Z_start_serving)
r rq r rh ru rg rc rC �msgZserverr r r �create_unix_server sP
z)_UnixSelectorEventLoop.create_unix_server)N)NN)NN)N)N)�__name__�
__module__� __qualname__�__doc__r r# r% r1 rE r/ r) r4 rS rU r
rd rY rs r� �
__classcell__r r )r! r r 1 s, -
%r � set_blockingc C s t j| d� d S )NF)r{ r� )�fdr r r �_set_nonblockingB s r� c C s, t j | t j�}|tjB }t j | t j|� d S )N)�fcntlZF_GETFLr{ �
O_NONBLOCKZF_SETFL)r� �flagsr r r r� G s
c s� e Zd Zd Zd � fdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z dd� Z
dd� Z dd� Z e
jrhdd� Zd!dd�Zdd � Zd d � Z� ZS )"rN � i Nc s� t � j|� || jd< || _|| _|j� | _|| _d| _t j
| j�j }t j
|�pbt j|�pbt j|�s~d | _d | _d | _td��t| j� | jj| jj| � | jj| jj| j| j� |d k r�| jjtj|d � d S )NrO Fz)Pipe transport is for pipes/sockets only.)r r �_extra�_loop�_piper7 �_fileno� _protocol�_closingr{ �fstatr| ry �S_ISFIFOrz �S_ISCHRr8 r� � call_soon�connection_made� _add_reader� _read_readyr � _set_result_unless_cancelled)r �looprO rP rQ rR �mode)r! r r r Q s,
z _UnixReadPipeTransport.__init__c C s� | j jg}| jd kr |jd� n| jr0|jd� |jd| j � t| jdd �}| jd k r�|d k r�tj || jt
j �}|r�|jd� q�|jd� n | jd k r�|jd� n
|jd� dd j |� S )
N�closed�closingzfd=%s� _selector�polling�idle�openz<%s>� )
r! r� r� �appendr� r� �getattrr� r
�_test_selector_eventr Z
EVENT_READ�join)r r= r r� r r r �__repr__n s$
z _UnixReadPipeTransport.__repr__c C s� yt j| j| j�}W nD ttfk
r, Y n� tk
rX } z| j|d� W Y d d }~X n^X |rl| jj |� nJ| j
j � r�t j
d| � d| _| j
j| j� | j
j| jj� | j
j| jd � d S )Nz"Fatal read error on pipe transportz%r was closed by peerT)r{ �readr� �max_size�BlockingIOError�InterruptedErrorr9 � _fatal_errorr� Z
data_receivedr� � get_debugr r= r� �_remove_readerr� Z eof_received�_call_connection_lost)r r0 rC r r r r� � s
z"_UnixReadPipeTransport._read_readyc C s | j j| j� d S )N)r� r� r� )r r r r �
pause_reading� s z$_UnixReadPipeTransport.pause_readingc C s | j j| j| j� d S )N)r� r� r� r� )r r r r �resume_reading� s z%_UnixReadPipeTransport.resume_readingc C s
|| _ d S )N)r� )r rP r r r � set_protocol� s z#_UnixReadPipeTransport.set_protocolc C s | j S )N)r� )r r r r � get_protocol� s z#_UnixReadPipeTransport.get_protocolc C s | j S )N)r� )r r r r �
is_closing� s z!_UnixReadPipeTransport.is_closingc C s | j s| jd � d S )N)r� �_close)r r r r r% � s z _UnixReadPipeTransport.closec C s, | j d k r(tjd| t| d� | j j� d S )Nzunclosed transport %r)r$ )r� r* r+ r, r% )r r r r �__del__� s
z _UnixReadPipeTransport.__del__� Fatal error on pipe transportc C sZ t |t�r4|jtjkr4| jj� rLtjd| |dd� n| jj||| | j d�� | j
|� d S )Nz%r: %sT)�exc_info)�message� exceptionrr rP ) rK r9 r> ZEIOr� r� r �debug�call_exception_handlerr� r� )r rC r� r r r r� � s
z#_UnixReadPipeTransport._fatal_errorc C s( d| _ | jj| j� | jj| j|� d S )NT)r� r� r� r� r� r� )r rC r r r r� � s z _UnixReadPipeTransport._closec C s4 z| j j|� W d | jj� d | _d | _ d | _X d S )N)r� �connection_lostr� r% r� )r rC r r r r� � s
z,_UnixReadPipeTransport._call_connection_losti )NN)r� )r� r� r� r� r r� r� r� r� r� r� r� r% r �PY34r� r� r� r� r� r r )r! r rN M s
rN c s� e Zd Zd%� fdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zejr|dd� Zd d � Zd&d d �Zd'd!d"�Zd#d$� Z� ZS )(rT Nc
s� t � j||� || jd< || _|j� | _|| _t� | _d| _ d| _
t j | j�j
}tj|�}tj|�}tj|�} |px|px| s�d | _d | _d | _td��t| j� | jj| jj| � | s�|r�tjjd� r�| jj| jj| j| j� |d k r�| jjt j |d � d S )NrO r Fz?Pipe transport is only for pipes, sockets and character devices�aix) r r r� r� r7 r� r� � bytearray�_buffer�
_conn_lostr� r{ r� r| ry r� r� rz r8 r� r� r� r� r& �platform�
startswithr� r� r r� )
r r� rO rP rQ rR r� Zis_charZis_fifoZ is_socket)r! r r r � s2
z _UnixWritePipeTransport.__init__c C s� | j jg}| jd kr |jd� n| jr0|jd� |jd| j � t| jdd �}| jd k r�|d k r�tj || jt
j �}|r�|jd� n
|jd� | j � }|jd| � n | jd k r�|jd� n
|jd� d d
j
|� S ) Nr� r� zfd=%sr� r� r� z
bufsize=%sr� z<%s>r� )r! r� r� r� r� r� r� r� r
r� r Z EVENT_WRITE�get_write_buffer_sizer� )r r= r r� r_ r r r r� � s(
z _UnixWritePipeTransport.__repr__c C s
t | j�S )N)�lenr� )r r r r r� s z-_UnixWritePipeTransport.get_write_buffer_sizec C s6 | j j� rtjd| � | jr*| jt� � n| j� d S )Nz%r was closed by peer)r� r� r r= r� r� �BrokenPipeError)r r r r r� s
z#_UnixWritePipeTransport._read_readyc C s0 t |tttf�s tt|���t |t�r.t|�}|s6d S | jsB| jrj| jtj krXt
j d� | jd7 _d S | j �syt
j| j|�}W nT ttfk
r� d}Y n: tk
r� } z | jd7 _| j|d� d S d }~X nX |t|�kr�d S |dk�rt|�|d � }| jj| j| j� | j |7 _ | j� d S )Nz=pipe closed by peer or os.write(pipe, data) raised exception.r r z#Fatal write error on pipe transport)rK �bytesr� �
memoryviewrj �reprr� r� r Z!LOG_THRESHOLD_FOR_CONNLOST_WRITESr �warningr� r{ �writer� r� r� rZ r� r� r� Z _add_writer� _write_readyZ_maybe_pause_protocol)r r0 �nrC r r r r� s4
z _UnixWritePipeTransport.writec C s� | j std��ytj| j| j �}W nj ttfk
r: Y n� tk
r� } z8| j j� | j d7 _ | j
j | j� | j |d� W Y d d }~X nfX |t
| j �kr�| j j� | j
j | j� | j� | jr�| j
j| j� | jd � d S |dkr�| j d |�= d S )NzData should not be emptyr z#Fatal write error on pipe transportr )r� rj r{ r� r� r� r� rZ r- r� r� �_remove_writerr� r� Z_maybe_resume_protocolr� r� r� )r r� rC r r r r� > s(
z$_UnixWritePipeTransport._write_readyc C s dS )NTr )r r r r �
can_write_eofX s z%_UnixWritePipeTransport.can_write_eofc C sB | j r
d S | jst�d| _ | js>| jj| j� | jj| jd � d S )NT) r� r� rj r� r� r� r� r� r� )r r r r � write_eof[ s
z!_UnixWritePipeTransport.write_eofc C s
|| _ d S )N)r� )r rP r r r r� d s z$_UnixWritePipeTransport.set_protocolc C s | j S )N)r� )r r r r r� g s z$_UnixWritePipeTransport.get_protocolc C s | j S )N)r� )r r r r r� j s z"_UnixWritePipeTransport.is_closingc C s | j d k r| j r| j� d S )N)r� r� r� )r r r r r% m s z _UnixWritePipeTransport.closec C s, | j d k r(tjd| t| d� | j j� d S )Nzunclosed transport %r)r$ )r� r* r+ r, r% )r r r r r� v s
z _UnixWritePipeTransport.__del__c C s | j d � d S )N)r� )r r r r �abort| s z _UnixWritePipeTransport.abort� Fatal error on pipe transportc C sP t |tj�r*| jj� rBtjd| |dd� n| jj||| | jd�� | j |� d S )Nz%r: %sT)r� )r� r� rr rP )
rK r Z_FATAL_ERROR_IGNOREr� r� r r� r� r� r� )r rC r� r r r r� s
z$_UnixWritePipeTransport._fatal_errorc C sF d| _ | jr| jj| j� | jj� | jj| j� | jj| j|� d S )NT) r� r� r� r� r� r- r� r� r� )r rC r r r r� � s
z _UnixWritePipeTransport._closec C s4 z| j j|� W d | jj� d | _d | _ d | _X d S )N)r� r� r� r% r� )r rC 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 rT � s$ % !
rT �set_inheritablec C sN t tdd�}tj| tj�}|s4tj| tj||B � ntj| tj|| @ � d S )NZ
FD_CLOEXECr )r� r� ZF_GETFDZF_SETFD)r� Z inheritableZ cloexec_flag�oldr r r �_set_inheritable� s
r� c @ s e Zd Zdd� ZdS )rW c K sv d }|t jkr*| jj� \}}t|j� d� t j|f||||d|d�|��| _|d k rr|j� t |j
� d|d�| j_ d S )NF)r[ r\ r] r^ Zuniversal_newlinesr_ �wb)� buffering) �
subprocess�PIPEr� r# r� r7 �Popen�_procr% r� �detachr\ ) r rB r[ r\ r] r^ r_ r` Zstdin_wr r r �_start� s
z _UnixSubprocessTransport._startN)r� r� r� r� r r r r rW � s rW c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� 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.
N)�NotImplementedError)r re rA rB r r r rX � s z&AbstractChildWatcher.add_child_handlerc C s
t � �dS )z�Removes the handler for process 'pid'.
The function returns True if the handler was successfully removed,
False if there was nothing to remove.N)r� )r re r r r �remove_child_handler� s z)AbstractChildWatcher.remove_child_handlerc C s
t � �dS )z�Attach 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.
N)r� )r r� r r r � attach_loop� 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.
N)r� )r r r r r% � s zAbstractChildWatcher.closec C s
t � �dS )zdEnter the watcher's context and allow starting new processes
This function must return selfN)r� )r r r r � __enter__ s z AbstractChildWatcher.__enter__c C s
t � �dS )zExit the watcher's contextN)r� )r �a�b�cr r r �__exit__ s z AbstractChildWatcher.__exit__N)
r� r� r� r� rX r� r� r% r� r� r r r r r � s
c @ sD e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dS )�BaseChildWatcherc C s d | _ i | _d S )N)r� �
_callbacks)r r r r r s zBaseChildWatcher.__init__c C s | j d � d S )N)r� )r r r r r% s zBaseChildWatcher.closec C s
t � �d S )N)r� )r � expected_pidr r r � _do_waitpid s z BaseChildWatcher._do_waitpidc C s
t � �d S )N)r� )r r r r �_do_waitpid_all s z BaseChildWatcher._do_waitpid_allc C s~ |d kst |tj�st�| jd k r<|d kr<| jr<tjdt� | jd k rT| jj t
j � || _|d k rz|j t
j | j
� | j� d S )NzCA loop is being detached from a child watcher with pending handlers)rK r ZAbstractEventLooprj r� r� r* r+ �RuntimeWarningr) r5 �SIGCHLDrE � _sig_chldr� )r r� r r r r� s
z BaseChildWatcher.attach_loopc C sF y | j � W n4 tk
r@ } z| jjd|d�� W Y d d }~X nX d S )Nz$Unknown exception in SIGCHLD handler)r� r� )r� rZ r� r� )r rC r r r r� 1 s zBaseChildWatcher._sig_chldc C s2 t j|�rt j|� S t j|�r*t j|�S |S d S )N)r{ � WIFSIGNALED�WTERMSIG� WIFEXITED� WEXITSTATUS)r �statusr r r �_compute_returncode= s
z$BaseChildWatcher._compute_returncodeN)
r� r� r� r r% r� r� r� r� r� r r r r r� s r� c sP e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
� Z S )r ad 'Safe' child watcher implementation.
This implementation avoids disrupting other code spawning processes by
polling explicitly each process in the SIGCHLD handler instead of calling
os.waitpid(-1).
This is a safe solution but it has a significant overhead when handling a
big number of children (O(n) each time SIGCHLD is raised)
c s | j j� t� j� d S )N)r� r- r r% )r )r! r r r% V s
zSafeChildWatcher.closec C s | S )Nr )r r r r r� Z s zSafeChildWatcher.__enter__c C s d S )Nr )r r� r� r� r r r r� ] s zSafeChildWatcher.__exit__c G s. | j d krtd��||f| j|< | j|� d S )NzICannot add child handler, the child watcher does not have a loop attached)r� r: r� r� )r re rA rB r r r rX ` s
z"SafeChildWatcher.add_child_handlerc C s& y | j |= dS tk
r dS X d S )NTF)r� rG )r re r r r r� k s
z%SafeChildWatcher.remove_child_handlerc C s" x t | j�D ]}| j|� q W d S )N)r( r� r� )r re r r r r� r s z SafeChildWatcher._do_waitpid_allc C s� |dks t �ytj|tj�\}}W n( tk
rJ |}d}tjd|� Y n0X |dkrXd S | j|�}| jj � rztj
d||� y| j j |�\}}W n. t
k
r� | jj � r�tjd|dd� Y nX |||f|�� d S )Nr � z8Unknown child process pid %d, will report returncode 255z$process %s exited with returncode %sz'Child watcher got an unexpected pid: %rT)r� )rj r{ �waitpid�WNOHANG�ChildProcessErrorr r� r� r� r� r� r� �poprG )r r� re r� rf rA rB r r r r� w s,
z SafeChildWatcher._do_waitpid) r� r� r� r� r% r� r� rX r� r� r� r� r r )r! r r K s c sT e Zd ZdZ� fdd�Z� fdd�Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
� Z S )r aW 'Fast' child watcher implementation.
This implementation reaps every terminated processes by calling
os.waitpid(-1) directly, possibly breaking other code spawning processes
and waiting for their termination.
There is no noticeable overhead when handling a big number of children
(O(1) each time a child terminates).
c s$ t � j� tj� | _i | _d| _d S )Nr )r r � threadingZLock�_lock�_zombies�_forks)r )r! r r r � s
zFastChildWatcher.__init__c s" | j j� | jj� t� j� d S )N)r� r- r� r r% )r )r! r r r% � s
zFastChildWatcher.closec
C s$ | j � | jd7 _| S Q R X d S )Nr )r� r� )r r r r r� � s zFastChildWatcher.__enter__c
C sV | j �: | jd8 _| js$| j r(d S t| j�}| jj� W d Q R X tjd|� 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 sz | j std��| jd kr td��| j�: y| jj|�}W n" tk
rZ ||f| j|< d S X W d Q R X |||f|�� d S )Nz Must use the context managerzICannot add child handler, the child watcher does not have a loop attached) r� rj r� r: r� r� r� rG r� )r re rA rB rf r r r rX � s
z"FastChildWatcher.add_child_handlerc C s& y | j |= dS tk
r dS X d S )NTF)r� rG )r re r r r r� � s
z%FastChildWatcher.remove_child_handlerc C s� x�yt jdt j�\}}W n tk
r, d S X |dkr:d S | j|�}| j�v y| jj|�\}}W nB tk
r� | j r�|| j
|< | j j � r�t
jd||� wd }Y nX | j j � r�t
jd||� W d Q R X |d kr�t
jd||� q|||f|�� qW d S )Nr r z,unknown process %s exited with returncode %sz$process %s exited with returncode %sz8Caught subprocess termination from unknown pid: %d -> %dr2 )r{ r� r� r� r� r� r� r� rG r� r� r� r� r r� r� )r re r� rf rA rB r r r r� � s6
z FastChildWatcher._do_waitpid_all) r� r� r� r� r r% r� r� rX r� r� r� r r )r! r r � s c sH e Zd ZdZeZ� fdd�Zdd� Z� fdd�Zdd � Z d
d � Z
� Z S ) �_UnixDefaultEventLoopPolicyz:UNIX event loop policy with a watcher for child processes.c s t � j� d | _d S )N)r r �_watcher)r )r! r r r s
z$_UnixDefaultEventLoopPolicy.__init__c
C sH t j�8 | jd kr:t� | _ttj� tj�r:| jj| j j
� W d Q R X d S )N) r r� r r rK r� �current_thread� _MainThreadr� �_localr� )r r r r �
_init_watcher s
z)_UnixDefaultEventLoopPolicy._init_watcherc s6 t � j|� | jdk r2ttj� tj�r2| jj|� dS )z�Set 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_loopr rK r� r r r� )r r� )r! r r r s
z*_UnixDefaultEventLoopPolicy.set_event_loopc C s | j dkr| j� | j S )zzGet the watcher for child processes.
If not yet set, a SafeChildWatcher object is automatically created.
N)r r )r r r r rV & s
z-_UnixDefaultEventLoopPolicy.get_child_watcherc C s4 |dkst |t�st�| jdk r*| jj� || _dS )z$Set the watcher for child processes.N)rK r rj r r% )r ra r r r �set_child_watcher0 s
z-_UnixDefaultEventLoopPolicy.set_child_watcher) r� r� r� r� r Z
_loop_factoryr r r rV r r� r r )r! r r s
r )5r� r> r{ r5 r" ry r� r& r� r* � r r r r r r r r
r r r
�logr �__all__r� � ImportErrorr �fspathrx �AttributeErrorZBaseSelectorEventLoopr �hasattrr� r� Z
ReadTransportrN Z_FlowControlMixinZWriteTransportrT r� r� ZBaseSubprocessTransportrW r r� r r ZBaseDefaultEventLoopPolicyr r r r r r r �<module> sn
O
F=On2PK [ U��4 4 ) __pycache__/sslproto.cpython-36.opt-2.pycnu �[��� 3
\�e �
@ s� d dl Z d dlZy d dlZW n ek
r4 dZY nX ddlmZ ddlmZ ddlmZ ddlmZ ddl m
Z
dd � Z d
d � Z d Z
d
ZdZdZG dd� de�ZG dd� dejej�ZG dd� dej�ZdS )� N� )� base_events)�compat)� protocols)�
transports)�loggerc C sj | r t d��ttd�r*tj� }|sfd|_n<tjtj�}| jtjO _| jtj O _|j
� tj |_ |S )Nz(Server side SSL needs a valid SSLContext�create_default_contextF)
�
ValueError�hasattr�sslr �check_hostnameZ
SSLContextZPROTOCOL_SSLv23ZoptionsZ OP_NO_SSLv2Z OP_NO_SSLv3Zset_default_verify_pathsZ
CERT_REQUIRED� verify_mode)� server_side�server_hostname�
sslcontext� r �(/usr/lib64/python3.6/asyncio/sslproto.py�_create_transport_context s
r c C s
t td�S )N� MemoryBIO)r
r r r r r �_is_sslproto_available% s r Z UNWRAPPEDZ DO_HANDSHAKEZWRAPPEDZSHUTDOWNc @ sz e Zd ZdZddd�Zedd� �Zedd � �Zed
d � �Zed d
� �Z d dd�Z
d dd�Z dd� Z d dd�Z
d dd�ZdS ) �_SSLPipe� i Nc C sH || _ || _|| _t| _tj� | _tj� | _d | _ d| _
d | _ d | _ d S )NF)
�_context� _server_side�_server_hostname�
_UNWRAPPED�_stater r � _incoming� _outgoing�_sslobj�
_need_ssldata�
_handshake_cb� _shutdown_cb)�self�contextr r r r r �__init__D s
z_SSLPipe.__init__c C s | j S )N)r )r# r r r r$ Z s z_SSLPipe.contextc C s | j S )N)r )r# r r r �
ssl_object_ s z_SSLPipe.ssl_objectc C s | j S )N)r )r# r r r � need_ssldatag s z_SSLPipe.need_ssldatac C s
| j tkS )N)r �_WRAPPED)r# r r r �wrappedm 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_ssldata)r# �callback�ssldata�appdatar r r � do_handshakev s
z_SSLPipe.do_handshakec C sB | j tkrtd��| j tkr$td��t| _ || _| jd�\}}|S )Nzno security layer presentzshutdown in progressr* )r r r, � _SHUTDOWNr" r. )r# r/ r0 r1 r r r �shutdown� s
z_SSLPipe.shutdownc C s | j j� | jd�\}}d S )Nr* )r Z write_eofr. )r# r0 r1 r r r �feed_eof� s
z_SSLPipe.feed_eofFc C s� | j tkr"|r|g}ng }g |fS d| _|r8| jj|� g }g }y�| j tkrx| jj� t| _ | j rl| j d � |rx||fS | j tkr�xn| jj
| j �}|j |� |s�P q�W nJ| j t
kr�| jj� d | _t| _ | jr�| j� n| j tkr�|j | jj
� � W nx tjtjfk
�rl } zRt|dd �tjtjtjfk�rN| j tk�rL| j �rL| j |� � |jtjk| _W Y d d }~X nX | jj�r�|j | jj
� � ||fS )NF�errno)r r r r �writer- r r2 r( r! �read�max_size�appendr3 Zunwrapr" r �SSLError�CertificateError�getattr�SSL_ERROR_WANT_READ�SSL_ERROR_WANT_WRITE�SSL_ERROR_SYSCALLr6 r �pending)r# �datar+ r1 r0 �chunk�excr r r r. � sV
z_SSLPipe.feed_ssldatar c C s | j tkr6|t|�k r&||d � g}ng }|t|�fS g }t|�}x�d| _y(|t|�k rp|| jj||d � �7 }W n\ tjk
r� } z>|j dkr�tj
|_ |j tj
tj tj
fkr�� |j tj
k| _W Y d d }~X nX | jjr�|j| jj� � |t|�ks�| jrDP qDW ||fS )NFZPROTOCOL_IS_SHUTDOWN)r r �len�
memoryviewr r r7 r r; �reasonr> r6 r? r@ r rA r: r8 )r# rB �offsetr0 ZviewrD r r r � feed_appdata� s2
z_SSLPipe.feed_appdatai )N)N)N)F)r )�__name__�
__module__� __qualname__r9 r% �propertyr$ r& r' r) r2 r4 r5 r. rI r r r r r 0 s
Jr c @ s� e Zd Zdd� Zd dd�Zdd� Zdd � Zd
d � Zd d
� Ze j
rHdd� Z dd� Z dd� Z
d dd�Zdd� Zdd� Zdd� 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 j||�S )N)rP �_get_extra_info)r# �name�defaultr r r �get_extra_info/ s z$_SSLProtocolTransport.get_extra_infoc C s || j _d S )N)rP �
_app_protocol)r# �protocolr r r � set_protocol3 s z"_SSLProtocolTransport.set_protocolc C s | j jS )N)rP rW )r# r r r � get_protocol6 s z"_SSLProtocolTransport.get_protocolc C s | j S )N)rQ )r# r r r �
is_closing9 s z _SSLProtocolTransport.is_closingc C s d| _ | jj� d S )NT)rQ rP �_start_shutdown)r# r r r �close< s z_SSLProtocolTransport.closec C s& | j s"tjd| t| d� | j� d S )Nzunclosed transport %r)�source)rQ �warnings�warn�ResourceWarningr] )r# r r r �__del__K s z _SSLProtocolTransport.__del__c C s | j jj� d S )N)rP �
_transport�
pause_reading)r# r r r rd Q s z#_SSLProtocolTransport.pause_readingc C s | j jj� d S )N)rP rc �resume_reading)r# r r r re Y s z$_SSLProtocolTransport.resume_readingc C s | j jj||� d S )N)rP rc �set_write_buffer_limits)r# ZhighZlowr r r rf a s z-_SSLProtocolTransport.set_write_buffer_limitsc C s | j jj� S )N)rP rc �get_write_buffer_size)r# r r r rg v s z+_SSLProtocolTransport.get_write_buffer_sizec C s< t |tttf�s$tdjt|�j���|s,d S | jj |� d S )Nz/data: expecting a bytes-like instance, got {!r})
�
isinstance�bytes� bytearrayrF � TypeError�format�typerJ rP �_write_appdata)r# rB r r r r7 z s z_SSLProtocolTransport.writec C s dS )NFr )r# r r r �
can_write_eof� s z#_SSLProtocolTransport.can_write_eofc C s | j j� d S )N)rP �_abort)r# r r r �abort� s z_SSLProtocolTransport.abort)N)NN)rJ rK rL r% rV rY rZ r[ r] r ZPY34rb rd re rf rg r7 ro rq r r r r rN & s
rN c @ s� e Zd Zd'dd�Zd(dd�Zdd � Zd
d � Zd d
� Zdd� Zdd� Z dd� Z
d)dd�Z dd� Z dd� Z
dd� Zd d � Zd d � Zd*d!d"�Zd#d$� Zd%d&� ZdS )+� SSLProtocolFNTc C s� t d krtd��|s t||�}|| _|r6| r6|| _nd | _|| _t|d�| _tj � | _
d| _ || _ || _
|| _t| j
| �| _d | _d| _d| _d| _d | _|| _d S )Nz stdlib ssl module not available)r r F)r r, r r r � _sslcontext�dict�_extra� collections�deque�_write_backlog�_write_buffer_size�_waiterrO rW rN �_app_transport�_sslpipe�_session_established�
_in_handshake� _in_shutdownrc �_call_connection_made)r# rR Z app_protocolr Zwaiterr r Zcall_connection_mader r r r% � s,
zSSLProtocol.__init__c C sD | j d krd S | j j� s:|d k r.| j j|� n | j jd � d | _ d S )N)rz Z cancelledZ
set_exceptionZ
set_result)r# rD r r r �_wakeup_waiter� s
zSSLProtocol._wakeup_waiterc C s& || _ t| j| j| j�| _| j� d S )N)rc r rs r r r| �_start_handshake)r# � transportr r r �connection_made� s
zSSLProtocol.connection_madec C s8 | j r d| _ | jj| jj|� d | _d | _| j|� d S )NF)r} rO � call_soonrW �connection_lostrc r{ r� )r# rD r r r r� � s zSSLProtocol.connection_lostc C s | j j� d S )N)rW �
pause_writing)r# r r r r� � s zSSLProtocol.pause_writingc C s | j j� d S )N)rW �resume_writing)r# r r r r� � s zSSLProtocol.resume_writingc C s� | j d krd S y| j j|�\}}W nH tjk
rj } z*| jj� rTtjd| |j|j � | j
� d S d }~X nX x|D ]}| j j |� qrW x(|D ] }|r�| j
j|� q�| j� P q�W d S )Nz %r: SSL error %s (reason %s))r| r. r r; rO � get_debugr �warningr6 rG rp rc r7 rW �
data_receivedr\ )r# rB r0 r1 �erC r r r r� � s"
zSSLProtocol.data_receivedc
C sT zB| j j� rtjd| � | jt� | js@| jj� }|r@tj d� W d | j
j � X d S )Nz%r received EOFz?returning true from eof_received() has no effect when using ssl) rO r� r �debugr� �ConnectionResetErrorr~ rW � eof_receivedr� rc r] )r# Z keep_openr r r r� s
zSSLProtocol.eof_receivedc C s4 || j kr| j | S | jd k r,| jj||�S |S d S )N)ru rc rV )r# rT rU r r r rS ! s
zSSLProtocol._get_extra_infoc C s. | j r
d S | jr| j� nd| _ | jd� d S )NTr* )r r~ rp rn )r# r r r r\ ) s
zSSLProtocol._start_shutdownc C s. | j j|df� | jt|�7 _| j� d S )Nr )rx r: ry rE �_process_write_backlog)r# rB r r r rn 2 s zSSLProtocol._write_appdatac C sH | j j� r$tjd| � | j j� | _nd | _d| _| jjd� | j � d S )Nz%r starts SSL handshakeTr* r )r* r )
rO r� r r� �time�_handshake_start_timer~ rx r: r� )r# r r r r� 7 s
z SSLProtocol._start_handshakec C sT d| _ | jj}yF|d k r |�|j� }t| jd�sR| jrR| jjtj krRtj
|| j� W n~ t k
r� } zb| j j
� r�t|tj�r�tjd| dd� ntjd| dd� | jj� t|t�r�| j|� d S � W Y d d }~X nX | j j
� �r| j j� | j }tjd| |d � | jj||j� |j � |d � | j �r4| j j | j � | j� d| _!| j j"| j#� d S )
NFr z5%r: SSL handshake failed on verifying the certificateT)�exc_infoz%r: SSL handshake failedz %r: SSL handshake took %.1f msg @�@)�peercert�cipher� compressionr& )$r~ r| r& Z getpeercertr
rs r r
r Z CERT_NONEZmatch_hostname�
BaseExceptionrO r� rh r< r r� rc r] � Exceptionr� r� r� r� ru �updater� r� r� rW r� r{ r} r� r� )r# Z
handshake_excZsslobjr� rD Zdtr r r �_on_handshake_completeC sD
z"SSLProtocol._on_handshake_completec C s> | j d ks| jd krd S y�x�tt| j��D ]�}| jd \}}|rT| jj||�\}}n*|rl| jj| j�}d}n| jj| j �}d}x|D ]}| j j
|� q�W |t|�k r�||f| jd< | j j r�| j j � P | jd= | j
t|�8 _
q*W W nR tk
�r8 } z4| j�r| j|� n | j|d� t|t��s(� W Y d d }~X nX d S )Nr r z Fatal error on SSL transport)rc r| �rangerE rx rI r2 r� r4 � _finalizer7 Z_pausedre ry r� r~ � _fatal_errorrh r� )r# �irB rH r0 rC rD r r r r� w s8
z"SSLProtocol._process_write_backlog�Fatal error on transportc C sX t |tj�r*| jj� rBtjd| |dd� n| jj||| j| d�� | jrT| jj |� d S )Nz%r: %sT)r� )�messageZ exceptionr� rX )
rh r Z_FATAL_ERROR_IGNORErO r� r r� Zcall_exception_handlerrc Z _force_close)r# rD r� r r r r� � s
zSSLProtocol._fatal_errorc C s d | _ | jd k r| jj� d S )N)r| rc r] )r# r r r r� � s
zSSLProtocol._finalizec
C s( z| j d k r| j j� W d | j� X d S )N)rc rq r� )r# r r r rp � s
zSSLProtocol._abort)FNT)N)N)r� )rJ rK rL r% r� r� r� r� r� r� r� rS r\ rn r� r� r� r� r� rp r r r r rr � s$
"
4,
rr )rv r_ r � ImportError� r r r r �logr r r r r- r( r3 �objectr Z_FlowControlMixinZ TransportrN ZProtocolrr r r r r �<module> s*
wnPK [��ېb �b ' __pycache__/events.cpython-36.opt-1.pycnu �[��� 3
\�[ � @ s� d Z ddddddddd d
d d d
dgZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl m Z ddl m
Z
dd� Zdd� Zd3dd�Zdd � Zd4d d �ZG d d� d�ZG d d� de�ZG d!d� d�ZG d"d� d�ZG d#d� d�ZG d$d%� d%e�Zdae j� ZG d&d'� d'e j �Z e � Z d(d� Z d)d
� Z d*d+� Z!d,d� Z"d-d� Z#d.d� Z$d/d � Z%d0d
� Z&d1d � Z'd2d � Z(dS )5z!Event loop and event loop policy.�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� N� )�compat)� constantsc C st t jrtj| �} nt| d�r"| j} tj| �r>| j}|j|j fS t
| t j �rTt
| j�S t jrpt
| t j�rpt
| j�S d S )N� __wrapped__)r ZPY34�inspectZunwrap�hasattrr Z
isfunction�__code__� co_filename�co_firstlineno�
isinstance� functools�partial�_get_function_source�func�
partialmethod)r �code� r �&/usr/lib64/python3.6/asyncio/events.pyr s
r c C sJ g }| r |j dd� | D �� |r8|j dd� |j� D �� ddj|� d S )z�Format function arguments and keyword arguments.
Special case for a single parameter: ('hello',) is formatted as ('hello').
c s s | ]}t j|�V qd S )N)�reprlib�repr)�.0�argr r r! � <genexpr>1 s z*_format_args_and_kwargs.<locals>.<genexpr>c s s$ | ] \}}d j |tj|��V qdS )z{}={}N)�formatr" r# )r$ �k�vr r r! r& 3 s �(z, �))�extend�items�join)�args�kwargsr- r r r! �_format_args_and_kwargs) s
r1 � c C s� t | tj�r.t||�| }t| j| j| j|�S t| d�rF| j rF| j }n t| d�r^| j
r^| j
}nt | �}|t||�7 }|r�||7 }|S )N� __qualname__�__name__) r r r r1 �_format_callbackr r/ �keywordsr r3 r4 r# )r r/ r0 �suffix� func_reprr r r! r5 8 s r5 c C s( t | |d �}t| �}|r$|d| 7 }|S )Nz at %s:%s)r5 r )r r/ r8 �sourcer r r! �_format_callback_sourceI s
r: c C sD | dkrt j� j} |dkr tj}tjjtj| �|dd�}|j � |S )zlReplacement for traceback.extract_stack() that only does the
necessary work for asyncio debug mode.
NF)�limit� lookup_lines)
�sys� _getframe�f_backr ZDEBUG_STACK_DEPTH� traceback� StackSummary�extract�
walk_stack�reverse)�fr; �stackr r r! �
extract_stackQ s
rG c @ s< e Zd ZdZdZd d
� Zd d � Zd
d� Zdd� Zdd� Z dS )r z1Object returned by callback registration methods.� _callback�_args�
_cancelled�_loop�_source_traceback�_repr� __weakref__c C sD || _ || _|| _d| _d | _| j j� r:ttjd��| _ nd | _ d S )NFr )
rK rH rI rJ rM � get_debugrG r= r> rL )�self�callbackr/ �loopr r r! �__init__h s
zHandle.__init__c C sf | j jg}| jr|jd� | jd k r8|jt| j| j�� | jrb| jd }|jd|d |d f � |S )NZ cancelledr zcreated at %s:%sr ���)� __class__r4 rJ �appendrH r: rI rL )rP �info�framer r r! �
_repr_infos s
zHandle._repr_infoc C s& | j d k r| j S | j� }ddj|� S )Nz<%s>� )rM rY r. )rP rW r r r! �__repr__~ s
zHandle.__repr__c C s0 | j s,d| _ | jj� r t| �| _d | _d | _d S )NT)rJ rK rO r# rM rH rI )rP r r r! �cancel� s
z
Handle.cancelc C s| y| j | j� W nb tk
rr } zFt| j | j�}dj|�}||| d�}| jrV| j|d< | jj|� W Y d d }~X nX d } d S )NzException in callback {})�messageZ exception�handleZsource_traceback)rH rI � Exceptionr: r' rL rK �call_exception_handler)rP �exc�cb�msg�contextr r r! �_run� s
z Handle._runN)rH rI rJ rK rL rM rN )
r4 �
__module__r3 �__doc__� __slots__rS rY r[ r\ re r r r r! r b s c sx e Zd ZdZddgZ� fdd�Z� fdd�Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
� fdd�Z� ZS )r z7Object returned by timed callback registration methods.�
_scheduled�_whenc s. t � j|||� | jr | jd= || _d| _d S )Nr FrT )�superrS rL rj ri )rP �whenrQ r/ rR )rU r r! rS � s
zTimerHandle.__init__c s. t � j� }| jrdnd}|j|d| j � |S )N� r zwhen=%s)rk rY rJ �insertrj )rP rW �pos)rU r r! rY � s
zTimerHandle._repr_infoc C s
t | j�S )N)�hashrj )rP r r r! �__hash__� s zTimerHandle.__hash__c C s | j |j k S )N)rj )rP �otherr r r! �__lt__� s zTimerHandle.__lt__c C s | j |j k rdS | j|�S )NT)rj �__eq__)rP rr r r r! �__le__� s zTimerHandle.__le__c C s | j |j kS )N)rj )rP rr r r r! �__gt__� s zTimerHandle.__gt__c C s | j |j krdS | j|�S )NT)rj rt )rP rr r r r! �__ge__� s zTimerHandle.__ge__c C s> t |t�r:| j|jko8| j|jko8| j|jko8| j|jkS tS )N)r r rj rH rI rJ �NotImplemented)rP rr r r r! rt � s
zTimerHandle.__eq__c C s | j |�}|tkrtS | S )N)rt rx )rP rr Zequalr r r! �__ne__� s
zTimerHandle.__ne__c s | j s| jj| � t� j� d S )N)rJ rK �_timer_handle_cancelledrk r\ )rP )rU r r! r\ � s zTimerHandle.cancel)r4 rf r3 rg rh rS rY rq rs ru rv rw rt ry r\ �
__classcell__r r )rU r! r � s c @ s e Zd ZdZdd� Zdd� ZdS )r z,Abstract server returned by create_server().c C s t S )z5Stop serving. This leaves existing connections open.)rx )rP r r r! �close� s zAbstractServer.closec C s t S )z*Coroutine to wait until service is closed.)rx )rP r r r! � wait_closed� s zAbstractServer.wait_closedN)r4 rf r3 rg r| r} r r r r! r � s c @ s e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d$d$d$d%�d&d'�Zdhd(d)�Zdid*d$d$d$d*d*d*d+�d,d-�Zdjejejd*d.d*d*d*d/�d0d1�Zd*d*d*d2�d3d4�Z d*d.d*d5�d6d7�Z dkd$d$d$d*d*d*d*d8�d9d:�Z d;d<� Z d=d>� Z e!j"e!j"e!j"d?�d@dA�Z#e!j"e!j"e!j"d?�dBdC�Z$dDdE� Z%dFdG� Z&dHdI� Z'dJdK� Z(dLdM� Z)dNdO� Z*dPdQ� Z+dRdS� Z,dTdU� Z-dVdW� Z.dXdY� Z/dZd[� Z0d\d]� Z1d^d_� Z2d`da� Z3dbdc� Z4ddde� Z5dfdg� Z6d*S )lr zAbstract event loop.c C s t �dS )z*Run the event loop until stop() is called.N)�NotImplementedError)rP 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.
N)r~ )rP Zfuturer r r! �run_until_complete� s z$AbstractEventLoop.run_until_completec C s t �dS )z�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.
N)r~ )rP r r r! �stop� s zAbstractEventLoop.stopc C s t �dS )z3Return whether the event loop is currently running.N)r~ )rP r r r! �
is_running� s z AbstractEventLoop.is_runningc C s t �dS )z*Returns True if the event loop was closed.N)r~ )rP r r r! � is_closed s zAbstractEventLoop.is_closedc C s t �dS )z�Close the loop.
The loop should not be running.
This is idempotent and irreversible.
No other methods should be called after this one.
N)r~ )rP r r r! r| s zAbstractEventLoop.closec C s t �dS )z,Shutdown all active asynchronous generators.N)r~ )rP r r r! �shutdown_asyncgens s z$AbstractEventLoop.shutdown_asyncgensc C s t �dS )z3Notification that a TimerHandle has been cancelled.N)r~ )rP r^ r r r! rz s z)AbstractEventLoop._timer_handle_cancelledc G s | j d|f|�� S )Nr )�
call_later)rP rQ r/ r r r! � call_soon s zAbstractEventLoop.call_soonc G s t �d S )N)r~ )rP ZdelayrQ r/ r r r! r� s z AbstractEventLoop.call_laterc G s t �d S )N)r~ )rP rl rQ r/ r r r! �call_at s zAbstractEventLoop.call_atc C s t �d S )N)r~ )rP r r r! �time" s zAbstractEventLoop.timec C s t �d S )N)r~ )rP r r r! �
create_future% s z AbstractEventLoop.create_futurec C s t �d S )N)r~ )rP �coror r r! � create_task* s z AbstractEventLoop.create_taskc G s t �d S )N)r~ )rP rQ r/ r r r! �call_soon_threadsafe/ s z&AbstractEventLoop.call_soon_threadsafec G s t �d S )N)r~ )rP �executorr r/ r r r! �run_in_executor2 s z!AbstractEventLoop.run_in_executorc C s t �d S )N)r~ )rP r� r r r! �set_default_executor5 s z&AbstractEventLoop.set_default_executorr )�family�type�proto�flagsc C s t �d S )N)r~ )rP �host�portr� r� r� r� r r r! � getaddrinfo: s z AbstractEventLoop.getaddrinfoc C s t �d S )N)r~ )rP Zsockaddrr� r r r! � getnameinfo= s z AbstractEventLoop.getnameinfoN)�sslr� r� r� �sock�
local_addr�server_hostnamec C s t �d S )N)r~ ) rP �protocol_factoryr� r� r� r� r� r� r� r� r� r r r! �create_connection@ s z#AbstractEventLoop.create_connection�d )r� r� r� �backlogr� �
reuse_address�
reuse_portc C s t �dS )a� 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.
N)r~ ) rP r� r� r� r� r� r� r� r� r� r� r r r! �
create_serverE s 'z AbstractEventLoop.create_server)r� r� r� c C s t �d S )N)r~ )rP r� �pathr� r� r� r r r! �create_unix_connectionn s z(AbstractEventLoop.create_unix_connection)r� r� r� c 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.
N)r~ )rP r� r� r� r� r� r r r! �create_unix_servers s z$AbstractEventLoop.create_unix_server)r� r� r� r� r� �allow_broadcastr� c 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 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.
N)r~ ) rP r� r� Z remote_addrr� r� r� r� r� r� r� r r r! �create_datagram_endpoint� s !z*AbstractEventLoop.create_datagram_endpointc C 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.N)r~ )rP r� �piper r r! �connect_read_pipe� s z#AbstractEventLoop.connect_read_pipec C 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.N)r~ )rP r� r� r r r! �connect_write_pipe� s z$AbstractEventLoop.connect_write_pipe)�stdin�stdout�stderrc K s t �d S )N)r~ )rP r� �cmdr� r� r� r0 r r r! �subprocess_shell� s z"AbstractEventLoop.subprocess_shellc O s t �d S )N)r~ )rP r� r� r� r� r/ r0 r r r! �subprocess_exec� s z!AbstractEventLoop.subprocess_execc G s t �d S )N)r~ )rP �fdrQ r/ r r r! �
add_reader� s z AbstractEventLoop.add_readerc C s t �d S )N)r~ )rP r� r r r! �
remove_reader� s z AbstractEventLoop.remove_readerc G s t �d S )N)r~ )rP r� rQ r/ r r r! �
add_writer� s z AbstractEventLoop.add_writerc C s t �d S )N)r~ )rP r� r r r! �
remove_writer� s z AbstractEventLoop.remove_writerc C s t �d S )N)r~ )rP r� �nbytesr r r! � sock_recv� s zAbstractEventLoop.sock_recvc C s t �d S )N)r~ )rP r� �datar r r! � sock_sendall� s z AbstractEventLoop.sock_sendallc C s t �d S )N)r~ )rP r� Zaddressr r r! � sock_connect� s z AbstractEventLoop.sock_connectc C s t �d S )N)r~ )rP r� r r r! � sock_accept� s z AbstractEventLoop.sock_acceptc G s t �d S )N)r~ )rP �sigrQ r/ r r r! �add_signal_handler� s z$AbstractEventLoop.add_signal_handlerc C s t �d S )N)r~ )rP r� r r r! �remove_signal_handler� s z'AbstractEventLoop.remove_signal_handlerc C s t �d S )N)r~ )rP �factoryr r r! �set_task_factory� s z"AbstractEventLoop.set_task_factoryc C s t �d S )N)r~ )rP r r r! �get_task_factory� s z"AbstractEventLoop.get_task_factoryc C s t �d S )N)r~ )rP r r r! �get_exception_handler s z'AbstractEventLoop.get_exception_handlerc C s t �d S )N)r~ )rP Zhandlerr r r! �set_exception_handler s z'AbstractEventLoop.set_exception_handlerc C s t �d S )N)r~ )rP rd r r r! �default_exception_handler s z+AbstractEventLoop.default_exception_handlerc C s t �d S )N)r~ )rP rd r r r! r` s z(AbstractEventLoop.call_exception_handlerc C s t �d S )N)r~ )rP r r r! rO s zAbstractEventLoop.get_debugc C s t �d S )N)r~ )rP Zenabledr r r! � set_debug s zAbstractEventLoop.set_debug)r )NN)NN)NN)7r4 rf r3 rg r r� r� r� r� r| r� rz r� r� r� r� r� r� r� r� r� r� r� r� �socketZ AF_UNSPECZ
AI_PASSIVEr� r� r� r� r� r� �
subprocess�PIPEr� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r` rO r� r r r r! r � st
'!
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.N)r~ )rP r r r! r s z&AbstractEventLoopPolicy.get_event_loopc C s t �dS )z3Set the event loop for the current context to loop.N)r~ )rP rR r r r! r $ s z&AbstractEventLoopPolicy.set_event_loopc C s t �dS )z�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.N)r~ )rP r r r! r
( s z&AbstractEventLoopPolicy.new_event_loopc C s t �dS )z$Get the watcher for child processes.N)r~ )rP r r r! r 0 s z)AbstractEventLoopPolicy.get_child_watcherc C s t �dS )z$Set the watcher for child processes.N)r~ )rP �watcherr r r! r 4 s z)AbstractEventLoopPolicy.set_child_watcherN) r4 rf r3 rg r r r
r r r r r r! r s
c @ sF e Zd ZdZdZG dd� dej�Zdd� 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)r4 rf r3 rK � _set_calledr r r r! �_LocalH s r� c C s | j � | _d S )N)r� �_local)rP r r r! rS L s z#BaseDefaultEventLoopPolicy.__init__c C sZ | j jdkr4| j j r4ttj� tj�r4| j| j� � | j jdkrRt dtj� j
��| j jS )zSGet the event loop.
This may be None or an instance of EventLoop.
Nz,There is no current event loop in thread %r.) r� rK r� r � threadingZcurrent_threadZ _MainThreadr r
� RuntimeError�name)rP r r r! r O s
z)BaseDefaultEventLoopPolicy.get_event_loopc C s d| j _|| j _dS )zSet the event loop.TN)r� r� rK )rP rR r r r! r ] s z)BaseDefaultEventLoopPolicy.set_event_loopc C s | j � S )zvCreate a new event loop.
You must call set_event_loop() to make this the current event
loop.
)�
_loop_factory)rP r r r! r
c s z)BaseDefaultEventLoopPolicy.new_event_loop) r4 rf r3 rg r� r� �localr� rS r r r
r r r r! r� 9 s r� c @ s e Zd ZdZdS )� _RunningLoopN)NN)r4 rf r3 �loop_pidr r r r! r� w s r� c C s& t j\} }| dk r"|tj� kr"| S dS )z�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.
N)�
_running_loopr� �os�getpid)Z running_loop�pidr r r! r ~ s
c C s | t j� ft_dS )z�Set 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� )rR r r r! r
� s c C s. t � td kr ddlm} | � aW d Q R X d S )Nr )�DefaultEventLoopPolicy)�_lock�_event_loop_policyr2 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 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 c C s t � } | dk r| S t� j� 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 c C s t � j| � dS )zCEquivalent to calling get_event_loop_policy().set_event_loop(loop).N)r r )rR r r r! r � s c C s
t � j� S )z?Equivalent to calling get_event_loop_policy().new_event_loop().)r r
r r r r! r
� s c C s
t � j� S )zBEquivalent to calling get_event_loop_policy().get_child_watcher().)r r r r r r! r � s c C s t � j| �S )zMEquivalent to calling
get_event_loop_policy().set_child_watcher(watcher).)r r )r� r r r! r � s )r2 )NN))rg �__all__r r r� r" r� r� r= r� r@ r2 r r r r1 r5 r: rG r r r r r r� r� ZLockr� r� r� r� r r
r� r r r r r
r r r r r r! �<module> sZ
>8 5"7 PK [�#�~� � ' __pycache__/queues.cpython-36.opt-1.pycnu �[��� 3
\ � @ s� d Z dddddgZddlZddlZdd lmZ dd
lmZ dd lmZ dd lm Z G d
d� de
�Z G dd� de
�Z G dd� d�Z
G dd� de
�ZG dd� de
�Zejs�e
Zejd� dS )ZQueues�Queue�
PriorityQueue� LifoQueue� QueueFull�
QueueEmpty� N� )�compat)�events)�locks)� coroutinec @ s e Zd ZdZdS )r z]Exception raised when Queue.get_nowait() is called on a Queue object
which is empty.
N)�__name__�
__module__� __qualname__�__doc__� r r �&/usr/lib64/python3.6/asyncio/queues.pyr s c @ s e Zd ZdZdS )r zgException raised when the Queue.put_nowait() method is called on a Queue
object which is full.
N)r r
r r r r r r r s c @ s� e Zd ZdZd)dd�dd�Zdd� Zd d
� Zd d � Zd
d� Zdd� Z dd� Z
dd� Z dd� Z e
dd� �Zdd� Zdd � Zed d � �Zd d � Zed!d"� �Zd#d$� Zd%d&� Zed'd(� �ZdS )*r a A queue, useful for coordinating producer and consumer coroutines.
If maxsize is less than or equal to zero, the queue size is infinite. If it
is an integer greater than 0, then "yield from put()" will block when the
queue reaches maxsize, until an item is removed by get().
Unlike the standard library Queue, you can reliably know this Queue's size
with qsize(), since your single-threaded asyncio application won't be
interrupted between calling qsize() and doing an operation on the Queue.
r N)�loopc C sb |d krt j� | _n|| _|| _tj� | _tj� | _d| _t j
| jd�| _ | j j � | j
|� d S )Nr )r )r Zget_event_loop�_loop�_maxsize� collections�deque�_getters�_putters�_unfinished_tasksr
ZEvent� _finished�set�_init)�self�maxsizer r r r �__init__( s
zQueue.__init__c C s t j� | _d S )N)r r �_queue)r r r r r r : s z Queue._initc C s
| j j� S )N)r �popleft)r r r r �_get= s z
Queue._getc C s | j j|� d S )N)r �append)r �itemr r r �_put@ s z
Queue._putc C s* x$|r$|j � }|j� s|jd � P qW d S )N)r! �doneZ
set_result)r �waitersZwaiterr r r � _wakeup_nextE s
zQueue._wakeup_nextc C s dj t| �jt| �| j� �S )Nz<{} at {:#x} {}>)�format�typer �id�_format)r r r r �__repr__M s zQueue.__repr__c C s dj t| �j| j� �S )Nz<{} {}>)r) r* r r, )r r r r �__str__Q s z
Queue.__str__c C sz dj | j�}t| dd �r,|dj t| j��7 }| jrF|dj t| j��7 }| jr`|dj t| j��7 }| jrv|dj | j�7 }|S )Nz maxsize={!r}r z _queue={!r}z
_getters[{}]z
_putters[{}]z tasks={}) r) r �getattr�listr r �lenr r )r �resultr r r r, T s z
Queue._formatc C s
t | j�S )z Number of items in the queue.)r1 r )r r r r �qsize` s z Queue.qsizec C s | j S )z%Number of items allowed in the queue.)r )r r r r r d s z
Queue.maxsizec C s | j S )z3Return True if the queue is empty, False otherwise.)r )r r r r �emptyi s z Queue.emptyc C s | j dkrdS | j� | j kS dS )z�Return True if there are maxsize items in the queue.
Note: if the Queue was initialized with maxsize=0 (the default),
then full() is never True.
r FN)r r3 )r r r r �fullm s
z
Queue.fullc c st xh| j � rh| jj� }| jj|� y|E dH W q |j� | j � r^|j� r^| j| j� � Y qX qW | j|�S )z�Put an item into the queue.
Put an item into the queue. If the queue is full, wait until a free
slot is available before adding item.
This method is a coroutine.
N) r5 r �
create_futurer r# �cancel� cancelledr( �
put_nowait)r r$ Zputterr r r �putx s
z Queue.putc C s> | j � r t�| j|� | jd7 _| jj� | j| j� dS )zyPut an item into the queue without blocking.
If no free slot is immediately available, raise QueueFull.
r N)r5 r r% r r �clearr( r )r r$ r r r r9 � s
zQueue.put_nowaitc c s� x�| j � r�| jj� }| jj|� y|E dH W q |j� y| jj|� W n tk
rb Y nX | j � r�|j� r�| j | j� � Y qX qW | j
� S )z�Remove and return an item from the queue.
If queue is empty, wait until an item is available.
This method is a coroutine.
N) r4 r r6 r r# r7 �remove�
ValueErrorr8 r( �
get_nowait)r �getterr r r �get� s
z Queue.getc C s$ | j � r t�| j� }| j| j� |S )z�Remove and return an item from the queue.
Return an item if one is immediately available, else raise QueueEmpty.
)r4 r r" r( r )r r$ r r r r> � s
zQueue.get_nowaitc C s8 | j dkrtd��| j d8 _ | j dkr4| jj� dS )a$ Indicate that a formerly enqueued task is complete.
Used by queue consumers. For each get() used to fetch a task,
a subsequent call to task_done() tells the queue that the processing
on the task is complete.
If a join() is currently blocking, it will resume when all items have
been processed (meaning that a task_done() call was received for every
item that had been put() into the queue).
Raises ValueError if called more times than there were items placed in
the queue.
r z!task_done() called too many timesr N)r r= r r )r r r r � task_done� s
zQueue.task_donec c s | j dkr| jj� E dH dS )a Block until all items in the queue have been gotten and processed.
The count of unfinished tasks goes up whenever an item is added to the
queue. The count goes down whenever a consumer calls task_done() to
indicate that the item was retrieved and all work on it is complete.
When the count of unfinished tasks drops to zero, join() unblocks.
r N)r r �wait)r r r r �join� s
z
Queue.join)r )r r
r r r r r" r% r( r- r. r, r3 �propertyr r4 r5 r r: r9 r@ r> rA rC r r r r r s&
c @ s4 e Zd ZdZdd� Zejfdd�Zejfdd�Z dS ) r z�A subclass of Queue; retrieves entries in priority order (lowest first).
Entries are typically tuples of the form: (priority number, data).
c C s
g | _ d S )N)r )r r r r r r � s zPriorityQueue._initc C s || j |� d S )N)r )r r$ �heappushr r r r% � s zPriorityQueue._putc C s
|| j �S )N)r )r �heappopr r r r" � s zPriorityQueue._getN)
r r
r r r �heapqrE r% rF r" r r r r r � s c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) r zEA subclass of Queue that retrieves most recently added entries first.c C s
g | _ d S )N)r )r r r r r r � s zLifoQueue._initc C s | j j|� d S )N)r r# )r r$ r r r r% � s zLifoQueue._putc C s
| j j� S )N)r �pop)r r r r r" � s zLifoQueue._getN)r r
r r r r% r" r r r r r � s �
JoinableQueue)r �__all__r rG � r r r
Z
coroutinesr � Exceptionr r r r r ZPY35rI r# r r r r �<module> s H
PK [��� �N �N ) __pycache__/sslproto.cpython-36.opt-1.pycnu �[��� 3
\�e �
@ s� d dl Z d dlZy d dlZW n ek
r4 dZY nX ddlmZ ddlmZ ddlmZ ddlmZ ddl m
Z
dd � Z d
d � Z d Z
d
ZdZdZG dd� de�ZG dd� dejej�ZG dd� dej�ZdS )� N� )� base_events)�compat)� protocols)�
transports)�loggerc C sj | r t d��ttd�r*tj� }|sfd|_n<tjtj�}| jtjO _| jtj O _|j
� tj |_ |S )Nz(Server side SSL needs a valid SSLContext�create_default_contextF)
�
ValueError�hasattr�sslr �check_hostnameZ
SSLContextZPROTOCOL_SSLv23ZoptionsZ OP_NO_SSLv2Z OP_NO_SSLv3Zset_default_verify_pathsZ
CERT_REQUIRED� verify_mode)� server_side�server_hostname�
sslcontext� r �(/usr/lib64/python3.6/asyncio/sslproto.py�_create_transport_context s
r c C s
t td�S )N� MemoryBIO)r
r r r r r �_is_sslproto_available% s r Z UNWRAPPEDZ DO_HANDSHAKEZWRAPPEDZSHUTDOWNc @ s~ e Zd ZdZdZd dd�Zedd� �Zed d
� �Zed d � �Z ed
d� �Z
d dd�Z d dd�Z dd� Z
d dd�Zd dd�ZdS )!�_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| _tj� | _tj� | _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 r � _incoming� _outgoing�_sslobj�
_need_ssldata�
_handshake_cb� _shutdown_cb)�self�contextr r r r r �__init__D s
z_SSLPipe.__init__c C s | j S )z*The SSL context passed to the constructor.)r )r# r r r r$ Z 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_object_ 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_ssldatag s z_SSLPipe.need_ssldatac C s
| j tkS )zj
Whether a security layer is currently in effect.
Return False during handshake.
)r �_WRAPPED)r# r r r �wrappedm 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_ssldata)r# �callback�ssldata�appdatar r r � do_handshakev s
z_SSLPipe.do_handshakec C sB | j tkrtd��| j tkr$td��t| _ || _| jd�\}}|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/ r0 r1 r r r �shutdown� s
z_SSLPipe.shutdownc C s | j j� | jd�\}}dS )z�Send 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# r0 r1 r r r �feed_eof� s
z_SSLPipe.feed_eofFc C s� | j tkr"|r|g}ng }g |fS d| _|r8| jj|� g }g }y�| j tkrx| jj� t| _ | j rl| j d� |rx||fS | j tkr�xn| jj
| j �}|j |� |s�P q�W nJ| j t
kr�| jj� d| _t| _ | jr�| j� n| j tkr�|j | jj
� � W nx tjtjfk
�rl } zRt|dd�tjtjtjfk�rN| j tk�rL| j �rL| j |� � |jtjk| _W Y dd}~X nX | jj�r�|j | jj
� � ||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().
FN�errno)r r r r �writer- r r2 r( r! �read�max_size�appendr3 Zunwrapr" r �SSLError�CertificateError�getattr�SSL_ERROR_WANT_READ�SSL_ERROR_WANT_WRITE�SSL_ERROR_SYSCALLr6 r �pending)r# �datar+ r1 r0 �chunk�excr r r r. � sV
z_SSLPipe.feed_ssldatar c C s | j tkr6|t|�k r&||d� g}ng }|t|�fS g }t|�}x�d| _y(|t|�k rp|| jj||d� �7 }W n\ tjk
r� } z>|j dkr�tj
|_ |j tj
tj tj
fkr�� |j tj
k| _W Y dd}~X nX | jjr�|j| jj� � |t|�ks�| jrDP qDW ||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.
NFZPROTOCOL_IS_SHUTDOWN)r r �len�
memoryviewr r r7 r r; �reasonr> r6 r? r@ r rA r: r8 )r# rB �offsetr0 ZviewrD r r r � feed_appdata� s2
z_SSLPipe.feed_appdatai )N)N)N)F)r )�__name__�
__module__� __qualname__�__doc__r9 r% �propertyr$ r& r' r) r2 r4 r5 r. rI r r r r r 0 s
Jr c @ s� e Zd Zdd� Zd dd�Zdd� Zdd � Zd
d � Zd d
� Ze j
rHdd� Z dd� Z dd� Z
d dd�Zdd� Zdd� Zdd� 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 j||�S )z#Get optional transport information.)rQ �_get_extra_info)r# �name�defaultr r r �get_extra_info/ s z$_SSLProtocolTransport.get_extra_infoc C s || j _d S )N)rQ �
_app_protocol)r# �protocolr r r � set_protocol3 s z"_SSLProtocolTransport.set_protocolc C s | j jS )N)rQ rX )r# r r r � get_protocol6 s z"_SSLProtocolTransport.get_protocolc C s | j S )N)rR )r# r r r �
is_closing9 s z _SSLProtocolTransport.is_closingc C s d| _ | jj� 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)rR rQ �_start_shutdown)r# r r r �close< s z_SSLProtocolTransport.closec C s& | j s"tjd| t| d� | j� d S )Nzunclosed transport %r)�source)rR �warnings�warn�ResourceWarningr^ )r# r r r �__del__K s z _SSLProtocolTransport.__del__c C s | j jj� dS )z�Pause the receiving end.
No data will be passed to the protocol's data_received()
method until resume_reading() is called.
N)rQ �
_transport�
pause_reading)r# r r r re Q s z#_SSLProtocolTransport.pause_readingc C s | j jj� dS )z�Resume the receiving end.
Data received will once again be passed to the protocol's
data_received() method.
N)rQ rd �resume_reading)r# r r r rf Y s z$_SSLProtocolTransport.resume_readingc C s | j jj||� 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)rQ rd �set_write_buffer_limits)r# ZhighZlowr r r rg a s z-_SSLProtocolTransport.set_write_buffer_limitsc C s | j jj� S )z,Return the current size of the write buffer.)rQ rd �get_write_buffer_size)r# r r r rh v s z+_SSLProtocolTransport.get_write_buffer_sizec C s< t |tttf�s$tdjt|�j���|s,dS | jj |� dS )z�Write 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 {!r}N)
�
isinstance�bytes� bytearrayrF � TypeError�format�typerJ rQ �_write_appdata)r# rB r r r r7 z 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 j� dS )z�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.
N)rQ �_abort)r# r r r �abort� s z_SSLProtocolTransport.abort)N)NN)rJ rK rL r% rW rZ r[ r\ r^ r ZPY34rc re rf rg rh r7 rp rr r r r r rO & s
rO c @ s� e Zd ZdZd(dd�Zd)dd�Zd d
� Zd d � Zd
d� Zdd� Z dd� Z
dd� Z d*dd�Z dd� Z
dd� Zdd � Zd d � Zd d � Zd+d"d#�Zd$d%� Zd&d'� ZdS ),� SSLProtocolz�SSL 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��|s t||�}|| _|r6| r6|| _nd | _|| _t|d�| _tj � | _
d| _ || _ || _
|| _t| j
| �| _d | _d| _d| _d| _d | _|| _d S )Nz stdlib ssl module not available)r r F)r r, r r r � _sslcontext�dict�_extra� collections�deque�_write_backlog�_write_buffer_size�_waiterrP rX rO �_app_transport�_sslpipe�_session_established�
_in_handshake� _in_shutdownrd �_call_connection_made)r# rS Z app_protocolr Zwaiterr r Zcall_connection_mader r r r% � s,
zSSLProtocol.__init__c C sD | j d krd S | j j� s:|d k r.| j j|� n | j jd � d | _ d S )N)r{ Z cancelledZ
set_exceptionZ
set_result)r# rD r r r �_wakeup_waiter� s
zSSLProtocol._wakeup_waiterc C s& || _ t| j| j| j�| _| j� dS )zXCalled when the low-level connection is made.
Start the SSL handshake.
N)rd r rt r r r} �_start_handshake)r# � transportr r r �connection_made� s
zSSLProtocol.connection_madec C s8 | j r d| _ | jj| jj|� d| _d| _| j|� dS )z�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).
FN)r~ rP � call_soonrX �connection_lostrd r| r� )r# rD r r r r� � s zSSLProtocol.connection_lostc C s | j j� dS )z\Called when the low-level transport's buffer goes over
the high-water mark.
N)rX �
pause_writing)r# r r r r� � s zSSLProtocol.pause_writingc C s | j j� dS )z^Called when the low-level transport's buffer drains below
the low-water mark.
N)rX �resume_writing)r# r r r r� � s zSSLProtocol.resume_writingc C s� | j dkrdS y| j j|�\}}W nH tjk
rj } z*| jj� rTtjd| |j|j � | j
� dS d}~X nX x|D ]}| j j |� qrW x(|D ] }|r�| j
j|� q�| j� P q�W dS )zXCalled when some SSL data is received.
The argument is a bytes object.
Nz %r: SSL error %s (reason %s))r} r. r r; rP � get_debugr �warningr6 rG rq rd r7 rX �
data_receivedr] )r# rB r0 r1 �erC r r r r� � s"
zSSLProtocol.data_receivedc
C sT zB| j j� rtjd| � | jt� | js@| jj� }|r@tj d� W d| j
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) rP r� r �debugr� �ConnectionResetErrorr rX � eof_receivedr� rd r^ )r# Z keep_openr r r r� s
zSSLProtocol.eof_receivedc C s4 || j kr| j | S | jd k r,| jj||�S |S d S )N)rv rd rW )r# rU rV r r r rT ! s
zSSLProtocol._get_extra_infoc C s. | j r
d S | jr| j� nd| _ | jd� d S )NTr* )r� r rq ro )r# r r r r] ) s
zSSLProtocol._start_shutdownc C s. | j j|df� | jt|�7 _| j� d S )Nr )ry r: rz rE �_process_write_backlog)r# rB r r r ro 2 s zSSLProtocol._write_appdatac C sH | j j� r$tjd| � | j j� | _nd | _d| _| jjd� | j � d S )Nz%r starts SSL handshakeTr* r )r* r )
rP r� r r� �time�_handshake_start_timer ry r: r� )r# r r r r� 7 s
z SSLProtocol._start_handshakec C sT d| _ | jj}yF|d k r |�|j� }t| jd�sR| jrR| jjtj krRtj
|| j� W n~ t k
r� } zb| j j
� r�t|tj�r�tjd| dd� ntjd| dd� | jj� t|t�r�| j|� d S � W Y d d }~X nX | j j
� �r| j j� | j }tjd| |d � | jj||j� |j � |d � | j �r4| j j | j � | j� d| _!| j j"| j#� d S )
NFr z5%r: SSL handshake failed on verifying the certificateT)�exc_infoz%r: SSL handshake failedz %r: SSL handshake took %.1f msg @�@)�peercert�cipher� compressionr& )$r r} r& Z getpeercertr
rt r r
r Z CERT_NONEZmatch_hostname�
BaseExceptionrP r� ri r< r r� rd r^ � Exceptionr� r� r� r� rv �updater� r� r� rX r� r| r~ r� r� )r# Z
handshake_excZsslobjr� rD Zdtr r r �_on_handshake_completeC sD
z"SSLProtocol._on_handshake_completec C s> | j d ks| jd krd S y�x�tt| j��D ]�}| jd \}}|rT| jj||�\}}n*|rl| jj| j�}d}n| jj| j �}d}x|D ]}| j j
|� q�W |t|�k r�||f| jd< | j j r�| j j � P | jd= | j
t|�8 _
q*W W nR tk
�r8 } z4| j�r| j|� n | j|d� t|t��s(� W Y d d }~X nX d S )Nr r z Fatal error on SSL transport)rd r} �rangerE ry rI r2 r� r4 � _finalizer7 Z_pausedrf rz r� r � _fatal_errorri r� )r# �irB rH r0 rC rD r r r r� w s8
z"SSLProtocol._process_write_backlog�Fatal error on transportc C sX t |tj�r*| jj� rBtjd| |dd� n| jj||| j| d�� | jrT| jj |� d S )Nz%r: %sT)r� )�messageZ exceptionr� rY )
ri r Z_FATAL_ERROR_IGNORErP r� r r� Zcall_exception_handlerrd Z _force_close)r# rD r� r r r r� � s
zSSLProtocol._fatal_errorc C s d | _ | jd k r| jj� d S )N)r} rd r^ )r# r r r r� � s
zSSLProtocol._finalizec
C s( z| j d k r| j j� W d | j� X d S )N)rd rr r� )r# r r r rq � s
zSSLProtocol._abort)FNT)N)N)r� )rJ rK rL rM r% r� r� r� r� r� r� r� rT r] ro r� r� r� r� r� rq r r r r rs � s&
"
4,
rs )rw r` r � ImportError� r r r r �logr r r r r- r( r3 �objectr Z_FlowControlMixinZ TransportrO ZProtocolrs r r r r �<module> s*
wnPK [�R�ӸA �A * __pycache__/proactor_events.cpython-36.pycnu �[��� 3
\�O � @ s� d Z dgZddlZddlZddlmZ ddlmZ ddlmZ ddlmZ dd lm Z dd
lm
Z
dd l m Z G d d
� d
e
j
e
j�ZG dd� dee
j�ZG dd� dee
j�ZG dd� de�ZG dd� deee
j�ZG dd� deee
j�ZG dd� dej�ZdS )z�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.
�BaseProactorEventLoop� N� )� base_events)�compat)� constants)�futures)�sslproto)�
transports)�loggerc s� e Zd ZdZd � fdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
e j rXdd� Z
d dd�Zdd� Zdd� Zdd� Z� ZS ) �_ProactorBasePipeTransportz*Base class for pipe and socket transports.Nc s� t � j||� | j|� || _|| _|| _d | _d | _d | _d| _ d| _
d| _ d| _ | jd k rh| jj
� | jj| jj| � |d k r�| jjtj|d � d S )Nr F)�super�__init__�
_set_extra�_sock� _protocol�_server�_buffer� _read_fut�
_write_fut�_pending_write�
_conn_lost�_closing� _eof_writtenZ_attach�_loop� call_soonZconnection_mader Z _set_result_unless_cancelled)�self�loop�sock�protocol�waiter�extra�server)� __class__� �//usr/lib64/python3.6/asyncio/proactor_events.pyr
s$
z#_ProactorBasePipeTransport.__init__c C s� | j jg}| jd kr |jd� n| jr0|jd� | jd k rN|jd| jj� � | jd k rh|jd| j � | jd k r�|jd| j � | jr�t | j�}|jd| � | j
r�|jd� dd j |� S )
N�closed�closingzfd=%szread=%szwrite=%rzwrite_bufsize=%sz EOF writtenz<%s>� ) r" �__name__r �appendr �filenor r r �lenr �join)r �info�bufsizer# r# r$ �__repr__/ s"
z#_ProactorBasePipeTransport.__repr__c C s || j d< d S )N�pipe)�_extra)r r r# r# r$ r B s z%_ProactorBasePipeTransport._set_extrac C s
|| _ d S )N)r )r r r# r# r$ � set_protocolE s z'_ProactorBasePipeTransport.set_protocolc C s | j S )N)r )r r# r# r$ � get_protocolH s z'_ProactorBasePipeTransport.get_protocolc C s | j S )N)r )r r# r# r$ �
is_closingK s z%_ProactorBasePipeTransport.is_closingc C s^ | j r
d S d| _ | jd7 _| j r@| jd kr@| jj| jd � | jd k rZ| jj� d | _d S )NTr ) r r r r r r �_call_connection_lostr �cancel)r r# r# r$ �closeN s
z _ProactorBasePipeTransport.closec C s* | j d k r&tjd| t| d� | j� d S )Nzunclosed transport %r)�source)r �warnings�warn�ResourceWarningr7 )r r# r# r$ �__del__] s
z"_ProactorBasePipeTransport.__del__� Fatal error on pipe transportc C sP t |tj�r*| jj� rBtjd| |dd� n| jj||| | jd�� | j |� d S )Nz%r: %sT)�exc_info)�message� exceptionZ transportr )
�
isinstancer Z_FATAL_ERROR_IGNOREr � get_debugr
�debug�call_exception_handlerr � _force_close)r �excr? r# r# r$ � _fatal_errorc s
z'_ProactorBasePipeTransport._fatal_errorc C sj | j r
d S d| _ | jd7 _| jr4| jj� d | _| jrJ| jj� d | _d| _d | _| jj| j |� d S )NTr r )
r r r r6 r r r r r r5 )r rF r# r# r$ rE p s
z'_ProactorBasePipeTransport._force_closec C s^ z| j j|� W d t| jd�r,| jjtj� | jj� d | _| j}|d k rX|j � d | _X d S )N�shutdown)
r Zconnection_lost�hasattrr rH �socketZ SHUT_RDWRr7 r Z_detach)r rF r! r# r# r$ r5 s
z0_ProactorBasePipeTransport._call_connection_lostc C s" | j }| jd k r |t| j�7 }|S )N)r r r+ )r �sizer# r# r$ �get_write_buffer_size� s
z0_ProactorBasePipeTransport.get_write_buffer_size)NNN)r= )r( �
__module__� __qualname__�__doc__r
r/ r r2 r3 r4 r7 r ZPY34r< rG rE r5 rL �
__classcell__r# r# )r" r$ r s
r c s< e Zd ZdZd � fdd� Zdd� Zdd� Zd d d
�Z� ZS )
�_ProactorReadPipeTransportzTransport for read pipes.Nc s4 t � j||||||� d| _d| _| jj| j� d S )NF)r r
�_paused�_reschedule_on_resumer r �
_loop_reading)r r r r r r r! )r" r# r$ r
� s z#_ProactorReadPipeTransport.__init__c C s0 | j s | jrd S d| _| jj� r,tjd| � d S )NTz%r pauses reading)r rR r rB r
rC )r r# r# r$ �
pause_reading� s
z(_ProactorReadPipeTransport.pause_readingc C sP | j s| j rd S d| _| jr6| jj| j| j� d| _| jj� rLtj d| � d S )NFz%r resumes reading)
r rR rS r r rT r rB r
rC )r r# r# r$ �resume_reading� s
z)_ProactorReadPipeTransport.resume_readingc C s� | j rd| _d S d }�z@yf|d k rN| j|ks@| jd kr<| js@t�d | _|j� }| jr\d }d S |dkrhd S | jjj| j d�| _W n� t
k
r� } z2| js�| j |d� n| jj � r�t
jddd� W Y d d }~X n� tk
r� } z| j|� W Y d d }~X n^ tk
�r$ } z| j |d� W Y d d }~X n0 tjk
�rD | j�s@� Y nX | jj| j� W d |�rl| jj|� n:|d k �r�| jj � �r�t
jd| � | jj� }|�s�| j� X d S )NT� i z"Fatal read error on pipe transportz*Read error on pipe transport while closing)r> z%r received EOF)rR rS r r �AssertionError�resultr � _proactor�recvr �ConnectionAbortedErrorrG rB r
rC �ConnectionResetErrorrE �OSErrorr �CancelledError�add_done_callbackrT r Z
data_receivedZ eof_receivedr7 )r �fut�datarF Z keep_openr# r# r$ rT � sL
z(_ProactorReadPipeTransport._loop_reading)NNN)N) r( rM rN rO r
rU rV rT rP r# r# )r" r$ rQ � s
rQ c @ s: e Zd ZdZdd� Zd
dd�Zdd� Zd d
� Zd d � ZdS )� _ProactorBaseWritePipeTransportzTransport for write pipes.c C s� t |tttf�s&dt|�j }t|��| jr4td��|s<d S | j rj| j t
j krXt j
d� | j d7 _ d S | jd kr�| jd ks�t�| jt|�d� n.| js�t|�| _| j� n| jj|� | j� d S )Nz3data argument must be a bytes-like object, not '%s'zwrite_eof() already calledz socket.send() raised exception.r )rb )rA �bytes� bytearray�
memoryview�typer( � TypeErrorr � RuntimeErrorr r Z!LOG_THRESHOLD_FOR_CONNLOST_WRITESr
�warningr r rX �
_loop_writing�_maybe_pause_protocol�extend)r rb �msgr# r# r$ �write� s*
z%_ProactorBaseWritePipeTransport.writeNc C s4 y�|| j kst�d | _ d| _|r(|j� |d kr<| j}d | _|st| jrV| jj| jd � | j rj| j
j t j
� | j� n\| jjj| j
|�| _ | j j� s�| jdks�t�t|�| _| j j| j� | j� n| j j| j� W n\ tk
�r } z| j|� W Y d d }~X n0 tk
�r. } z| j|d� W Y d d }~X nX d S )Nr z#Fatal write error on pipe transport)r rX r rY r r r r r5 r r rH rJ �SHUT_WRZ_maybe_resume_protocolrZ �send�doner+ r` rk rl r] rE r^ rG )r �frb rF r# r# r$ rk
s4
z-_ProactorBaseWritePipeTransport._loop_writingc C s dS )NTr# )r r# r# r$ �
can_write_eof0 s z-_ProactorBaseWritePipeTransport.can_write_eofc C s | j � d S )N)r7 )r r# r# r$ � write_eof3 s z)_ProactorBaseWritePipeTransport.write_eofc C s | j d � d S )N)rE )r r# r# r$ �abort6 s z%_ProactorBaseWritePipeTransport.abort)NN) r( rM rN rO ro rk rt ru rv r# r# r# r$ rc � s $
#rc c s$ e Zd Z� fdd�Zdd� Z� ZS )�_ProactorWritePipeTransportc s4 t � j||� | jjj| jd�| _| jj| j� d S )N� ) r r
r rZ r[ r r r` � _pipe_closed)r �args�kw)r" r# r$ r
; s z$_ProactorWritePipeTransport.__init__c C sv |j � r d S |j� dks t�| jr4| jd ks0t�d S || jksLt|| jf��d | _| jd k rj| jt� � n| j� d S )NrW ) Z cancelledrY rX r r r rE �BrokenPipeErrorr7 )r ra r# r# r$ ry @ s
z(_ProactorWritePipeTransport._pipe_closed)r( rM rN r
ry rP r# r# )r" r$ rw : s rw c @ s e Zd ZdZdd� Zdd� ZdS )� _ProactorDuplexPipeTransportzTransport for duplex pipes.c C s dS )NFr# )r r# r# r$ rt U s z*_ProactorDuplexPipeTransport.can_write_eofc C s t �d S )N)�NotImplementedError)r r# r# r$ ru X s z&_ProactorDuplexPipeTransport.write_eofN)r( rM rN rO rt ru r# r# r# r$ r} P s r} c s: e Zd ZdZd � fdd� Zdd� Zdd� Zd d
� Z� ZS ) �_ProactorSocketTransportz Transport for connected sockets.Nc s$ t � j||||||� tj|� d S )N)r r
r Z _set_nodelay)r r r r r r r! )r" r# r$ r
a s z!_ProactorSocketTransport.__init__c C s� || j d< y|j� | j d< W n4 tjtfk
rP | jj� rLtjd|dd� Y nX d| j kr�y|j � | j d< W n4 tjtfk
r� | jj� r�tjd|dd� Y nX d S )NrJ Zsocknamezgetsockname() failed on %rT)r> �peernamezgetpeername() failed on %r)
r1 Z getsocknamerJ �error�AttributeErrorr rB r
rj Z getpeername)r r r# r# r$ r f s
z#_ProactorSocketTransport._set_extrac C s dS )NTr# )r r# r# r$ rt v s z&_ProactorSocketTransport.can_write_eofc C s2 | j s | jrd S d| _| jd kr.| jjtj� d S )NT)r r r r rH rJ rp )r r# r# r$ ru y s
z"_ProactorSocketTransport.write_eof)NNN) r( rM rN rO r
r rt ru rP r# r# )r" r$ r \ s r c s� e Zd Z� fdd�Zd-dd�Zd.ddddd�dd �Zd/d
d �Zd0d d
�Zd1dd�Z� fdd�Z dd� Z
dd� Z dd� Z dd� Z
dd� Zd d � Zd d � Zd2d d!�Zd"d#� Zd3d%d&�Zd'd(� Zd)d*� Zd+d,� Z� ZS )4r c sH t � j� tjd|jj� || _|| _d | _i | _ |j
| � | j � d S )NzUsing proactor: %s) r r
r
rC r" r( rZ � _selector�_self_reading_future�_accept_futuresZset_loop�_make_self_pipe)r Zproactor)r" r# r$ r
� s
z BaseProactorEventLoop.__init__Nc C s t | |||||�S )N)r )r r r r r r! r# r# r$ �_make_socket_transport� s
z,BaseProactorEventLoop._make_socket_transportF)� server_side�server_hostnamer r! c
C s< t j� std��t j| |||||�} t| || ||d� | jS )NzOProactor event loop requires Python 3.5 or newer (ssl.MemoryBIO) to support SSL)r r! )r Z_is_sslproto_availabler~ Z SSLProtocolr Z_app_transport)
r Zrawsockr �
sslcontextr r� r� r r! Z ssl_protocolr# r# r$ �_make_ssl_transport� s
z)BaseProactorEventLoop._make_ssl_transportc C s t | ||||�S )N)r} )r r r r r r# r# r$ �_make_duplex_pipe_transport� s z1BaseProactorEventLoop._make_duplex_pipe_transportc C s t | ||||�S )N)rQ )r r r r r r# r# r$ �_make_read_pipe_transport� s z/BaseProactorEventLoop._make_read_pipe_transportc C s t | ||||�S )N)rw )r r r r r r# r# r$ �_make_write_pipe_transport� s z0BaseProactorEventLoop._make_write_pipe_transportc sP | j � rtd��| j� r d S | j� | j� | jj� d | _d | _t� j� d S )Nz!Cannot close a running event loop) Z
is_runningri � is_closed�_stop_accept_futures�_close_self_piperZ r7 r� r )r )r" r# r$ r7 � s
zBaseProactorEventLoop.closec C s | j j||�S )N)rZ r[ )r r �nr# r# r$ � sock_recv� s z BaseProactorEventLoop.sock_recvc C s | j j||�S )N)rZ rq )r r rb r# r# r$ � sock_sendall� s z"BaseProactorEventLoop.sock_sendallc C s | j j||�S )N)rZ Zconnect)r r Zaddressr# r# r$ � sock_connect� s z"BaseProactorEventLoop.sock_connectc C s | j j|�S )N)rZ �accept)r r r# r# r$ � sock_accept� s z!BaseProactorEventLoop.sock_acceptc C s t �d S )N)r~ )r r# r# r$ � _socketpair� s z!BaseProactorEventLoop._socketpairc C sL | j d k r| j j� d | _ | jj� d | _| jj� d | _| jd8 _d S )Nr )r� r6 �_ssockr7 �_csock�
_internal_fds)r r# r# r$ r� � s
z&BaseProactorEventLoop._close_self_pipec C sF | j � \| _| _| jjd� | jjd� | jd7 _| j| j� d S )NFr )r� r� r� Z setblockingr� r �_loop_self_reading)r r# r# r$ r� � s
z%BaseProactorEventLoop._make_self_pipec C s� y$|d k r|j � | jj| jd�}W nH tjk
r: d S tk
rl } z| jd|| d�� W Y d d }~X nX || _|j | j
� d S )Ni z.Error on reading from the event loop self pipe)r? r@ r ) rY rZ r[ r� r r_ � ExceptionrD r� r` r� )r rs rF r# r# r$ r� � s z(BaseProactorEventLoop._loop_self_readingc C s | j jd� d S )N� )r� rq )r r# r# r$ �_write_to_self� s z$BaseProactorEventLoop._write_to_self�d c s& d� �����fdd� � �j � � d S )Nc s" y�| d k rl| j � \}}�jr,tjd�||� �� }�d k rV�j||�dd|i�d� n�j||d|i�d� �j� rxd S �jj��} W n~ t k
r� } zD�j
� d kr��j d|�d�� �j � n�jr�tjd �dd
� W Y d d }~X n8 t
jk
�r �j � Y nX | �j�j
� < | j� � d S ) Nz#%r got a new connection from %r: %rTr� )r� r r! )r r! r zAccept failed on a socket)r? r@ rJ zAccept failed on socket %r)r> ���)rY Z_debugr
rC r� r� r� rZ r� r^ r* rD r7 r r_ r� r` )rs ZconnZaddrr rF )r �protocol_factoryr r! r r� r# r$ r � s>
z2BaseProactorEventLoop._start_serving.<locals>.loop)N)r )r r� r r� r! Zbacklogr# )r r� r r! r r� r$ �_start_serving� s $z$BaseProactorEventLoop._start_servingc C s d S )Nr# )r Z
event_listr# r# r$ �_process_events s z%BaseProactorEventLoop._process_eventsc C s* x| j j� D ] }|j� q W | j j� d S )N)r� �valuesr6 �clear)r Zfuturer# r# r$ r� $ s z*BaseProactorEventLoop._stop_accept_futuresc C s | j � | jj|� |j� d S )N)r� rZ �
_stop_servingr7 )r r r# r# r$ r� ) s z#BaseProactorEventLoop._stop_serving)NNN)N)NN)NN)NN)N)NNr� )r( rM rN r
r� r� r� r� r� r7 r� r� r� r� r� r� r� r� r� r� r� r� r� rP r# r# )r" r$ r � s4
()rO �__all__rJ r9 � r r r r r r �logr
Z_FlowControlMixinZ
BaseTransportr Z
ReadTransportrQ ZWriteTransportrc rw Z Transportr} r Z
BaseEventLoopr r# r# r# r$ �<module> s2 M T
#PK [$��dv v , __pycache__/unix_events.cpython-36.opt-1.pycnu �[��� 3
\�� �
@ 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 l
mZ dd
l
mZ ddlmZ ddlmZ dddddgZejdkr�ed��dd� Zy
ej Z W n e k
�r, dd� Z Y nX G dd � d ej �Z e!ed ��rVd d � Z"nddl#Z#d d � Z"G d!d"� d"ej$�Z%G d#d$� d$ej&ej'�Z(e!ed%��r�ej)Z*nddl#Z#d&d'� Z*G d(d)� d)e j+�Z,G d*d� d�Z-G d+d,� d,e-�Z.G d-d� de.�Z/G d.d� de.�Z0G d/d0� d0ej1�Z2e Z3e2Z4dS )1z2Selector event loop for Unix with signal handling.� N� )� base_events)�base_subprocess)�compat)� constants)�
coroutines)�events)�futures)�selector_events)� selectors)�
transports)� coroutine)�logger�SelectorEventLoop�AbstractChildWatcher�SafeChildWatcher�FastChildWatcher�DefaultEventLoopPolicyZwin32z+Signals are not really supported on Windowsc C s dS )zDummy signal handler.N� )�signum�framer r �+/usr/lib64/python3.6/asyncio/unix_events.py�_sighandler_noop% s r c C s | S )Nr )�pathr r r �<lambda>. s r c s� e Zd ZdZd"� fdd� Zdd� Z� fdd�Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z d#dd�Z d$dd�Z
ed%dd��Zdd� Zedddd�d d ��Zed&dd dd �d d!��Z� ZS )'�_UnixSelectorEventLoopzdUnix event loop.
Adds signal handling and UNIX Domain Socket support to SelectorEventLoop.
Nc s t � j|� i | _d S )N)�super�__init__�_signal_handlers)�self�selector)� __class__r r r 7 s z _UnixSelectorEventLoop.__init__c C s t j� S )N)�socketZ
socketpair)r r r r � _socketpair; s z"_UnixSelectorEventLoop._socketpairc s^ t � j� tj� s2xFt| j�D ]}| j|� q W n(| jrZtjd| �d�t | d� | jj
� d S )NzClosing the loop z@ on interpreter shutdown stage, skipping signal handlers removal)�source) r �close�sys�
is_finalizing�listr �remove_signal_handler�warnings�warn�ResourceWarning�clear)r �sig)r! r r r% > s
z _UnixSelectorEventLoop.closec C s" x |D ]}|sq| j |� qW d S )N)�_handle_signal)r �datar r r r �_process_self_dataL s
z)_UnixSelectorEventLoop._process_self_datac + G sH t j|�st j|�r td��| j|� | j� ytj| jj � � W n2 t
t fk
rt } zt t
|���W Y dd}~X nX tj||| �}|| j|< y tj|t� tj|d� W n� t k
�rB } zz| j|= | j�sytjd� W n4 t
t fk
�r } ztjd|� W Y dd}~X nX |jtjk�r0t dj|���n� W Y dd}~X nX dS )z�Add 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()NFr z set_wakeup_fd(-1) failed: %szsig {} cannot be caught���)r Z iscoroutineZiscoroutinefunction� TypeError�
_check_signalZ
_check_closed�signal�
set_wakeup_fdZ_csock�fileno�
ValueError�OSError� RuntimeError�strr ZHandler r � siginterruptr �info�errno�EINVAL�format)r r. �callback�args�exc�handleZnexcr r r �add_signal_handlerS s0
z)_UnixSelectorEventLoop.add_signal_handlerc C s8 | j j|�}|dkrdS |jr*| j|� n
| j|� dS )z2Internal helper that is the actual signal handler.N)r �getZ
_cancelledr) Z_add_callback_signalsafe)r r. rD r r r r/ � s z%_UnixSelectorEventLoop._handle_signalc & C s� | j |� y | j|= W n tk
r* dS X |tjkr>tj}ntj}ytj||� W n@ tk
r� } z$|jtj kr�t
dj |���n� W Y dd}~X nX | js�ytj d� W n2 t
tfk
r� } ztjd|� W Y dd}~X nX dS )zwRemove a handler for a signal. UNIX only.
Return True if a signal handler was removed, False if not.
Fzsig {} cannot be caughtNr z set_wakeup_fd(-1) failed: %sTr2 )r4 r �KeyErrorr5 �SIGINT�default_int_handler�SIG_DFLr9 r> r? r: r@ r6 r8 r r= )r r. ZhandlerrC r r r r) � s(
z,_UnixSelectorEventLoop.remove_signal_handlerc C sH t |t�stdj|���d| ko,tjk n sDtdj|tj���dS )z�Internal 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.
z sig must be an int, not {!r}r zsig {} out of range(1, {})N)�
isinstance�intr3 r@ r5 �NSIGr8 )r r. r r r r4 � s
z$_UnixSelectorEventLoop._check_signalc C s t | ||||�S )N)�_UnixReadPipeTransport)r �pipe�protocol�waiter�extrar r r �_make_read_pipe_transport� s z0_UnixSelectorEventLoop._make_read_pipe_transportc C s t | ||||�S )N)�_UnixWritePipeTransport)r rO rP rQ rR r r r �_make_write_pipe_transport� s z1_UnixSelectorEventLoop._make_write_pipe_transportc k s� t j� ��}
| j� } t| |||||||f| |d�| ��} |
j| j� | j| � y| E d H W n& tk
r~ }
z
|
}W Y d d }
~
X nX d }|d k r�| j� | j � E d H |�W d Q R X | S )N)rQ rR )
r �get_child_watcherZ
create_future�_UnixSubprocessTransport�add_child_handlerZget_pid�_child_watcher_callback� Exceptionr% Z_wait)r rP rB �shell�stdin�stdout�stderr�bufsizerR �kwargs�watcherrQ �transprC �errr r r �_make_subprocess_transport� s$
z1_UnixSelectorEventLoop._make_subprocess_transportc C s | j |j|� d S )N)Zcall_soon_threadsafeZ_process_exited)r �pid�
returncoderb r r r rY � s z._UnixSelectorEventLoop._child_watcher_callback)�ssl�sock�server_hostnamec c s� |r|d kr&t d��n|d k r&t d��|d k r�|d k r>t d��tjtjtjd�}y |jd� | j||�E d H W q� |j� � Y q�X nB|d kr�t d��|jtjks�tj |j
� r�t dj |���|jd� | j ||||�E d H \}}||fS )Nz/you have to pass server_hostname when using sslz+server_hostname is only meaningful with sslz3path and sock can not be specified at the same timer Fz no path and sock were specifiedz2A UNIX Domain Stream Socket was expected, got {!r})
r8 r" �AF_UNIX� SOCK_STREAM� setblockingZ sock_connectr% �familyr �_is_stream_socket�typer@ Z _create_connection_transport)r �protocol_factoryr rg rh ri � transportrP r r r �create_unix_connection� s8
z-_UnixSelectorEventLoop.create_unix_connection�d )rh �backlogrg c
! C s� t |t�rtd��|d k �r0|d k r,td��t|�}tjtjtj�}|d d
kr�y tj t
j|�j �rnt
j |� W nB t
k
r� Y n0 tk
r� } ztjd||� W Y d d }~X nX y|j|� W nj tk
�r } z8|j� |jtjk�rdj|�}ttj|�d �n� W Y d d }~X n |j� � Y nX n>|d k�rBtd��|jtjk�s`tj|j� �rntdj|���tj| |g�} |j|� |j d � | j |||| � | S ) Nz*ssl argument must be an SSLContext or Nonez3path and sock can not be specified at the same timer � z2Unable to check or remove stale UNIX socket %r: %rz Address {!r} is already in usez-path was not specified, and no sock specifiedz2A UNIX Domain Stream Socket was expected, got {!r}F)r ru ) rK �boolr3 r8 �_fspathr" rj rk �stat�S_ISSOCK�os�st_mode�remove�FileNotFoundErrorr9 r �errorZbindr% r> Z
EADDRINUSEr@ rm r rn ro ZServerZlistenrl Z_start_serving)
r rp r rh rt rg rc rC �msgZserverr r r �create_unix_server sP
z)_UnixSelectorEventLoop.create_unix_server)N)NN)NN)N)N)�__name__�
__module__� __qualname__�__doc__r r# r% r1 rE r/ r) r4 rS rU r
rd rY rr r� �
__classcell__r r )r! r r 1 s, -
%r � set_blockingc C s t j| d� d S )NF)rz r� )�fdr r r �_set_nonblockingB s r� c C s, t j | t j�}|tjB }t j | t j|� d S )N)�fcntlZF_GETFLrz �
O_NONBLOCKZF_SETFL)r� �flagsr r r r� G s
c s� e Zd Zd Zd � fdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z dd� Z
dd� Z dd� Z e
jrhdd� Zd!dd�Zdd � Zd d � Z� ZS )"rN � i Nc s� t � j|� || jd< || _|| _|j� | _|| _d| _t j
| j�j }t j
|�pbt j|�pbt j|�s~d | _d | _d | _td��t| j� | jj| jj| � | jj| jj| j| j� |d k r�| jjtj|d � d S )NrO Fz)Pipe transport is for pipes/sockets only.)r r �_extra�_loop�_piper7 �_fileno� _protocol�_closingrz �fstatr{ rx �S_ISFIFOry �S_ISCHRr8 r� � call_soon�connection_made� _add_reader� _read_readyr � _set_result_unless_cancelled)r �looprO rP rQ rR �mode)r! r r r Q s,
z _UnixReadPipeTransport.__init__c C s� | j jg}| jd kr |jd� n| jr0|jd� |jd| j � t| jdd �}| jd k r�|d k r�tj || jt
j �}|r�|jd� q�|jd� n | jd k r�|jd� n
|jd� dd j |� S )
N�closed�closingzfd=%s� _selector�polling�idle�openz<%s>� )
r! r� r� �appendr� r� �getattrr� r
�_test_selector_eventr Z
EVENT_READ�join)r r= r r� r r r �__repr__n s$
z _UnixReadPipeTransport.__repr__c C s� yt j| j| j�}W nD ttfk
r, Y n� tk
rX } z| j|d� W Y d d }~X n^X |rl| jj |� nJ| j
j � r�t j
d| � d| _| j
j| j� | j
j| jj� | j
j| jd � d S )Nz"Fatal read error on pipe transportz%r was closed by peerT)rz �readr� �max_size�BlockingIOError�InterruptedErrorr9 � _fatal_errorr� Z
data_receivedr� � get_debugr r= r� �_remove_readerr� Z eof_received�_call_connection_lost)r r0 rC r r r r� � s
z"_UnixReadPipeTransport._read_readyc C s | j j| j� d S )N)r� r� r� )r r r r �
pause_reading� s z$_UnixReadPipeTransport.pause_readingc C s | j j| j| j� d S )N)r� r� r� r� )r r r r �resume_reading� s z%_UnixReadPipeTransport.resume_readingc C s
|| _ d S )N)r� )r rP r r r � set_protocol� s z#_UnixReadPipeTransport.set_protocolc C s | j S )N)r� )r r r r � get_protocol� s z#_UnixReadPipeTransport.get_protocolc C s | j S )N)r� )r r r r �
is_closing� s z!_UnixReadPipeTransport.is_closingc C s | j s| jd � d S )N)r� �_close)r r r r r% � s z _UnixReadPipeTransport.closec C s, | j d k r(tjd| t| d� | j j� d S )Nzunclosed transport %r)r$ )r� r* r+ r, r% )r r r r �__del__� s
z _UnixReadPipeTransport.__del__� Fatal error on pipe transportc C sZ t |t�r4|jtjkr4| jj� rLtjd| |dd� n| jj||| | j d�� | j
|� d S )Nz%r: %sT)�exc_info)�message� exceptionrq rP ) rK r9 r> ZEIOr� r� r �debug�call_exception_handlerr� r� )r rC r� r r r r� � s
z#_UnixReadPipeTransport._fatal_errorc C s( d| _ | jj| j� | jj| j|� d S )NT)r� r� r� r� r� r� )r rC r r r r� � s z _UnixReadPipeTransport._closec C s4 z| j j|� W d | jj� d | _d | _ d | _X d S )N)r� �connection_lostr� r% r� )r rC r r r r� � s
z,_UnixReadPipeTransport._call_connection_losti )NN)r� )r� r� r� r� r r� r� r� r� r� r� r� r% r �PY34r� r� r� r� r� r r )r! r rN M s
rN c s� e Zd Zd%� fdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zejr|dd� Zd d � Zd&d d �Zd'd!d"�Zd#d$� Z� ZS )(rT Nc
s� t � j||� || jd< || _|j� | _|| _t� | _d| _ d| _
t j | j�j
}tj|�}tj|�}tj|�} |px|px| s�d | _d | _d | _td��t| j� | jj| jj| � | s�|r�tjjd� r�| jj| jj| j| j� |d k r�| jjt j |d � d S )NrO r Fz?Pipe transport is only for pipes, sockets and character devices�aix) r r r� r� r7 r� r� � bytearray�_buffer�
_conn_lostr� rz r� r{ rx r� r� ry r8 r� r� r� r� r& �platform�
startswithr� r� r r� )
r r� rO rP rQ rR r� Zis_charZis_fifoZ is_socket)r! r r r � s2
z _UnixWritePipeTransport.__init__c C s� | j jg}| jd kr |jd� n| jr0|jd� |jd| j � t| jdd �}| jd k r�|d k r�tj || jt
j �}|r�|jd� n
|jd� | j � }|jd| � n | jd k r�|jd� n
|jd� d d
j
|� S ) Nr� r� zfd=%sr� r� r� z
bufsize=%sr� z<%s>r� )r! r� r� r� r� r� r� r� r
r� r Z EVENT_WRITE�get_write_buffer_sizer� )r r= r r� r_ r r r r� � s(
z _UnixWritePipeTransport.__repr__c C s
t | j�S )N)�lenr� )r r r r r� s z-_UnixWritePipeTransport.get_write_buffer_sizec C s6 | j j� rtjd| � | jr*| jt� � n| j� d S )Nz%r was closed by peer)r� r� r r= r� r� �BrokenPipeError)r r r r r� s
z#_UnixWritePipeTransport._read_readyc C s t |t�rt|�}|sd S | js&| jrN| jtjkr<tjd� | jd7 _d S | j � s�yt
j | j |�}W nT t
tfk
r� d}Y n: tk
r� } z | jd7 _| j|d� d S d }~X nX |t|�kr�d S |dkr�t|�|d � }| jj| j | j� | j |7 _ | j� d S )Nz=pipe closed by peer or os.write(pipe, data) raised exception.r r z#Fatal write error on pipe transport)rK r� �
memoryviewr� r� r Z!LOG_THRESHOLD_FOR_CONNLOST_WRITESr �warningr� rz �writer� r� r� rZ r� r� r� Z _add_writer� _write_readyZ_maybe_pause_protocol)r r0 �nrC r r r r� s2
z _UnixWritePipeTransport.writec C s� yt j| j| j�}W nj ttfk
r, Y n� tk
r~ } z8| jj� | jd7 _| j j
| j� | j |d� W Y d d }~X nfX |t | j�kr�| jj� | j j
| j� | j
� | jr�| j j| j� | jd � d S |dkr�| jd |�= d S )Nr z#Fatal write error on pipe transportr )rz r� r� r� r� r� rZ r- r� r� �_remove_writerr� r� Z_maybe_resume_protocolr� r� r� )r r� rC r r r r� > s&
z$_UnixWritePipeTransport._write_readyc C s dS )NTr )r r r r �
can_write_eofX s z%_UnixWritePipeTransport.can_write_eofc C s8 | j r
d S d| _ | js4| jj| j� | jj| jd � d S )NT)r� r� r� r� r� r� r� )r r r r � write_eof[ s z!_UnixWritePipeTransport.write_eofc C s
|| _ d S )N)r� )r rP r r r r� d s z$_UnixWritePipeTransport.set_protocolc C s | j S )N)r� )r r r r r� g s z$_UnixWritePipeTransport.get_protocolc C s | j S )N)r� )r r r r r� j s z"_UnixWritePipeTransport.is_closingc C s | j d k r| j r| j� d S )N)r� r� r� )r r r r r% m s z _UnixWritePipeTransport.closec C s, | j d k r(tjd| t| d� | j j� d S )Nzunclosed transport %r)r$ )r� r* r+ r, r% )r r r r r� v s
z _UnixWritePipeTransport.__del__c C s | j d � d S )N)r� )r r r r �abort| s z _UnixWritePipeTransport.abort� Fatal error on pipe transportc C sP t |tj�r*| jj� rBtjd| |dd� n| jj||| | jd�� | j |� d S )Nz%r: %sT)r� )r� r� rq rP )
rK r Z_FATAL_ERROR_IGNOREr� r� r r� r� r� r� )r rC r� r r r r� s
z$_UnixWritePipeTransport._fatal_errorc C sF d| _ | jr| jj| j� | jj� | jj| j� | jj| j|� d S )NT) r� r� r� r� r� r- r� r� r� )r rC r r r r� � s
z _UnixWritePipeTransport._closec C s4 z| j j|� W d | jj� d | _d | _ d | _X d S )N)r� r� r� r% r� )r rC 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 rT � s$ % !
rT �set_inheritablec C sN t tdd�}tj| tj�}|s4tj| tj||B � ntj| tj|| @ � d S )NZ
FD_CLOEXECr )r� r� ZF_GETFDZF_SETFD)r� Z inheritableZ cloexec_flag�oldr r r �_set_inheritable� s
r� c @ s e Zd Zdd� ZdS )rW c K sv d }|t jkr*| jj� \}}t|j� d� t j|f||||d|d�|��| _|d k rr|j� t |j
� d|d�| j_ d S )NF)r[ r\ r] r^ Zuniversal_newlinesr_ �wb)� buffering) �
subprocess�PIPEr� r# r� r7 �Popen�_procr% r� �detachr\ ) r rB r[ r\ r] r^ r_ r` Zstdin_wr r r �_start� s
z _UnixSubprocessTransport._startN)r� r� r� r� r r r r rW � s rW c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� 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.
N)�NotImplementedError)r re rA rB r r r rX � s z&AbstractChildWatcher.add_child_handlerc C s
t � �dS )z�Removes the handler for process 'pid'.
The function returns True if the handler was successfully removed,
False if there was nothing to remove.N)r� )r re r r r �remove_child_handler� s z)AbstractChildWatcher.remove_child_handlerc C s
t � �dS )z�Attach 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.
N)r� )r r� r r r � attach_loop� 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.
N)r� )r r r r r% � s zAbstractChildWatcher.closec C s
t � �dS )zdEnter the watcher's context and allow starting new processes
This function must return selfN)r� )r r r r � __enter__ s z AbstractChildWatcher.__enter__c C s
t � �dS )zExit the watcher's contextN)r� )r �a�b�cr r r �__exit__ s z AbstractChildWatcher.__exit__N)
r� r� r� r� rX r� r� r% r� r� r r r r r � s
c @ sD e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dS )�BaseChildWatcherc C s d | _ i | _d S )N)r� �
_callbacks)r r r r r s zBaseChildWatcher.__init__c C s | j d � d S )N)r� )r r r r r% s zBaseChildWatcher.closec C s
t � �d S )N)r� )r � expected_pidr r r � _do_waitpid s z BaseChildWatcher._do_waitpidc C s
t � �d S )N)r� )r r r r �_do_waitpid_all s z BaseChildWatcher._do_waitpid_allc C sf | j d k r$|d kr$| jr$tjdt� | j d k r<| j jtj� || _ |d k rb|jtj| j � | j
� d S )NzCA loop is being detached from a child watcher with pending handlers) r� r� r* r+ �RuntimeWarningr) r5 �SIGCHLDrE � _sig_chldr� )r r� r r r r� s
z BaseChildWatcher.attach_loopc C sF y | j � W n4 tk
r@ } z| jjd|d�� W Y d d }~X nX d S )Nz$Unknown exception in SIGCHLD handler)r� r� )r� rZ r� r� )r rC r r r r� 1 s zBaseChildWatcher._sig_chldc C s2 t j|�rt j|� S t j|�r*t j|�S |S d S )N)rz � WIFSIGNALED�WTERMSIG� WIFEXITED� WEXITSTATUS)r �statusr r r �_compute_returncode= s
z$BaseChildWatcher._compute_returncodeN)
r� r� r� r r% r� r� r� r� r� r r r r r� s r� c sP e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
� Z S )r ad 'Safe' child watcher implementation.
This implementation avoids disrupting other code spawning processes by
polling explicitly each process in the SIGCHLD handler instead of calling
os.waitpid(-1).
This is a safe solution but it has a significant overhead when handling a
big number of children (O(n) each time SIGCHLD is raised)
c s | j j� t� j� d S )N)r� r- r r% )r )r! r r r% V s
zSafeChildWatcher.closec C s | S )Nr )r r r r r� Z s zSafeChildWatcher.__enter__c C s d S )Nr )r r� r� r� r r r r� ] s zSafeChildWatcher.__exit__c G s. | j d krtd��||f| j|< | j|� d S )NzICannot add child handler, the child watcher does not have a loop attached)r� r: r� r� )r re rA rB r r r rX ` s
z"SafeChildWatcher.add_child_handlerc C s& y | j |= dS tk
r dS X d S )NTF)r� rG )r re r r r r� k s
z%SafeChildWatcher.remove_child_handlerc C s" x t | j�D ]}| j|� q W d S )N)r( r� r� )r re r r r r� r s z SafeChildWatcher._do_waitpid_allc C s� yt j|t j�\}}W n( tk
r> |}d}tjd|� Y n0X |dkrLd S | j|�}| jj� rntj d||� y| j
j |�\}}W n. t k
r� | jj� r�tjd|dd� Y nX |||f|�� d S )N� z8Unknown child process pid %d, will report returncode 255r z$process %s exited with returncode %sz'Child watcher got an unexpected pid: %rT)r� )
rz �waitpid�WNOHANG�ChildProcessErrorr r� r� r� r� r� r� �poprG )r r� re r� rf rA rB r r r r� w s*
z SafeChildWatcher._do_waitpid) r� r� r� r� r% r� r� rX r� r� r� r� r r )r! r r K s c sT e Zd ZdZ� fdd�Z� fdd�Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
� Z S )r aW 'Fast' child watcher implementation.
This implementation reaps every terminated processes by calling
os.waitpid(-1) directly, possibly breaking other code spawning processes
and waiting for their termination.
There is no noticeable overhead when handling a big number of children
(O(1) each time a child terminates).
c s$ t � j� tj� | _i | _d| _d S )Nr )r r � threadingZLock�_lock�_zombies�_forks)r )r! r r r � s
zFastChildWatcher.__init__c s" | j j� | jj� t� j� d S )N)r� r- r� r r% )r )r! r r r% � s
zFastChildWatcher.closec
C s$ | j � | jd7 _| S Q R X d S )Nr )r� r� )r r r r r� � s zFastChildWatcher.__enter__c
C sV | j �: | jd8 _| js$| j r(d S t| j�}| jj� W d Q R X tjd|� 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 sl | j d krtd��| j�: y| jj|�}W n" tk
rL ||f| j|< d S X W d Q R X |||f|�� d S )NzICannot add child handler, the child watcher does not have a loop attached)r� r: r� r� r� rG r� )r re rA rB rf r r r rX � s
z"FastChildWatcher.add_child_handlerc C s& y | j |= dS tk
r dS X d S )NTF)r� rG )r re r r r r� � s
z%FastChildWatcher.remove_child_handlerc C s� x�yt jdt j�\}}W n tk
r, d S X |dkr:d S | j|�}| j�v y| jj|�\}}W nB tk
r� | j r�|| j
|< | j j � r�t
jd||� wd }Y nX | j j � r�t
jd||� W d Q R X |d kr�t
jd||� q|||f|�� qW d S )Nr r z,unknown process %s exited with returncode %sz$process %s exited with returncode %sz8Caught subprocess termination from unknown pid: %d -> %dr2 )rz r� r� r� r� r� r� r� rG r� r� r� r� r r� r� )r re r� rf rA rB r r r r� � s6
z FastChildWatcher._do_waitpid_all) r� r� r� r� r r% r� r� rX r� r� r� r r )r! r r � s c sH e Zd ZdZeZ� fdd�Zdd� Z� fdd�Zdd � Z d
d � Z
� Z S ) �_UnixDefaultEventLoopPolicyz:UNIX event loop policy with a watcher for child processes.c s t � j� d | _d S )N)r r �_watcher)r )r! r r r s
z$_UnixDefaultEventLoopPolicy.__init__c
C sH t j�8 | jd kr:t� | _ttj� tj�r:| jj| j j
� W d Q R X d S )N) r r� r� r rK r� �current_thread� _MainThreadr� �_localr� )r r r r �
_init_watcher s
z)_UnixDefaultEventLoopPolicy._init_watcherc s6 t � j|� | jdk r2ttj� tj�r2| jj|� dS )z�Set 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_loopr� rK r� r� r r� )r r� )r! r r r s
z*_UnixDefaultEventLoopPolicy.set_event_loopc C s | j dkr| j� | j S )zzGet the watcher for child processes.
If not yet set, a SafeChildWatcher object is automatically created.
N)r� r )r r r r rV & s
z-_UnixDefaultEventLoopPolicy.get_child_watcherc C s | j dk r| j j� || _ dS )z$Set the watcher for child processes.N)r� r% )r ra r r r �set_child_watcher0 s
z-_UnixDefaultEventLoopPolicy.set_child_watcher) r� r� r� r� r Z
_loop_factoryr r r rV r r� r r )r! r r� s
r� )5r� r> rz r5 r" rx r� r& r� r* � r r r r r r r r
r r r
�logr �__all__r� � ImportErrorr �fspathrw �AttributeErrorZBaseSelectorEventLoopr �hasattrr� r� Z
ReadTransportrN Z_FlowControlMixinZWriteTransportrT r� r� ZBaseSubprocessTransportrW r r� r r ZBaseDefaultEventLoopPolicyr� r r r r r r �<module> sn
O
F=On2PK [�»� � + __pycache__/subprocess.cpython-36.opt-1.pycnu �[��� 3
\� � @ s� d dgZ ddlZddlmZ ddlmZ ddlmZ ddlmZ dd lmZ dd
l m
Z
ej Z ej Z ej
Z
G d d � d ejej�ZG d
d� d�Zeddddejfdd��Zeddddejd�dd ��ZdS )�create_subprocess_exec�create_subprocess_shell� N� )�events)� protocols)�streams)�tasks)� coroutine)�loggerc sP e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
� Z S )�SubprocessStreamProtocolz0Like StreamReaderProtocol, but for a subprocess.c s< t � j|d� || _d | _ | _| _d | _d| _g | _d S )N)�loopF) �super�__init__�_limit�stdin�stdout�stderr�
_transport�_process_exited� _pipe_fds)�self�limitr )� __class__� �*/usr/lib64/python3.6/asyncio/subprocess.pyr s z!SubprocessStreamProtocol.__init__c C sf | j jg}| jd k r$|jd| j � | jd k r>|jd| j � | jd k rX|jd| j � ddj|� S )Nzstdin=%rz stdout=%rz stderr=%rz<%s>� )r �__name__r �appendr r �join)r �infor r r �__repr__ s
z!SubprocessStreamProtocol.__repr__c C s� || _ |jd�}|d k rDtj| j| jd�| _| jj|� | jj d� |jd�}|d k r�tj| j| jd�| _
| j
j|� | jj d� |jd�}|d k r�tj || d | jd�| _ d S )Nr )r r � r )�protocol�readerr )
r �get_pipe_transportr � StreamReaderr �_loopr 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|j|� d S )Nr r! )r r Z feed_data)r �fd�datar# r r r �pipe_data_received@ s z+SubprocessStreamProtocol.pipe_data_receivedc C s� |dkr,| j }|d k r |j� | j|� d S |dkr<| j}n|dkrL| j}nd }|d krt|d krj|j� n
|j|� || jkr�| jj|� | j � d S )Nr r r! )
r �closeZconnection_lostr r Zfeed_eofZ
set_exceptionr �remove�_maybe_close_transport)r r* �exc�piper# r r r �pipe_connection_lostJ s$
z-SubprocessStreamProtocol.pipe_connection_lostc C s d| _ | j� d S )NT)r r/ )r r r r �process_exiteda s z'SubprocessStreamProtocol.process_exitedc C s( t | j�dkr$| jr$| jj� d | _d S )Nr )�lenr r r r- )r r r r r/ e s
z/SubprocessStreamProtocol._maybe_close_transport) r �
__module__� __qualname__�__doc__r r r) r, r2 r3 r/ �
__classcell__r r )r r r s
r c @ s~ e Zd Zdd� Zdd� Zedd� �Zedd� �Zd d
� Z d d � Z
d
d� Z edd� �Z edd� �Z
edd� �Zeddd��ZdS )�Processc C s8 || _ || _|| _|j| _|j| _|j| _|j� | _d S )N)r Z _protocolr& r r r Zget_pid�pid)r r( r" r r r r r l s zProcess.__init__c C s d| j j| jf S )Nz<%s %s>)r r r: )r r r r r u s zProcess.__repr__c C s
| j j� S )N)r Zget_returncode)r r r r �
returncodex s zProcess.returncodec c s | j j� E dH S )zdWait until the process exit and return the process return code.
This method is a coroutine.N)r Z_wait)r r r r �wait| s z Process.waitc C s | j j|� d S )N)r � send_signal)r �signalr r r r= � s zProcess.send_signalc C s | j j� d S )N)r � terminate)r r r r r? � s zProcess.terminatec C s | j j� d S )N)r �kill)r r r r r@ � s z Process.killc c s� | j j� }| jj|� |r,tjd| t|�� y| jj� E d H W n8 tt fk
rx } z|rhtjd| |� W Y d d }~X nX |r�tjd| � | jj
� d S )Nz%%r communicate: feed stdin (%s bytes)z %r communicate: stdin got %rz%r communicate: close stdin) r& � get_debugr �writer
�debugr4 Zdrain�BrokenPipeError�ConnectionResetErrorr- )r �inputrC r0 r r r � _feed_stdin� s
zProcess._feed_stdinc C s d S )Nr )r r r r �_noop� s z
Process._noopc c s� | j j|�}|dkr | j}n| j}| jj� rJ|dkr8dnd}tjd| |� |j� E d H }| jj� r�|dkrndnd}tjd| |� |j � |S )Nr! r r r z%r communicate: read %sz%r communicate: close %s)
r r$ r r r& rA r
rC �readr- )r r* r( �stream�name�outputr r r � _read_stream� s
zProcess._read_streamNc c s� |d k r| j |�}n| j� }| jd k r2| jd�}n| j� }| jd k rP| jd�}n| j� }tj|||| jd�E d H \}}}| j� E d H ||fS )Nr r! )r ) rG rH r rM r r Zgatherr& r< )r rF r r r r r r � communicate� s
zProcess.communicate)N)r r5 r6 r r �propertyr; r r< r= r? r@ rG rH rM rN r r r r r9 k s r9 c
+ sP �d krt j� �� �fdd�}�j|| f|||d�|��E d H \}} t|| ��S )Nc s t � �d�S )N)r r )r r )r r r r �<lambda>� s z)create_subprocess_shell.<locals>.<lambda>)r r r )r �get_event_loopZsubprocess_shellr9 )
�cmdr r r r r �kwds�protocol_factoryr( r" r )r r r r � s )r r r r r c / sT �d krt j� �� �fdd�}�j|| f|�|||d�|��E d H \} }
t| |
��S )Nc s t � �d�S )N)r r )r r )r r r r rP � s z(create_subprocess_exec.<locals>.<lambda>)r r r )r rQ Zsubprocess_execr9 ) Zprogramr r r r r �argsrS rT r( r" r )r r r r � s )�__all__�
subprocess� r r r r Z
coroutinesr �logr
�PIPEZSTDOUTZDEVNULLZFlowControlMixinZSubprocessProtocolr r9 Z_DEFAULT_LIMITr r r r r r �<module> s( X] PK [ ��[? [? + __pycache__/test_utils.cpython-36.opt-2.pycnu �[��� 3
\�: �
@ s� d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl Z d dl
Z
d dl Z d dl Z d dl
Z
d dl mZ d dlmZ d dlmZmZ y d dlZW n ek
r� dZY nX ddlmZ ddlmZ ddlmZ dd lmZ dd
lmZ dd lm Z dd l m Z dd
l m Z d dl!m"Z" ej#dk�rDddl$m%Z% n d dlm%Z% dd� Z&e&d�Z'e&d�Z(dd� Z)dd� Z*dQdd�Z+d d � Z,G d d � d e�Z-G d d!� d!e�Z.G d"d#� d#�Z/G d$d%� d%e/e.�Z0d&d'�d(d)�Z1e2ed*��rVG d+d,� d,ej3e�Z4G d-d.� d.e4e�Z5G d/d0� d0e5�Z6G d1d2� d2e/e6�Z7d3d4� Z8ej9d5d6� �Z:ej9d&d'�d7d8��Z;ej9d9d d&d:�d;d<��Z<d=d>� Z=G d?d@� d@ej>�Z?G dAdB� dBej@�ZAdCdD� ZBG dEdF� dFeC�ZDdGdH� ZEG dIdJ� dJe jF�ZFej9dKdL� �ZGejHejIejJfdMdN�ZKdOdP� ZLdS )R� N)�mock)�
HTTPServer)�WSGIRequestHandler�
WSGIServer� )� base_events)�compat)�events)�futures)� selectors)�tasks)� coroutine)�logger)�supportZwin32)�
socketpairc C s` t td�r*tjjtj| �}tjj|�r*|S tjjtjjtj�d| �}tjj|�rT|S t | ��d S )N�
TEST_HOME_DIR�test)
�hasattrr �os�path�joinr �isfile�dirname�__file__�FileNotFoundError)�filename�fullname� r �*/usr/lib64/python3.6/asyncio/test_utils.py� data_file- s
r z ssl_cert.pemz ssl_key.pemc C s t d kr d S t jt j�S d S )N)�ssl�
SSLContextZPROTOCOL_SSLv23r r r r �dummy_ssl_context< s r" c
C s@ t dd� �}|� }| j|�}d|_z| j|� W d |j� X d S )Nc S s d S )Nr r r r r �onceD s zrun_briefly.<locals>.onceF)r
Z create_taskZ_log_destroy_pending�run_until_complete�close)�loopr# �gen�tr r r � run_brieflyC s
r) � c C sT t j � | }xB|� sN|d k r8|t j � }|dkr8tj� �| jtjd| d�� qW d S )Nr g����MbP?)r& )�timer
� TimeoutErrorr$ r Zsleep)r& Zpred�timeoutZdeadliner r r � run_untilR s r. c C s | j | j� | j� d S )N)Z call_soon�stopZ run_forever)r& r r r �run_once\ s r0 c @ s e Zd Zdd� Zdd� ZdS )�SilentWSGIRequestHandlerc C s t j� S )N)�io�StringIO)�selfr r r �
get_stderri s z#SilentWSGIRequestHandler.get_stderrc G s d S )Nr )r4 �format�argsr r r � log_messagel s z$SilentWSGIRequestHandler.log_messageN)�__name__�
__module__� __qualname__r5 r8 r r r r r1 g s r1 c s( e Zd ZdZ� fdd�Zdd� Z� ZS )�SilentWSGIServer� c s" t � j� \}}|j| j� ||fS )N)�super� get_request�
settimeout�request_timeout)r4 �request� client_addr)� __class__r r r? t s z SilentWSGIServer.get_requestc C s d S )Nr )r4 rB �client_addressr r r � handle_errory s z SilentWSGIServer.handle_error)r9 r: r; rA r? rF �
__classcell__r r )rD r r< p s r< c @ s e Zd Zdd� ZdS )�SSLWSGIServerMixinc C s^ t }t}tj� }|j||� |j|dd�}y| j||| � |j� W n tk
rX Y nX d S )NT)Z server_side) �ONLYKEY�ONLYCERTr r! Zload_cert_chainZ wrap_socketZRequestHandlerClassr% �OSError)r4 rB rE ZkeyfileZcertfile�contextZssockr r r �finish_request s z!SSLWSGIServerMixin.finish_requestN)r9 r: r; rM r r r r rH } s rH c @ s e Zd ZdS )�
SSLWSGIServerN)r9 r: r; r r r r rN � s rN F)�use_sslc
# sv dd� }|r|n|}|| t �� � j|� � j� _tj� fdd�d�}|j� z
� V W d � j� � j� |j � X d S )Nc S s d}dg}|||� dgS )Nz200 OK� Content-type�
text/plains Test message)rP rQ r )�environZstart_responseZstatusZheadersr r r �app� s
z _run_test_server.<locals>.appc s � j dd�S )Ng�������?)Z
poll_interval)Z
serve_foreverr )�httpdr r �<lambda>� s z"_run_test_server.<locals>.<lambda>)�target)
r1 Zset_appZserver_address�address� threadingZThread�start�shutdownZ server_closer )rW rO �
server_cls�server_ssl_clsrS Z server_classZ
server_threadr )rT r �_run_test_server� s
r] ZAF_UNIXc @ s e Zd Zdd� ZdS )�UnixHTTPServerc C s t jj| � d| _d| _d S )Nz 127.0.0.1�P )� socketserver�UnixStreamServer� server_bindZ server_nameZ server_port)r4 r r r rb � s zUnixHTTPServer.server_bindN)r9 r: r; rb r r r r r^ � s r^ c s( e Zd ZdZdd� Z� fdd�Z� ZS )�UnixWSGIServerr= c C s t j| � | j� d S )N)r^ rb Z
setup_environ)r4 r r r rb � s
zUnixWSGIServer.server_bindc s" t � j� \}}|j| j� |dfS )N� 127.0.0.1� )rd re )r> r? r@ rA )r4 rB rC )rD r r r? � s zUnixWSGIServer.get_request)r9 r: r; rA rb r? rG r r )rD r rc � s rc c @ s e Zd Zdd� ZdS )�SilentUnixWSGIServerc C s d S )Nr )r4 rB rE r r r rF � s z!SilentUnixWSGIServer.handle_errorN)r9 r: r; rF r r r r rf � s rf c @ s e Zd ZdS )�UnixSSLWSGIServerN)r9 r: r; r r r r rg � s rg c C s t j� �} | jS Q R X d S )N)�tempfileZNamedTemporaryFile�name)�filer r r �gen_unix_socket_path� s
rk c c s< t � } z
| V W d ytj| � W n tk
r4 Y nX X d S )N)rk r �unlinkrK )r r r r �unix_socket_path� s
rm c
c s, t � � }t|| ttd�E d H W d Q R X d S )N)rW rO r[ r\ )rm r] rf rg )rO r r r r �run_test_unix_server� s rn z 127.0.0.1)�host�portrO c c s t | |f|ttd�E d H d S )N)rW rO r[ r\ )r] r< rN )ro rp rO r r r �run_test_server� s
rq c C sP i }x4t | �D ](}|jd�r(|jd�r(qtd d�||< qW td| f| j |�� S )N�__)� return_valueZ TestProtocol)�dir�
startswith�endswith� MockCallback�type� __bases__)�baseZdctri r r r �make_test_protocol� s r{ c @ s6 e Zd Zdd� Zd dd�Zdd� Zdd � Zd
d � ZdS )
� TestSelectorc C s
i | _ d S )N)�keys)r4 r r r �__init__ s zTestSelector.__init__Nc C s t j|d||�}|| j|< |S )Nr )r Z SelectorKeyr} )r4 �fileobjr �data�keyr r r �register s
zTestSelector.registerc C s | j j|�S )N)r} �pop)r4 r r r r �
unregister s zTestSelector.unregisterc C s g S )Nr )r4 r- r r r �select s zTestSelector.selectc C s | j S )N)r} )r4 r r r �get_map s zTestSelector.get_map)N)r9 r: r; r~ r� r� r� r� r r r r r| s
r| c s� e Zd Zd,� fdd� Zdd� Zdd� Z� fdd �Zd
d � Zd d
� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Z� fd$d%�Z� fd&d'�Zd(d)� Zd*d+� Z� ZS )-�TestLoopNc sv t � j� |d kr"dd� }d| _nd| _|� | _t| j� d| _d| _g | _t� | _ i | _
i | _ | j � t
j� | _d S )Nc s s
d V d S )Nr r r r r r' , s z TestLoop.__init__.<locals>.genFTr g��&� .>)r> r~ �_check_on_close�_gen�next�_timeZ_clock_resolution�_timersr| Z _selector�readers�writers�reset_counters�weakref�WeakValueDictionary� _transports)r4 r' )rD r r r~ ( s
zTestLoop.__init__c C s | j S )N)r� )r4 r r r r+ ? s z
TestLoop.timec C s |r| j |7 _ d S )N)r� )r4 �advancer r r � advance_timeB s zTestLoop.advance_timec sB t � j� | jr>y| jjd� W n tk
r4 Y n
X td��d S )Nr z Time generator is not finished)r> r% r� r� �send�
StopIteration�AssertionError)r4 )rD r r r% G s
zTestLoop.closec G s t j||| �| j|< d S )N)r �Handler� )r4 �fd�callbackr7 r r r � _add_readerQ s zTestLoop._add_readerc C s0 | j | d7 < || jkr(| j|= dS dS d S )Nr TF)�remove_reader_countr� )r4 r� r r r �_remove_readerT s
zTestLoop._remove_readerc G sh || j krtd|� d���| j | }|j|krDtd|j� d|� ���|j|krdtd|j� d|� ���d S )Nzfd z is not registeredzunexpected callback: z != zunexpected callback args: )r� r� Z _callbackZ_args)r4 r� r� r7 �handler r r �
assert_reader\ s
zTestLoop.assert_readerc C s || j krtd|� d���d S )Nzfd z is registered)r� r� )r4 r� r r r �assert_no_readerg s
zTestLoop.assert_no_readerc G s t j||| �| j|< d S )N)r r� r� )r4 r� r� r7 r r r � _add_writerk s zTestLoop._add_writerc C s0 | j | d7 < || jkr(| j|= dS dS d S )Nr TF)�remove_writer_countr� )r4 r� r r r �_remove_writern s
zTestLoop._remove_writerc G s | j | }d S )N)r� )r4 r� r� r7 r� r r r �
assert_writerv s
zTestLoop.assert_writerc C s8 y| j | }W n tk
r" Y nX tdj||���d S )Nz.File descriptor {!r} is used by transport {!r})r� �KeyError� RuntimeErrorr6 )r4 r� Z transportr r r �_ensure_fd_no_transport~ s z TestLoop._ensure_fd_no_transportc G s | j |� | j||f|�� S )N)r� r� )r4 r� r� r7 r r r �
add_reader� s
zTestLoop.add_readerc C s | j |� | j|�S )N)r� r� )r4 r� r r r �
remove_reader� s
zTestLoop.remove_readerc G s | j |� | j||f|�� S )N)r� r� )r4 r� r� r7 r r r �
add_writer� s
zTestLoop.add_writerc C s | j |� | j|�S )N)r� r� )r4 r� r r r �
remove_writer� s
zTestLoop.remove_writerc C s t jt�| _t jt�| _d S )N)� collections� defaultdict�intr� r� )r4 r r r r� � s zTestLoop.reset_countersc s: t � j� x$| jD ]}| jj|�}| j|� qW g | _d S )N)r> � _run_oncer� r� r� r� )r4 �whenr� )rD r r r� � s
zTestLoop._run_oncec s | j j|� t� j||f|�� S )N)r� �appendr> �call_at)r4 r� r� r7 )rD r r r� � s zTestLoop.call_atc C s d S )Nr )r4 Z
event_listr r r �_process_events� s zTestLoop._process_eventsc C s d S )Nr )r4 r r r �_write_to_self� s zTestLoop._write_to_self)N)r9 r: r; r~ r+ r� r% r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rG r r )rD r r� s*
r� c K s t jf ddgi| ��S )N�spec�__call__)r ZMock)�kwargsr r r rw � s rw c @ s e Zd Zdd� ZdS )� MockPatternc C s t tjt| �|tj��S )N)�bool�re�search�str�S)r4 �otherr r r �__eq__� s zMockPattern.__eq__N)r9 r: r; r� r r r r r� � s r� c C s$ t j| �}|d kr td| f ��|S )Nz unable to get the source of %r)r Z_get_function_source�
ValueError)�func�sourcer r r �get_function_source� s
r� c @ sV e Zd Zedd� �Zdd�dd�Zddd �Zd
d � Zd d
� Zdd� Z e
j sRdd� Z dS )�TestCasec C s& | j }|d k r|jdd� | j� d S )NT)�wait)Z_default_executorrZ r% )r& Zexecutorr r r �
close_loop� s zTestCase.close_loopT)�cleanupc C s t jd � |r | j| j|� d S )N)r �set_event_loopZ
addCleanupr� )r4 r& r� r r r r� � s
zTestCase.set_event_loopNc C s t |�}| j|� |S )N)r� r� )r4 r' r& r r r �
new_test_loop� s
zTestCase.new_test_loopc C s | j t_ d S )N)�_get_running_loopr )r4 r r r �unpatch_get_running_loop� s z!TestCase.unpatch_get_running_loopc C s t j| _dd� t _tj� | _d S )Nc S s d S )Nr r r r r rU � s z TestCase.setUp.<locals>.<lambda>)r r� r Zthreading_setup�_thread_cleanup)r4 r r r �setUp� s
zTestCase.setUpc C sB | j � tjd � | jtj� d� | j� tj| j � tj
� d S )N)NNN) r� r r� Z assertEqual�sys�exc_infoZ
doCleanupsr Zthreading_cleanupr� Z
reap_children)r4 r r r �tearDown� s
zTestCase.tearDownc O s G dd� d�}|� S )Nc @ s e Zd Zdd� Zdd� ZdS )z!TestCase.subTest.<locals>.EmptyCMc S s d S )Nr )r4 r r r � __enter__� s z+TestCase.subTest.<locals>.EmptyCM.__enter__c W s d S )Nr )r4 �excr r r �__exit__� s z*TestCase.subTest.<locals>.EmptyCM.__exit__N)r9 r: r; r� r� r r r r �EmptyCM� s r� r )r4 r7 r� r� r r r �subTest� s zTestCase.subTest)N)
r9 r: r; � staticmethodr� r� r� r� r� r� r ZPY34r� r r r r r� � s
r� c c s2 t j} zt jtjd � d V W d t j| � X d S )Nr )r �levelZsetLevel�loggingZCRITICAL)Z old_levelr r r �disable_logger� s
r� c C s* t jtj�}| |_||_||_d|j_|S )Ng )r Z MagicMock�socket�protorx �familyZ
gettimeoutrs )r� rx r� Zsockr r r �mock_nonblocking_socket s r� c C s t jddd�S )Nz'asyncio.sslproto._is_sslproto_availableF)rs )r Zpatchr r r r �force_legacy_ssl_support s r� )r* )Mr� �
contextlibr2 r� r r� r� r` r� rh rX r+ Zunittestr� r Z http.serverr Zwsgiref.simple_serverr r r � ImportErrorre r r r r
r r Z
coroutinesr
�logr r r �platformZ
windows_utilsr r rJ rI r" r) r. r0 r1 r< rH rN r] r ra r^ rc rf rg rk �contextmanagerrm rn rq r{ Z BaseSelectorr| Z
BaseEventLoopr� rw r� r� r� r� r� Z IPPROTO_TCPZ SOCK_STREAMZAF_INETr� r� r r r r �<module> s�
4
PK [���� � __pycache__/log.cpython-36.pycnu �[��� 3
\| � @ s d Z ddlZeje�ZdS )zLogging configuration.� N)�__doc__ZloggingZ getLogger� __package__Zlogger� r r �#/usr/lib64/python3.6/asyncio/log.py�<module> s PK [G��4G G + __pycache__/base_tasks.cpython-36.opt-2.pycnu �[��� 3
\� � @ sD d dl Z d dlZddlmZ ddlmZ dd� Zdd� Zd d
� ZdS ) � N� )� base_futures)�
coroutinesc C sT t j| �}| jrd|d< tj| j�}|jdd| � | jd k rP|jdd| j � |S )NZ
cancellingr r z coro=<%s>� z wait_for=%r)r Z_future_repr_infoZ _must_cancelr Z_format_coroutine�_coro�insertZ _fut_waiter)�task�info�coro� r �*/usr/lib64/python3.6/asyncio/base_tasks.py�_task_repr_info s
r
c C s� g }y | j j}W n tk
r, | j j}Y nX |d k rxx6|d k rl|d k rZ|dkrRP |d8 }|j|� |j}q8W |j� nL| jd k r�| jj}x8|d k r�|d k r�|dkr�P |d8 }|j|j � |j
}q�W |S )Nr r ) r �cr_frame�AttributeError�gi_frame�append�f_back�reverse�
_exception�
__traceback__�tb_frame�tb_next)r �limitZframes�f�tbr r r �_task_get_stack s0
r c C s� g }t � }xj| j|d�D ]Z}|j}|j}|j}|j} ||krP|j|� tj|� tj |||j
�}
|j ||| |
f� qW | j } |s�t
d| |d� n*| d k r�t
d| |d� nt
d| |d� tj||d� | d k r�x$tj| j| �D ]}
t
|
|dd� q�W d S )N)r zNo stack for %r)�filez)Traceback for %r (most recent call last):z%Stack for %r (most recent call last):� )r �end)�setZ get_stack�f_lineno�f_code� co_filename�co_name�add� linecache�
checkcache�getline� f_globalsr r �print� traceback�
print_list�format_exception_only� __class__) r r r �extracted_listZcheckedr �lineno�co�filename�name�line�excr r r �_task_print_stack3 s0
r5 )r% r* r r r r
r r5 r r r r �<module> s PK [s�58�s �s * __pycache__/selector_events.cpython-36.pycnu �[��� 3
\�� �
@ s< d Z dgZddlZddlZddlZddlZddlZddlZy ddlZW n e k
r^ dZY nX ddl
m Z ddl
m Z ddl
m
Z
ddl
mZ dd l
mZ dd
l
mZ dd l
mZ dd l
mZ dd
lmZ ddlmZ dd� ZG dd� de j�ZG dd� dejej�Z G dd� de �Z G dd� de �Z G dd� de �Z dS )z�Event 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)�compat)� constants)�events)�futures)� selectors)�
transports)�sslproto)� coroutine)�loggerc C s6 y| j |�}W n tk
r" dS X t|j|@ �S d S )NF)�get_key�KeyError�boolr )�selector�fdZevent�key� r �//usr/lib64/python3.6/asyncio/selector_events.py�_test_selector_event s
r c sr e Zd ZdZdO� fdd� ZdPddd�dd�ZdQddddd �d
d �Zddddd �d d
�ZdRdd�Z� fdd�Z dd� Z
dd� Z dd� Z dd� Z
dd� Zd d � ZdSd d �ZdTd!d"�ZedUd#d$��Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Zd5d6� Z d7d8� Z d9d:� Z d;d<� Z d=d>� Z ed?d@� �Z!dAdB� Z"dCdD� Z#dEdF� Z$dGdH� Z%dIdJ� Z&dKdL� Z'dMdN� Z(� Z)S )Vr zJSelector event loop.
See events.EventLoop for API specification.
Nc sF t � j� |d krtj� }tjd|jj� || _| j � t
j � | _ d S )NzUsing selector: %s)
�super�__init__r ZDefaultSelectorr
�debug� __class__�__name__� _selector�_make_self_pipe�weakref�WeakValueDictionary� _transports)�selfr )r r r r 1 s
z BaseSelectorEventLoop.__init__)�extra�serverc C s t | |||||�S )N)�_SelectorSocketTransport)r! �sock�protocol�waiterr" r# r r r �_make_socket_transport; s
z,BaseSelectorEventLoop._make_socket_transportF)� server_side�server_hostnamer" r# c
C sN t j� s"| j||||||||d�S t j| |||||�} t| || ||d� | jS )N)r) r* r" r# )r" r# )r Z_is_sslproto_available�_make_legacy_ssl_transportZ SSLProtocolr$ Z_app_transport)
r! �rawsockr& �
sslcontextr' r) r* r" r# Z ssl_protocolr r r �_make_ssl_transport@ s
z)BaseSelectorEventLoop._make_ssl_transportc
C s t | ||||||||� S )N)�_SelectorSslTransport) r! r, r& r- r' r) r* r" r# r r r r+ O s
z0BaseSelectorEventLoop._make_legacy_ssl_transportc C s t | |||||�S )N)�_SelectorDatagramTransport)r! r% r& �addressr' r" r r r �_make_datagram_transportY s z.BaseSelectorEventLoop._make_datagram_transportc sL | j � rtd��| j� r d S | j� t� j� | jd k rH| jj� d | _d S )Nz!Cannot close a running event loop)Z
is_running� RuntimeError� is_closed�_close_self_piper �closer )r! )r r r r6 ^ s
zBaseSelectorEventLoop.closec C s t �d S )N)�NotImplementedError)r! r r r � _socketpairi s z!BaseSelectorEventLoop._socketpairc C sB | j | jj� � | jj� d | _| jj� d | _| jd8 _d S )Nr )�_remove_reader�_ssock�filenor6 �_csock�
_internal_fds)r! r r r r5 l s
z&BaseSelectorEventLoop._close_self_pipec C sN | j � \| _| _| jjd� | jjd� | jd7 _| j| jj� | j� d S )NFr )r8 r: r< � setblockingr= � _add_readerr; �_read_from_self)r! r r r r t s
z%BaseSelectorEventLoop._make_self_pipec C s d S )Nr )r! �datar r r �_process_self_data| s z(BaseSelectorEventLoop._process_self_datac C sV xPy | j jd�}|sP | j|� W q tk
r8 wY q tk
rL P Y qX qW d S )Ni )r: �recvrB �InterruptedError�BlockingIOError)r! rA r r r r@ s z%BaseSelectorEventLoop._read_from_selfc C sJ | j }|d k rFy|jd� W n( tk
rD | jr@tjddd� Y nX d S )N� z3Fail to write a null byte into the self-pipe socketT)�exc_info)r< �send�OSError�_debugr
r )r! Zcsockr r r �_write_to_self� s z$BaseSelectorEventLoop._write_to_self�d c C s | j |j� | j|||||� d S )N)r? r; �_accept_connection)r! �protocol_factoryr% r- r# �backlogr r r �_start_serving� s z$BaseSelectorEventLoop._start_servingc C s� x�t |�D ]�}y0|j� \}}| jr2tjd|||� |jd� W n� tttfk
rX d S t k
r� } z^| j
t
j t
j t
j
t
jfkr�| jd| |d�� | j|j� � | jtj| j|||||� n� W Y d d } ~ X q
X d|i}
| j|||
||�} | j| � q
W d S )Nz#%r got a new connection from %r: %rFz&socket.accept() out of system resource)�message� exception�socket�peername)�range�acceptrJ r
r r> rE rD �ConnectionAbortedErrorrI �errnoZEMFILEZENFILEZENOBUFSZENOMEM�call_exception_handlerr9 r; Z
call_laterr ZACCEPT_RETRY_DELAYrP �_accept_connection2Z create_task) r! rN r% r- r# rO �_�conn�addr�excr" rV r r r rM � s4
z(BaseSelectorEventLoop._accept_connectionc c s� d }d }yj|� }| j � }|r6| j||||d||d�}n| j|||||d�}y|E d H W n |j� � Y nX W n\ tk
r� } z@| jr�d| d�}
|d k r�||
d< |d k r�||
d< | j|
� W Y d d } ~ X nX d S )NT)r' r) r" r# )r' r" r# z3Error on transport creation for incoming connection)rQ rR r& � transport)�
create_futurer. r( r6 � ExceptionrJ rY ) r! rN r\ r" r- r# r& r_ r' r^ �contextr r r rZ � s4 z)BaseSelectorEventLoop._accept_connection2c C s@ y| j | }W n tk
r" Y nX |j� s<tdj||���d S )Nz.File descriptor {!r} is used by transport {!r})r r �
is_closingr3 �format)r! r r_ r r r �_ensure_fd_no_transport� s z-BaseSelectorEventLoop._ensure_fd_no_transportc
G s� | j � tj||| �}y| jj|�}W n* tk
rP | jj|tj|d f� Y n>X |j|j }\}}| jj
||tjB ||f� |d k r�|j � d S )N) �
_check_closedr �Handler r r �registerr �
EVENT_READrA �modify�cancel) r! r �callback�args�handler �mask�reader�writerr r r r? � s
z!BaseSelectorEventLoop._add_readerc
C s� | j � r dS y| jj|�}W n tk
r0 dS X |j|j }\}}|tj M }|sb| jj|� n| jj ||d |f� |d k r�|j
� dS dS d S )NFT) r4 r r r r rA r ri �
unregisterrj rk )r! r r ro rp rq r r r r9 s z$BaseSelectorEventLoop._remove_readerc
G s� | j � tj||| �}y| jj|�}W n* tk
rP | jj|tjd |f� Y n>X |j|j }\}}| jj
||tjB ||f� |d k r�|j � d S )N) rf r rg r r r rh r � EVENT_WRITErA rj rk ) r! r rl rm rn r ro rp rq r r r � _add_writer s
z!BaseSelectorEventLoop._add_writerc
C s� | j � r dS y| jj|�}W n tk
r0 dS X |j|j }\}}|tj M }|sb| jj|� n| jj |||df� |dk r�|j
� dS dS dS )zRemove a writer callback.FNT) r4 r r r r rA r rs rr rj rk )r! r r ro rp rq r r r �_remove_writer, s z$BaseSelectorEventLoop._remove_writerc G s | j |� | j||f|�� S )zAdd a reader callback.)re r? )r! r rl rm r r r �
add_readerC s
z BaseSelectorEventLoop.add_readerc C s | j |� | j|�S )zRemove a reader callback.)re r9 )r! r r r r �
remove_readerH s
z#BaseSelectorEventLoop.remove_readerc G s | j |� | j||f|�� S )zAdd a writer callback..)re rt )r! r rl rm r r r �
add_writerM s
z BaseSelectorEventLoop.add_writerc C s | j |� | j|�S )zRemove a writer callback.)re ru )r! r r r r �
remove_writerR s
z#BaseSelectorEventLoop.remove_writerc C s6 | j r|j� dkrtd��| j� }| j|d||� |S )z�Receive 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.
This method is a coroutine.
r z the socket must be non-blockingN)rJ �
gettimeout�
ValueErrorr` �
_sock_recv)r! r% �n�futr r r � sock_recvW s
z BaseSelectorEventLoop.sock_recvc C s� |d k r| j |� |j� r d S y|j|�}W n` ttfk
rb |j� }| j|| j||||� Y n6 tk
r� } z|j |� W Y d d }~X n X |j
|� d S )N) rw � cancelledrC rE rD r; rv r| ra �
set_exception�
set_result)r! r~ �
registered_fdr% r} rA r r^ r r r r| f s
z BaseSelectorEventLoop._sock_recvc C sF | j r|j� dkrtd��| j� }|r8| j|d||� n
|jd� |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.
This method is a coroutine.
r z the socket must be non-blockingN)rJ rz r{ r` �
_sock_sendallr� )r! r% rA r~ r r r � sock_sendall{ s
z"BaseSelectorEventLoop.sock_sendallc C s� |d k r| j |� |j� r d S y|j|�}W nD ttfk
rH d}Y n* tk
rp } z|j|� d S d }~X nX |t|�kr�|jd � n.|r�||d � }|j � }| j
|| j ||||� d S )Nr ) ry r� rH rE rD ra r� �lenr� r; rx r� )r! r~ r� r% rA r} r^ r r r r r� � s"
z#BaseSelectorEventLoop._sock_sendallc c s� | j r|j� dkrtd��ttd� s2|jtjkrptj||j|j | d�}|j
� sZ|E dH |j � d \}}}}}| j � }| j
|||� |E dH S )zTConnect to a remote socket at address.
This method is a coroutine.
r z the socket must be non-blocking�AF_UNIX)�family�proto�loopN)rJ rz r{ �hasattrrS r� r� r Z_ensure_resolvedr� �done�resultr` �
_sock_connect)r! r% r1 Zresolvedr[ r~ r r r � sock_connect� s
z"BaseSelectorEventLoop.sock_connectc C s� |j � }y|j|� W nj ttfk
rV |jtj| j|�� | j|| j |||� Y n6 t
k
r� } z|j |� W Y d d }~X n X |j d � d S )N)
r; ZconnectrE rD Zadd_done_callback� functools�partial�_sock_connect_donerx �_sock_connect_cbra r� r� )r! r~ r% r1 r r^ r r r r� � s z#BaseSelectorEventLoop._sock_connectc C s | j |� d S )N)ry )r! r r~ r r r r� � s z(BaseSelectorEventLoop._sock_connect_donec C s� |j � r d S y,|jtjtj�}|dkr6t|d|f ��W nB ttfk
rP Y n6 tk
rz } z|j |� W Y d d }~X n X |j
d � d S )Nr zConnect call failed %s) r� Z
getsockoptrS Z
SOL_SOCKETZSO_ERRORrI rE rD ra r� r� )r! r~ r% r1 �errr^ r r r r� � s z&BaseSelectorEventLoop._sock_connect_cbc C s4 | j r|j� dkrtd��| j� }| j|d|� |S )a| 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.
This method is a coroutine.
r z the socket must be non-blockingF)rJ rz r{ r` � _sock_accept)r! r% r~ r r r � sock_accept� s
z!BaseSelectorEventLoop.sock_acceptc C s� |j � }|r| j|� |j� r"d S y|j� \}}|jd� W nV ttfk
rh | j|| j|d|� Y n: t k
r� } z|j
|� W Y d d }~X nX |j ||f� d S )NFT) r; rw r� rV r> rE rD rv r� ra r� r� )r! r~ Z
registeredr% r r\ r1 r^ r r r r� � s
z"BaseSelectorEventLoop._sock_acceptc C s� x~|D ]v\}}|j |j }\}}|tj@ rN|d k rN|jrD| j|� n
| j|� |tj@ r|d k r|jrr| j|� q| j|� qW d S )N) �fileobjrA r ri Z
_cancelledr9 Z
_add_callbackrs ru )r! Z
event_listr ro r� rp rq r r r �_process_events� s
z%BaseSelectorEventLoop._process_eventsc C s | j |j� � |j� d S )N)r9 r; r6 )r! r% r r r �
_stop_serving s z#BaseSelectorEventLoop._stop_serving)N)N)N)NNN)NNrL )NNrL )NN)*r �
__module__� __qualname__�__doc__r r( r. r+ r2 r6 r8 r5 r rB r@ rK rP rM r rZ re r? r9 rt ru rv rw rx ry r r| r� r� r� r� r� r� r� r� r� r� �
__classcell__r r )r r r + sT
( # c s� e Zd Zd ZeZdZd � fdd� Zdd� Zdd � Z d
d � Z
d d
� Z dd� Z dd� Z
ejr`dd� Zd!dd�Zdd� Zdd� Zdd � Zd d � Z� ZS )"�_SelectorTransport� i Nc s� t � j||� || jd< |j� | jd< d| jkrdy|j� | jd< W n tjk
rb d | jd< Y nX || _|j� | _ || _
d| _ || _ | j
� | _d| _d| _| j d k r�| j j� | |j| j < d S )NrS ZsocknamerT Tr F)r r �_extraZ getsocknameZ getpeernamerS �error�_sockr; �_sock_fd� _protocol�_protocol_connected�_server�_buffer_factory�_buffer�
_conn_lost�_closingZ_attachr )r! r� r% r& r" r# )r r r r s&
z_SelectorTransport.__init__c C s� | j jg}| jd kr |jd� n| jr0|jd� |jd| j � | jd k r�| jj� r�t| jj | jt
j �}|rz|jd� n
|jd� t| jj | jt
j �}|r�d}nd}| j
� }|jd||f � d d
j|� S ) N�closed�closingzfd=%sz read=pollingz read=idle�pollingZidlezwrite=<%s, bufsize=%s>z<%s>� )r r r� �appendr� r� �_loopr4 r r r ri rs �get_write_buffer_size�join)r! �infor� �state�bufsizer r r �__repr__2 s*
z_SelectorTransport.__repr__c C s | j d � d S )N)� _force_close)r! r r r �abortN s z_SelectorTransport.abortc C s
|| _ d S )N)r� )r! r& r r r � set_protocolQ s z _SelectorTransport.set_protocolc C s | j S )N)r� )r! r r r � get_protocolT s z _SelectorTransport.get_protocolc C s | j S )N)r� )r! r r r rc W s z _SelectorTransport.is_closingc C sT | j r
d S d| _ | jj| j� | jsP| jd7 _| jj| j� | jj| jd � d S )NTr ) r� r� r9 r� r� r� ru � call_soon�_call_connection_lost)r! r r r r6 Z s z_SelectorTransport.closec C s, | j d k r(tjd| t| d� | j j� d S )Nzunclosed transport %r)�source)r� �warnings�warn�ResourceWarningr6 )r! r r r �__del__h s
z_SelectorTransport.__del__�Fatal error on transportc C sP t |tj�r*| jj� rBtjd| |dd� n| jj||| | jd�� | j |� d S )Nz%r: %sT)rG )rQ rR r_ r& )
�
isinstancer Z_FATAL_ERROR_IGNOREr� � get_debugr
r rY r� r� )r! r^ rQ r r r � _fatal_errorn s
z _SelectorTransport._fatal_errorc C sd | j r
d S | jr(| jj� | jj| j� | jsBd| _| jj| j� | j d7 _ | jj| j |� d S )NTr )
r� r� �clearr� ru r� r� r9 r� r� )r! r^ r r r r� | s
z _SelectorTransport._force_closec C sV z| j r| jj|� W d | jj� d | _d | _d | _| j}|d k rP|j� d | _X d S )N)r� r� Zconnection_lostr� r6 r� r� Z_detach)r! r^ r# r r r r� � s
z(_SelectorTransport._call_connection_lostc C s
t | j�S )N)r� r� )r! r r r r� � s z(_SelectorTransport.get_write_buffer_sizec G s" | j r
d S | jj||f|�� d S )N)r� r� r? )r! r rl rm r r r r? � s z _SelectorTransport._add_readeri )NN)r� )r r� r� �max_size� bytearrayr� r� r r� r� r� r� rc r6 r ZPY34r� r� r� r� r� r? r� r r )r r r� s"
r� c sV e Zd Zd� fdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z dd� Z
� Z S )r$ Nc sr t � j|||||� d| _d| _tj| j� | jj| j j
| � | jj| j | j | j
� |d k rn| jjtj|d � d S )NF)r r �_eof�_pausedr Z _set_nodelayr� r� r� r� �connection_mader? r� � _read_readyr � _set_result_unless_cancelled)r! r� r% r& r' r" r# )r r r r � s
z!_SelectorSocketTransport.__init__c C s> | j s | jrd S d| _| jj| j� | jj� r:tjd| � d S )NTz%r pauses reading)r� r� r� r9 r� r� r
r )r! r r r �
pause_reading� s
z&_SelectorSocketTransport.pause_readingc C sB | j s| j rd S d| _| j| j| j� | jj� r>tjd| � d S )NFz%r resumes reading) r� r� r? r� r� r� r� r
r )r! r r r �resume_reading� s
z'_SelectorSocketTransport.resume_readingc C s� | j r
d S y| jj| j�}W nD ttfk
r4 Y n| tk
r` } z| j|d� W Y d d }~X nPX |rt| jj |� n<| j
j � r�t j
d| � | jj� }|r�| j
j| j� n| j� d S )Nz$Fatal read error on socket transportz%r received EOF)r� r� rC r� rE rD ra r� r� �
data_receivedr� r� r
r � eof_receivedr9 r� r6 )r! rA r^ � keep_openr r r r� � s
z$_SelectorSocketTransport._read_readyc C s� t |tttf�s"tdt|�j ��| jr0td��|s8d S | j rf| j t
j krTt j
d� | j d7 _ d S | js�y| jj|�}W nB ttfk
r� Y n@ tk
r� } z| j|d� d S d }~X nX ||d � }|s�d S | jj| j| j� | jj|� | j� d S )Nz1data argument must be a bytes-like object, not %rz%Cannot call write() after write_eof()z socket.send() raised exception.r z%Fatal write error on socket transport)r� �bytesr� �
memoryview� TypeError�typer r� r3 r� r �!LOG_THRESHOLD_FOR_CONNLOST_WRITESr
�warningr� r� rH rE rD ra r� r� rt r� � _write_ready�extend�_maybe_pause_protocol)r! rA r} r^ r r r �write� s4
z _SelectorSocketTransport.writec C s� | j std��| jrd S y| jj| j �}W n\ ttfk
rB Y n� tk
r� } z*| jj | j
� | j j � | j |d� W Y d d }~X nTX |r�| j d |�= | j
� | j s�| jj | j
� | jr�| jd � n| jr�| jjtj� d S )NzData should not be emptyz%Fatal write error on socket transport)r� �AssertionErrorr� r� rH rE rD ra r� ru r� r� r� �_maybe_resume_protocolr� r� r� �shutdownrS �SHUT_WR)r! r} r^ r r r r� s(
z%_SelectorSocketTransport._write_readyc C s. | j s | jrd S d| _| js*| jjtj� d S )NT)r� r� r� r� r� rS r� )r! r r r � write_eof s
z"_SelectorSocketTransport.write_eofc C s dS )NTr )r! r r r �
can_write_eof s z&_SelectorSocketTransport.can_write_eof)NNN) r r� r� r r� r� r� r� r� r� r� r� r r )r r r$ � s #r$ c sd e Zd ZeZd� fdd� Zddd�Zdd� Zd d
� Zd d � Z d
d� Z
dd� Z dd� Z dd� Z
� ZS )r/ NFc
s� t d krtd��|s tj||�}|dd�}
|r<| r<||
d< |j|f|
�} t� j|| ||| � d| _|| _|| _ || _
d| _ | j j
|d� | jj� r�tjd| � | jj� } nd } | j| � d S )Nz stdlib ssl module not availableF)r) Zdo_handshake_on_connectr* )r- z%r starts SSL handshake)�sslr3 r Z_create_transport_contextZ wrap_socketr r r� �_server_hostname�_waiter� _sslcontextr� r� �updater� r� r
r �time�
_on_handshake)
r! r� r, r& r- r' r) r* r" r# Z wrap_kwargsZsslsock�
start_time)r r r r ( s*
z _SelectorSslTransport.__init__c C sD | j d krd S | j j� s:|d k r.| j j|� n | j jd � d | _ d S )N)r� r� r� r� )r! r^ r r r �_wakeup_waiterL s
z$_SelectorSslTransport._wakeup_waiterc " C s$ y| j j� W n� tjk
r8 | jj| j| j|� d S tjk
r` | jj | j| j|� d S t
k
r� } z`| jj � r�t j
d| dd� | jj| j� | jj| j� | j j� | j|� t|t�r�d S � W Y d d }~X nX | jj| j� | jj| j� | j j� }t| jd��s�| j�r�| jjtjk�r�ytj|| j� W nR tk
�r� } z4| jj � �rjt j
d| dd� | j j� | j|� d S d }~X nX | jj || j j � | j j � | j d� d| _ d| _ | jj| j| j!� d| _"| jj#| j$j%| � | jj#| j� | jj � �r | jj&� | }t j'd| |d � d S )
Nz%r: SSL handshake failedT)rG Zcheck_hostnamez1%r: SSL handshake failed on matching the hostname)�peercert�cipher� compressionZ
ssl_objectFz %r: SSL handshake took %.1f msg @�@)(r� Z do_handshaker� �SSLWantReadErrorr� r? r� r� �SSLWantWriteErrorrt �
BaseExceptionr� r
r� r9 ru r6 r� r� ra Z getpeercertr� r� r� Z verify_modeZ CERT_NONEZmatch_hostnamer� r� r� r� �_read_wants_write�_write_wants_readr� r� r� r� r� r� r )r! r� r^ r� Zdtr r r r� V sb
z#_SelectorSslTransport._on_handshakec C sJ | j rtd��| jr td��d| _| jj| j� | jj� rFtjd| � d S )Nz#Cannot pause_reading() when closingzAlready pausedTz%r pauses reading) r� r3 r� r� r9 r� r� r
r )r! r r r r� � s
z#_SelectorSslTransport.pause_readingc C sJ | j std��d| _ | jr d S | jj| j| j� | jj� rFtj d| � d S )Nz
Not pausedFz%r resumes reading)
r� r3 r� r� r? r� r� r� r
r )r! r r r r� � s
z$_SelectorSslTransport.resume_readingc C s" | j r
d S | jr6d| _| j� | jr6| jj| j| j� y| jj| j �}W n� t
t t j
fk
rd Y n� t jk
r� d| _| jj| j� | jj| j| j� Y n� tk
r� } z| j|d� W Y d d }~X nTX |r�| jj|� n@z4| jj� r�tjd| � | jj� }|�rtjd� W d | j� X d S )NFTz!Fatal read error on SSL transportz%r received EOFz?returning true from eof_received() has no effect when using ssl)r� r� r� r� r� rt r� r� rC r� rE rD r� r� r� r� r9 ra r� r� r� r� r
r r� r� r6 )r! rA r^ r� r r r r� � s4
z!_SelectorSslTransport._read_readyc C s( | j r
d S | jr<d| _| j� | jp(| js<| jj| j| j� | jr�y| j j
| j�}W n� t t t
jfk
rt d}Y np t
jk
r� d}| jj| j� d| _Y nD tk
r� } z(| jj| j� | jj� | j|d� d S d }~X nX |r�| jd |�= | j� | j�s$| jj| j� | j�r$| jd � d S )NFr Tz"Fatal write error on SSL transport)r� r� r� r� r� r� r? r� r� r� rH rE rD r� r� r� ru r� ra r� r� r� r� )r! r} r^ r r r r� � s8
z"_SelectorSslTransport._write_readyc C s� t |tttf�s"tdt|�j ��|s*d S | jrX| jtj krFt
j d� | jd7 _d S | j sp| j
j| j| j� | j j|� | j� d S )Nz1data argument must be a bytes-like object, not %rz socket.send() raised exception.r )r� r� r� r� r� r� r r� r r� r
r� r� r� rt r� r� r� r� )r! rA r r r r� � s
z_SelectorSslTransport.writec C s dS )NFr )r! r r r r� s z#_SelectorSslTransport.can_write_eof)NFNNN)N)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 )r0 Nc s^ t � j||||� || _| jj| jj| � | jj| j| j| j � |d k rZ| jjt
j |d � d S )N) r r �_addressr� r� r� r� r? r� r� r r� )r! r� r% r& r1 r' r" )r r r r s
z#_SelectorDatagramTransport.__init__c C s t dd� | jD ��S )Nc s s | ]\}}t |�V qd S )N)r� )�.0rA r[ r r r � <genexpr> s zC_SelectorDatagramTransport.get_write_buffer_size.<locals>.<genexpr>)�sumr� )r! r r r r� s z0_SelectorDatagramTransport.get_write_buffer_sizec C s� | j r
d S y| jj| j�\}}W np ttfk
r8 Y nh tk
rd } z| jj|� W Y d d }~X n< t k
r� } z| j
|d� W Y d d }~X nX | jj ||� d S )Nz&Fatal read error on datagram transport) r� r� Zrecvfromr� rE rD rI r� �error_receivedra r� Zdatagram_received)r! rA r] r^ r r r r� s z&_SelectorDatagramTransport._read_readyc C sT t |tttf�s"tdt|�j ��|s*d S | jrN|d | jfkrNtd| jf ��| j r�| jr�| j t
j krpt j
d� | j d7 _ d S | j�s4y&| jr�| jj|� n| jj||� d S ttfk
r� | jj| j| j� Y nZ tk
�r } z| jj|� d S d }~X n. tk
�r2 } z| j |d� d S d }~X nX | jj t|�|f� | j � d S )Nz1data argument must be a bytes-like object, not %rz#Invalid address: must be None or %sz socket.send() raised exception.r z'Fatal write error on datagram transport) r� r� r� r� r� r� r r� r{ r� r r� r
r� r� r� rH �sendtorE rD r� rt r� �
_sendto_readyrI r� r� ra r� r� r� )r! rA r] r^ r r r r� . s<
z!_SelectorDatagramTransport.sendtoc C s� x�| j r�| j j� \}}y&| jr,| jj|� n| jj||� W q ttfk
rf | j j||f� P Y q t k
r� } z| j
j |� d S d }~X q t k
r� } z| j
|d� d S d }~X qX qW | j� | j s�| jj| j� | jr�| jd � d S )Nz'Fatal write error on datagram transport)r� �popleftr� r� rH r� rE rD �
appendleftrI r� r� ra r� r� r� ru r� r� r� )r! rA r] r^ r r r r� U s* z(_SelectorDatagramTransport._sendto_ready)NNN)N) r r� r� � collections�dequer� r r� r� r� r� r� r r )r r r0 s
'r0 ) r� �__all__r� rX r� rS r� r r� � ImportError� r r r r r r r
r Z
coroutinesr �logr
r Z
BaseEventLoopr Z_FlowControlMixinZ Transportr� r$ r/ r0 r r r r �<module> sD
i iPK [K�[ [ $ __pycache__/protocols.cpython-36.pycnu �[��� 3
\� � @ sR d Z ddddgZG dd� d�ZG dd� de�ZG dd� de�ZG dd� de�Zd S )
zAbstract Protocol class.� BaseProtocol�Protocol�DatagramProtocol�SubprocessProtocolc @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � 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 )z�Called 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.
N� )�selfZ transportr r �)/usr/lib64/python3.6/asyncio/protocols.py�connection_made s z BaseProtocol.connection_madec C s dS )z�Called 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_writing7 s zBaseProtocol.resume_writingN)�__name__�
__module__� __qualname__�__doc__r r
r r r r r r r s
c @ s e Zd ZdZdd� 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()
c C s dS )zTCalled when some data is received.
The argument is a bytes object.
Nr )r �datar r r �
data_receivedX s zProtocol.data_receivedc C s dS )z�Called 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_received^ s zProtocol.eof_receivedN)r
r r r r r r r r r r > s c @ s e Zd ZdZdd� Zdd� ZdS )r z Interface for datagram protocol.c C s dS )z&Called when some datagram is received.Nr )r r Zaddrr r r �datagram_receivedj 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 r �error_receivedm s z DatagramProtocol.error_receivedN)r
r r r r r r r r r r g s c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) r z,Interface for protocol for subprocess calls.c C s dS )z�Called 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_receivedw s z%SubprocessProtocol.pipe_data_receivedc C s dS )z�Called 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 t s N)r �__all__r r r r r r r r �<module> s 7)
PK [i|MZ�. �. & __pycache__/tasks.cpython-36.opt-2.pycnu �[��� 3
\�a �
@ s� d ddddddddd d
d d g
Z d
dlZd
dlZd
dlZd
dlZd
dlZddlmZ ddlm Z ddlm
Z
ddlm Z ddlm Z ddl
m
Z
G dd � d e j�ZeZy d
dlZW n ek
r� Y n X ej ZZej jZej jZej jZe
dded�dd��Zdd� Ze
dd�d d��Ze
d d � �Zddd �d d�Ze
d.dd�d!d��Z dd�d"d#�Z e e � d< de _ [ dd�d$d �Z e
d%d&� �Z!G d'd(� d(e j�Z"dd)d*�d+d �Z#dd�d,d
�Z$d-d � Z%dS )/�Task�FIRST_COMPLETED�FIRST_EXCEPTION�
ALL_COMPLETED�wait�wait_for� as_completed�sleep�async�gather�shield�
ensure_future�run_coroutine_threadsafe� N� )�
base_tasks)�compat)�
coroutines)�events)�futures)� coroutinec s� e Zd Zej� Zi ZdZeddd��Z eddd��Z
dd�� fdd �
Z e j
rTd
d � Zd d
� Zdd�dd�Zddd�dd�Zdd� Zd � fdd� Zdd� Z� ZS ) r TNc C s |d krt j� }| jj|�S )N)r �get_event_loop�_current_tasks�get)�cls�loop� r �%/usr/lib64/python3.6/asyncio/tasks.py� current_task. s zTask.current_taskc s$ � d krt j� � � fdd�| jD �S )Nc s h | ]}|j � kr|�qS r )�_loop)�.0�t)r r r � <setcomp>B s z!Task.all_tasks.<locals>.<setcomp>)r r �
_all_tasks)r r r )r r � all_tasks: s zTask.all_tasks)r c sN t � j|d� | jr | jd= || _d | _d| _| jj| j� | j j
j | � d S )N)r r F���) �super�__init__�_source_traceback�_coro� _fut_waiter� _must_cancelr � call_soon�_step� __class__r" �add)�self�coror )r- r r r& D s z
Task.__init__c C sH | j tjkr8| jr8| dd�}| jr,| j|d< | jj|� tjj| � d S )Nz%Task was destroyed but it is pending!)�task�messageZsource_traceback) Z_stater Z_PENDING�_log_destroy_pendingr' r Zcall_exception_handler�Future�__del__)r/ �contextr r r r5 S s
z Task.__del__c C s
t j| �S )N)r Z_task_repr_info)r/ r r r �
_repr_info^ s zTask._repr_info)�limitc C s t j| |�S )N)r Z_task_get_stack)r/ r8 r r r � get_stacka s zTask.get_stack)r8 �filec C s t j| ||�S )N)r Z_task_print_stack)r/ r8 r: r r r � print_stackx s zTask.print_stackc C s4 d| _ | j� rdS | jd k r*| jj� r*dS d| _dS )NFT)Z_log_traceback�doner) �cancelr* )r/ r r r r= � s
z Task.cancelc sf | j r t|tj�stj� }d| _ | j}d | _| | jj| j< �zy"|d krT|j d �}n
|j
|�}W n� t k
r� } z.| j r�d| _ | j tj� � n | j
|j� W Y d d }~X �n� tjk
r� t� j� Y �n| tk
r� } z| j |� W Y d d }~X �nP tk
�r( } z| j |� � W Y d d }~X �n X t|dd �}|d k �r�|j| jk �rl| jj| jtdj| |��� n||�r�|| k�r�| jj| jtdj| ��� n2d|_|j| j� || _| j �r�| jj� �r�d| _ n | jj| jtdj| |��� n^|d k�r| jj| j� nDtj |��r.| jj| jtdj| |��� n| jj| jtdj|��� W d | jjj | j� d } X d S )NF�_asyncio_future_blockingz6Task {!r} got Future {!r} attached to a different loopz!Task cannot await on itself: {!r}z;yield was used instead of yield from in task {!r} with {!r}zIyield was used instead of yield from for generator in task {!r} with {!r}zTask got bad yield: {!r}) r* �
isinstancer �CancelledErrorr( r) r- r r �send�throw�
StopIteration�
set_exception�
set_result�valuer% r= � Exception�
BaseException�getattrr+ r, � RuntimeError�formatr> �add_done_callback�_wakeup�inspectZ isgenerator�pop)r/ �excr0 �resultZblocking)r- r r r, � s~
z
Task._stepc C sJ y |j � W n, tk
r8 } z| j|� W Y d d }~X n
X | j� d } d S )N)rQ rG r, )r/ �futurerP r r r rM � s z Task._wakeup)N)N)N)�__name__�
__module__� __qualname__�weakref�WeakSetr" r r3 � classmethodr r# r& r ZPY34r5 r7 r9 r; r= r, rM �
__classcell__r r )r- r r s
!T)r �timeout� return_whenc # s� t j| �stj| �r&tdt| �j ��| s2td��|tt t
fkrNtdj |���� d kr^t j
� � � fdd�t| �D �} t| ||� �E d H S )Nz expect a list of futures, not %sz#Set of coroutines/Futures is empty.z Invalid return_when value: {}c s h | ]}t |� d ��qS ))r )r )r �f)r r r r! 7 s zwait.<locals>.<setcomp>)r �isfuturer � iscoroutine� TypeError�typerS �
ValueErrorr r r rK r r �set�_wait)�fsr rZ r[ r )r r r s c G s | j � s| jd � d S )N)r< rE )�waiter�argsr r r �_release_waiter< s rg )r c c s� |d krt j� }|d kr"| E d H S |j� }|j|t|�}tjt|�}t| |d�} | j|� zhy|E d H W n* t j
k
r� | j |� | j � � Y nX | j
� r�| j� S | j |� | j � t j� �W d |j � X d S )N)r )r r �
create_future�
call_laterrg � functools�partialr rL r r@ �remove_done_callbackr= r< rQ � TimeoutError)�futrZ r re �timeout_handle�cbr r r r A s,
c # s� |j � �d �|d k r"|j|t���t| �� � ���fdd�}x| D ]}|j|� qBW z�E d H W d �d k rt�j� X t� t� }}x4| D ],}|j|� |j� r�|j |� q�|j |� q�W ||fS )Nc s\ � d8 � � dks6�t ks6�tkrX| j� rX| j� d k rX�d k rF�j� �j� sX�jd � d S )Nr r )r r � cancelled� exceptionr= r< rE )r\ )�counterr[ ro re r r �_on_completion| s z _wait.<locals>._on_completion)
rh ri rg �lenrL r= rb rl r< r. )rd rZ r[ r rt r\ r< �pendingr )rs r[ ro re r rc o s&
rc )r rZ c # s� t j| �stj| �r&tdt| �j ���d k r2�ntj� ��fdd�t | �D ��ddl
m } |�d��d �� ��fdd�}���fd d
�� t �fd d ��}x�D ]}|j
� � q�W �r�|d k rʈj||��x tt���D ] }|� V q�W d S )
Nz expect a list of futures, not %sc s h | ]}t |� d ��qS ))r )r )r r\ )r r r r! � s z as_completed.<locals>.<setcomp>r )�Queue)r c s. x �D ]} | j � � �jd � qW �j� d S )N)rl �
put_nowait�clear)r\ )rt r< �todor r � _on_timeout� s
z!as_completed.<locals>._on_timeoutc s6 �sd S �j | � � j| � � r2�d k r2�j� d S )N)�removerx r= )r\ )r< ro rz r r rt � s
z$as_completed.<locals>._on_completionc 3 s$ � j � E d H } | d kr tj�| j� S )N)r r rm rQ )r\ )r< r r �
_wait_for_one� s z#as_completed.<locals>._wait_for_one)r r] r r^ r_ r` rS r r rb Zqueuesrw r rL ri �rangeru )rd r rZ rw r{ r} r\ �_r )rt r< r ro rz r r � s
c
c sX | dkrd V |S |d kr"t j� }|j� }|jj| tj||�}z
|E d H S |j� X d S )Nr )r r rh r ri r Z _set_result_unless_cancelledr= )ZdelayrQ r rR �hr r r r � s
c C s t jdtdd� t| |d�S )Nz;asyncio.async() function is deprecated, use ensure_future()� )�
stacklevel)r )�warnings�warn�DeprecationWarningr )�coro_or_futurer r r r �async_� s r� c C s� t j| �r(|d k r$|| jk r$td��| S tj| �r^|d krBtj� }|j| �}|j rZ|j d= |S t
j r~t j
| �r~tt| �|d�S td��d S )Nz$loop argument must agree with Futurer )r z:An asyncio.Future, a coroutine or an awaitable is requiredr$ )r r] r ra r r^ r r Z create_taskr' r ZPY35rN Z isawaitabler �_wrap_awaitabler_ )r� r r1 r r r r � s
c c s | j � E d H S )N)� __await__)Z awaitabler r r r� s r� c s* e Zd Zdd�� fdd�
Zdd� Z� ZS )�_GatheringFutureN)r c s t � j|d� || _d| _d S )N)r F)r% r& � _children�_cancel_requested)r/ �childrenr )r- r r r& $ s z_GatheringFuture.__init__c C s: | j � r dS d}x| jD ]}|j� rd}qW |r6d| _|S )NFT)r< r� r= r� )r/ ZretZchildr r r r= ) s z_GatheringFuture.cancel)rS rT rU r& r= rY r r )r- r r� s r� F)r �return_exceptionsc s |s*| d krt j� } | j� ��jg � �S i � xjt|�D ]^}tj|�sht|| d�}| d kr`|j} d|_ n&|}| d kr||j} n|j| k r�t
d��|� |< q8W � fdd�|D �}t |��t || d��d�d g� ������fdd�}x&t
|�D ]\}}|jtj||�� q�W �S ) N)r Fz)futures are tied to different event loopsc s g | ] }� | �qS r r )r �arg)�
arg_to_futr r �
<listcomp>h s zgather.<locals>.<listcomp>r c s� �j � r |j� s|j� d S |j� r@tj� }�sl�j|� d S n,|jd k rf|j� }�sl�j|� d S n|j}|�| < �d7 ��� kr��jr��jtj� � n
�j �� d S )Nr )
r< rq rr r r@ rD Z
_exceptionZ_resultr� rE )�irn �res)� nchildren� nfinished�outer�resultsr� r r �_done_callbackn s*
z gather.<locals>._done_callback)r r rh rE rb r r] r r r3 ra ru r� � enumeraterL rj rk )r r� Zcoros_or_futuresr� rn r� r� r� r )r� r� r� r� r� r� r r
8 s8
c s@ t | |d�}|j� r|S |j}|j� � � fdd�}|j|� � S )N)r c s\ � j � r | j � s| j� d S | j � r.� j� n*| j� }|d k rJ� j|� n� j| j� � d S )N)rq rr r= rD rE rQ )�innerrP )r� r r r� � s
z shield.<locals>._done_callback)r r< r rh rL )r� r r� r� r )r� r r � s
c s: t j� �std��tjj� �� ��fdd�}�j|� �S )Nz A coroutine object is requiredc sT yt jt� �d��� W n6 tk
rN } z�j� r<�j| � � W Y d d } ~ X nX d S )N)r )r Z
_chain_futurer rG Z set_running_or_notify_cancelrD )rP )r0 rR r r r �callback� s
z*run_coroutine_threadsafe.<locals>.callback)r r^ r_ �
concurrentr r4 Zcall_soon_threadsafe)r0 r r� r )r0 rR r r r
� s
)N)&�__all__Zconcurrent.futuresr� rj rN r� rV � r r r r r r r4 r Z_PyTaskZ_asyncio� ImportErrorZ_CTaskr r r r rg r rc r r r� �globalsrS r r� r� r
r r
r r r r �<module> sX
s
- -8
W5PK [H�V1 + __pycache__/coroutines.cpython-36.opt-2.pycnu �[��� 3
\+ � @ s� d ddgZ ddlZddlZddlZddlZddlZddlZddlZddlm Z ddlm
Z
ddlm Z dd lm Z dd
l
mZ ejd Zejj o�eejjd ��ZyejZejZW n ek
r� dZdZY nX y
ej Z W n ek
r� d
d� Z Y nX yddl m Z m!Z" W n e#k
�r* d Z Z"Y nX dd� Z$e$� Z%[$dd� Z&G dd� d�Z'dd � Ze(� Z)dd� Z ej*e'fZ+e dk �r�e+e f7 Z+edk �r�efe+ Z+dd� Z,dd� Z-dS )� coroutine�iscoroutinefunction� iscoroutine� N� )�compat)� constants)�events)� base_futures)�loggerZ
YIELD_FROMZPYTHONASYNCIODEBUGc C s dS )NF� )�funcr r �*/usr/lib64/python3.6/asyncio/coroutines.py�<lambda>/ s r )� Coroutine� Awaitablec C sF G dd� d�} dd� }d}| � }||�}t |� |j|� |j|fkS ) Nc @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S )
z!has_yield_from_bug.<locals>.MyGenc S s
d | _ d S )N)� send_args)�selfr r r
�__init__; s z*has_yield_from_bug.<locals>.MyGen.__init__c S s | S )Nr )r r r r
�__iter__= s z*has_yield_from_bug.<locals>.MyGen.__iter__c S s dS )N�* r )r r r r
�__next__? s z*has_yield_from_bug.<locals>.MyGen.__next__c W s
|| _ d S )N)r )r Zwhatr r r
�sendA s z&has_yield_from_bug.<locals>.MyGen.sendN)�__name__�
__module__� __qualname__r r r r r r r r
�MyGen: s r c s s | E d H d S )Nr )�genr r r
�yield_from_genD s z*has_yield_from_bug.<locals>.yield_from_genr � � )r r r )�nextr r )r r �valuer �coror r r
�has_yield_from_bug9 s
r# c C s
t | d �S )N)� CoroWrapper)r r r r
�
debug_wrapperP s r% c @ s� e Zd Zd%dd�Zdd� Zdd� Zdd � Zer8d
d � Znd d � Zd&d
d�Z dd� Z
e dd� �Z e dd� �Z
e dd� �Zejr�dd� Ze dd� �Ze dd � �Ze d d � �Ze d d � �Ze d!d"� �Zd#d$� ZdS )'r$ Nc C s> || _ || _tjtjd��| _t|dd �| _t|dd �| _ d S )Nr r r )
r r r �
extract_stack�sys� _getframe�_source_traceback�getattrr r )r r r r r r
r [ s
zCoroWrapper.__init__c C s@ t | �}| jr0| jd }|d|d |d f 7 }d| jj|f S )Nr z, created at %s:%sr z<%s %s>���)�_format_coroutiner) � __class__r )r � coro_repr�framer r r
�__repr__c s
zCoroWrapper.__repr__c C s | S )Nr )r r r r
r j s zCoroWrapper.__iter__c C s | j jd �S )N)r r )r r r r
r m s zCoroWrapper.__next__c G s4 t j� }|j}|jj|j tkr(|d }| jj|�S )Nr ) r' r( �f_back�f_code�co_code�f_lasti� _YIELD_FROMr r )r r! r/ Zcallerr r r
r u s
zCoroWrapper.sendc C s | j j|�S )N)r r )r r! r r r
r } s c C s | j j|||�S )N)r �throw)r �typer! � tracebackr r r
r6 � s zCoroWrapper.throwc C s
| j j� S )N)r �close)r r r r
r9 � s zCoroWrapper.closec C s | j jS )N)r �gi_frame)r r r r
r: � s zCoroWrapper.gi_framec C s | j jS )N)r �
gi_running)r r r r
r; � s zCoroWrapper.gi_runningc C s | j jS )N)r �gi_code)r r r r
r< � s zCoroWrapper.gi_codec C s, t | jdd �}|d k r(tdj| j|���| S )N�cr_awaitz;Cannot await on coroutine {!r} while it's awaiting for {!r})r* r � RuntimeError�format)r r= r r r
� __await__� s zCoroWrapper.__await__c C s | j jS )N)r � gi_yieldfrom)r r r r
rA � s zCoroWrapper.gi_yieldfromc C s | j jS )N)r r= )r r r r
r= � s zCoroWrapper.cr_awaitc C s | j jS )N)r �
cr_running)r r r r
rB � s zCoroWrapper.cr_runningc C s | j jS )N)r �cr_code)r r r r
rC � s zCoroWrapper.cr_codec C s | j jS )N)r �cr_frame)r r r r
rD � s zCoroWrapper.cr_framec C s� t | dd �}t |dd �}|d kr,t |dd �}|d k r�|jd
kr�d| }t | df �}|r�djtj|��}|dtj� d �7 }||j� 7 }tj |� d S ) Nr r: rD r z%r was never yielded fromr) � zB
Coroutine object created at (most recent call last, truncated to z last lines):
r+ )
r* r4 �joinr8 � format_listr ZDEBUG_STACK_DEPTH�rstripr
�error)r r r/ �msg�tbr r r
�__del__� s zCoroWrapper.__del__)N)NN)r r r r r0 r r �_YIELD_FROM_BUGr r6 r9 �propertyr: r; r< r ZPY35r@ rA r= rB rC rD rL r r r r
r$ X s(
r$ c sp t ��r �S tj��r �� ntj���fdd��� tsNtd krD� }qft� �}ntj��� �fdd��}t|_|S )Nc ? sv � | |�}t j|�s(tj|�s(t|t�r4|E d H }n>td k rry
|j}W n tk
rZ Y nX t|t�rr|� E d H }|S )N) r Zisfuture�inspectZ isgenerator�
isinstancer$ �
_AwaitableABCr@ �AttributeError)�args�kw�resZ
await_meth)r r r
r" � s
zcoroutine.<locals>.coroc s@ t � | |��d�}|jr |jd= t�dd �|_t�dd �|_|S )N)r r r r r+ )r$ r) r* r r )rS �kwds�w)r" r r r
�wrapper� s zcoroutine.<locals>.wrapper)� _inspect_iscoroutinefunctionrO �isgeneratorfunction� functools�wraps�_DEBUG�_types_coroutine�
_is_coroutine)r rX r )r" r r
r � s
c C s t | dd �tkpt| �S )Nr_ )r* r_ rY )r r r r
r � s c C s
t | t�S )N)rP �_COROUTINE_TYPES)�objr r r
r s c
C s t | d� r�t | d� r�t| dt| dt| �j��}dj|�}d}y
| j}W n4 tk
r~ y
| j}W n tk
rx Y nX Y nX |r�dj|�S |S d }t| t �r�| j
}| j }|d k r�dj|�}n| }|d kr�t j
|f i �}d }t | d�r�| jr�| j}nt | d��r| j�r| j}d }t | d��r0| j�r0| j}nt | d ��rJ| j�rJ| j}d
}|�rb|j�rb|j}d }|}t| t ��r�tj| j
� �r�| j
d k �r�t j| j
�} | d k �r�| \}}|d k�r�d |||f }nd
|||f }n:|d k �r�|j}d|||f }n|�r|j}d |||f }|S )NrC r< r r z{}()Fz
{} runningrD r: z<empty co_filename>r z%s done, defined at %s:%sz %s running, defined at %s:%sz%s running at %s:%s)�hasattrr* r7 r r? rB rR r; rP r$ r r r Z_format_callbackrC r< rD r: � co_filenamerO rZ Z_get_function_source�f_lineno�co_firstlineno)
r" Z coro_nameZrunningr Z coro_codeZ
coro_frame�filename�linenor. �sourcer r r
r, sx
r, ).�__all__r[ rO Zopcode�osr' r8 �typesrE r r r r �logr
Zopmapr5 �flags�ignore_environment�bool�environ�getr] r r^ �
CoroutineTypeZ_types_CoroutineTyperR r rY �collections.abcr Z
_CoroutineABCr rQ � ImportErrorr# rM r% r$ �objectr_ �
GeneratorTyper` r r, r r r r
�<module> sZ
j:
PK [���e e . __pycache__/windows_utils.cpython-36.opt-2.pycnu �[��� 3
\� � @ s� d dl Z e jdkred��d dlZd dlZd dlZd dlZd dlZd dlZd dl Z d dl
Z
dddddgZ d Z ej
Z
ejZej� Zeed�r�ejZnejejd fd
d�Zd de d
�dd�ZG dd� d�ZG dd� dej�ZdS )� NZwin32z
win32 only�
socketpair�pipe�Popen�PIPE�
PipeHandlei c
C s | t jkrd}n| t jkr d}ntd��|t jkr:td��|dkrJtd��t j | ||�}z�|j|df� |jd� |j� d d� \}}t j | ||�}yP|jd � y|j ||f� W n t
t fk
r� Y nX |jd
� |j � \}} W n |j
� � Y nX W d |j
� X ||fS ) Nz 127.0.0.1z::1z?Only AF_INET and AF_INET6 socket address families are supportedz)Only SOCK_STREAM socket type is supportedr z Only protocol zero is supported� � FT)�socket�AF_INETZAF_INET6�
ValueError� SOCK_STREAMZbindZlistenZ getsocknameZ setblockingZconnect�BlockingIOError�InterruptedErrorZaccept�close)
Zfamily�type�proto�hostZlsockZaddrZportZcsockZssock�_� r �-/usr/lib64/python3.6/asyncio/windows_utils.pyr % s8
FT)�duplex�
overlapped�bufsizec C s" t jdtj� tt�f d�}| r>tj}tjtj B }|| }}ntj
}tj }d| }}|tj O }|d rp|tj O }|d r�tj }nd}d } }
yZtj
||tjd||tjtj�} tj||dtjtj|tj�}
tj| dd�} | jd� | |
fS | d k �rtj| � |
d k �rtj|
� � Y nX d S )Nz\\.\pipe\python-pipe-%d-%d-)�prefixr r T)r )�tempfileZmktemp�os�getpid�next�
_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 ZaddressZopenmode�accessZobsizeZibsizeZflags_and_attribsZh1Zh2Zovr r r r S s@
c @ sX e Zd Zdd� Zdd� Zedd� �Zdd� Zej d �d
d �Z
d d
� Z dd� Z dd� Z
dS )r c C s
|| _ d S )N)�_handle)�self�handler r r �__init__� s zPipeHandle.__init__c C s* | j d k rd| j }nd}d| jj|f S )Nz handle=%r�closedz<%s %s>)r" � __class__�__name__)r# r$ r r r �__repr__� s
zPipeHandle.__repr__c C s | j S )N)r" )r# r r r r$ � s zPipeHandle.handlec C s | j d krtd��| j S )Nz I/O operatioon on closed pipe)r" r )r# r r r �fileno� s
zPipeHandle.fileno)r c C s | j d k r|| j � d | _ d S )N)r" )r# r r r r r � s
zPipeHandle.closec C s* | j d k r&tjd| t| d� | j� d S )Nz unclosed %r)�source)r" �warnings�warn�ResourceWarningr )r# r r r �__del__� s
zPipeHandle.__del__c C s | S )Nr )r# r r r � __enter__� s zPipeHandle.__enter__c C s | j � d S )N)r )r# �t�v�tbr r r �__exit__� s zPipeHandle.__exit__N)r( �
__module__� __qualname__r% r) �propertyr$ r* r r r r/ r0 r4 r r r r r � s c s e Zd Zd� fdd� Z� ZS )r Nc s| d } }}d } }
} |t kr@tddd�\} } tj| tj�}n|}|t krhtdd�\}
}
tj|
d�}n|}|t kr�td d�\} }tj|d�}n|tkr�|}n|}z�y t� j|f|||d�|�� W n4 x$| |
| fD ]}|d k r�t j
|� q�W � Y n>X | d k �rt | �| _ |
d k �r"t |
�| _
| d k �r6t | �| _W d |t k�rNtj|� |t k�rbtj|� |t k�rvtj|� X d S )
NFT)r r )r r )�stdin�stdout�stderr)FT)TF)TF)r r �msvcrtZopen_osfhandler �O_RDONLY�STDOUT�superr% r r r r8 r9 r: r )r# �argsr8 r9 r: �kwdsZ stdin_rfdZ
stdout_wfdZ
stderr_wfdZstdin_whZ stdout_rhZ stderr_rhZstdin_rhZ stdout_whZ stderr_wh�h)r' r r r% � sH
zPopen.__init__)NNN)r( r5 r6 r% �
__classcell__r r )r' r r � s )TT)�sys�platform� ImportErrorr � itertoolsr; r r �
subprocessr r, �__all__ZBUFSIZEr r= �countr �hasattrr r
r r r r r r r r �<module> s*
.0-PK [����� � + __pycache__/subprocess.cpython-36.opt-2.pycnu �[��� 3
\� � @ s� d dgZ ddlZddlmZ ddlmZ ddlmZ ddlmZ dd lmZ dd
l m
Z
ej Z ej Z ej
Z
G d d � d ejej�ZG d
d� d�Zeddddejfdd��Zeddddejd�dd ��ZdS )�create_subprocess_exec�create_subprocess_shell� N� )�events)� protocols)�streams)�tasks)� coroutine)�loggerc sL e Zd Z� fdd�Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z � Z
S )�SubprocessStreamProtocolc s< t � j|d� || _d | _ | _| _d | _d| _g | _d S )N)�loopF) �super�__init__�_limit�stdin�stdout�stderr�
_transport�_process_exited� _pipe_fds)�self�limitr )� __class__� �*/usr/lib64/python3.6/asyncio/subprocess.pyr s z!SubprocessStreamProtocol.__init__c C sf | j jg}| jd k r$|jd| j � | jd k r>|jd| j � | jd k rX|jd| j � ddj|� S )Nzstdin=%rz stdout=%rz stderr=%rz<%s>� )r �__name__r �appendr r �join)r �infor r r �__repr__ s
z!SubprocessStreamProtocol.__repr__c C s� || _ |jd�}|d k rDtj| j| jd�| _| jj|� | jj d� |jd�}|d k r�tj| j| jd�| _
| j
j|� | jj d� |jd�}|d k r�tj || d | jd�| _ d S )Nr )r r � r )�protocol�readerr )
r �get_pipe_transportr � StreamReaderr �_loopr 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|j|� d S )Nr r! )r r Z feed_data)r �fd�datar# r r r �pipe_data_received@ s z+SubprocessStreamProtocol.pipe_data_receivedc C s� |dkr,| j }|d k r |j� | j|� d S |dkr<| j}n|dkrL| j}nd }|d krt|d krj|j� n
|j|� || jkr�| jj|� | j � d S )Nr r r! )
r �closeZconnection_lostr r Zfeed_eofZ
set_exceptionr �remove�_maybe_close_transport)r r* �exc�piper# r r r �pipe_connection_lostJ s$
z-SubprocessStreamProtocol.pipe_connection_lostc C s d| _ | j� d S )NT)r r/ )r r r r �process_exiteda s z'SubprocessStreamProtocol.process_exitedc C s( t | j�dkr$| jr$| jj� d | _d S )Nr )�lenr r r r- )r r r r r/ e s
z/SubprocessStreamProtocol._maybe_close_transport) r �
__module__� __qualname__r r r) r, r2 r3 r/ �
__classcell__r r )r r r s
r c @ s~ e Zd Zdd� Zdd� Zedd� �Zedd� �Zd d
� Z d d � Z
d
d� Z edd� �Z edd� �Z
edd� �Zeddd��ZdS )�Processc C s8 || _ || _|| _|j| _|j| _|j| _|j� | _d S )N)r Z _protocolr& r r r Zget_pid�pid)r r( r" r r r r r l s zProcess.__init__c C s d| j j| jf S )Nz<%s %s>)r r r9 )r r r r r u s zProcess.__repr__c C s
| j j� S )N)r Zget_returncode)r r r r �
returncodex s zProcess.returncodec c s | j j� E d H S )N)r Z_wait)r r r r �wait| s z Process.waitc C s | j j|� d S )N)r � send_signal)r �signalr r r r< � s zProcess.send_signalc C s | j j� d S )N)r � terminate)r r r r r> � s zProcess.terminatec C s | j j� d S )N)r �kill)r r r r r? � s z Process.killc c s� | j j� }| jj|� |r,tjd| t|�� y| jj� E d H W n8 tt fk
rx } z|rhtjd| |� W Y d d }~X nX |r�tjd| � | jj
� d S )Nz%%r communicate: feed stdin (%s bytes)z %r communicate: stdin got %rz%r communicate: close stdin) r& � get_debugr �writer
�debugr4 Zdrain�BrokenPipeError�ConnectionResetErrorr- )r �inputrB r0 r r r � _feed_stdin� s
zProcess._feed_stdinc C s d S )Nr )r r r r �_noop� s z
Process._noopc c s� | j j|�}|dkr | j}n| j}| jj� rJ|dkr8dnd}tjd| |� |j� E d H }| jj� r�|dkrndnd}tjd| |� |j � |S )Nr! r r r z%r communicate: read %sz%r communicate: close %s)
r r$ r r r& r@ r
rB �readr- )r r* r( �stream�name�outputr r r � _read_stream� s
zProcess._read_streamNc c s� |d k r| j |�}n| j� }| jd k r2| jd�}n| j� }| jd k rP| jd�}n| j� }tj|||| jd�E d H \}}}| j� E d H ||fS )Nr r! )r ) rF rG r rL r r Zgatherr& r; )r rE r r r r r r � communicate� s
zProcess.communicate)N)r r5 r6 r r �propertyr: r r; r< r> r? rF rG rL rM r r r r r8 k s r8 c
+ sP �d krt j� �� �fdd�}�j|| f|||d�|��E d H \}} t|| ��S )Nc s t � �d�S )N)r r )r r )r r r r �<lambda>� s z)create_subprocess_shell.<locals>.<lambda>)r r r )r �get_event_loopZsubprocess_shellr8 )
�cmdr r r r r �kwds�protocol_factoryr( r" r )r r r r � s )r r r r r c / sT �d krt j� �� �fdd�}�j|| f|�|||d�|��E d H \} }
t| |
��S )Nc s t � �d�S )N)r r )r r )r r r r rO � s z(create_subprocess_exec.<locals>.<lambda>)r r r )r rP Zsubprocess_execr8 ) Zprogramr r r r r �argsrR rS r( r" r )r r r r � s )�__all__�
subprocess� r r r r Z
coroutinesr �logr
�PIPEZSTDOUTZDEVNULLZFlowControlMixinZSubprocessProtocolr r8 Z_DEFAULT_LIMITr r r r r r �<module> s( X] PK [Q*_ / / % __pycache__/transports.cpython-36.pycnu �[��� 3
\R' � @ s� d Z ddlmZ ddddddgZG d d� d�ZG d
d� de�ZG d d� de�ZG d d� dee�ZG d
d� de�ZG dd� de�Z G dd� de�Z
dS )zAbstract Transport class.� )�compat�
BaseTransport�
ReadTransport�WriteTransport� Transport�DatagramTransport�SubprocessTransportc @ sD e Zd ZdZddd�Zddd�Zdd� Zd d
� Zd d � Zd
d� Z dS )r zBase class for transports.Nc C s |d kr i }|| _ d S )N)�_extra)�self�extra� r �*/usr/lib64/python3.6/asyncio/transports.py�__init__
s zBaseTransport.__init__c C s | j j||�S )z#Get optional transport information.)r �get)r
�name�defaultr r r
�get_extra_info s z BaseTransport.get_extra_infoc C s t �dS )z2Return True if the transport is closing or closed.N)�NotImplementedError)r
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) called
with None as its argument.
N)r )r
r r r
�close s zBaseTransport.closec C s t �dS )zSet a new protocol.N)r )r
�protocolr r r
� set_protocol$ s zBaseTransport.set_protocolc C s t �dS )z Return the current protocol.N)r )r
r r r
� get_protocol( s zBaseTransport.get_protocol)N)N)
�__name__�
__module__� __qualname__�__doc__r r r r r r r r r r
r
s
c @ s e Zd ZdZdd� Zdd� ZdS )r z#Interface for read-only transports.c C s t �dS )z�Pause the receiving end.
No data will be passed to the protocol's data_received()
method until resume_reading() is called.
N)r )r
r r r
�
pause_reading0 s zReadTransport.pause_readingc C s t �dS )z�Resume the receiving end.
Data received will once again be passed to the protocol's
data_received() method.
N)r )r
r r r
�resume_reading8 s z ReadTransport.resume_readingN)r r r r r r r r r r
r - s c @ sJ e Zd ZdZddd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dS )r z$Interface for write-only transports.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.
N)r )r
�high�lowr r r
�set_write_buffer_limitsD s z&WriteTransport.set_write_buffer_limitsc C s t �dS )z,Return the current size of the write buffer.N)r )r
r r r
�get_write_buffer_sizeY s z$WriteTransport.get_write_buffer_sizec C s t �dS )z�Write some data bytes to the transport.
This does not block; it buffers the data and arranges for it
to be sent out asynchronously.
N)r )r
�datar r r
�write] s zWriteTransport.writec C s t j|�}| j|� dS )z�Write a list (or any iterable) of data bytes to the transport.
The default implementation concatenates the arguments and
calls write() on the result.
N)r Zflatten_list_bytesr$ )r
Z list_of_datar# r r r
�
writelinese s
zWriteTransport.writelinesc C s t �dS )z�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.
N)r )r
r r r
� write_eofn s zWriteTransport.write_eofc C s t �dS )zAReturn True if this transport supports write_eof(), False if not.N)r )r
r r r
�
can_write_eofw s z WriteTransport.can_write_eofc C s t �dS )z�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.
N)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 A s
c @ s e Zd ZdZdS )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.
N)r r r r r r r r
r � s c @ s" e Zd ZdZddd�Zdd� ZdS )r z(Interface for datagram (UDP) transports.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.
N)r )r
r# Zaddrr r r
�sendto� s zDatagramTransport.sendtoc C s t �dS )z�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.
N)r )r
r r r
r( � s zDatagramTransport.abort)N)r r r r r) r( r r r r
r � s
c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
S )r c C s t �dS )zGet subprocess id.N)r )r
r r r
�get_pid� s zSubprocessTransport.get_pidc C s t �dS )z�Get subprocess returncode.
See also
http://docs.python.org/3/library/subprocess#subprocess.Popen.returncode
N)r )r
r r r
�get_returncode� s z"SubprocessTransport.get_returncodec C s t �dS )z&Get transport for pipe with number fd.N)r )r
�fdr r r
�get_pipe_transport� s z&SubprocessTransport.get_pipe_transportc C s t �dS )z�Send signal to subprocess.
See also:
docs.python.org/3/library/subprocess#subprocess.Popen.send_signal
N)r )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
N)r )r
r r r
� terminate� s z SubprocessTransport.terminatec C s t �dS )z�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
N)r )r
r r r
�kill� s zSubprocessTransport.killN) r r r r* r+ r- r/ r0 r1 r r r r
r � s c sV e Zd ZdZd� fdd� Zdd� Zdd� Zd d
� Zdd d �Zdd
d�Z 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.
Nc s0 t � j|� |d k st�|| _d| _| j� d S )NF)�superr �AssertionError�_loop�_protocol_paused�_set_write_buffer_limits)r
r Zloop)� __class__r r
r � s
z_FlowControlMixin.__init__c C sp | j � }|| jkrd S | jsld| _y| jj� W n: tk
rj } z | jjd|| | jd�� W Y d d }~X nX d S )NTz protocol.pause_writing() failed)�message� exception� transportr )r" � _high_waterr6 � _protocolZ
pause_writing� Exceptionr5 �call_exception_handler)r
�size�excr r r
�_maybe_pause_protocol� s
z'_FlowControlMixin._maybe_pause_protocolc C sh | j rd| j� | jkrdd| _ y| jj� W n: tk
rb } z | jjd|| | jd�� W Y d d }~X nX d S )NFz protocol.resume_writing() failed)r9 r: r; r )r6 r" �
_low_waterr= Zresume_writingr> r5 r? )r
rA r r r
�_maybe_resume_protocol s z(_FlowControlMixin._maybe_resume_protocolc C s | j | jfS )N)rC r< )r
r r r
�get_write_buffer_limits s z)_FlowControlMixin.get_write_buffer_limitsc C sf |d kr |d krd}nd| }|d kr.|d }|| ko@dkn sVt d||f ��|| _|| _d S )N�@ i � r z*high (%r) must be >= low (%r) must be >= 0i )�
ValueErrorr< rC )r
r r r r r
r7 s z*_FlowControlMixin._set_write_buffer_limitsc C s | j ||d� | j� d S )N)r r )r7 rB )r
r r r r r
r! - s z)_FlowControlMixin.set_write_buffer_limitsc C s t �d S )N)r )r
r r r
r" 1 s z'_FlowControlMixin.get_write_buffer_size)NN)NN)NN) r r r r r rB rD rE r7 r! r" �
__classcell__r r )r8 r
r2 � s
r2 N) r Zasyncior �__all__r r r r r r r2 r r r r
�<module> s
#D4PK [̡��b3 b3
futures.pynu �[��� """A Future class similar to the one in PEP 3148."""
__all__ = (
'Future', 'wrap_future', 'isfuture',
)
import concurrent.futures
import contextvars
import logging
import sys
from . import base_futures
from . import events
from . import exceptions
from . import format_helpers
isfuture = base_futures.isfuture
_PENDING = base_futures._PENDING
_CANCELLED = base_futures._CANCELLED
_FINISHED = base_futures._FINISHED
STACK_DEBUG = logging.DEBUG - 1 # heavy-duty debugging
class Future:
"""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.)
"""
# Class variables serving as defaults for instance variables.
_state = _PENDING
_result = None
_exception = None
_loop = None
_source_traceback = None
# This field is used for a dual purpose:
# - Its presence is a marker to declare that a class implements
# the Future protocol (i.e. is intended to be duck-type compatible).
# The value must also be not-None, to enable a subclass to declare
# that it is not compatible by setting this to None.
# - It is set by __iter__() below so that Task._step() can tell
# the difference between
# `await Future()` or`yield from Future()` (correct) vs.
# `yield Future()` (incorrect).
_asyncio_future_blocking = False
__log_traceback = False
def __init__(self, *, loop=None):
"""Initialize the future.
The optional event_loop argument allows explicitly setting the event
loop object used by the future. If it's not provided, the future uses
the default event loop.
"""
if loop is None:
self._loop = events.get_event_loop()
else:
self._loop = loop
self._callbacks = []
if self._loop.get_debug():
self._source_traceback = format_helpers.extract_stack(
sys._getframe(1))
_repr_info = base_futures._future_repr_info
def __repr__(self):
return '<{} {}>'.format(self.__class__.__name__,
' '.join(self._repr_info()))
def __del__(self):
if not self.__log_traceback:
# set_exception() was not called, or result() or exception()
# has consumed the exception
return
exc = self._exception
context = {
'message':
f'{self.__class__.__name__} exception was never retrieved',
'exception': exc,
'future': self,
}
if self._source_traceback:
context['source_traceback'] = self._source_traceback
self._loop.call_exception_handler(context)
@property
def _log_traceback(self):
return self.__log_traceback
@_log_traceback.setter
def _log_traceback(self, val):
if bool(val):
raise ValueError('_log_traceback can only be set to False')
self.__log_traceback = False
def get_loop(self):
"""Return the event loop the Future is bound to."""
loop = self._loop
if loop is None:
raise RuntimeError("Future object is not initialized.")
return loop
def cancel(self):
"""Cancel the future and schedule callbacks.
If the future is already done or cancelled, return False. Otherwise,
change the future's state to cancelled, schedule the callbacks and
return True.
"""
self.__log_traceback = False
if self._state != _PENDING:
return False
self._state = _CANCELLED
self.__schedule_callbacks()
return True
def __schedule_callbacks(self):
"""Internal: Ask the event loop to call all callbacks.
The callbacks are scheduled to be called as soon as possible. Also
clears the callback list.
"""
callbacks = self._callbacks[:]
if not callbacks:
return
self._callbacks[:] = []
for callback, ctx in callbacks:
self._loop.call_soon(callback, self, context=ctx)
def cancelled(self):
"""Return True if the future was cancelled."""
return self._state == _CANCELLED
# Don't implement running(); see http://bugs.python.org/issue18699
def done(self):
"""Return True if the future is done.
Done means either that a result / exception are available, or that the
future was cancelled.
"""
return self._state != _PENDING
def result(self):
"""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.
"""
if self._state == _CANCELLED:
raise exceptions.CancelledError
if self._state != _FINISHED:
raise exceptions.InvalidStateError('Result is not ready.')
self.__log_traceback = False
if self._exception is not None:
raise self._exception
return self._result
def exception(self):
"""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.
"""
if self._state == _CANCELLED:
raise exceptions.CancelledError
if self._state != _FINISHED:
raise exceptions.InvalidStateError('Exception is not set.')
self.__log_traceback = False
return self._exception
def add_done_callback(self, fn, *, context=None):
"""Add a callback to be run when the future becomes done.
The callback is called with a single argument - the future object. If
the future is already done when this is called, the callback is
scheduled with call_soon.
"""
if self._state != _PENDING:
self._loop.call_soon(fn, self, context=context)
else:
if context is None:
context = contextvars.copy_context()
self._callbacks.append((fn, context))
# New method not in PEP 3148.
def remove_done_callback(self, fn):
"""Remove all instances of a callback from the "call when done" list.
Returns the number of callbacks removed.
"""
filtered_callbacks = [(f, ctx)
for (f, ctx) in self._callbacks
if f != fn]
removed_count = len(self._callbacks) - len(filtered_callbacks)
if removed_count:
self._callbacks[:] = filtered_callbacks
return removed_count
# So-called internal methods (note: no set_running_or_notify_cancel()).
def set_result(self, result):
"""Mark the future done and set its result.
If the future is already done when this method is called, raises
InvalidStateError.
"""
if self._state != _PENDING:
raise exceptions.InvalidStateError(f'{self._state}: {self!r}')
self._result = result
self._state = _FINISHED
self.__schedule_callbacks()
def set_exception(self, exception):
"""Mark the future done and set an exception.
If the future is already done when this method is called, raises
InvalidStateError.
"""
if self._state != _PENDING:
raise exceptions.InvalidStateError(f'{self._state}: {self!r}')
if isinstance(exception, type):
exception = exception()
if type(exception) is StopIteration:
raise TypeError("StopIteration interacts badly with generators "
"and cannot be raised into a Future")
self._exception = exception
self._state = _FINISHED
self.__schedule_callbacks()
self.__log_traceback = True
def __await__(self):
if not self.done():
self._asyncio_future_blocking = True
yield self # This tells Task to wait for completion.
if not self.done():
raise RuntimeError("await wasn't used with future")
return self.result() # May raise too.
__iter__ = __await__ # make compatible with 'yield from'.
# Needed for testing purposes.
_PyFuture = Future
def _get_loop(fut):
# Tries to call Future.get_loop() if it's available.
# Otherwise fallbacks to using the old '_loop' property.
try:
get_loop = fut.get_loop
except AttributeError:
pass
else:
return get_loop()
return fut._loop
def _set_result_unless_cancelled(fut, result):
"""Helper setting the result only if the future was not cancelled."""
if fut.cancelled():
return
fut.set_result(result)
def _convert_future_exc(exc):
exc_class = type(exc)
if exc_class is concurrent.futures.CancelledError:
return exceptions.CancelledError(*exc.args)
elif exc_class is concurrent.futures.TimeoutError:
return exceptions.TimeoutError(*exc.args)
elif exc_class is concurrent.futures.InvalidStateError:
return exceptions.InvalidStateError(*exc.args)
else:
return exc
def _set_concurrent_future_state(concurrent, source):
"""Copy state from a future to a concurrent.futures.Future."""
assert source.done()
if source.cancelled():
concurrent.cancel()
if not concurrent.set_running_or_notify_cancel():
return
exception = source.exception()
if exception is not None:
concurrent.set_exception(_convert_future_exc(exception))
else:
result = source.result()
concurrent.set_result(result)
def _copy_future_state(source, dest):
"""Internal helper to copy state from another Future.
The other Future may be a concurrent.futures.Future.
"""
assert source.done()
if dest.cancelled():
return
assert not dest.done()
if source.cancelled():
dest.cancel()
else:
exception = source.exception()
if exception is not None:
dest.set_exception(_convert_future_exc(exception))
else:
result = source.result()
dest.set_result(result)
def _chain_future(source, destination):
"""Chain two futures so that when one completes, so does the other.
The result (or exception) of source will be copied to destination.
If destination is cancelled, source gets cancelled too.
Compatible with both asyncio.Future and concurrent.futures.Future.
"""
if not isfuture(source) and not isinstance(source,
concurrent.futures.Future):
raise TypeError('A future is required for source argument')
if not isfuture(destination) and not isinstance(destination,
concurrent.futures.Future):
raise TypeError('A future is required for destination argument')
source_loop = _get_loop(source) if isfuture(source) else None
dest_loop = _get_loop(destination) if isfuture(destination) else None
def _set_state(future, other):
if isfuture(future):
_copy_future_state(other, future)
else:
_set_concurrent_future_state(future, other)
def _call_check_cancel(destination):
if destination.cancelled():
if source_loop is None or source_loop is dest_loop:
source.cancel()
else:
source_loop.call_soon_threadsafe(source.cancel)
def _call_set_state(source):
if (destination.cancelled() and
dest_loop is not None and dest_loop.is_closed()):
return
if dest_loop is None or dest_loop is source_loop:
_set_state(destination, source)
else:
dest_loop.call_soon_threadsafe(_set_state, destination, source)
destination.add_done_callback(_call_check_cancel)
source.add_done_callback(_call_set_state)
def wrap_future(future, *, loop=None):
"""Wrap concurrent.futures.Future object."""
if isfuture(future):
return future
assert isinstance(future, concurrent.futures.Future), \
f'concurrent.futures.Future is expected, got {future!r}'
if loop is None:
loop = events.get_event_loop()
new_future = loop.create_future()
_chain_future(future, new_future)
return new_future
try:
import _asyncio
except ImportError:
pass
else:
# _CFuture is needed for tests.
Future = _CFuture = _asyncio.Future
PK [a��ۿ ۿ unix_events.pynu �[��� """Selector event loop for Unix with signal handling."""
import errno
import io
import itertools
import os
import selectors
import signal
import socket
import stat
import subprocess
import sys
import threading
import warnings
from . import base_events
from . import base_subprocess
from . import constants
from . import coroutines
from . import events
from . import exceptions
from . import futures
from . import selector_events
from . import tasks
from . import transports
from .log import logger
__all__ = (
'SelectorEventLoop',
'AbstractChildWatcher', 'SafeChildWatcher',
'FastChildWatcher',
'MultiLoopChildWatcher', 'ThreadedChildWatcher',
'DefaultEventLoopPolicy',
)
if sys.platform == 'win32': # pragma: no cover
raise ImportError('Signals are not really supported on Windows')
def _sighandler_noop(signum, frame):
"""Dummy signal handler."""
pass
class _UnixSelectorEventLoop(selector_events.BaseSelectorEventLoop):
"""Unix event loop.
Adds signal handling and UNIX Domain Socket support to SelectorEventLoop.
"""
def __init__(self, selector=None):
super().__init__(selector)
self._signal_handlers = {}
def close(self):
super().close()
if not sys.is_finalizing():
for sig in list(self._signal_handlers):
self.remove_signal_handler(sig)
else:
if self._signal_handlers:
warnings.warn(f"Closing the loop {self!r} "
f"on interpreter shutdown "
f"stage, skipping signal handlers removal",
ResourceWarning,
source=self)
self._signal_handlers.clear()
def _process_self_data(self, data):
for signum in data:
if not signum:
# ignore null bytes written by _write_to_self()
continue
self._handle_signal(signum)
def add_signal_handler(self, sig, callback, *args):
"""Add 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.
"""
if (coroutines.iscoroutine(callback) or
coroutines.iscoroutinefunction(callback)):
raise TypeError("coroutines cannot be used "
"with add_signal_handler()")
self._check_signal(sig)
self._check_closed()
try:
# set_wakeup_fd() raises ValueError if this is not the
# main thread. By calling it early we ensure that an
# event loop running in another thread cannot add a signal
# handler.
signal.set_wakeup_fd(self._csock.fileno())
except (ValueError, OSError) as exc:
raise RuntimeError(str(exc))
handle = events.Handle(callback, args, self, None)
self._signal_handlers[sig] = handle
try:
# Register a dummy signal handler to ask Python to write the signal
# number in the wakeup file descriptor. _process_self_data() will
# read signal numbers from this file descriptor to handle signals.
signal.signal(sig, _sighandler_noop)
# Set SA_RESTART to limit EINTR occurrences.
signal.siginterrupt(sig, False)
except OSError as exc:
del self._signal_handlers[sig]
if not self._signal_handlers:
try:
signal.set_wakeup_fd(-1)
except (ValueError, OSError) as nexc:
logger.info('set_wakeup_fd(-1) failed: %s', nexc)
if exc.errno == errno.EINVAL:
raise RuntimeError(f'sig {sig} cannot be caught')
else:
raise
def _handle_signal(self, sig):
"""Internal helper that is the actual signal handler."""
handle = self._signal_handlers.get(sig)
if handle is None:
return # Assume it's some race condition.
if handle._cancelled:
self.remove_signal_handler(sig) # Remove it properly.
else:
self._add_callback_signalsafe(handle)
def remove_signal_handler(self, sig):
"""Remove a handler for a signal. UNIX only.
Return True if a signal handler was removed, False if not.
"""
self._check_signal(sig)
try:
del self._signal_handlers[sig]
except KeyError:
return False
if sig == signal.SIGINT:
handler = signal.default_int_handler
else:
handler = signal.SIG_DFL
try:
signal.signal(sig, handler)
except OSError as exc:
if exc.errno == errno.EINVAL:
raise RuntimeError(f'sig {sig} cannot be caught')
else:
raise
if not self._signal_handlers:
try:
signal.set_wakeup_fd(-1)
except (ValueError, OSError) as exc:
logger.info('set_wakeup_fd(-1) failed: %s', exc)
return True
def _check_signal(self, sig):
"""Internal 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.
"""
if not isinstance(sig, int):
raise TypeError(f'sig must be an int, not {sig!r}')
if sig not in signal.valid_signals():
raise ValueError(f'invalid signal number {sig}')
def _make_read_pipe_transport(self, pipe, protocol, waiter=None,
extra=None):
return _UnixReadPipeTransport(self, pipe, protocol, waiter, extra)
def _make_write_pipe_transport(self, pipe, protocol, waiter=None,
extra=None):
return _UnixWritePipeTransport(self, pipe, protocol, waiter, extra)
async def _make_subprocess_transport(self, protocol, args, shell,
stdin, stdout, stderr, bufsize,
extra=None, **kwargs):
with events.get_child_watcher() as watcher:
if not watcher.is_active():
# Check early.
# Raising exception before process creation
# prevents subprocess execution if the watcher
# is not ready to handle it.
raise RuntimeError("asyncio.get_child_watcher() is not activated, "
"subprocess support is not installed.")
waiter = self.create_future()
transp = _UnixSubprocessTransport(self, protocol, args, shell,
stdin, stdout, stderr, bufsize,
waiter=waiter, extra=extra,
**kwargs)
watcher.add_child_handler(transp.get_pid(),
self._child_watcher_callback, transp)
try:
await waiter
except (SystemExit, KeyboardInterrupt):
raise
except BaseException:
transp.close()
await transp._wait()
raise
return transp
def _child_watcher_callback(self, pid, returncode, transp):
self.call_soon_threadsafe(transp._process_exited, returncode)
async def create_unix_connection(
self, protocol_factory, path=None, *,
ssl=None, sock=None,
server_hostname=None,
ssl_handshake_timeout=None):
assert server_hostname is None or isinstance(server_hostname, str)
if ssl:
if server_hostname is None:
raise ValueError(
'you have to pass server_hostname when using ssl')
else:
if server_hostname is not None:
raise ValueError('server_hostname is only meaningful with ssl')
if ssl_handshake_timeout is not None:
raise ValueError(
'ssl_handshake_timeout is only meaningful with ssl')
if path is not None:
if sock is not None:
raise ValueError(
'path and sock can not be specified at the same time')
path = os.fspath(path)
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM, 0)
try:
sock.setblocking(False)
await self.sock_connect(sock, path)
except:
sock.close()
raise
else:
if sock is None:
raise ValueError('no path and sock were specified')
if (sock.family != socket.AF_UNIX or
sock.type != socket.SOCK_STREAM):
raise ValueError(
f'A UNIX Domain Stream Socket was expected, got {sock!r}')
sock.setblocking(False)
transport, protocol = await self._create_connection_transport(
sock, protocol_factory, ssl, server_hostname,
ssl_handshake_timeout=ssl_handshake_timeout)
return transport, protocol
async def create_unix_server(
self, protocol_factory, path=None, *,
sock=None, backlog=100, ssl=None,
ssl_handshake_timeout=None,
start_serving=True):
if isinstance(ssl, bool):
raise TypeError('ssl argument must be an SSLContext or None')
if ssl_handshake_timeout is not None and not ssl:
raise ValueError(
'ssl_handshake_timeout is only meaningful with ssl')
if path is not None:
if sock is not None:
raise ValueError(
'path and sock can not be specified at the same time')
path = os.fspath(path)
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
# Check for abstract socket. `str` and `bytes` paths are supported.
if path[0] not in (0, '\x00'):
try:
if stat.S_ISSOCK(os.stat(path).st_mode):
os.remove(path)
except FileNotFoundError:
pass
except OSError as err:
# Directory may have permissions only to create socket.
logger.error('Unable to check or remove stale UNIX socket '
'%r: %r', path, err)
try:
sock.bind(path)
except OSError as exc:
sock.close()
if exc.errno == errno.EADDRINUSE:
# Let's improve the error message by adding
# with what exact address it occurs.
msg = f'Address {path!r} is already in use'
raise OSError(errno.EADDRINUSE, msg) from None
else:
raise
except:
sock.close()
raise
else:
if sock is None:
raise ValueError(
'path was not specified, and no sock specified')
if (sock.family != socket.AF_UNIX or
sock.type != socket.SOCK_STREAM):
raise ValueError(
f'A UNIX Domain Stream Socket was expected, got {sock!r}')
sock.setblocking(False)
server = base_events.Server(self, [sock], protocol_factory,
ssl, backlog, ssl_handshake_timeout)
if start_serving:
server._start_serving()
# Skip one loop iteration so that all 'loop.add_reader'
# go through.
await tasks.sleep(0, loop=self)
return server
async def _sock_sendfile_native(self, sock, file, offset, count):
try:
os.sendfile
except AttributeError as exc:
raise exceptions.SendfileNotAvailableError(
"os.sendfile() is not available")
try:
fileno = file.fileno()
except (AttributeError, io.UnsupportedOperation) as err:
raise exceptions.SendfileNotAvailableError("not a regular file")
try:
fsize = os.fstat(fileno).st_size
except OSError as err:
raise exceptions.SendfileNotAvailableError("not a regular file")
blocksize = count if count else fsize
if not blocksize:
return 0 # empty file
fut = self.create_future()
self._sock_sendfile_native_impl(fut, None, sock, fileno,
offset, count, blocksize, 0)
return await fut
def _sock_sendfile_native_impl(self, fut, registered_fd, sock, fileno,
offset, count, blocksize, total_sent):
fd = sock.fileno()
if registered_fd is not None:
# Remove the callback early. It should be rare that the
# selector says the fd is ready but the call still returns
# EAGAIN, and I am willing to take a hit in that case in
# order to simplify the common case.
self.remove_writer(registered_fd)
if fut.cancelled():
self._sock_sendfile_update_filepos(fileno, offset, total_sent)
return
if count:
blocksize = count - total_sent
if blocksize <= 0:
self._sock_sendfile_update_filepos(fileno, offset, total_sent)
fut.set_result(total_sent)
return
try:
sent = os.sendfile(fd, fileno, offset, blocksize)
except (BlockingIOError, InterruptedError):
if registered_fd is None:
self._sock_add_cancellation_callback(fut, sock)
self.add_writer(fd, self._sock_sendfile_native_impl, fut,
fd, sock, fileno,
offset, count, blocksize, total_sent)
except OSError as exc:
if (registered_fd is not None and
exc.errno == errno.ENOTCONN and
type(exc) is not ConnectionError):
# If we have an ENOTCONN and this isn't a first call to
# sendfile(), i.e. the connection was closed in the middle
# of the operation, normalize the error to ConnectionError
# to make it consistent across all Posix systems.
new_exc = ConnectionError(
"socket is not connected", errno.ENOTCONN)
new_exc.__cause__ = exc
exc = new_exc
if total_sent == 0:
# We can get here for different reasons, the main
# one being 'file' is not a regular mmap(2)-like
# file, in which case we'll fall back on using
# plain send().
err = exceptions.SendfileNotAvailableError(
"os.sendfile call failed")
self._sock_sendfile_update_filepos(fileno, offset, total_sent)
fut.set_exception(err)
else:
self._sock_sendfile_update_filepos(fileno, offset, total_sent)
fut.set_exception(exc)
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
self._sock_sendfile_update_filepos(fileno, offset, total_sent)
fut.set_exception(exc)
else:
if sent == 0:
# EOF
self._sock_sendfile_update_filepos(fileno, offset, total_sent)
fut.set_result(total_sent)
else:
offset += sent
total_sent += sent
if registered_fd is None:
self._sock_add_cancellation_callback(fut, sock)
self.add_writer(fd, self._sock_sendfile_native_impl, fut,
fd, sock, fileno,
offset, count, blocksize, total_sent)
def _sock_sendfile_update_filepos(self, fileno, offset, total_sent):
if total_sent > 0:
os.lseek(fileno, offset, os.SEEK_SET)
def _sock_add_cancellation_callback(self, fut, sock):
def cb(fut):
if fut.cancelled():
fd = sock.fileno()
if fd != -1:
self.remove_writer(fd)
fut.add_done_callback(cb)
class _UnixReadPipeTransport(transports.ReadTransport):
max_size = 256 * 1024 # max bytes we read in one event loop iteration
def __init__(self, loop, pipe, protocol, waiter=None, extra=None):
super().__init__(extra)
self._extra['pipe'] = pipe
self._loop = loop
self._pipe = pipe
self._fileno = pipe.fileno()
self._protocol = protocol
self._closing = False
self._paused = False
mode = os.fstat(self._fileno).st_mode
if not (stat.S_ISFIFO(mode) or
stat.S_ISSOCK(mode) or
stat.S_ISCHR(mode)):
self._pipe = None
self._fileno = None
self._protocol = None
raise ValueError("Pipe transport is for pipes/sockets only.")
os.set_blocking(self._fileno, False)
self._loop.call_soon(self._protocol.connection_made, self)
# only start reading when connection_made() has been called
self._loop.call_soon(self._loop._add_reader,
self._fileno, self._read_ready)
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._pipe is None:
info.append('closed')
elif self._closing:
info.append('closing')
info.append(f'fd={self._fileno}')
selector = getattr(self._loop, '_selector', None)
if self._pipe is not None and selector is not None:
polling = selector_events._test_selector_event(
selector, self._fileno, selectors.EVENT_READ)
if polling:
info.append('polling')
else:
info.append('idle')
elif self._pipe is not None:
info.append('open')
else:
info.append('closed')
return '<{}>'.format(' '.join(info))
def _read_ready(self):
try:
data = os.read(self._fileno, self.max_size)
except (BlockingIOError, InterruptedError):
pass
except OSError as exc:
self._fatal_error(exc, 'Fatal read error on pipe transport')
else:
if data:
self._protocol.data_received(data)
else:
if self._loop.get_debug():
logger.info("%r was closed by peer", self)
self._closing = True
self._loop._remove_reader(self._fileno)
self._loop.call_soon(self._protocol.eof_received)
self._loop.call_soon(self._call_connection_lost, None)
def pause_reading(self):
if self._closing or self._paused:
return
self._paused = True
self._loop._remove_reader(self._fileno)
if self._loop.get_debug():
logger.debug("%r pauses reading", self)
def resume_reading(self):
if self._closing or not self._paused:
return
self._paused = False
self._loop._add_reader(self._fileno, self._read_ready)
if self._loop.get_debug():
logger.debug("%r resumes reading", self)
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 not self._closing:
self._close(None)
def __del__(self, _warn=warnings.warn):
if self._pipe is not None:
_warn(f"unclosed transport {self!r}", ResourceWarning, source=self)
self._pipe.close()
def _fatal_error(self, exc, message='Fatal error on pipe transport'):
# should be called by exception handler only
if (isinstance(exc, OSError) and exc.errno == errno.EIO):
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._close(exc)
def _close(self, exc):
self._closing = True
self._loop._remove_reader(self._fileno)
self._loop.call_soon(self._call_connection_lost, exc)
def _call_connection_lost(self, exc):
try:
self._protocol.connection_lost(exc)
finally:
self._pipe.close()
self._pipe = None
self._protocol = None
self._loop = None
class _UnixWritePipeTransport(transports._FlowControlMixin,
transports.WriteTransport):
def __init__(self, loop, pipe, protocol, waiter=None, extra=None):
super().__init__(extra, loop)
self._extra['pipe'] = pipe
self._pipe = pipe
self._fileno = pipe.fileno()
self._protocol = protocol
self._buffer = bytearray()
self._conn_lost = 0
self._closing = False # Set when close() or write_eof() called.
mode = os.fstat(self._fileno).st_mode
is_char = stat.S_ISCHR(mode)
is_fifo = stat.S_ISFIFO(mode)
is_socket = stat.S_ISSOCK(mode)
if not (is_char or is_fifo or is_socket):
self._pipe = None
self._fileno = None
self._protocol = None
raise ValueError("Pipe transport is only for "
"pipes, sockets and character devices")
os.set_blocking(self._fileno, False)
self._loop.call_soon(self._protocol.connection_made, self)
# On AIX, the reader trick (to be notified when the read end of the
# socket is closed) only works for sockets. On other platforms it
# works for pipes and sockets. (Exception: OS X 10.4? Issue #19294.)
if is_socket or (is_fifo and not sys.platform.startswith("aix")):
# only start reading when connection_made() has been called
self._loop.call_soon(self._loop._add_reader,
self._fileno, self._read_ready)
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._pipe is None:
info.append('closed')
elif self._closing:
info.append('closing')
info.append(f'fd={self._fileno}')
selector = getattr(self._loop, '_selector', None)
if self._pipe is not None and selector is not None:
polling = selector_events._test_selector_event(
selector, self._fileno, selectors.EVENT_WRITE)
if polling:
info.append('polling')
else:
info.append('idle')
bufsize = self.get_write_buffer_size()
info.append(f'bufsize={bufsize}')
elif self._pipe is not None:
info.append('open')
else:
info.append('closed')
return '<{}>'.format(' '.join(info))
def get_write_buffer_size(self):
return len(self._buffer)
def _read_ready(self):
# Pipe was closed by peer.
if self._loop.get_debug():
logger.info("%r was closed by peer", self)
if self._buffer:
self._close(BrokenPipeError())
else:
self._close()
def write(self, data):
assert isinstance(data, (bytes, bytearray, memoryview)), repr(data)
if isinstance(data, bytearray):
data = memoryview(data)
if not data:
return
if self._conn_lost or self._closing:
if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
logger.warning('pipe closed by peer or '
'os.write(pipe, data) raised exception.')
self._conn_lost += 1
return
if not self._buffer:
# Attempt to send it right away first.
try:
n = os.write(self._fileno, data)
except (BlockingIOError, InterruptedError):
n = 0
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
self._conn_lost += 1
self._fatal_error(exc, 'Fatal write error on pipe transport')
return
if n == len(data):
return
elif n > 0:
data = memoryview(data)[n:]
self._loop._add_writer(self._fileno, self._write_ready)
self._buffer += data
self._maybe_pause_protocol()
def _write_ready(self):
assert self._buffer, 'Data should not be empty'
try:
n = os.write(self._fileno, self._buffer)
except (BlockingIOError, InterruptedError):
pass
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
self._buffer.clear()
self._conn_lost += 1
# Remove writer here, _fatal_error() doesn't it
# because _buffer is empty.
self._loop._remove_writer(self._fileno)
self._fatal_error(exc, 'Fatal write error on pipe transport')
else:
if n == len(self._buffer):
self._buffer.clear()
self._loop._remove_writer(self._fileno)
self._maybe_resume_protocol() # May append to buffer.
if self._closing:
self._loop._remove_reader(self._fileno)
self._call_connection_lost(None)
return
elif n > 0:
del self._buffer[:n]
def can_write_eof(self):
return True
def write_eof(self):
if self._closing:
return
assert self._pipe
self._closing = True
if not self._buffer:
self._loop._remove_reader(self._fileno)
self._loop.call_soon(self._call_connection_lost, None)
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._pipe is not None and not self._closing:
# write_eof is all what we needed to close the write pipe
self.write_eof()
def __del__(self, _warn=warnings.warn):
if self._pipe is not None:
_warn(f"unclosed transport {self!r}", ResourceWarning, source=self)
self._pipe.close()
def abort(self):
self._close(None)
def _fatal_error(self, exc, message='Fatal error on pipe transport'):
# should be called by exception handler only
if isinstance(exc, OSError):
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._close(exc)
def _close(self, exc=None):
self._closing = True
if self._buffer:
self._loop._remove_writer(self._fileno)
self._buffer.clear()
self._loop._remove_reader(self._fileno)
self._loop.call_soon(self._call_connection_lost, exc)
def _call_connection_lost(self, exc):
try:
self._protocol.connection_lost(exc)
finally:
self._pipe.close()
self._pipe = None
self._protocol = None
self._loop = None
class _UnixSubprocessTransport(base_subprocess.BaseSubprocessTransport):
def _start(self, args, shell, stdin, stdout, stderr, bufsize, **kwargs):
stdin_w = None
if stdin == subprocess.PIPE:
# Use a socket pair for stdin, since not all platforms
# support selecting read events on the write end of a
# socket (which we use in order to detect closing of the
# other end). Notably this is needed on AIX, and works
# just fine on other platforms.
stdin, stdin_w = socket.socketpair()
try:
self._proc = subprocess.Popen(
args, shell=shell, stdin=stdin, stdout=stdout, stderr=stderr,
universal_newlines=False, bufsize=bufsize, **kwargs)
if stdin_w is not None:
stdin.close()
self._proc.stdin = open(stdin_w.detach(), 'wb', buffering=bufsize)
stdin_w = None
finally:
if stdin_w is not None:
stdin.close()
stdin_w.close()
class AbstractChildWatcher:
"""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.
"""
def add_child_handler(self, pid, callback, *args):
"""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.
"""
raise NotImplementedError()
def remove_child_handler(self, pid):
"""Removes the handler for process 'pid'.
The function returns True if the handler was successfully removed,
False if there was nothing to remove."""
raise NotImplementedError()
def attach_loop(self, loop):
"""Attach 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.
"""
raise NotImplementedError()
def close(self):
"""Close the watcher.
This must be called to make sure that any underlying resource is freed.
"""
raise NotImplementedError()
def is_active(self):
"""Return ``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.
"""
raise NotImplementedError()
def __enter__(self):
"""Enter the watcher's context and allow starting new processes
This function must return self"""
raise NotImplementedError()
def __exit__(self, a, b, c):
"""Exit the watcher's context"""
raise NotImplementedError()
def _compute_returncode(status):
if os.WIFSIGNALED(status):
# The child process died because of a signal.
return -os.WTERMSIG(status)
elif os.WIFEXITED(status):
# The child process exited (e.g sys.exit()).
return os.WEXITSTATUS(status)
else:
# The child exited, but we don't understand its status.
# This shouldn't happen, but if it does, let's just
# return that status; perhaps that helps debug it.
return status
class BaseChildWatcher(AbstractChildWatcher):
def __init__(self):
self._loop = None
self._callbacks = {}
def close(self):
self.attach_loop(None)
def is_active(self):
return self._loop is not None and self._loop.is_running()
def _do_waitpid(self, expected_pid):
raise NotImplementedError()
def _do_waitpid_all(self):
raise NotImplementedError()
def attach_loop(self, loop):
assert loop is None or isinstance(loop, events.AbstractEventLoop)
if self._loop is not None and loop is None and self._callbacks:
warnings.warn(
'A loop is being detached '
'from a child watcher with pending handlers',
RuntimeWarning)
if self._loop is not None:
self._loop.remove_signal_handler(signal.SIGCHLD)
self._loop = loop
if loop is not None:
loop.add_signal_handler(signal.SIGCHLD, self._sig_chld)
# Prevent a race condition in case a child terminated
# during the switch.
self._do_waitpid_all()
def _sig_chld(self):
try:
self._do_waitpid_all()
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
# self._loop should always be available here
# as '_sig_chld' is added as a signal handler
# in 'attach_loop'
self._loop.call_exception_handler({
'message': 'Unknown exception in SIGCHLD handler',
'exception': exc,
})
class SafeChildWatcher(BaseChildWatcher):
"""'Safe' child watcher implementation.
This implementation avoids disrupting other code spawning processes by
polling explicitly each process in the SIGCHLD handler instead of calling
os.waitpid(-1).
This is a safe solution but it has a significant overhead when handling a
big number of children (O(n) each time SIGCHLD is raised)
"""
def close(self):
self._callbacks.clear()
super().close()
def __enter__(self):
return self
def __exit__(self, a, b, c):
pass
def add_child_handler(self, pid, callback, *args):
self._callbacks[pid] = (callback, args)
# Prevent a race condition in case the child is already terminated.
self._do_waitpid(pid)
def remove_child_handler(self, pid):
try:
del self._callbacks[pid]
return True
except KeyError:
return False
def _do_waitpid_all(self):
for pid in list(self._callbacks):
self._do_waitpid(pid)
def _do_waitpid(self, expected_pid):
assert expected_pid > 0
try:
pid, status = os.waitpid(expected_pid, os.WNOHANG)
except ChildProcessError:
# The child process is already reaped
# (may happen if waitpid() is called elsewhere).
pid = expected_pid
returncode = 255
logger.warning(
"Unknown child process pid %d, will report returncode 255",
pid)
else:
if pid == 0:
# The child process is still alive.
return
returncode = _compute_returncode(status)
if self._loop.get_debug():
logger.debug('process %s exited with returncode %s',
expected_pid, returncode)
try:
callback, args = self._callbacks.pop(pid)
except KeyError: # pragma: no cover
# May happen if .remove_child_handler() is called
# after os.waitpid() returns.
if self._loop.get_debug():
logger.warning("Child watcher got an unexpected pid: %r",
pid, exc_info=True)
else:
callback(pid, returncode, *args)
class FastChildWatcher(BaseChildWatcher):
"""'Fast' child watcher implementation.
This implementation reaps every terminated processes by calling
os.waitpid(-1) directly, possibly breaking other code spawning processes
and waiting for their termination.
There is no noticeable overhead when handling a big number of children
(O(1) each time a child terminates).
"""
def __init__(self):
super().__init__()
self._lock = threading.Lock()
self._zombies = {}
self._forks = 0
def close(self):
self._callbacks.clear()
self._zombies.clear()
super().close()
def __enter__(self):
with self._lock:
self._forks += 1
return self
def __exit__(self, a, b, c):
with self._lock:
self._forks -= 1
if self._forks or not self._zombies:
return
collateral_victims = str(self._zombies)
self._zombies.clear()
logger.warning(
"Caught subprocesses termination from unknown pids: %s",
collateral_victims)
def add_child_handler(self, pid, callback, *args):
assert self._forks, "Must use the context manager"
with self._lock:
try:
returncode = self._zombies.pop(pid)
except KeyError:
# The child is running.
self._callbacks[pid] = callback, args
return
# The child is dead already. We can fire the callback.
callback(pid, returncode, *args)
def remove_child_handler(self, pid):
try:
del self._callbacks[pid]
return True
except KeyError:
return False
def _do_waitpid_all(self):
# Because of signal coalescing, we must keep calling waitpid() as
# long as we're able to reap a child.
while True:
try:
pid, status = os.waitpid(-1, os.WNOHANG)
except ChildProcessError:
# No more child processes exist.
return
else:
if pid == 0:
# A child process is still alive.
return
returncode = _compute_returncode(status)
with self._lock:
try:
callback, args = self._callbacks.pop(pid)
except KeyError:
# unknown child
if self._forks:
# It may not be registered yet.
self._zombies[pid] = returncode
if self._loop.get_debug():
logger.debug('unknown process %s exited '
'with returncode %s',
pid, returncode)
continue
callback = None
else:
if self._loop.get_debug():
logger.debug('process %s exited with returncode %s',
pid, returncode)
if callback is None:
logger.warning(
"Caught subprocess termination from unknown pid: "
"%d -> %d", pid, returncode)
else:
callback(pid, returncode, *args)
class MultiLoopChildWatcher(AbstractChildWatcher):
"""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).
"""
# Implementation note:
# The class keeps compatibility with AbstractChildWatcher ABC
# To achieve this it has empty attach_loop() method
# and doesn't accept explicit loop argument
# for add_child_handler()/remove_child_handler()
# but retrieves the current loop by get_running_loop()
def __init__(self):
self._callbacks = {}
self._saved_sighandler = None
def is_active(self):
return self._saved_sighandler is not None
def close(self):
self._callbacks.clear()
if self._saved_sighandler is None:
return
handler = signal.getsignal(signal.SIGCHLD)
if handler != self._sig_chld:
logger.warning("SIGCHLD handler was changed by outside code")
else:
signal.signal(signal.SIGCHLD, self._saved_sighandler)
self._saved_sighandler = None
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
pass
def add_child_handler(self, pid, callback, *args):
loop = events.get_running_loop()
self._callbacks[pid] = (loop, callback, args)
# Prevent a race condition in case the child is already terminated.
self._do_waitpid(pid)
def remove_child_handler(self, pid):
try:
del self._callbacks[pid]
return True
except KeyError:
return False
def attach_loop(self, loop):
# Don't save the loop but initialize itself if called first time
# The reason to do it here is that attach_loop() is called from
# unix policy only for the main thread.
# Main thread is required for subscription on SIGCHLD signal
if self._saved_sighandler is not None:
return
self._saved_sighandler = signal.signal(signal.SIGCHLD, self._sig_chld)
if self._saved_sighandler is None:
logger.warning("Previous SIGCHLD handler was set by non-Python code, "
"restore to default handler on watcher close.")
self._saved_sighandler = signal.SIG_DFL
# Set SA_RESTART to limit EINTR occurrences.
signal.siginterrupt(signal.SIGCHLD, False)
def _do_waitpid_all(self):
for pid in list(self._callbacks):
self._do_waitpid(pid)
def _do_waitpid(self, expected_pid):
assert expected_pid > 0
try:
pid, status = os.waitpid(expected_pid, os.WNOHANG)
except ChildProcessError:
# The child process is already reaped
# (may happen if waitpid() is called elsewhere).
pid = expected_pid
returncode = 255
logger.warning(
"Unknown child process pid %d, will report returncode 255",
pid)
debug_log = False
else:
if pid == 0:
# The child process is still alive.
return
returncode = _compute_returncode(status)
debug_log = True
try:
loop, callback, args = self._callbacks.pop(pid)
except KeyError: # pragma: no cover
# May happen if .remove_child_handler() is called
# after os.waitpid() returns.
logger.warning("Child watcher got an unexpected pid: %r",
pid, exc_info=True)
else:
if loop.is_closed():
logger.warning("Loop %r that handles pid %r is closed", loop, pid)
else:
if debug_log and loop.get_debug():
logger.debug('process %s exited with returncode %s',
expected_pid, returncode)
loop.call_soon_threadsafe(callback, pid, returncode, *args)
def _sig_chld(self, signum, frame):
try:
self._do_waitpid_all()
except (SystemExit, KeyboardInterrupt):
raise
except BaseException:
logger.warning('Unknown exception in SIGCHLD handler', exc_info=True)
class ThreadedChildWatcher(AbstractChildWatcher):
"""Threaded child watcher implementation.
The watcher uses a thread per process
for waiting for the process finish.
It doesn't require subscription on POSIX signal
but a thread creation is not free.
The watcher has O(1) complexity, its performance doesn't depend
on amount of spawn processes.
"""
def __init__(self):
self._pid_counter = itertools.count(0)
self._threads = {}
def is_active(self):
return True
def close(self):
self._join_threads()
def _join_threads(self):
"""Internal: Join all non-daemon threads"""
threads = [thread for thread in list(self._threads.values())
if thread.is_alive() and not thread.daemon]
for thread in threads:
thread.join()
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
pass
def __del__(self, _warn=warnings.warn):
threads = [thread for thread in list(self._threads.values())
if thread.is_alive()]
if threads:
_warn(f"{self.__class__} has registered but not finished child processes",
ResourceWarning,
source=self)
def add_child_handler(self, pid, callback, *args):
loop = events.get_running_loop()
thread = threading.Thread(target=self._do_waitpid,
name=f"waitpid-{next(self._pid_counter)}",
args=(loop, pid, callback, args),
daemon=True)
self._threads[pid] = thread
thread.start()
def remove_child_handler(self, pid):
# asyncio never calls remove_child_handler() !!!
# The method is no-op but is implemented because
# abstract base classe requires it
return True
def attach_loop(self, loop):
pass
def _do_waitpid(self, loop, expected_pid, callback, args):
assert expected_pid > 0
try:
pid, status = os.waitpid(expected_pid, 0)
except ChildProcessError:
# The child process is already reaped
# (may happen if waitpid() is called elsewhere).
pid = expected_pid
returncode = 255
logger.warning(
"Unknown child process pid %d, will report returncode 255",
pid)
else:
returncode = _compute_returncode(status)
if loop.get_debug():
logger.debug('process %s exited with returncode %s',
expected_pid, returncode)
if loop.is_closed():
logger.warning("Loop %r that handles pid %r is closed", loop, pid)
else:
loop.call_soon_threadsafe(callback, pid, returncode, *args)
self._threads.pop(expected_pid)
class _UnixDefaultEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
"""UNIX event loop policy with a watcher for child processes."""
_loop_factory = _UnixSelectorEventLoop
def __init__(self):
super().__init__()
self._watcher = None
def _init_watcher(self):
with events._lock:
if self._watcher is None: # pragma: no branch
self._watcher = ThreadedChildWatcher()
if isinstance(threading.current_thread(),
threading._MainThread):
self._watcher.attach_loop(self._local._loop)
def set_event_loop(self, loop):
"""Set 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.
"""
super().set_event_loop(loop)
if (self._watcher is not None and
isinstance(threading.current_thread(), threading._MainThread)):
self._watcher.attach_loop(loop)
def get_child_watcher(self):
"""Get the watcher for child processes.
If not yet set, a ThreadedChildWatcher object is automatically created.
"""
if self._watcher is None:
self._init_watcher()
return self._watcher
def set_child_watcher(self, watcher):
"""Set the watcher for child processes."""
assert watcher is None or isinstance(watcher, AbstractChildWatcher)
if self._watcher is not None:
self._watcher.close()
self._watcher = watcher
SelectorEventLoop = _UnixSelectorEventLoop
DefaultEventLoopPolicy = _UnixDefaultEventLoopPolicy
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 [E{C�| | log.pynu �[��� """Logging configuration."""
import logging
# Name the logger after the package.
logger = logging.getLogger(__package__)
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 ['J��i� i� windows_events.pynu �[��� """Selector and proactor event loops for Windows."""
import _overlapped
import _winapi
import errno
import math
import msvcrt
import socket
import struct
import time
import weakref
from . import events
from . import base_subprocess
from . import futures
from . import exceptions
from . import proactor_events
from . import selector_events
from . import tasks
from . import windows_utils
from .log import logger
__all__ = (
'SelectorEventLoop', 'ProactorEventLoop', 'IocpProactor',
'DefaultEventLoopPolicy', 'WindowsSelectorEventLoopPolicy',
'WindowsProactorEventLoopPolicy',
)
NULL = 0
INFINITE = 0xffffffff
ERROR_CONNECTION_REFUSED = 1225
ERROR_CONNECTION_ABORTED = 1236
# Initial delay in seconds for connect_pipe() before retrying to connect
CONNECT_PIPE_INIT_DELAY = 0.001
# Maximum delay in seconds for connect_pipe() before retrying to connect
CONNECT_PIPE_MAX_DELAY = 0.100
class _OverlappedFuture(futures.Future):
"""Subclass of Future which represents an overlapped operation.
Cancelling it will immediately cancel the overlapped operation.
"""
def __init__(self, ov, *, loop=None):
super().__init__(loop=loop)
if self._source_traceback:
del self._source_traceback[-1]
self._ov = ov
def _repr_info(self):
info = super()._repr_info()
if self._ov is not None:
state = 'pending' if self._ov.pending else 'completed'
info.insert(1, f'overlapped=<{state}, {self._ov.address:#x}>')
return info
def _cancel_overlapped(self):
if self._ov is None:
return
try:
self._ov.cancel()
except OSError as exc:
context = {
'message': 'Cancelling an overlapped future failed',
'exception': exc,
'future': self,
}
if self._source_traceback:
context['source_traceback'] = self._source_traceback
self._loop.call_exception_handler(context)
self._ov = None
def cancel(self):
self._cancel_overlapped()
return super().cancel()
def set_exception(self, exception):
super().set_exception(exception)
self._cancel_overlapped()
def set_result(self, result):
super().set_result(result)
self._ov = None
class _BaseWaitHandleFuture(futures.Future):
"""Subclass of Future which represents a wait handle."""
def __init__(self, ov, handle, wait_handle, *, loop=None):
super().__init__(loop=loop)
if self._source_traceback:
del self._source_traceback[-1]
# Keep a reference to the Overlapped object to keep it alive until the
# wait is unregistered
self._ov = ov
self._handle = handle
self._wait_handle = wait_handle
# Should we call UnregisterWaitEx() if the wait completes
# or is cancelled?
self._registered = True
def _poll(self):
# non-blocking wait: use a timeout of 0 millisecond
return (_winapi.WaitForSingleObject(self._handle, 0) ==
_winapi.WAIT_OBJECT_0)
def _repr_info(self):
info = super()._repr_info()
info.append(f'handle={self._handle:#x}')
if self._handle is not None:
state = 'signaled' if self._poll() else 'waiting'
info.append(state)
if self._wait_handle is not None:
info.append(f'wait_handle={self._wait_handle:#x}')
return info
def _unregister_wait_cb(self, fut):
# The wait was unregistered: it's not safe to destroy the Overlapped
# object
self._ov = None
def _unregister_wait(self):
if not self._registered:
return
self._registered = False
wait_handle = self._wait_handle
self._wait_handle = None
try:
_overlapped.UnregisterWait(wait_handle)
except OSError as exc:
if exc.winerror != _overlapped.ERROR_IO_PENDING:
context = {
'message': 'Failed to unregister the wait handle',
'exception': exc,
'future': self,
}
if self._source_traceback:
context['source_traceback'] = self._source_traceback
self._loop.call_exception_handler(context)
return
# ERROR_IO_PENDING means that the unregister is pending
self._unregister_wait_cb(None)
def cancel(self):
self._unregister_wait()
return super().cancel()
def set_exception(self, exception):
self._unregister_wait()
super().set_exception(exception)
def set_result(self, result):
self._unregister_wait()
super().set_result(result)
class _WaitCancelFuture(_BaseWaitHandleFuture):
"""Subclass of Future which represents a wait for the cancellation of a
_WaitHandleFuture using an event.
"""
def __init__(self, ov, event, wait_handle, *, loop=None):
super().__init__(ov, event, wait_handle, loop=loop)
self._done_callback = None
def cancel(self):
raise RuntimeError("_WaitCancelFuture must not be cancelled")
def set_result(self, result):
super().set_result(result)
if self._done_callback is not None:
self._done_callback(self)
def set_exception(self, exception):
super().set_exception(exception)
if self._done_callback is not None:
self._done_callback(self)
class _WaitHandleFuture(_BaseWaitHandleFuture):
def __init__(self, ov, handle, wait_handle, proactor, *, loop=None):
super().__init__(ov, handle, wait_handle, loop=loop)
self._proactor = proactor
self._unregister_proactor = True
self._event = _overlapped.CreateEvent(None, True, False, None)
self._event_fut = None
def _unregister_wait_cb(self, fut):
if self._event is not None:
_winapi.CloseHandle(self._event)
self._event = None
self._event_fut = None
# If the wait was cancelled, the wait may never be signalled, so
# it's required to unregister it. Otherwise, IocpProactor.close() will
# wait forever for an event which will never come.
#
# If the IocpProactor already received the event, it's safe to call
# _unregister() because we kept a reference to the Overlapped object
# which is used as a unique key.
self._proactor._unregister(self._ov)
self._proactor = None
super()._unregister_wait_cb(fut)
def _unregister_wait(self):
if not self._registered:
return
self._registered = False
wait_handle = self._wait_handle
self._wait_handle = None
try:
_overlapped.UnregisterWaitEx(wait_handle, self._event)
except OSError as exc:
if exc.winerror != _overlapped.ERROR_IO_PENDING:
context = {
'message': 'Failed to unregister the wait handle',
'exception': exc,
'future': self,
}
if self._source_traceback:
context['source_traceback'] = self._source_traceback
self._loop.call_exception_handler(context)
return
# ERROR_IO_PENDING is not an error, the wait was unregistered
self._event_fut = self._proactor._wait_cancel(self._event,
self._unregister_wait_cb)
class PipeServer(object):
"""Class representing a pipe server.
This is much like a bound, listening socket.
"""
def __init__(self, address):
self._address = address
self._free_instances = weakref.WeakSet()
# initialize the pipe attribute before calling _server_pipe_handle()
# because this function can raise an exception and the destructor calls
# the close() method
self._pipe = None
self._accept_pipe_future = None
self._pipe = self._server_pipe_handle(True)
def _get_unconnected_pipe(self):
# Create new instance and return previous one. This ensures
# that (until the server is closed) there is always at least
# one pipe handle for address. Therefore if a client attempt
# to connect it will not fail with FileNotFoundError.
tmp, self._pipe = self._pipe, self._server_pipe_handle(False)
return tmp
def _server_pipe_handle(self, first):
# Return a wrapper for a new pipe handle.
if self.closed():
return None
flags = _winapi.PIPE_ACCESS_DUPLEX | _winapi.FILE_FLAG_OVERLAPPED
if first:
flags |= _winapi.FILE_FLAG_FIRST_PIPE_INSTANCE
h = _winapi.CreateNamedPipe(
self._address, flags,
_winapi.PIPE_TYPE_MESSAGE | _winapi.PIPE_READMODE_MESSAGE |
_winapi.PIPE_WAIT,
_winapi.PIPE_UNLIMITED_INSTANCES,
windows_utils.BUFSIZE, windows_utils.BUFSIZE,
_winapi.NMPWAIT_WAIT_FOREVER, _winapi.NULL)
pipe = windows_utils.PipeHandle(h)
self._free_instances.add(pipe)
return pipe
def closed(self):
return (self._address is None)
def close(self):
if self._accept_pipe_future is not None:
self._accept_pipe_future.cancel()
self._accept_pipe_future = None
# Close all instances which have not been connected to by a client.
if self._address is not None:
for pipe in self._free_instances:
pipe.close()
self._pipe = None
self._address = None
self._free_instances.clear()
__del__ = close
class _WindowsSelectorEventLoop(selector_events.BaseSelectorEventLoop):
"""Windows version of selector event loop."""
class ProactorEventLoop(proactor_events.BaseProactorEventLoop):
"""Windows version of proactor event loop using IOCP."""
def __init__(self, proactor=None):
if proactor is None:
proactor = IocpProactor()
super().__init__(proactor)
def run_forever(self):
try:
assert self._self_reading_future is None
self.call_soon(self._loop_self_reading)
super().run_forever()
finally:
if self._self_reading_future is not None:
ov = self._self_reading_future._ov
self._self_reading_future.cancel()
# self_reading_future was just cancelled so if it hasn't been
# finished yet, it never will be (it's possible that it has
# already finished and its callback is waiting in the queue,
# where it could still happen if the event loop is restarted).
# Unregister it otherwise IocpProactor.close will wait for it
# forever
if ov is not None:
self._proactor._unregister(ov)
self._self_reading_future = None
async def create_pipe_connection(self, protocol_factory, address):
f = self._proactor.connect_pipe(address)
pipe = await f
protocol = protocol_factory()
trans = self._make_duplex_pipe_transport(pipe, protocol,
extra={'addr': address})
return trans, protocol
async def start_serving_pipe(self, protocol_factory, address):
server = PipeServer(address)
def loop_accept_pipe(f=None):
pipe = None
try:
if f:
pipe = f.result()
server._free_instances.discard(pipe)
if server.closed():
# A client connected before the server was closed:
# drop the client (close the pipe) and exit
pipe.close()
return
protocol = protocol_factory()
self._make_duplex_pipe_transport(
pipe, protocol, extra={'addr': address})
pipe = server._get_unconnected_pipe()
if pipe is None:
return
f = self._proactor.accept_pipe(pipe)
except OSError as exc:
if pipe and pipe.fileno() != -1:
self.call_exception_handler({
'message': 'Pipe accept failed',
'exception': exc,
'pipe': pipe,
})
pipe.close()
elif self._debug:
logger.warning("Accept pipe failed on pipe %r",
pipe, exc_info=True)
except exceptions.CancelledError:
if pipe:
pipe.close()
else:
server._accept_pipe_future = f
f.add_done_callback(loop_accept_pipe)
self.call_soon(loop_accept_pipe)
return [server]
async def _make_subprocess_transport(self, protocol, args, shell,
stdin, stdout, stderr, bufsize,
extra=None, **kwargs):
waiter = self.create_future()
transp = _WindowsSubprocessTransport(self, protocol, args, shell,
stdin, stdout, stderr, bufsize,
waiter=waiter, extra=extra,
**kwargs)
try:
await waiter
except (SystemExit, KeyboardInterrupt):
raise
except BaseException:
transp.close()
await transp._wait()
raise
return transp
class IocpProactor:
"""Proactor implementation using IOCP."""
def __init__(self, concurrency=0xffffffff):
self._loop = None
self._results = []
self._iocp = _overlapped.CreateIoCompletionPort(
_overlapped.INVALID_HANDLE_VALUE, NULL, 0, concurrency)
self._cache = {}
self._registered = weakref.WeakSet()
self._unregistered = []
self._stopped_serving = weakref.WeakSet()
def _check_closed(self):
if self._iocp is None:
raise RuntimeError('IocpProactor is closed')
def __repr__(self):
info = ['overlapped#=%s' % len(self._cache),
'result#=%s' % len(self._results)]
if self._iocp is None:
info.append('closed')
return '<%s %s>' % (self.__class__.__name__, " ".join(info))
def set_loop(self, loop):
self._loop = loop
def select(self, timeout=None):
if not self._results:
self._poll(timeout)
tmp = self._results
self._results = []
return tmp
def _result(self, value):
fut = self._loop.create_future()
fut.set_result(value)
return fut
def recv(self, conn, nbytes, flags=0):
self._register_with_iocp(conn)
ov = _overlapped.Overlapped(NULL)
try:
if isinstance(conn, socket.socket):
ov.WSARecv(conn.fileno(), nbytes, flags)
else:
ov.ReadFile(conn.fileno(), nbytes)
except BrokenPipeError:
return self._result(b'')
def finish_recv(trans, key, ov):
try:
return ov.getresult()
except OSError as exc:
if exc.winerror in (_overlapped.ERROR_NETNAME_DELETED,
_overlapped.ERROR_OPERATION_ABORTED):
raise ConnectionResetError(*exc.args)
else:
raise
return self._register(ov, conn, finish_recv)
def recv_into(self, conn, buf, flags=0):
self._register_with_iocp(conn)
ov = _overlapped.Overlapped(NULL)
try:
if isinstance(conn, socket.socket):
ov.WSARecvInto(conn.fileno(), buf, flags)
else:
ov.ReadFileInto(conn.fileno(), buf)
except BrokenPipeError:
return self._result(0)
def finish_recv(trans, key, ov):
try:
return ov.getresult()
except OSError as exc:
if exc.winerror in (_overlapped.ERROR_NETNAME_DELETED,
_overlapped.ERROR_OPERATION_ABORTED):
raise ConnectionResetError(*exc.args)
else:
raise
return self._register(ov, conn, finish_recv)
def recvfrom(self, conn, nbytes, flags=0):
self._register_with_iocp(conn)
ov = _overlapped.Overlapped(NULL)
try:
ov.WSARecvFrom(conn.fileno(), nbytes, flags)
except BrokenPipeError:
return self._result((b'', None))
def finish_recv(trans, key, ov):
try:
return ov.getresult()
except OSError as exc:
if exc.winerror in (_overlapped.ERROR_NETNAME_DELETED,
_overlapped.ERROR_OPERATION_ABORTED):
raise ConnectionResetError(*exc.args)
else:
raise
return self._register(ov, conn, finish_recv)
def sendto(self, conn, buf, flags=0, addr=None):
self._register_with_iocp(conn)
ov = _overlapped.Overlapped(NULL)
ov.WSASendTo(conn.fileno(), buf, flags, addr)
def finish_send(trans, key, ov):
try:
return ov.getresult()
except OSError as exc:
if exc.winerror in (_overlapped.ERROR_NETNAME_DELETED,
_overlapped.ERROR_OPERATION_ABORTED):
raise ConnectionResetError(*exc.args)
else:
raise
return self._register(ov, conn, finish_send)
def send(self, conn, buf, flags=0):
self._register_with_iocp(conn)
ov = _overlapped.Overlapped(NULL)
if isinstance(conn, socket.socket):
ov.WSASend(conn.fileno(), buf, flags)
else:
ov.WriteFile(conn.fileno(), buf)
def finish_send(trans, key, ov):
try:
return ov.getresult()
except OSError as exc:
if exc.winerror in (_overlapped.ERROR_NETNAME_DELETED,
_overlapped.ERROR_OPERATION_ABORTED):
raise ConnectionResetError(*exc.args)
else:
raise
return self._register(ov, conn, finish_send)
def accept(self, listener):
self._register_with_iocp(listener)
conn = self._get_accept_socket(listener.family)
ov = _overlapped.Overlapped(NULL)
ov.AcceptEx(listener.fileno(), conn.fileno())
def finish_accept(trans, key, ov):
ov.getresult()
# Use SO_UPDATE_ACCEPT_CONTEXT so getsockname() etc work.
buf = struct.pack('@P', listener.fileno())
conn.setsockopt(socket.SOL_SOCKET,
_overlapped.SO_UPDATE_ACCEPT_CONTEXT, buf)
conn.settimeout(listener.gettimeout())
return conn, conn.getpeername()
async def accept_coro(future, conn):
# Coroutine closing the accept socket if the future is cancelled
try:
await future
except exceptions.CancelledError:
conn.close()
raise
future = self._register(ov, listener, finish_accept)
coro = accept_coro(future, conn)
tasks.ensure_future(coro, loop=self._loop)
return future
def connect(self, conn, address):
if conn.type == socket.SOCK_DGRAM:
# WSAConnect will complete immediately for UDP sockets so we don't
# need to register any IOCP operation
_overlapped.WSAConnect(conn.fileno(), address)
fut = self._loop.create_future()
fut.set_result(None)
return fut
self._register_with_iocp(conn)
# The socket needs to be locally bound before we call ConnectEx().
try:
_overlapped.BindLocal(conn.fileno(), conn.family)
except OSError as e:
if e.winerror != errno.WSAEINVAL:
raise
# Probably already locally bound; check using getsockname().
if conn.getsockname()[1] == 0:
raise
ov = _overlapped.Overlapped(NULL)
ov.ConnectEx(conn.fileno(), address)
def finish_connect(trans, key, ov):
ov.getresult()
# Use SO_UPDATE_CONNECT_CONTEXT so getsockname() etc work.
conn.setsockopt(socket.SOL_SOCKET,
_overlapped.SO_UPDATE_CONNECT_CONTEXT, 0)
return conn
return self._register(ov, conn, finish_connect)
def sendfile(self, sock, file, offset, count):
self._register_with_iocp(sock)
ov = _overlapped.Overlapped(NULL)
offset_low = offset & 0xffff_ffff
offset_high = (offset >> 32) & 0xffff_ffff
ov.TransmitFile(sock.fileno(),
msvcrt.get_osfhandle(file.fileno()),
offset_low, offset_high,
count, 0, 0)
def finish_sendfile(trans, key, ov):
try:
return ov.getresult()
except OSError as exc:
if exc.winerror in (_overlapped.ERROR_NETNAME_DELETED,
_overlapped.ERROR_OPERATION_ABORTED):
raise ConnectionResetError(*exc.args)
else:
raise
return self._register(ov, sock, finish_sendfile)
def accept_pipe(self, pipe):
self._register_with_iocp(pipe)
ov = _overlapped.Overlapped(NULL)
connected = ov.ConnectNamedPipe(pipe.fileno())
if connected:
# ConnectNamePipe() failed with ERROR_PIPE_CONNECTED which means
# that the pipe is connected. There is no need to wait for the
# completion of the connection.
return self._result(pipe)
def finish_accept_pipe(trans, key, ov):
ov.getresult()
return pipe
return self._register(ov, pipe, finish_accept_pipe)
async def connect_pipe(self, address):
delay = CONNECT_PIPE_INIT_DELAY
while True:
# Unfortunately there is no way to do an overlapped connect to
# a pipe. Call CreateFile() in a loop until it doesn't fail with
# ERROR_PIPE_BUSY.
try:
handle = _overlapped.ConnectPipe(address)
break
except OSError as exc:
if exc.winerror != _overlapped.ERROR_PIPE_BUSY:
raise
# ConnectPipe() failed with ERROR_PIPE_BUSY: retry later
delay = min(delay * 2, CONNECT_PIPE_MAX_DELAY)
await tasks.sleep(delay)
return windows_utils.PipeHandle(handle)
def wait_for_handle(self, handle, timeout=None):
"""Wait 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).
"""
return self._wait_for_handle(handle, timeout, False)
def _wait_cancel(self, event, done_callback):
fut = self._wait_for_handle(event, None, True)
# add_done_callback() cannot be used because the wait may only complete
# in IocpProactor.close(), while the event loop is not running.
fut._done_callback = done_callback
return fut
def _wait_for_handle(self, handle, timeout, _is_cancel):
self._check_closed()
if timeout is None:
ms = _winapi.INFINITE
else:
# RegisterWaitForSingleObject() has a resolution of 1 millisecond,
# round away from zero to wait *at least* timeout seconds.
ms = math.ceil(timeout * 1e3)
# We only create ov so we can use ov.address as a key for the cache.
ov = _overlapped.Overlapped(NULL)
wait_handle = _overlapped.RegisterWaitWithQueue(
handle, self._iocp, ov.address, ms)
if _is_cancel:
f = _WaitCancelFuture(ov, handle, wait_handle, loop=self._loop)
else:
f = _WaitHandleFuture(ov, handle, wait_handle, self,
loop=self._loop)
if f._source_traceback:
del f._source_traceback[-1]
def finish_wait_for_handle(trans, key, ov):
# Note that this second wait means that we should only use
# this with handles types where a successful wait has no
# effect. So events or processes are all right, but locks
# or semaphores are not. Also note if the handle is
# signalled and then quickly reset, then we may return
# False even though we have not timed out.
return f._poll()
self._cache[ov.address] = (f, ov, 0, finish_wait_for_handle)
return f
def _register_with_iocp(self, obj):
# To get notifications of finished ops on this objects sent to the
# completion port, were must register the handle.
if obj not in self._registered:
self._registered.add(obj)
_overlapped.CreateIoCompletionPort(obj.fileno(), self._iocp, 0, 0)
# XXX We could also use SetFileCompletionNotificationModes()
# to avoid sending notifications to completion port of ops
# that succeed immediately.
def _register(self, ov, obj, callback):
self._check_closed()
# Return a future which will be set with the result of the
# operation when it completes. The future's value is actually
# the value returned by callback().
f = _OverlappedFuture(ov, loop=self._loop)
if f._source_traceback:
del f._source_traceback[-1]
if not ov.pending:
# The operation has completed, so no need to postpone the
# work. We cannot take this short cut if we need the
# NumberOfBytes, CompletionKey values returned by
# PostQueuedCompletionStatus().
try:
value = callback(None, None, ov)
except OSError as e:
f.set_exception(e)
else:
f.set_result(value)
# Even if GetOverlappedResult() was called, we have to wait for the
# notification of the completion in GetQueuedCompletionStatus().
# Register the overlapped operation to keep a reference to the
# OVERLAPPED object, otherwise the memory is freed and Windows may
# read uninitialized memory.
# Register the overlapped operation for later. Note that
# we only store obj to prevent it from being garbage
# collected too early.
self._cache[ov.address] = (f, ov, obj, callback)
return f
def _unregister(self, ov):
"""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).
"""
self._check_closed()
self._unregistered.append(ov)
def _get_accept_socket(self, family):
s = socket.socket(family)
s.settimeout(0)
return s
def _poll(self, timeout=None):
if timeout is None:
ms = INFINITE
elif timeout < 0:
raise ValueError("negative timeout")
else:
# GetQueuedCompletionStatus() has a resolution of 1 millisecond,
# round away from zero to wait *at least* timeout seconds.
ms = math.ceil(timeout * 1e3)
if ms >= INFINITE:
raise ValueError("timeout too big")
while True:
status = _overlapped.GetQueuedCompletionStatus(self._iocp, ms)
if status is None:
break
ms = 0
err, transferred, key, address = status
try:
f, ov, obj, callback = self._cache.pop(address)
except KeyError:
if self._loop.get_debug():
self._loop.call_exception_handler({
'message': ('GetQueuedCompletionStatus() returned an '
'unexpected event'),
'status': ('err=%s transferred=%s key=%#x address=%#x'
% (err, transferred, key, address)),
})
# key is either zero, or it is used to return a pipe
# handle which should be closed to avoid a leak.
if key not in (0, _overlapped.INVALID_HANDLE_VALUE):
_winapi.CloseHandle(key)
continue
if obj in self._stopped_serving:
f.cancel()
# Don't call the callback if _register() already read the result or
# if the overlapped has been cancelled
elif not f.done():
try:
value = callback(transferred, key, ov)
except OSError as e:
f.set_exception(e)
self._results.append(f)
else:
f.set_result(value)
self._results.append(f)
# Remove unregistered futures
for ov in self._unregistered:
self._cache.pop(ov.address, None)
self._unregistered.clear()
def _stop_serving(self, obj):
# obj is a socket or pipe handle. It will be closed in
# BaseProactorEventLoop._stop_serving() which will make any
# pending operations fail quickly.
self._stopped_serving.add(obj)
def close(self):
if self._iocp is None:
# already closed
return
# Cancel remaining registered operations.
for address, (fut, ov, obj, callback) in list(self._cache.items()):
if fut.cancelled():
# Nothing to do with cancelled futures
pass
elif isinstance(fut, _WaitCancelFuture):
# _WaitCancelFuture must not be cancelled
pass
else:
try:
fut.cancel()
except OSError as exc:
if self._loop is not None:
context = {
'message': 'Cancelling a future failed',
'exception': exc,
'future': fut,
}
if fut._source_traceback:
context['source_traceback'] = fut._source_traceback
self._loop.call_exception_handler(context)
# Wait until all cancelled overlapped complete: don't exit with running
# overlapped to prevent a crash. Display progress every second if the
# loop is still running.
msg_update = 1.0
start_time = time.monotonic()
next_msg = start_time + msg_update
while self._cache:
if next_msg <= time.monotonic():
logger.debug('%r is running after closing for %.1f seconds',
self, time.monotonic() - start_time)
next_msg = time.monotonic() + msg_update
# handle a few events, or timeout
self._poll(msg_update)
self._results = []
_winapi.CloseHandle(self._iocp)
self._iocp = None
def __del__(self):
self.close()
class _WindowsSubprocessTransport(base_subprocess.BaseSubprocessTransport):
def _start(self, args, shell, stdin, stdout, stderr, bufsize, **kwargs):
self._proc = windows_utils.Popen(
args, shell=shell, stdin=stdin, stdout=stdout, stderr=stderr,
bufsize=bufsize, **kwargs)
def callback(f):
returncode = self._proc.poll()
self._process_exited(returncode)
f = self._loop._proactor.wait_for_handle(int(self._proc._handle))
f.add_done_callback(callback)
SelectorEventLoop = _WindowsSelectorEventLoop
class WindowsSelectorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
_loop_factory = SelectorEventLoop
class WindowsProactorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
_loop_factory = ProactorEventLoop
DefaultEventLoopPolicy = WindowsProactorEventLoopPolicy
PK [����� � __init__.pynu �[��� """The asyncio package, tracking PEP 3156."""
# flake8: noqa
import sys
# This relies on each of the submodules having an __all__ variable.
from .base_events import *
from .coroutines import *
from .events import *
from .exceptions import *
from .futures import *
from .locks import *
from .protocols import *
from .runners import *
from .queues import *
from .streams import *
from .subprocess import *
from .tasks import *
from .transports import *
# Exposed for _asynciomodule.c to implement now deprecated
# Task.all_tasks() method. This function will be removed in 3.9.
from .tasks import _all_tasks_compat # NoQA
__all__ = (base_events.__all__ +
coroutines.__all__ +
events.__all__ +
exceptions.__all__ +
futures.__all__ +
locks.__all__ +
protocols.__all__ +
runners.__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 [0�� queues.pynu �[��� __all__ = ('Queue', 'PriorityQueue', 'LifoQueue', 'QueueFull', 'QueueEmpty')
import collections
import heapq
import warnings
from . import events
from . import locks
class QueueEmpty(Exception):
"""Raised when Queue.get_nowait() is called on an empty Queue."""
pass
class QueueFull(Exception):
"""Raised when the Queue.put_nowait() method is called on a full Queue."""
pass
class Queue:
"""A queue, useful for coordinating producer and consumer coroutines.
If maxsize is less than or equal to zero, the queue size is infinite. If it
is an integer greater than 0, then "await put()" will block when the
queue reaches maxsize, until an item is removed by get().
Unlike the standard library Queue, you can reliably know this Queue's size
with qsize(), since your single-threaded asyncio application won't be
interrupted between calling qsize() and doing an operation on the Queue.
"""
def __init__(self, maxsize=0, *, loop=None):
if loop is None:
self._loop = events.get_event_loop()
else:
self._loop = loop
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
self._maxsize = maxsize
# Futures.
self._getters = collections.deque()
# Futures.
self._putters = collections.deque()
self._unfinished_tasks = 0
self._finished = locks.Event(loop=loop)
self._finished.set()
self._init(maxsize)
# These three are overridable in subclasses.
def _init(self, maxsize):
self._queue = collections.deque()
def _get(self):
return self._queue.popleft()
def _put(self, item):
self._queue.append(item)
# End of the overridable methods.
def _wakeup_next(self, waiters):
# Wake up the next waiter (if any) that isn't cancelled.
while waiters:
waiter = waiters.popleft()
if not waiter.done():
waiter.set_result(None)
break
def __repr__(self):
return f'<{type(self).__name__} at {id(self):#x} {self._format()}>'
def __str__(self):
return f'<{type(self).__name__} {self._format()}>'
def _format(self):
result = f'maxsize={self._maxsize!r}'
if getattr(self, '_queue', None):
result += f' _queue={list(self._queue)!r}'
if self._getters:
result += f' _getters[{len(self._getters)}]'
if self._putters:
result += f' _putters[{len(self._putters)}]'
if self._unfinished_tasks:
result += f' tasks={self._unfinished_tasks}'
return result
def qsize(self):
"""Number of items in the queue."""
return len(self._queue)
@property
def maxsize(self):
"""Number of items allowed in the queue."""
return self._maxsize
def empty(self):
"""Return True if the queue is empty, False otherwise."""
return not self._queue
def full(self):
"""Return True if there are maxsize items in the queue.
Note: if the Queue was initialized with maxsize=0 (the default),
then full() is never True.
"""
if self._maxsize <= 0:
return False
else:
return self.qsize() >= self._maxsize
async def put(self, item):
"""Put an item into the queue.
Put an item into the queue. If the queue is full, wait until a free
slot is available before adding item.
"""
while self.full():
putter = self._loop.create_future()
self._putters.append(putter)
try:
await putter
except:
putter.cancel() # Just in case putter is not done yet.
try:
# Clean self._putters from canceled putters.
self._putters.remove(putter)
except ValueError:
# The putter could be removed from self._putters by a
# previous get_nowait call.
pass
if not self.full() and not putter.cancelled():
# We were woken up by get_nowait(), but can't take
# the call. Wake up the next in line.
self._wakeup_next(self._putters)
raise
return self.put_nowait(item)
def put_nowait(self, item):
"""Put an item into the queue without blocking.
If no free slot is immediately available, raise QueueFull.
"""
if self.full():
raise QueueFull
self._put(item)
self._unfinished_tasks += 1
self._finished.clear()
self._wakeup_next(self._getters)
async def get(self):
"""Remove and return an item from the queue.
If queue is empty, wait until an item is available.
"""
while self.empty():
getter = self._loop.create_future()
self._getters.append(getter)
try:
await getter
except:
getter.cancel() # Just in case getter is not done yet.
try:
# Clean self._getters from canceled getters.
self._getters.remove(getter)
except ValueError:
# The getter could be removed from self._getters by a
# previous put_nowait call.
pass
if not self.empty() and not getter.cancelled():
# We were woken up by put_nowait(), but can't take
# the call. Wake up the next in line.
self._wakeup_next(self._getters)
raise
return self.get_nowait()
def get_nowait(self):
"""Remove and return an item from the queue.
Return an item if one is immediately available, else raise QueueEmpty.
"""
if self.empty():
raise QueueEmpty
item = self._get()
self._wakeup_next(self._putters)
return item
def task_done(self):
"""Indicate that a formerly enqueued task is complete.
Used by queue consumers. For each get() used to fetch a task,
a subsequent call to task_done() tells the queue that the processing
on the task is complete.
If a join() is currently blocking, it will resume when all items have
been processed (meaning that a task_done() call was received for every
item that had been put() into the queue).
Raises ValueError if called more times than there were items placed in
the queue.
"""
if self._unfinished_tasks <= 0:
raise ValueError('task_done() called too many times')
self._unfinished_tasks -= 1
if self._unfinished_tasks == 0:
self._finished.set()
async def join(self):
"""Block until all items in the queue have been gotten and processed.
The count of unfinished tasks goes up whenever an item is added to the
queue. The count goes down whenever a consumer calls task_done() to
indicate that the item was retrieved and all work on it is complete.
When the count of unfinished tasks drops to zero, join() unblocks.
"""
if self._unfinished_tasks > 0:
await self._finished.wait()
class PriorityQueue(Queue):
"""A subclass of Queue; retrieves entries in priority order (lowest first).
Entries are typically tuples of the form: (priority number, data).
"""
def _init(self, maxsize):
self._queue = []
def _put(self, item, heappush=heapq.heappush):
heappush(self._queue, item)
def _get(self, heappop=heapq.heappop):
return heappop(self._queue)
class LifoQueue(Queue):
"""A subclass of Queue that retrieves most recently added entries first."""
def _init(self, maxsize):
self._queue = []
def _put(self, item):
self._queue.append(item)
def _get(self):
return self._queue.pop()
PK [VW�<} <} 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 io
import os
import socket
import warnings
import signal
import threading
import collections
from . import base_events
from . import constants
from . import futures
from . import exceptions
from . import protocols
from . import sslproto
from . import transports
from . import trsock
from .log import logger
def _set_socket_extra(transport, sock):
transport._extra['socket'] = trsock.TransportSocket(sock)
try:
transport._extra['sockname'] = sock.getsockname()
except socket.error:
if transport._loop.get_debug():
logger.warning(
"getsockname() failed on %r", sock, exc_info=True)
if 'peername' not in transport._extra:
try:
transport._extra['peername'] = sock.getpeername()
except socket.error:
# UDP sockets may not have a peer name
transport._extra['peername'] = None
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.set_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(f'fd={self._sock.fileno()}')
if self._read_fut is not None:
info.append(f'read={self._read_fut!r}')
if self._write_fut is not None:
info.append(f'write={self._write_fut!r}')
if self._buffer:
info.append(f'write_bufsize={len(self._buffer)}')
if self._eof_written:
info.append('EOF written')
return '<{}>'.format(' '.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
def __del__(self, _warn=warnings.warn):
if self._sock is not None:
_warn(f"unclosed transport {self!r}", ResourceWarning, source=self)
self.close()
def _fatal_error(self, exc, message='Fatal error on pipe transport'):
try:
if isinstance(exc, OSError):
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,
})
finally:
self._force_close(exc)
def _force_close(self, exc):
if self._empty_waiter is not None and not self._empty_waiter.done():
if exc is None:
self._empty_waiter.set_result(None)
else:
self._empty_waiter.set_exception(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):
self._pending_data = None
self._paused = True
super().__init__(loop, sock, protocol, waiter, extra, server)
self._loop.call_soon(self._loop_reading)
self._paused = False
def is_reading(self):
return not self._paused and not self._closing
def pause_reading(self):
if self._closing or self._paused:
return
self._paused = True
# bpo-33694: Don't cancel self._read_fut because cancelling an
# overlapped WSASend() loss silently data with the current proactor
# implementation.
#
# If CancelIoEx() fails with ERROR_NOT_FOUND, it means that WSASend()
# completed (even if HasOverlappedIoCompleted() returns 0), but
# Overlapped.cancel() currently silently ignores the ERROR_NOT_FOUND
# error. Once the overlapped is ignored, the IOCP loop will ignores the
# completion I/O event and so not read the result of the overlapped
# WSARecv().
if self._loop.get_debug():
logger.debug("%r pauses reading", self)
def resume_reading(self):
if self._closing or not self._paused:
return
self._paused = False
if self._read_fut is None:
self._loop.call_soon(self._loop_reading, None)
data = self._pending_data
self._pending_data = None
if data is not None:
# Call the protocol methode after calling _loop_reading(),
# since the protocol can decide to pause reading again.
self._loop.call_soon(self._data_received, data)
if self._loop.get_debug():
logger.debug("%r resumes reading", self)
def _eof_received(self):
if self._loop.get_debug():
logger.debug("%r received EOF", self)
try:
keep_open = self._protocol.eof_received()
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
self._fatal_error(
exc, 'Fatal error: protocol.eof_received() call failed.')
return
if not keep_open:
self.close()
def _data_received(self, data):
if self._paused:
# Don't call any protocol method while reading is paused.
# The protocol will be called on resume_reading().
assert self._pending_data is None
self._pending_data = data
return
if not data:
self._eof_received()
return
if isinstance(self._protocol, protocols.BufferedProtocol):
try:
protocols._feed_data_to_buffered_proto(self._protocol, data)
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
self._fatal_error(exc,
'Fatal error: protocol.buffer_updated() '
'call failed.')
return
else:
self._protocol.data_received(data)
def _loop_reading(self, fut=None):
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
if fut.done():
# deliver data later in "finally" clause
data = fut.result()
else:
# the future will be replaced by next proactor.recv call
fut.cancel()
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
# bpo-33694: buffer_updated() has currently no fast path because of
# a data loss issue caused by overlapped WSASend() cancellation.
if not self._paused:
# reschedule a new read
self._read_fut = self._loop._proactor.recv(self._sock, 32768)
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 exceptions.CancelledError:
if not self._closing:
raise
else:
if not self._paused:
self._read_fut.add_done_callback(self._loop_reading)
finally:
if data is not None:
self._data_received(data)
class _ProactorBaseWritePipeTransport(_ProactorBasePipeTransport,
transports.WriteTransport):
"""Transport for write pipes."""
_start_tls_compatible = True
def __init__(self, *args, **kw):
super().__init__(*args, **kw)
self._empty_waiter = None
def write(self, data):
if not isinstance(data, (bytes, bytearray, memoryview)):
raise TypeError(
f"data argument must be a bytes-like object, "
f"not {type(data).__name__}")
if self._eof_written:
raise RuntimeError('write_eof() already called')
if self._empty_waiter is not None:
raise RuntimeError('unable to write; sendfile is in progress')
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:
if f is not None and self._write_fut is None and self._closing:
# XXX most likely self._force_close() has been called, and
# it has set self._write_fut to None.
return
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)
if self._empty_waiter is not None and self._write_fut is None:
self._empty_waiter.set_result(None)
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)
def _make_empty_waiter(self):
if self._empty_waiter is not None:
raise RuntimeError("Empty waiter is already set")
self._empty_waiter = self._loop.create_future()
if self._write_fut is None:
self._empty_waiter.set_result(None)
return self._empty_waiter
def _reset_empty_waiter(self):
self._empty_waiter = 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 _ProactorDatagramTransport(_ProactorBasePipeTransport):
max_size = 256 * 1024
def __init__(self, loop, sock, protocol, address=None,
waiter=None, extra=None):
self._address = address
self._empty_waiter = None
# We don't need to call _protocol.connection_made() since our base
# constructor does it for us.
super().__init__(loop, sock, protocol, waiter=waiter, extra=extra)
# The base constructor sets _buffer = None, so we set it here
self._buffer = collections.deque()
self._loop.call_soon(self._loop_reading)
def _set_extra(self, sock):
_set_socket_extra(self, sock)
def get_write_buffer_size(self):
return sum(len(data) for data, _ in self._buffer)
def abort(self):
self._force_close(None)
def sendto(self, data, addr=None):
if not isinstance(data, (bytes, bytearray, memoryview)):
raise TypeError('data argument must be bytes-like object (%r)',
type(data))
if not data:
return
if self._address is not None and addr not in (None, self._address):
raise ValueError(
f'Invalid address: must be None or {self._address}')
if self._conn_lost and self._address:
if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
logger.warning('socket.sendto() raised exception.')
self._conn_lost += 1
return
# Ensure that what we buffer is immutable.
self._buffer.append((bytes(data), addr))
if self._write_fut is None:
# No current write operations are active, kick one off
self._loop_writing()
# else: A write operation is already kicked off
self._maybe_pause_protocol()
def _loop_writing(self, fut=None):
try:
if self._conn_lost:
return
assert fut is self._write_fut
self._write_fut = None
if fut:
# We are in a _loop_writing() done callback, get the result
fut.result()
if not self._buffer or (self._conn_lost and self._address):
# The connection has been closed
if self._closing:
self._loop.call_soon(self._call_connection_lost, None)
return
data, addr = self._buffer.popleft()
if self._address is not None:
self._write_fut = self._loop._proactor.send(self._sock,
data)
else:
self._write_fut = self._loop._proactor.sendto(self._sock,
data,
addr=addr)
except OSError as exc:
self._protocol.error_received(exc)
except Exception as exc:
self._fatal_error(exc, 'Fatal write error on datagram transport')
else:
self._write_fut.add_done_callback(self._loop_writing)
self._maybe_resume_protocol()
def _loop_reading(self, fut=None):
data = None
try:
if self._conn_lost:
return
assert self._read_fut is fut or (self._read_fut is None and
self._closing)
self._read_fut = None
if fut is not None:
res = fut.result()
if self._closing:
# since close() has been called we ignore any read data
data = None
return
if self._address is not None:
data, addr = res, self._address
else:
data, addr = res
if self._conn_lost:
return
if self._address is not None:
self._read_fut = self._loop._proactor.recv(self._sock,
self.max_size)
else:
self._read_fut = self._loop._proactor.recvfrom(self._sock,
self.max_size)
except OSError as exc:
self._protocol.error_received(exc)
except exceptions.CancelledError:
if not self._closing:
raise
else:
if self._read_fut is not None:
self._read_fut.add_done_callback(self._loop_reading)
finally:
if data:
self._protocol.datagram_received(data, addr)
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."""
_sendfile_compatible = constants._SendfileMode.TRY_NATIVE
def __init__(self, loop, sock, protocol, waiter=None,
extra=None, server=None):
super().__init__(loop, sock, protocol, waiter, extra, server)
base_events._set_nodelay(sock)
def _set_extra(self, sock):
_set_socket_extra(self, sock)
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()
if threading.current_thread() is threading.main_thread():
# wakeup fd can only be installed to a file descriptor from the main thread
signal.set_wakeup_fd(self._csock.fileno())
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,
ssl_handshake_timeout=None):
ssl_protocol = sslproto.SSLProtocol(
self, protocol, sslcontext, waiter,
server_side, server_hostname,
ssl_handshake_timeout=ssl_handshake_timeout)
_ProactorSocketTransport(self, rawsock, ssl_protocol,
extra=extra, server=server)
return ssl_protocol._app_transport
def _make_datagram_transport(self, sock, protocol,
address=None, waiter=None, extra=None):
return _ProactorDatagramTransport(self, sock, protocol, address,
waiter, extra)
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
if threading.current_thread() is threading.main_thread():
signal.set_wakeup_fd(-1)
# 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()
async def sock_recv(self, sock, n):
return await self._proactor.recv(sock, n)
async def sock_recv_into(self, sock, buf):
return await self._proactor.recv_into(sock, buf)
async def sock_sendall(self, sock, data):
return await self._proactor.send(sock, data)
async def sock_connect(self, sock, address):
return await self._proactor.connect(sock, address)
async def sock_accept(self, sock):
return await self._proactor.accept(sock)
async def _sock_sendfile_native(self, sock, file, offset, count):
try:
fileno = file.fileno()
except (AttributeError, io.UnsupportedOperation) as err:
raise exceptions.SendfileNotAvailableError("not a regular file")
try:
fsize = os.fstat(fileno).st_size
except OSError as err:
raise exceptions.SendfileNotAvailableError("not a regular file")
blocksize = count if count else fsize
if not blocksize:
return 0 # empty file
blocksize = min(blocksize, 0xffff_ffff)
end_pos = min(offset + count, fsize) if count else fsize
offset = min(offset, fsize)
total_sent = 0
try:
while True:
blocksize = min(end_pos - offset, blocksize)
if blocksize <= 0:
return total_sent
await self._proactor.sendfile(sock, file, offset, blocksize)
offset += blocksize
total_sent += blocksize
finally:
if total_sent > 0:
file.seek(offset)
async def _sendfile_native(self, transp, file, offset, count):
resume_reading = transp.is_reading()
transp.pause_reading()
await transp._make_empty_waiter()
try:
return await self.sock_sendfile(transp._sock, file, offset, count,
fallback=False)
finally:
transp._reset_empty_waiter()
if resume_reading:
transp.resume_reading()
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 = socket.socketpair()
self._ssock.setblocking(False)
self._csock.setblocking(False)
self._internal_fds += 1
def _loop_self_reading(self, f=None):
try:
if f is not None:
f.result() # may raise
if self._self_reading_future is not f:
# When we scheduled this Future, we assigned it to
# _self_reading_future. If it's not there now, something has
# tried to cancel the loop while this callback was still in the
# queue (see windows_events.ProactorEventLoop.run_forever). In
# that case stop here instead of continuing to schedule a new
# iteration.
return
f = self._proactor.recv(self._ssock, 4096)
except exceptions.CancelledError:
# _close_self_pipe() has been called, stop waiting for data
return
except (SystemExit, KeyboardInterrupt):
raise
except BaseException 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):
# This may be called from a different thread, possibly after
# _close_self_pipe() has been called or even while it is
# running. Guard for self._csock being None or closed. When
# a socket is closed, send() raises OSError (with errno set to
# EBADF, but let's not rely on the exact error code).
csock = self._csock
if csock is None:
return
try:
csock.send(b'\0')
except OSError:
if self._debug:
logger.debug("Fail to write a null byte into the "
"self-pipe socket",
exc_info=True)
def _start_serving(self, protocol_factory, sock,
sslcontext=None, server=None, backlog=100,
ssl_handshake_timeout=None):
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,
ssl_handshake_timeout=ssl_handshake_timeout)
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': trsock.TransportSocket(sock),
})
sock.close()
elif self._debug:
logger.debug("Accept failed on socket %r",
sock, exc_info=True)
except exceptions.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):
future = self._accept_futures.pop(sock.fileno(), None)
if future:
future.cancel()
self._proactor._stop_serving(sock)
sock.close()
PK [�H��� � base_events.pynu �[��� """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.
"""
import collections
import collections.abc
import concurrent.futures
import functools
import heapq
import itertools
import os
import socket
import stat
import subprocess
import threading
import time
import traceback
import sys
import warnings
import weakref
try:
import ssl
except ImportError: # pragma: no cover
ssl = None
from . import constants
from . import coroutines
from . import events
from . import exceptions
from . import futures
from . import protocols
from . import sslproto
from . import staggered
from . import tasks
from . import transports
from . import trsock
from .log import logger
__all__ = 'BaseEventLoop',
# Minimum number of _scheduled timer handles before cleanup of
# cancelled handles is performed.
_MIN_SCHEDULED_TIMER_HANDLES = 100
# Minimum fraction of _scheduled timer handles that are cancelled
# before cleanup of cancelled handles is performed.
_MIN_CANCELLED_TIMER_HANDLES_FRACTION = 0.5
_HAS_IPv6 = hasattr(socket, 'AF_INET6')
# Maximum timeout passed to select to avoid OS limitations
MAXIMUM_SELECT_TIMEOUT = 24 * 3600
# Used for deprecation and removal of `loop.create_datagram_endpoint()`'s
# *reuse_address* parameter
_unset = object()
def _format_handle(handle):
cb = handle._callback
if isinstance(getattr(cb, '__self__', None), tasks.Task):
# format the task
return repr(cb.__self__)
else:
return str(handle)
def _format_pipe(fd):
if fd == subprocess.PIPE:
return '<pipe>'
elif fd == subprocess.STDOUT:
return '<stdout>'
else:
return repr(fd)
def _set_reuseport(sock):
if not hasattr(socket, 'SO_REUSEPORT'):
raise ValueError('reuse_port not supported by socket module')
else:
try:
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
except OSError:
raise ValueError('reuse_port not supported by socket module, '
'SO_REUSEPORT defined but not implemented.')
def _ipaddr_info(host, port, family, type, proto, flowinfo=0, scopeid=0):
# Try to skip getaddrinfo if "host" is already an IP. Users might have
# handled name resolution in their own code and pass in resolved IPs.
if not hasattr(socket, 'inet_pton'):
return
if proto not in {0, socket.IPPROTO_TCP, socket.IPPROTO_UDP} or \
host is None:
return None
if type == socket.SOCK_STREAM:
proto = socket.IPPROTO_TCP
elif type == socket.SOCK_DGRAM:
proto = socket.IPPROTO_UDP
else:
return None
if port is None:
port = 0
elif isinstance(port, bytes) and port == b'':
port = 0
elif isinstance(port, str) and port == '':
port = 0
else:
# If port's a service name like "http", don't skip getaddrinfo.
try:
port = int(port)
except (TypeError, ValueError):
return None
if family == socket.AF_UNSPEC:
afs = [socket.AF_INET]
if _HAS_IPv6:
afs.append(socket.AF_INET6)
else:
afs = [family]
if isinstance(host, bytes):
host = host.decode('idna')
if '%' in host:
# Linux's inet_pton doesn't accept an IPv6 zone index after host,
# like '::1%lo0'.
return None
for af in afs:
try:
socket.inet_pton(af, host)
# The host has already been resolved.
if _HAS_IPv6 and af == socket.AF_INET6:
return af, type, proto, '', (host, port, flowinfo, scopeid)
else:
return af, type, proto, '', (host, port)
except OSError:
pass
# "host" is not an IP address.
return None
def _interleave_addrinfos(addrinfos, first_address_family_count=1):
"""Interleave list of addrinfo tuples by family."""
# Group addresses by family
addrinfos_by_family = collections.OrderedDict()
for addr in addrinfos:
family = addr[0]
if family not in addrinfos_by_family:
addrinfos_by_family[family] = []
addrinfos_by_family[family].append(addr)
addrinfos_lists = list(addrinfos_by_family.values())
reordered = []
if first_address_family_count > 1:
reordered.extend(addrinfos_lists[0][:first_address_family_count - 1])
del addrinfos_lists[0][:first_address_family_count - 1]
reordered.extend(
a for a in itertools.chain.from_iterable(
itertools.zip_longest(*addrinfos_lists)
) if a is not None)
return reordered
def _run_until_complete_cb(fut):
if not fut.cancelled():
exc = fut.exception()
if isinstance(exc, (SystemExit, KeyboardInterrupt)):
# Issue #22429: run_forever() already finished, no need to
# stop it.
return
futures._get_loop(fut).stop()
if hasattr(socket, 'TCP_NODELAY'):
def _set_nodelay(sock):
if (sock.family in {socket.AF_INET, socket.AF_INET6} and
sock.type == socket.SOCK_STREAM and
sock.proto == socket.IPPROTO_TCP):
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
else:
def _set_nodelay(sock):
pass
class _SendfileFallbackProtocol(protocols.Protocol):
def __init__(self, transp):
if not isinstance(transp, transports._FlowControlMixin):
raise TypeError("transport should be _FlowControlMixin instance")
self._transport = transp
self._proto = transp.get_protocol()
self._should_resume_reading = transp.is_reading()
self._should_resume_writing = transp._protocol_paused
transp.pause_reading()
transp.set_protocol(self)
if self._should_resume_writing:
self._write_ready_fut = self._transport._loop.create_future()
else:
self._write_ready_fut = None
async def drain(self):
if self._transport.is_closing():
raise ConnectionError("Connection closed by peer")
fut = self._write_ready_fut
if fut is None:
return
await fut
def connection_made(self, transport):
raise RuntimeError("Invalid state: "
"connection should have been established already.")
def connection_lost(self, exc):
if self._write_ready_fut is not None:
# Never happens if peer disconnects after sending the whole content
# Thus disconnection is always an exception from user perspective
if exc is None:
self._write_ready_fut.set_exception(
ConnectionError("Connection is closed by peer"))
else:
self._write_ready_fut.set_exception(exc)
self._proto.connection_lost(exc)
def pause_writing(self):
if self._write_ready_fut is not None:
return
self._write_ready_fut = self._transport._loop.create_future()
def resume_writing(self):
if self._write_ready_fut is None:
return
self._write_ready_fut.set_result(False)
self._write_ready_fut = None
def data_received(self, data):
raise RuntimeError("Invalid state: reading should be paused")
def eof_received(self):
raise RuntimeError("Invalid state: reading should be paused")
async def restore(self):
self._transport.set_protocol(self._proto)
if self._should_resume_reading:
self._transport.resume_reading()
if self._write_ready_fut is not None:
# Cancel the future.
# Basically it has no effect because protocol is switched back,
# no code should wait for it anymore.
self._write_ready_fut.cancel()
if self._should_resume_writing:
self._proto.resume_writing()
class Server(events.AbstractServer):
def __init__(self, loop, sockets, protocol_factory, ssl_context, backlog,
ssl_handshake_timeout):
self._loop = loop
self._sockets = sockets
self._active_count = 0
self._waiters = []
self._protocol_factory = protocol_factory
self._backlog = backlog
self._ssl_context = ssl_context
self._ssl_handshake_timeout = ssl_handshake_timeout
self._serving = False
self._serving_forever_fut = None
def __repr__(self):
return f'<{self.__class__.__name__} sockets={self.sockets!r}>'
def _attach(self):
assert self._sockets is not None
self._active_count += 1
def _detach(self):
assert self._active_count > 0
self._active_count -= 1
if self._active_count == 0 and self._sockets is None:
self._wakeup()
def _wakeup(self):
waiters = self._waiters
self._waiters = None
for waiter in waiters:
if not waiter.done():
waiter.set_result(waiter)
def _start_serving(self):
if self._serving:
return
self._serving = True
for sock in self._sockets:
sock.listen(self._backlog)
self._loop._start_serving(
self._protocol_factory, sock, self._ssl_context,
self, self._backlog, self._ssl_handshake_timeout)
def get_loop(self):
return self._loop
def is_serving(self):
return self._serving
@property
def sockets(self):
if self._sockets is None:
return ()
return tuple(trsock.TransportSocket(s) for s in self._sockets)
def close(self):
sockets = self._sockets
if sockets is None:
return
self._sockets = None
for sock in sockets:
self._loop._stop_serving(sock)
self._serving = False
if (self._serving_forever_fut is not None and
not self._serving_forever_fut.done()):
self._serving_forever_fut.cancel()
self._serving_forever_fut = None
if self._active_count == 0:
self._wakeup()
async def start_serving(self):
self._start_serving()
# Skip one loop iteration so that all 'loop.add_reader'
# go through.
await tasks.sleep(0, loop=self._loop)
async def serve_forever(self):
if self._serving_forever_fut is not None:
raise RuntimeError(
f'server {self!r} is already being awaited on serve_forever()')
if self._sockets is None:
raise RuntimeError(f'server {self!r} is closed')
self._start_serving()
self._serving_forever_fut = self._loop.create_future()
try:
await self._serving_forever_fut
except exceptions.CancelledError:
try:
self.close()
await self.wait_closed()
finally:
raise
finally:
self._serving_forever_fut = None
async def wait_closed(self):
if self._sockets is None or self._waiters is None:
return
waiter = self._loop.create_future()
self._waiters.append(waiter)
await waiter
class BaseEventLoop(events.AbstractEventLoop):
def __init__(self):
self._timer_cancelled_count = 0
self._closed = False
self._stopping = False
self._ready = collections.deque()
self._scheduled = []
self._default_executor = None
self._internal_fds = 0
# Identifier of the thread running the event loop, or None if the
# event loop is not running
self._thread_id = None
self._clock_resolution = time.get_clock_info('monotonic').resolution
self._exception_handler = None
self.set_debug(coroutines._is_debug_mode())
# In debug mode, if the execution of a callback or a step of a task
# exceed this duration in seconds, the slow callback/task is logged.
self.slow_callback_duration = 0.1
self._current_handle = None
self._task_factory = None
self._coroutine_origin_tracking_enabled = False
self._coroutine_origin_tracking_saved_depth = None
# A weak set of all asynchronous generators that are
# being iterated by the loop.
self._asyncgens = weakref.WeakSet()
# Set to True when `loop.shutdown_asyncgens` is called.
self._asyncgens_shutdown_called = False
def __repr__(self):
return (
f'<{self.__class__.__name__} running={self.is_running()} '
f'closed={self.is_closed()} debug={self.get_debug()}>'
)
def create_future(self):
"""Create a Future object attached to the loop."""
return futures.Future(loop=self)
def create_task(self, coro, *, name=None):
"""Schedule a coroutine object.
Return a task object.
"""
self._check_closed()
if self._task_factory is None:
task = tasks.Task(coro, loop=self, name=name)
if task._source_traceback:
del task._source_traceback[-1]
else:
task = self._task_factory(self, coro)
tasks._set_task_name(task, name)
return task
def set_task_factory(self, factory):
"""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.
"""
if factory is not None and not callable(factory):
raise TypeError('task factory must be a callable or None')
self._task_factory = factory
def get_task_factory(self):
"""Return a task factory, or None if the default one is in use."""
return self._task_factory
def _make_socket_transport(self, sock, protocol, waiter=None, *,
extra=None, server=None):
"""Create socket transport."""
raise NotImplementedError
def _make_ssl_transport(
self, rawsock, protocol, sslcontext, waiter=None,
*, server_side=False, server_hostname=None,
extra=None, server=None,
ssl_handshake_timeout=None,
call_connection_made=True):
"""Create SSL transport."""
raise NotImplementedError
def _make_datagram_transport(self, sock, protocol,
address=None, waiter=None, extra=None):
"""Create datagram transport."""
raise NotImplementedError
def _make_read_pipe_transport(self, pipe, protocol, waiter=None,
extra=None):
"""Create read pipe transport."""
raise NotImplementedError
def _make_write_pipe_transport(self, pipe, protocol, waiter=None,
extra=None):
"""Create write pipe transport."""
raise NotImplementedError
async def _make_subprocess_transport(self, protocol, args, shell,
stdin, stdout, stderr, bufsize,
extra=None, **kwargs):
"""Create subprocess transport."""
raise NotImplementedError
def _write_to_self(self):
"""Write a byte to self-pipe, to wake up the event loop.
This may be called from a different thread.
The subclass is responsible for implementing the self-pipe.
"""
raise NotImplementedError
def _process_events(self, event_list):
"""Process selector events."""
raise NotImplementedError
def _check_closed(self):
if self._closed:
raise RuntimeError('Event loop is closed')
def _asyncgen_finalizer_hook(self, agen):
self._asyncgens.discard(agen)
if not self.is_closed():
self.call_soon_threadsafe(self.create_task, agen.aclose())
def _asyncgen_firstiter_hook(self, agen):
if self._asyncgens_shutdown_called:
warnings.warn(
f"asynchronous generator {agen!r} was scheduled after "
f"loop.shutdown_asyncgens() call",
ResourceWarning, source=self)
self._asyncgens.add(agen)
async def shutdown_asyncgens(self):
"""Shutdown all active asynchronous generators."""
self._asyncgens_shutdown_called = True
if not len(self._asyncgens):
# If Python version is <3.6 or we don't have any asynchronous
# generators alive.
return
closing_agens = list(self._asyncgens)
self._asyncgens.clear()
results = await tasks.gather(
*[ag.aclose() for ag in closing_agens],
return_exceptions=True,
loop=self)
for result, agen in zip(results, closing_agens):
if isinstance(result, Exception):
self.call_exception_handler({
'message': f'an error occurred during closing of '
f'asynchronous generator {agen!r}',
'exception': result,
'asyncgen': agen
})
def _check_running(self):
if self.is_running():
raise RuntimeError('This event loop is already running')
if events._get_running_loop() is not None:
raise RuntimeError(
'Cannot run the event loop while another loop is running')
def run_forever(self):
"""Run until stop() is called."""
self._check_closed()
self._check_running()
self._set_coroutine_origin_tracking(self._debug)
self._thread_id = threading.get_ident()
old_agen_hooks = sys.get_asyncgen_hooks()
sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,
finalizer=self._asyncgen_finalizer_hook)
try:
events._set_running_loop(self)
while True:
self._run_once()
if self._stopping:
break
finally:
self._stopping = False
self._thread_id = None
events._set_running_loop(None)
self._set_coroutine_origin_tracking(False)
sys.set_asyncgen_hooks(*old_agen_hooks)
def run_until_complete(self, future):
"""Run until the Future is done.
If the argument is a coroutine, it is wrapped in a Task.
WARNING: It would be disastrous to call run_until_complete()
with the same coroutine twice -- it would wrap it in two
different Tasks and that can't be good.
Return the Future's result, or raise its exception.
"""
self._check_closed()
self._check_running()
new_task = not futures.isfuture(future)
future = tasks.ensure_future(future, loop=self)
if new_task:
# An exception is raised if the future didn't complete, so there
# is no need to log the "destroy pending task" message
future._log_destroy_pending = False
future.add_done_callback(_run_until_complete_cb)
try:
self.run_forever()
except:
if new_task and future.done() and not future.cancelled():
# The coroutine raised a BaseException. Consume the exception
# to not log a warning, the caller doesn't have access to the
# local task.
future.exception()
raise
finally:
future.remove_done_callback(_run_until_complete_cb)
if not future.done():
raise RuntimeError('Event loop stopped before Future completed.')
return future.result()
def stop(self):
"""Stop running the event loop.
Every callback already scheduled will still run. This simply informs
run_forever to stop looping after a complete iteration.
"""
self._stopping = True
def close(self):
"""Close the event loop.
This clears the queues and shuts down the executor,
but does not wait for the executor to finish.
The event loop must not be running.
"""
if self.is_running():
raise RuntimeError("Cannot close a running event loop")
if self._closed:
return
if self._debug:
logger.debug("Close %r", self)
self._closed = True
self._ready.clear()
self._scheduled.clear()
executor = self._default_executor
if executor is not None:
self._default_executor = None
executor.shutdown(wait=False)
def is_closed(self):
"""Returns True if the event loop was closed."""
return self._closed
def __del__(self, _warn=warnings.warn):
if not self.is_closed():
_warn(f"unclosed event loop {self!r}", ResourceWarning, source=self)
if not self.is_running():
self.close()
def is_running(self):
"""Returns True if the event loop is running."""
return (self._thread_id is not None)
def time(self):
"""Return the time according to the event loop's clock.
This is a float expressed in seconds since an epoch, but the
epoch, precision, accuracy and drift are unspecified and may
differ per event loop.
"""
return time.monotonic()
def call_later(self, delay, callback, *args, context=None):
"""Arrange for a callback to be called at a given time.
Return a Handle: an opaque object with a cancel() method that
can be used to cancel the call.
The delay can be an int or float, expressed in seconds. It is
always relative to the current time.
Each callback will be called exactly once. If two callbacks
are scheduled for exactly the same time, it undefined which
will be called first.
Any positional arguments after the callback will be passed to
the callback when it is called.
"""
timer = self.call_at(self.time() + delay, callback, *args,
context=context)
if timer._source_traceback:
del timer._source_traceback[-1]
return timer
def call_at(self, when, callback, *args, context=None):
"""Like call_later(), but uses an absolute time.
Absolute time corresponds to the event loop's time() method.
"""
self._check_closed()
if self._debug:
self._check_thread()
self._check_callback(callback, 'call_at')
timer = events.TimerHandle(when, callback, args, self, context)
if timer._source_traceback:
del timer._source_traceback[-1]
heapq.heappush(self._scheduled, timer)
timer._scheduled = True
return timer
def call_soon(self, callback, *args, context=None):
"""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.
"""
self._check_closed()
if self._debug:
self._check_thread()
self._check_callback(callback, 'call_soon')
handle = self._call_soon(callback, args, context)
if handle._source_traceback:
del handle._source_traceback[-1]
return handle
def _check_callback(self, callback, method):
if (coroutines.iscoroutine(callback) or
coroutines.iscoroutinefunction(callback)):
raise TypeError(
f"coroutines cannot be used with {method}()")
if not callable(callback):
raise TypeError(
f'a callable object was expected by {method}(), '
f'got {callback!r}')
def _call_soon(self, callback, args, context):
handle = events.Handle(callback, args, self, context)
if handle._source_traceback:
del handle._source_traceback[-1]
self._ready.append(handle)
return handle
def _check_thread(self):
"""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.
"""
if self._thread_id is None:
return
thread_id = threading.get_ident()
if thread_id != self._thread_id:
raise RuntimeError(
"Non-thread-safe operation invoked on an event loop other "
"than the current one")
def call_soon_threadsafe(self, callback, *args, context=None):
"""Like call_soon(), but thread-safe."""
self._check_closed()
if self._debug:
self._check_callback(callback, 'call_soon_threadsafe')
handle = self._call_soon(callback, args, context)
if handle._source_traceback:
del handle._source_traceback[-1]
self._write_to_self()
return handle
def run_in_executor(self, executor, func, *args):
self._check_closed()
if self._debug:
self._check_callback(func, 'run_in_executor')
if executor is None:
executor = self._default_executor
if executor is None:
executor = concurrent.futures.ThreadPoolExecutor()
self._default_executor = executor
return futures.wrap_future(
executor.submit(func, *args), loop=self)
def set_default_executor(self, executor):
if not isinstance(executor, concurrent.futures.ThreadPoolExecutor):
warnings.warn(
'Using the default executor that is not an instance of '
'ThreadPoolExecutor is deprecated and will be prohibited '
'in Python 3.9',
DeprecationWarning, 2)
self._default_executor = executor
def _getaddrinfo_debug(self, host, port, family, type, proto, flags):
msg = [f"{host}:{port!r}"]
if family:
msg.append(f'family={family!r}')
if type:
msg.append(f'type={type!r}')
if proto:
msg.append(f'proto={proto!r}')
if flags:
msg.append(f'flags={flags!r}')
msg = ', '.join(msg)
logger.debug('Get address info %s', msg)
t0 = self.time()
addrinfo = socket.getaddrinfo(host, port, family, type, proto, flags)
dt = self.time() - t0
msg = f'Getting address info {msg} took {dt * 1e3:.3f}ms: {addrinfo!r}'
if dt >= self.slow_callback_duration:
logger.info(msg)
else:
logger.debug(msg)
return addrinfo
async def getaddrinfo(self, host, port, *,
family=0, type=0, proto=0, flags=0):
if self._debug:
getaddr_func = self._getaddrinfo_debug
else:
getaddr_func = socket.getaddrinfo
return await self.run_in_executor(
None, getaddr_func, host, port, family, type, proto, flags)
async def getnameinfo(self, sockaddr, flags=0):
return await self.run_in_executor(
None, socket.getnameinfo, sockaddr, flags)
async def sock_sendfile(self, sock, file, offset=0, count=None,
*, fallback=True):
if self._debug and sock.gettimeout() != 0:
raise ValueError("the socket must be non-blocking")
self._check_sendfile_params(sock, file, offset, count)
try:
return await self._sock_sendfile_native(sock, file,
offset, count)
except exceptions.SendfileNotAvailableError as exc:
if not fallback:
raise
return await self._sock_sendfile_fallback(sock, file,
offset, count)
async def _sock_sendfile_native(self, sock, file, offset, count):
# NB: sendfile syscall is not supported for SSL sockets and
# non-mmap files even if sendfile is supported by OS
raise exceptions.SendfileNotAvailableError(
f"syscall sendfile is not available for socket {sock!r} "
"and file {file!r} combination")
async def _sock_sendfile_fallback(self, sock, file, offset, count):
if offset:
file.seek(offset)
blocksize = (
min(count, constants.SENDFILE_FALLBACK_READBUFFER_SIZE)
if count else constants.SENDFILE_FALLBACK_READBUFFER_SIZE
)
buf = bytearray(blocksize)
total_sent = 0
try:
while True:
if count:
blocksize = min(count - total_sent, blocksize)
if blocksize <= 0:
break
view = memoryview(buf)[:blocksize]
read = await self.run_in_executor(None, file.readinto, view)
if not read:
break # EOF
await self.sock_sendall(sock, view[:read])
total_sent += read
return total_sent
finally:
if total_sent > 0 and hasattr(file, 'seek'):
file.seek(offset + total_sent)
def _check_sendfile_params(self, sock, file, offset, count):
if 'b' not in getattr(file, 'mode', 'b'):
raise ValueError("file should be opened in binary mode")
if not sock.type == socket.SOCK_STREAM:
raise ValueError("only SOCK_STREAM type sockets are supported")
if count is not None:
if not isinstance(count, int):
raise TypeError(
"count must be a positive integer (got {!r})".format(count))
if count <= 0:
raise ValueError(
"count must be a positive integer (got {!r})".format(count))
if not isinstance(offset, int):
raise TypeError(
"offset must be a non-negative integer (got {!r})".format(
offset))
if offset < 0:
raise ValueError(
"offset must be a non-negative integer (got {!r})".format(
offset))
async def _connect_sock(self, exceptions, addr_info, local_addr_infos=None):
"""Create, bind and connect one socket."""
my_exceptions = []
exceptions.append(my_exceptions)
family, type_, proto, _, address = addr_info
sock = None
try:
sock = socket.socket(family=family, type=type_, proto=proto)
sock.setblocking(False)
if local_addr_infos is not None:
for _, _, _, _, laddr in local_addr_infos:
try:
sock.bind(laddr)
break
except OSError as exc:
msg = (
f'error while attempting to bind on '
f'address {laddr!r}: '
f'{exc.strerror.lower()}'
)
exc = OSError(exc.errno, msg)
my_exceptions.append(exc)
else: # all bind attempts failed
raise my_exceptions.pop()
await self.sock_connect(sock, address)
return sock
except OSError as exc:
my_exceptions.append(exc)
if sock is not None:
sock.close()
raise
except:
if sock is not None:
sock.close()
raise
async 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,
ssl_handshake_timeout=None,
happy_eyeballs_delay=None, interleave=None):
"""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.
"""
if server_hostname is not None and not ssl:
raise ValueError('server_hostname is only meaningful with ssl')
if server_hostname is None and ssl:
# Use host as default for server_hostname. It is an error
# if host is empty or not set, e.g. when an
# already-connected socket was passed or when only a port
# is given. To avoid this error, you can pass
# server_hostname='' -- this will bypass the hostname
# check. (This also means that if host is a numeric
# IP/IPv6 address, we will attempt to verify that exact
# address; this will probably fail, but it is possible to
# create a certificate for a specific IP address, so we
# don't judge it here.)
if not host:
raise ValueError('You must set server_hostname '
'when using ssl without a host')
server_hostname = host
if ssl_handshake_timeout is not None and not ssl:
raise ValueError(
'ssl_handshake_timeout is only meaningful with ssl')
if happy_eyeballs_delay is not None and interleave is None:
# If using happy eyeballs, default to interleave addresses by family
interleave = 1
if host is not None or port is not None:
if sock is not None:
raise ValueError(
'host/port and sock can not be specified at the same time')
infos = await self._ensure_resolved(
(host, port), family=family,
type=socket.SOCK_STREAM, proto=proto, flags=flags, loop=self)
if not infos:
raise OSError('getaddrinfo() returned empty list')
if local_addr is not None:
laddr_infos = await self._ensure_resolved(
local_addr, family=family,
type=socket.SOCK_STREAM, proto=proto,
flags=flags, loop=self)
if not laddr_infos:
raise OSError('getaddrinfo() returned empty list')
else:
laddr_infos = None
if interleave:
infos = _interleave_addrinfos(infos, interleave)
exceptions = []
if happy_eyeballs_delay is None:
# not using happy eyeballs
for addrinfo in infos:
try:
sock = await self._connect_sock(
exceptions, addrinfo, laddr_infos)
break
except OSError:
continue
else: # using happy eyeballs
sock, _, _ = await staggered.staggered_race(
(functools.partial(self._connect_sock,
exceptions, addrinfo, laddr_infos)
for addrinfo in infos),
happy_eyeballs_delay, loop=self)
if sock is None:
exceptions = [exc for sub in exceptions for exc in sub]
if len(exceptions) == 1:
raise exceptions[0]
else:
# If they all have the same str(), raise one.
model = str(exceptions[0])
if all(str(exc) == model for exc in exceptions):
raise exceptions[0]
# Raise a combined exception so the user can see all
# the various error messages.
raise OSError('Multiple exceptions: {}'.format(
', '.join(str(exc) for exc in exceptions)))
else:
if sock is None:
raise ValueError(
'host and port was not specified and no sock specified')
if sock.type != socket.SOCK_STREAM:
# We allow AF_INET, AF_INET6, AF_UNIX as long as they
# are SOCK_STREAM.
# We support passing AF_UNIX sockets even though we have
# a dedicated API for that: create_unix_connection.
# Disallowing AF_UNIX in this method, breaks backwards
# compatibility.
raise ValueError(
f'A Stream Socket was expected, got {sock!r}')
transport, protocol = await self._create_connection_transport(
sock, protocol_factory, ssl, server_hostname,
ssl_handshake_timeout=ssl_handshake_timeout)
if self._debug:
# Get the socket from the transport because SSL transport closes
# the old socket and creates a new SSL socket
sock = transport.get_extra_info('socket')
logger.debug("%r connected to %s:%r: (%r, %r)",
sock, host, port, transport, protocol)
return transport, protocol
async def _create_connection_transport(
self, sock, protocol_factory, ssl,
server_hostname, server_side=False,
ssl_handshake_timeout=None):
sock.setblocking(False)
protocol = protocol_factory()
waiter = self.create_future()
if ssl:
sslcontext = None if isinstance(ssl, bool) else ssl
transport = self._make_ssl_transport(
sock, protocol, sslcontext, waiter,
server_side=server_side, server_hostname=server_hostname,
ssl_handshake_timeout=ssl_handshake_timeout)
else:
transport = self._make_socket_transport(sock, protocol, waiter)
try:
await waiter
except:
transport.close()
raise
return transport, protocol
async def sendfile(self, transport, file, offset=0, count=None,
*, fallback=True):
"""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.
"""
if transport.is_closing():
raise RuntimeError("Transport is closing")
mode = getattr(transport, '_sendfile_compatible',
constants._SendfileMode.UNSUPPORTED)
if mode is constants._SendfileMode.UNSUPPORTED:
raise RuntimeError(
f"sendfile is not supported for transport {transport!r}")
if mode is constants._SendfileMode.TRY_NATIVE:
try:
return await self._sendfile_native(transport, file,
offset, count)
except exceptions.SendfileNotAvailableError as exc:
if not fallback:
raise
if not fallback:
raise RuntimeError(
f"fallback is disabled and native sendfile is not "
f"supported for transport {transport!r}")
return await self._sendfile_fallback(transport, file,
offset, count)
async def _sendfile_native(self, transp, file, offset, count):
raise exceptions.SendfileNotAvailableError(
"sendfile syscall is not supported")
async def _sendfile_fallback(self, transp, file, offset, count):
if offset:
file.seek(offset)
blocksize = min(count, 16384) if count else 16384
buf = bytearray(blocksize)
total_sent = 0
proto = _SendfileFallbackProtocol(transp)
try:
while True:
if count:
blocksize = min(count - total_sent, blocksize)
if blocksize <= 0:
return total_sent
view = memoryview(buf)[:blocksize]
read = await self.run_in_executor(None, file.readinto, view)
if not read:
return total_sent # EOF
await proto.drain()
transp.write(view[:read])
total_sent += read
finally:
if total_sent > 0 and hasattr(file, 'seek'):
file.seek(offset + total_sent)
await proto.restore()
async def start_tls(self, transport, protocol, sslcontext, *,
server_side=False,
server_hostname=None,
ssl_handshake_timeout=None):
"""Upgrade transport to TLS.
Return a new transport that *protocol* should start using
immediately.
"""
if ssl is None:
raise RuntimeError('Python ssl module is not available')
if not isinstance(sslcontext, ssl.SSLContext):
raise TypeError(
f'sslcontext is expected to be an instance of ssl.SSLContext, '
f'got {sslcontext!r}')
if not getattr(transport, '_start_tls_compatible', False):
raise TypeError(
f'transport {transport!r} is not supported by start_tls()')
waiter = self.create_future()
ssl_protocol = sslproto.SSLProtocol(
self, protocol, sslcontext, waiter,
server_side, server_hostname,
ssl_handshake_timeout=ssl_handshake_timeout,
call_connection_made=False)
# Pause early so that "ssl_protocol.data_received()" doesn't
# have a chance to get called before "ssl_protocol.connection_made()".
transport.pause_reading()
transport.set_protocol(ssl_protocol)
conmade_cb = self.call_soon(ssl_protocol.connection_made, transport)
resume_cb = self.call_soon(transport.resume_reading)
try:
await waiter
except BaseException:
transport.close()
conmade_cb.cancel()
resume_cb.cancel()
raise
return ssl_protocol._app_transport
async def create_datagram_endpoint(self, protocol_factory,
local_addr=None, remote_addr=None, *,
family=0, proto=0, flags=0,
reuse_address=_unset, reuse_port=None,
allow_broadcast=None, sock=None):
"""Create datagram connection."""
if sock is not None:
if sock.type != socket.SOCK_DGRAM:
raise ValueError(
f'A UDP Socket was expected, got {sock!r}')
if (local_addr or remote_addr or
family or proto or flags or
reuse_port or allow_broadcast):
# show the problematic kwargs in exception msg
opts = dict(local_addr=local_addr, remote_addr=remote_addr,
family=family, proto=proto, flags=flags,
reuse_address=reuse_address, reuse_port=reuse_port,
allow_broadcast=allow_broadcast)
problems = ', '.join(f'{k}={v}' for k, v in opts.items() if v)
raise ValueError(
f'socket modifier keyword arguments can not be used '
f'when sock is specified. ({problems})')
sock.setblocking(False)
r_addr = None
else:
if not (local_addr or remote_addr):
if family == 0:
raise ValueError('unexpected address family')
addr_pairs_info = (((family, proto), (None, None)),)
elif hasattr(socket, 'AF_UNIX') and family == socket.AF_UNIX:
for addr in (local_addr, remote_addr):
if addr is not None and not isinstance(addr, str):
raise TypeError('string is expected')
if local_addr and local_addr[0] not in (0, '\x00'):
try:
if stat.S_ISSOCK(os.stat(local_addr).st_mode):
os.remove(local_addr)
except FileNotFoundError:
pass
except OSError as err:
# Directory may have permissions only to create socket.
logger.error('Unable to check or remove stale UNIX '
'socket %r: %r',
local_addr, err)
addr_pairs_info = (((family, proto),
(local_addr, remote_addr)), )
else:
# join address by (family, protocol)
addr_infos = {} # Using order preserving dict
for idx, addr in ((0, local_addr), (1, remote_addr)):
if addr is not None:
assert isinstance(addr, tuple) and len(addr) == 2, (
'2-tuple is expected')
infos = await self._ensure_resolved(
addr, family=family, type=socket.SOCK_DGRAM,
proto=proto, flags=flags, loop=self)
if not infos:
raise OSError('getaddrinfo() returned empty list')
for fam, _, pro, _, address in infos:
key = (fam, pro)
if key not in addr_infos:
addr_infos[key] = [None, None]
addr_infos[key][idx] = address
# each addr has to have info for each (family, proto) pair
addr_pairs_info = [
(key, addr_pair) for key, addr_pair in addr_infos.items()
if not ((local_addr and addr_pair[0] is None) or
(remote_addr and addr_pair[1] is None))]
if not addr_pairs_info:
raise ValueError('can not get address information')
exceptions = []
# bpo-37228
if reuse_address is not _unset:
if reuse_address:
raise ValueError("Passing `reuse_address=True` is no "
"longer supported, as the usage of "
"SO_REUSEPORT in UDP poses a significant "
"security concern.")
else:
warnings.warn("The *reuse_address* parameter has been "
"deprecated as of 3.5.10 and is scheduled "
"for removal in 3.11.", DeprecationWarning,
stacklevel=2)
for ((family, proto),
(local_address, remote_address)) in addr_pairs_info:
sock = None
r_addr = None
try:
sock = socket.socket(
family=family, type=socket.SOCK_DGRAM, proto=proto)
if reuse_port:
_set_reuseport(sock)
if allow_broadcast:
sock.setsockopt(
socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
sock.setblocking(False)
if local_addr:
sock.bind(local_address)
if remote_addr:
if not allow_broadcast:
await self.sock_connect(sock, remote_address)
r_addr = remote_address
except OSError as exc:
if sock is not None:
sock.close()
exceptions.append(exc)
except:
if sock is not None:
sock.close()
raise
else:
break
else:
raise exceptions[0]
protocol = protocol_factory()
waiter = self.create_future()
transport = self._make_datagram_transport(
sock, protocol, r_addr, waiter)
if self._debug:
if local_addr:
logger.info("Datagram endpoint local_addr=%r remote_addr=%r "
"created: (%r, %r)",
local_addr, remote_addr, transport, protocol)
else:
logger.debug("Datagram endpoint remote_addr=%r created: "
"(%r, %r)",
remote_addr, transport, protocol)
try:
await waiter
except:
transport.close()
raise
return transport, protocol
async def _ensure_resolved(self, address, *,
family=0, type=socket.SOCK_STREAM,
proto=0, flags=0, loop):
host, port = address[:2]
info = _ipaddr_info(host, port, family, type, proto, *address[2:])
if info is not None:
# "host" is already a resolved IP.
return [info]
else:
return await loop.getaddrinfo(host, port, family=family, type=type,
proto=proto, flags=flags)
async def _create_server_getaddrinfo(self, host, port, family, flags):
infos = await self._ensure_resolved((host, port), family=family,
type=socket.SOCK_STREAM,
flags=flags, loop=self)
if not infos:
raise OSError(f'getaddrinfo({host!r}) returned empty list')
return infos
async 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,
ssl_handshake_timeout=None,
start_serving=True):
"""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.
"""
if isinstance(ssl, bool):
raise TypeError('ssl argument must be an SSLContext or None')
if ssl_handshake_timeout is not None and ssl is None:
raise ValueError(
'ssl_handshake_timeout is only meaningful with ssl')
if host is not None or port is not None:
if sock is not None:
raise ValueError(
'host/port and sock can not be specified at the same time')
if reuse_address is None:
reuse_address = os.name == 'posix' and sys.platform != 'cygwin'
sockets = []
if host == '':
hosts = [None]
elif (isinstance(host, str) or
not isinstance(host, collections.abc.Iterable)):
hosts = [host]
else:
hosts = host
fs = [self._create_server_getaddrinfo(host, port, family=family,
flags=flags)
for host in hosts]
infos = await tasks.gather(*fs, loop=self)
infos = set(itertools.chain.from_iterable(infos))
completed = False
try:
for res in infos:
af, socktype, proto, canonname, sa = res
try:
sock = socket.socket(af, socktype, proto)
except socket.error:
# Assume it's a bad family/type/protocol combination.
if self._debug:
logger.warning('create_server() failed to create '
'socket.socket(%r, %r, %r)',
af, socktype, proto, exc_info=True)
continue
sockets.append(sock)
if reuse_address:
sock.setsockopt(
socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
if reuse_port:
_set_reuseport(sock)
# Disable IPv4/IPv6 dual stack support (enabled by
# default on Linux) which makes a single socket
# listen on both address families.
if (_HAS_IPv6 and
af == socket.AF_INET6 and
hasattr(socket, 'IPPROTO_IPV6')):
sock.setsockopt(socket.IPPROTO_IPV6,
socket.IPV6_V6ONLY,
True)
try:
sock.bind(sa)
except OSError as err:
raise OSError(err.errno, 'error while attempting '
'to bind on address %r: %s'
% (sa, err.strerror.lower())) from None
completed = True
finally:
if not completed:
for sock in sockets:
sock.close()
else:
if sock is None:
raise ValueError('Neither host/port nor sock were specified')
if sock.type != socket.SOCK_STREAM:
raise ValueError(f'A Stream Socket was expected, got {sock!r}')
sockets = [sock]
for sock in sockets:
sock.setblocking(False)
server = Server(self, sockets, protocol_factory,
ssl, backlog, ssl_handshake_timeout)
if start_serving:
server._start_serving()
# Skip one loop iteration so that all 'loop.add_reader'
# go through.
await tasks.sleep(0, loop=self)
if self._debug:
logger.info("%r is serving", server)
return server
async def connect_accepted_socket(
self, protocol_factory, sock,
*, ssl=None,
ssl_handshake_timeout=None):
"""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.
"""
if sock.type != socket.SOCK_STREAM:
raise ValueError(f'A Stream Socket was expected, got {sock!r}')
if ssl_handshake_timeout is not None and not ssl:
raise ValueError(
'ssl_handshake_timeout is only meaningful with ssl')
transport, protocol = await self._create_connection_transport(
sock, protocol_factory, ssl, '', server_side=True,
ssl_handshake_timeout=ssl_handshake_timeout)
if self._debug:
# Get the socket from the transport because SSL transport closes
# the old socket and creates a new SSL socket
sock = transport.get_extra_info('socket')
logger.debug("%r handled: (%r, %r)", sock, transport, protocol)
return transport, protocol
async def connect_read_pipe(self, protocol_factory, pipe):
protocol = protocol_factory()
waiter = self.create_future()
transport = self._make_read_pipe_transport(pipe, protocol, waiter)
try:
await waiter
except:
transport.close()
raise
if self._debug:
logger.debug('Read pipe %r connected: (%r, %r)',
pipe.fileno(), transport, protocol)
return transport, protocol
async def connect_write_pipe(self, protocol_factory, pipe):
protocol = protocol_factory()
waiter = self.create_future()
transport = self._make_write_pipe_transport(pipe, protocol, waiter)
try:
await waiter
except:
transport.close()
raise
if self._debug:
logger.debug('Write pipe %r connected: (%r, %r)',
pipe.fileno(), transport, protocol)
return transport, protocol
def _log_subprocess(self, msg, stdin, stdout, stderr):
info = [msg]
if stdin is not None:
info.append(f'stdin={_format_pipe(stdin)}')
if stdout is not None and stderr == subprocess.STDOUT:
info.append(f'stdout=stderr={_format_pipe(stdout)}')
else:
if stdout is not None:
info.append(f'stdout={_format_pipe(stdout)}')
if stderr is not None:
info.append(f'stderr={_format_pipe(stderr)}')
logger.debug(' '.join(info))
async def subprocess_shell(self, protocol_factory, cmd, *,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
universal_newlines=False,
shell=True, bufsize=0,
encoding=None, errors=None, text=None,
**kwargs):
if not isinstance(cmd, (bytes, str)):
raise ValueError("cmd must be a string")
if universal_newlines:
raise ValueError("universal_newlines must be False")
if not shell:
raise ValueError("shell must be True")
if bufsize != 0:
raise ValueError("bufsize must be 0")
if text:
raise ValueError("text must be False")
if encoding is not None:
raise ValueError("encoding must be None")
if errors is not None:
raise ValueError("errors must be None")
protocol = protocol_factory()
debug_log = None
if self._debug:
# don't log parameters: they may contain sensitive information
# (password) and may be too long
debug_log = 'run shell command %r' % cmd
self._log_subprocess(debug_log, stdin, stdout, stderr)
transport = await self._make_subprocess_transport(
protocol, cmd, True, stdin, stdout, stderr, bufsize, **kwargs)
if self._debug and debug_log is not None:
logger.info('%s: %r', debug_log, transport)
return transport, protocol
async def subprocess_exec(self, protocol_factory, program, *args,
stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, universal_newlines=False,
shell=False, bufsize=0,
encoding=None, errors=None, text=None,
**kwargs):
if universal_newlines:
raise ValueError("universal_newlines must be False")
if shell:
raise ValueError("shell must be False")
if bufsize != 0:
raise ValueError("bufsize must be 0")
if text:
raise ValueError("text must be False")
if encoding is not None:
raise ValueError("encoding must be None")
if errors is not None:
raise ValueError("errors must be None")
popen_args = (program,) + args
protocol = protocol_factory()
debug_log = None
if self._debug:
# don't log parameters: they may contain sensitive information
# (password) and may be too long
debug_log = f'execute program {program!r}'
self._log_subprocess(debug_log, stdin, stdout, stderr)
transport = await self._make_subprocess_transport(
protocol, popen_args, False, stdin, stdout, stderr,
bufsize, **kwargs)
if self._debug and debug_log is not None:
logger.info('%s: %r', debug_log, transport)
return transport, protocol
def get_exception_handler(self):
"""Return an exception handler, or None if the default one is in use.
"""
return self._exception_handler
def set_exception_handler(self, handler):
"""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).
"""
if handler is not None and not callable(handler):
raise TypeError(f'A callable object or None is expected, '
f'got {handler!r}')
self._exception_handler = handler
def default_exception_handler(self, context):
"""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()`.
"""
message = context.get('message')
if not message:
message = 'Unhandled exception in event loop'
exception = context.get('exception')
if exception is not None:
exc_info = (type(exception), exception, exception.__traceback__)
else:
exc_info = False
if ('source_traceback' not in context and
self._current_handle is not None and
self._current_handle._source_traceback):
context['handle_traceback'] = \
self._current_handle._source_traceback
log_lines = [message]
for key in sorted(context):
if key in {'message', 'exception'}:
continue
value = context[key]
if key == 'source_traceback':
tb = ''.join(traceback.format_list(value))
value = 'Object created at (most recent call last):\n'
value += tb.rstrip()
elif key == 'handle_traceback':
tb = ''.join(traceback.format_list(value))
value = 'Handle created at (most recent call last):\n'
value += tb.rstrip()
else:
value = repr(value)
log_lines.append(f'{key}: {value}')
logger.error('\n'.join(log_lines), exc_info=exc_info)
def call_exception_handler(self, context):
"""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.
"""
if self._exception_handler is None:
try:
self.default_exception_handler(context)
except (SystemExit, KeyboardInterrupt):
raise
except BaseException:
# Second protection layer for unexpected errors
# in the default implementation, as well as for subclassed
# event loops with overloaded "default_exception_handler".
logger.error('Exception in default exception handler',
exc_info=True)
else:
try:
self._exception_handler(self, context)
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as exc:
# Exception in the user set custom exception handler.
try:
# Let's try default handler.
self.default_exception_handler({
'message': 'Unhandled error in exception handler',
'exception': exc,
'context': context,
})
except (SystemExit, KeyboardInterrupt):
raise
except BaseException:
# Guard 'default_exception_handler' in case it is
# overloaded.
logger.error('Exception in default exception handler '
'while handling an unexpected error '
'in custom exception handler',
exc_info=True)
def _add_callback(self, handle):
"""Add a Handle to _scheduled (TimerHandle) or _ready."""
assert isinstance(handle, events.Handle), 'A Handle is required here'
if handle._cancelled:
return
assert not isinstance(handle, events.TimerHandle)
self._ready.append(handle)
def _add_callback_signalsafe(self, handle):
"""Like _add_callback() but called from a signal handler."""
self._add_callback(handle)
self._write_to_self()
def _timer_handle_cancelled(self, handle):
"""Notification that a TimerHandle has been cancelled."""
if handle._scheduled:
self._timer_cancelled_count += 1
def _run_once(self):
"""Run one full iteration of the event loop.
This calls all currently ready callbacks, polls for I/O,
schedules the resulting callbacks, and finally schedules
'call_later' callbacks.
"""
sched_count = len(self._scheduled)
if (sched_count > _MIN_SCHEDULED_TIMER_HANDLES and
self._timer_cancelled_count / sched_count >
_MIN_CANCELLED_TIMER_HANDLES_FRACTION):
# Remove delayed calls that were cancelled if their number
# is too high
new_scheduled = []
for handle in self._scheduled:
if handle._cancelled:
handle._scheduled = False
else:
new_scheduled.append(handle)
heapq.heapify(new_scheduled)
self._scheduled = new_scheduled
self._timer_cancelled_count = 0
else:
# Remove delayed calls that were cancelled from head of queue.
while self._scheduled and self._scheduled[0]._cancelled:
self._timer_cancelled_count -= 1
handle = heapq.heappop(self._scheduled)
handle._scheduled = False
timeout = None
if self._ready or self._stopping:
timeout = 0
elif self._scheduled:
# Compute the desired timeout.
when = self._scheduled[0]._when
timeout = min(max(0, when - self.time()), MAXIMUM_SELECT_TIMEOUT)
event_list = self._selector.select(timeout)
self._process_events(event_list)
# Handle 'later' callbacks that are ready.
end_time = self.time() + self._clock_resolution
while self._scheduled:
handle = self._scheduled[0]
if handle._when >= end_time:
break
handle = heapq.heappop(self._scheduled)
handle._scheduled = False
self._ready.append(handle)
# This is the only place where callbacks are actually *called*.
# All other places just add them to ready.
# Note: We run all currently scheduled callbacks, but not any
# callbacks scheduled by callbacks run this time around --
# they will be run the next time (after another I/O poll).
# Use an idiom that is thread-safe without using locks.
ntodo = len(self._ready)
for i in range(ntodo):
handle = self._ready.popleft()
if handle._cancelled:
continue
if self._debug:
try:
self._current_handle = handle
t0 = self.time()
handle._run()
dt = self.time() - t0
if dt >= self.slow_callback_duration:
logger.warning('Executing %s took %.3f seconds',
_format_handle(handle), dt)
finally:
self._current_handle = None
else:
handle._run()
handle = None # Needed to break cycles when an exception occurs.
def _set_coroutine_origin_tracking(self, enabled):
if bool(enabled) == bool(self._coroutine_origin_tracking_enabled):
return
if enabled:
self._coroutine_origin_tracking_saved_depth = (
sys.get_coroutine_origin_tracking_depth())
sys.set_coroutine_origin_tracking_depth(
constants.DEBUG_STACK_DEPTH)
else:
sys.set_coroutine_origin_tracking_depth(
self._coroutine_origin_tracking_saved_depth)
self._coroutine_origin_tracking_enabled = enabled
def get_debug(self):
return self._debug
def set_debug(self, enabled):
self._debug = enabled
if self.is_running():
self.call_soon_threadsafe(self._set_coroutine_origin_tracking, enabled)
PK [���]" ]"
coroutines.pynu �[��� __all__ = 'coroutine', 'iscoroutinefunction', 'iscoroutine'
import collections.abc
import functools
import inspect
import os
import sys
import traceback
import types
import warnings
from . import base_futures
from . import constants
from . import format_helpers
from .log import logger
def _is_debug_mode():
# If you set _DEBUG to true, @coroutine will wrap the resulting
# generator objects in a CoroWrapper instance (defined below). That
# instance will log a message when the generator is never iterated
# over, which may happen when you forget to use "await" or "yield from"
# with a coroutine call.
# Note that the value of the _DEBUG flag is taken
# when the decorator is used, so to be of any use it must be set
# before you define your coroutines. A downside of using this feature
# is that tracebacks show entries for the CoroWrapper.__next__ method
# when _DEBUG is true.
return sys.flags.dev_mode or (not sys.flags.ignore_environment and
bool(os.environ.get('PYTHONASYNCIODEBUG')))
_DEBUG = _is_debug_mode()
class CoroWrapper:
# Wrapper for coroutine object in _DEBUG mode.
def __init__(self, gen, func=None):
assert inspect.isgenerator(gen) or inspect.iscoroutine(gen), gen
self.gen = gen
self.func = func # Used to unwrap @coroutine decorator
self._source_traceback = format_helpers.extract_stack(sys._getframe(1))
self.__name__ = getattr(gen, '__name__', None)
self.__qualname__ = getattr(gen, '__qualname__', None)
def __repr__(self):
coro_repr = _format_coroutine(self)
if self._source_traceback:
frame = self._source_traceback[-1]
coro_repr += f', created at {frame[0]}:{frame[1]}'
return f'<{self.__class__.__name__} {coro_repr}>'
def __iter__(self):
return self
def __next__(self):
return self.gen.send(None)
def send(self, value):
return self.gen.send(value)
def throw(self, type, value=None, traceback=None):
return self.gen.throw(type, value, traceback)
def close(self):
return self.gen.close()
@property
def gi_frame(self):
return self.gen.gi_frame
@property
def gi_running(self):
return self.gen.gi_running
@property
def gi_code(self):
return self.gen.gi_code
def __await__(self):
return self
@property
def gi_yieldfrom(self):
return self.gen.gi_yieldfrom
def __del__(self):
# Be careful accessing self.gen.frame -- self.gen might not exist.
gen = getattr(self, 'gen', None)
frame = getattr(gen, 'gi_frame', None)
if frame is not None and frame.f_lasti == -1:
msg = f'{self!r} was never yielded from'
tb = getattr(self, '_source_traceback', ())
if tb:
tb = ''.join(traceback.format_list(tb))
msg += (f'\nCoroutine object created at '
f'(most recent call last, truncated to '
f'{constants.DEBUG_STACK_DEPTH} last lines):\n')
msg += tb.rstrip()
logger.error(msg)
def coroutine(func):
"""Decorator to mark coroutines.
If the coroutine is not yielded from before it is destroyed,
an error message is logged.
"""
warnings.warn('"@coroutine" decorator is deprecated since Python 3.8, use "async def" instead',
DeprecationWarning,
stacklevel=2)
if inspect.iscoroutinefunction(func):
# In Python 3.5 that's all we need to do for coroutines
# defined with "async def".
return func
if inspect.isgeneratorfunction(func):
coro = func
else:
@functools.wraps(func)
def coro(*args, **kw):
res = func(*args, **kw)
if (base_futures.isfuture(res) or inspect.isgenerator(res) or
isinstance(res, CoroWrapper)):
res = yield from res
else:
# If 'res' is an awaitable, run it.
try:
await_meth = res.__await__
except AttributeError:
pass
else:
if isinstance(res, collections.abc.Awaitable):
res = yield from await_meth()
return res
coro = types.coroutine(coro)
if not _DEBUG:
wrapper = coro
else:
@functools.wraps(func)
def wrapper(*args, **kwds):
w = CoroWrapper(coro(*args, **kwds), func=func)
if w._source_traceback:
del w._source_traceback[-1]
# Python < 3.5 does not implement __qualname__
# on generator objects, so we set it manually.
# We use getattr as some callables (such as
# functools.partial may lack __qualname__).
w.__name__ = getattr(func, '__name__', None)
w.__qualname__ = getattr(func, '__qualname__', None)
return w
wrapper._is_coroutine = _is_coroutine # For iscoroutinefunction().
return wrapper
# A marker for iscoroutinefunction.
_is_coroutine = object()
def iscoroutinefunction(func):
"""Return True if func is a decorated coroutine function."""
return (inspect.iscoroutinefunction(func) or
getattr(func, '_is_coroutine', None) is _is_coroutine)
# Prioritize native coroutine check to speed-up
# asyncio.iscoroutine.
_COROUTINE_TYPES = (types.CoroutineType, types.GeneratorType,
collections.abc.Coroutine, CoroWrapper)
_iscoroutine_typecache = set()
def iscoroutine(obj):
"""Return True if obj is a coroutine object."""
if type(obj) in _iscoroutine_typecache:
return True
if isinstance(obj, _COROUTINE_TYPES):
# Just in case we don't want to cache more than 100
# positive types. That shouldn't ever happen, unless
# someone stressing the system on purpose.
if len(_iscoroutine_typecache) < 100:
_iscoroutine_typecache.add(type(obj))
return True
else:
return False
def _format_coroutine(coro):
assert iscoroutine(coro)
is_corowrapper = isinstance(coro, CoroWrapper)
def get_name(coro):
# Coroutines compiled with Cython sometimes don't have
# proper __qualname__ or __name__. While that is a bug
# in Cython, asyncio shouldn't crash with an AttributeError
# in its __repr__ functions.
if is_corowrapper:
return format_helpers._format_callback(coro.func, (), {})
if hasattr(coro, '__qualname__') and coro.__qualname__:
coro_name = coro.__qualname__
elif hasattr(coro, '__name__') and coro.__name__:
coro_name = coro.__name__
else:
# Stop masking Cython bugs, expose them in a friendly way.
coro_name = f'<{type(coro).__name__} without __name__>'
return f'{coro_name}()'
def is_running(coro):
try:
return coro.cr_running
except AttributeError:
try:
return coro.gi_running
except AttributeError:
return False
coro_code = None
if hasattr(coro, 'cr_code') and coro.cr_code:
coro_code = coro.cr_code
elif hasattr(coro, 'gi_code') and coro.gi_code:
coro_code = coro.gi_code
coro_name = get_name(coro)
if not coro_code:
# Built-in types might not have __qualname__ or __name__.
if is_running(coro):
return f'{coro_name} running'
else:
return coro_name
coro_frame = None
if hasattr(coro, 'gi_frame') and coro.gi_frame:
coro_frame = coro.gi_frame
elif hasattr(coro, 'cr_frame') and coro.cr_frame:
coro_frame = coro.cr_frame
# If Cython's coroutine has a fake code object without proper
# co_filename -- expose that.
filename = coro_code.co_filename or '<empty co_filename>'
lineno = 0
if (is_corowrapper and
coro.func is not None and
not inspect.isgeneratorfunction(coro.func)):
source = format_helpers._get_function_source(coro.func)
if source is not None:
filename, lineno = source
if coro_frame is None:
coro_repr = f'{coro_name} done, defined at {filename}:{lineno}'
else:
coro_repr = f'{coro_name} running, defined at {filename}:{lineno}'
elif coro_frame is not None:
lineno = coro_frame.f_lineno
coro_repr = f'{coro_name} running at {filename}:{lineno}'
else:
lineno = coro_code.co_firstlineno
coro_repr = f'{coro_name} done, defined at {filename}:{lineno}'
return coro_repr
PK [|�q�� � protocols.pynu �[��� """Abstract Protocol base classes."""
__all__ = (
'BaseProtocol', 'Protocol', 'DatagramProtocol',
'SubprocessProtocol', 'BufferedProtocol',
)
class BaseProtocol:
"""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
"""
__slots__ = ()
def connection_made(self, transport):
"""Called 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.
"""
def connection_lost(self, exc):
"""Called 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).
"""
def pause_writing(self):
"""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).
"""
def resume_writing(self):
"""Called when the transport's buffer drains below the low-water mark.
See pause_writing() for details.
"""
class Protocol(BaseProtocol):
"""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()
"""
__slots__ = ()
def data_received(self, data):
"""Called when some data is received.
The argument is a bytes object.
"""
def eof_received(self):
"""Called 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.
"""
class BufferedProtocol(BaseProtocol):
"""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()
"""
__slots__ = ()
def get_buffer(self, sizehint):
"""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 <bufferobjects>`.
It is an error to return a zero-sized buffer.
"""
def buffer_updated(self, nbytes):
"""Called when the buffer was updated with the received data.
*nbytes* is the total number of bytes that were written to
the buffer.
"""
def eof_received(self):
"""Called 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.
"""
class DatagramProtocol(BaseProtocol):
"""Interface for datagram protocol."""
__slots__ = ()
def datagram_received(self, data, addr):
"""Called when some datagram is received."""
def error_received(self, exc):
"""Called when a send or receive operation raises an OSError.
(Other than BlockingIOError or InterruptedError.)
"""
class SubprocessProtocol(BaseProtocol):
"""Interface for protocol for subprocess calls."""
__slots__ = ()
def pipe_data_received(self, fd, data):
"""Called when the subprocess writes data into stdout/stderr pipe.
fd is int file descriptor.
data is bytes object.
"""
def pipe_connection_lost(self, fd, exc):
"""Called when a file descriptor associated with the child process is
closed.
fd is the int file descriptor that was closed.
"""
def process_exited(self):
"""Called when subprocess has exited."""
def _feed_data_to_buffered_proto(proto, data):
data_len = len(data)
while data_len:
buf = proto.get_buffer(data_len)
buf_len = len(buf)
if not buf_len:
raise RuntimeError('get_buffer() returned an empty buffer')
if buf_len >= data_len:
buf[:data_len] = data
proto.buffer_updated(data_len)
return
else:
buf[:buf_len] = data[:buf_len]
proto.buffer_updated(buf_len)
data = data[buf_len:]
data_len = len(data)
PK [��Zd d format_helpers.pynu �[��� import functools
import inspect
import reprlib
import sys
import traceback
from . import constants
def _get_function_source(func):
func = inspect.unwrap(func)
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 isinstance(func, functools.partialmethod):
return _get_function_source(func.func)
return None
def _format_callback_source(func, args):
func_repr = _format_callback(func, args, None)
source = _get_function_source(func)
if source:
func_repr += f' at {source[0]}:{source[1]}'
return func_repr
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(f'{k}={reprlib.repr(v)}' for k, v in kwargs.items())
return '({})'.format(', '.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__') and func.__qualname__:
func_repr = func.__qualname__
elif hasattr(func, '__name__') and func.__name__:
func_repr = func.__name__
else:
func_repr = repr(func)
func_repr += _format_args_and_kwargs(args, kwargs)
if suffix:
func_repr += suffix
return func_repr
def extract_stack(f=None, limit=None):
"""Replacement for traceback.extract_stack() that only does the
necessary work for asyncio debug mode.
"""
if f is None:
f = sys._getframe().f_back
if limit is None:
# Limit the amount of work to a reasonable amount, as extract_stack()
# can be called for each coroutine and future in debug mode.
limit = constants.DEBUG_STACK_DEPTH
stack = traceback.StackSummary.extract(traceback.walk_stack(f),
limit=limit,
lookup_lines=False)
stack.reverse()
return stack
PK [z/%:
runners.pynu �[��� __all__ = 'run',
from . import coroutines
from . import events
from . import tasks
def run(main, *, debug=None):
"""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())
"""
if events._get_running_loop() is not None:
raise RuntimeError(
"asyncio.run() cannot be called from a running event loop")
if not coroutines.iscoroutine(main):
raise ValueError("a coroutine was expected, got {!r}".format(main))
loop = events.new_event_loop()
try:
events.set_event_loop(loop)
if debug is not None:
loop.set_debug(debug)
return loop.run_until_complete(main)
finally:
try:
_cancel_all_tasks(loop)
loop.run_until_complete(loop.shutdown_asyncgens())
finally:
events.set_event_loop(None)
loop.close()
def _cancel_all_tasks(loop):
to_cancel = tasks.all_tasks(loop)
if not to_cancel:
return
for task in to_cancel:
task.cancel()
loop.run_until_complete(
tasks.gather(*to_cancel, loop=loop, return_exceptions=True))
for task in to_cancel:
if task.cancelled():
continue
if task.exception() is not None:
loop.call_exception_handler({
'message': 'unhandled exception during asyncio.run() shutdown',
'exception': task.exception(),
'task': task,
})
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 [ ��M%! %! ' __pycache__/trsock.cpython-38.opt-1.pycnu �[��� U
e5d� � @ s" d dl Z d dlZG dd� d�ZdS )� Nc @ s� e Zd ZdZdZejd�dd�Zdd� 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"d<d=� Z#d>d?� 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 )]�TransportSocketz�A 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 �&/usr/lib64/python3.8/asyncio/trsock.py�__init__ s zTransportSocket.__init__c C s t jd|� d�t| 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)�warnings�warn�DeprecationWarning)r Zwhatr r r �_na s
�zTransportSocket._nac C s | j jS r )r �family�r 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| j�d| j�d| j� �}| � � dkr�z | �� }|rN|� d|� �}W n tjk
rf Y nX z | �� }|r�|� d|� �}W n tjk
r� Y nX |� d�S ) Nz <asyncio.TransportSocket fd=z , family=z, type=z, proto=���z, laddr=z, raddr=�>)�filenor r r � getsockname�socket�error� getpeername)r �sZladdrZraddrr r r �__repr__& s $� zTransportSocket.__repr__c C s t d��d 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 �
getsockopt�r �args�kwargsr 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 d��d S )Nr z<settimeout(): only 0 timeout is allowed on transport sockets��
ValueError)r �valuer r r �
settimeout� s
�zTransportSocket.settimeoutc C s dS )Nr r r r r r �
gettimeout� s zTransportSocket.gettimeoutc C s |sd S t d��d S )Nz3setblocking(): transport sockets cannot be blockingr? )r �flagr r r � setblocking� s
�zTransportSocket.setblockingc C s | � d� | j�� S �Nzcontext manager protocol)r r � __enter__r r r r rG � s
zTransportSocket.__enter__c G s | � d� | jj|� S rF )r r �__exit__)r �errr r r rH � s
zTransportSocket.__exit__N)3�__name__�
__module__� __qualname__�__doc__� __slots__r r
r �propertyr r r r r r r r r! r" r& r r r' r( r) r* r+ r, r- r. r/ r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r: r; r< r= r> rB rC rE rG rH r r r r r sb
r )r r r r r r r �<module> s PK [ߋ�ѢP �P " __pycache__/streams.cpython-38.pycnu �[��� U
e5d h � @ s& d Z ddlZddlZddlZddlZeed�r6e d7 Z ddlmZ ddlmZ ddlm Z dd lm
Z
dd
lm Z dd l m
Z
dd lmZ d
Zd ded�dd�Zd ded�dd�Zeed�r�d!ded�dd�Zd"ded�dd�ZG dd� de j�ZG dd� dee j�ZG dd � d �ZG d d � d �ZdS )#)� StreamReader� StreamWriter�StreamReaderProtocol�open_connection� start_server� NZAF_UNIX)�open_unix_connection�start_unix_server� )�
coroutines)�events)�
exceptions)�format_helpers)� protocols)�logger)�sleepi )�loop�limitc � 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.� ��
stacklevel�r r �r c s � S �N� r ��protocolr �'/usr/lib64/python3.8/asyncio/streams.py�<lambda>5 � z!open_connection.<locals>.<lambda>) r �get_event_loop�warnings�warn�DeprecationWarningr r Zcreate_connectionr ) �host�portr r �kwds�reader� 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.<locals>.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.<locals>.<lambda>) 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.<locals>.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 ZdZddd�Zdd� 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
t�d| _ | j�� r&t�d| � d S )NTz%r pauses writing)r5 �AssertionErrorr4 � get_debugr �debug�r8 r r r �
pause_writing� s
z FlowControlMixin.pause_writingc C sP | j s
t�d| _ | j�� r&t�d| � | j}|d k rLd | _|�� sL|�d � d S )NFz%r resumes writing) r5 r: r4 r; r r< r6 �done�
set_result�r8 �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_exception�r8 �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 )�NotImplementedError�r8 �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 �weakref�ref�_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|�|� |�d�d k | _ | j
d k r�t || || j�| _ | �
|| j �}t
�|�r�| j�|� d | _d S )N�messagezpAn open stream was garbage collected prior to establishing network connection; call "stream.close()" explicitly.Zsource_tracebackZ
sslcontext)r[ rY r4 Zcall_exception_handler�abortr] rc �
set_transport�get_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| j�d � 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� Zddd�Zdd� 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|t�s"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| j��g}| jd k r0|�d| j��� d�d�|��S )N�
transport=zreader=�<{}>� )rb rQ r] rw �append�format�join�r8 �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] �write�r8 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 �name�defaultr r r rg i s zStreamWriter.get_extra_infoc � sL | j dk r | j �� }|dk r |�| j�� r8td�I 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 ZdZedfdd�Zdd� 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
�t�d��| _d S )Nr zLimit cannot be <= 0Fr )�
ValueError�_limitr r r4 � bytearray�_buffer�_eof�_waiter�
_exceptionr] r5 r; r
�
extract_stack�sys� _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 bytes�eofzlimit=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| j�d| 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<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 dataz_wait_for_data after EOFF) r� � RuntimeErrorr� r: r5 r] r� r4 rK )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�||j�r�| 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 �IncompleteReadError�partial�LimitOverrunErrorr� �
startswith�consumed�clearr� r� �args)r8 �sep�seplen�line�er r r �readline s
zStreamReader.readliner� c � s� t |�}|dkrtd��| jdk r(| j�d}t | j�}|| |kr|| j�||�}|dkrZq�|d | }|| jkr|t�d|��| jr�t | j�}| j�
� t� |d��| � d�I dH q,|| jkr�t�d|��| 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 stringN���r 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� �offsetZbuflenZisep�chunkr r r r� ( s>
�
�zStreamReader.readuntilr� c � s� | j dk r| j �|dkr dS |dk rVg }| �| j�I dH }|s@qL|�|� q(d�|�S | jsr| jsr| �d�I 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 �nZblocks�blockrm 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�||��| � d�I dH q,t| j�|kr�t| 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 �<module> sF
� ! � '
� � DkPPK [[k�A A & __pycache__/tasks.cpython-38.opt-2.pycnu �[��� U
e5d�� � @ sr d Z ddlZddlZddlZddlZddlZddlZddlZddl Z ddl
m Z ddl
m Z ddl
m
Z
ddl
mZ ddl
mZ dd l mZ e�d�jZdAd
d �ZdBd d
�ZdCdd�Zdd� ZG dd� dej�ZeZz ddlZW n e k
r� Y n X ej ZZ dd�dd�Z ejj Z ejj Z ejj!Z!dde!d�dd�Z"dd� Z#dd �d d �Z$d d � Z%d!d"� Z&ddd#�d$d%�Z'ej(d&d'� �Z)dDdd �d(d)�Z*dd �d*d+�Z+ej(d,d-� �Z,ee,_G d.d/� d/ej-�Z.dd0d1�d2d3�Z/dd �d4d5�Z0d6d7� Z1e �2� Z3i Z4d8d9� Z5d:d;� Z6d<d=� Z7d>d?� Z8e5Z9e8Z:e6Z;e7Z<z$dd@lm5Z5m8Z8m6Z6m7Z7m3Z3m4Z4 W n e k
�r\ Y nX e5Z=e8Z>e6Z?e7Z@dS )E)�Task� create_task�FIRST_COMPLETED�FIRST_EXCEPTION�
ALL_COMPLETED�wait�wait_for� as_completed�sleep�gather�shield�
ensure_future�run_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 | d krt �� } t�| �S �N)r �get_running_loop�_current_tasks�get��loop� r" �%/usr/lib64/python3.8/asyncio/tasks.pyr " s r c s^ � d krt �� � d}z tt�}W qL tk
rF |d7 }|dkrB� Y qX qLq� fdd�|D �S )Nr r �� c s& h | ] }t �|�� kr|�� s|�qS r" )r � _get_loop�done��.0�tr r" r# � <setcomp>< s �z all_tasks.<locals>.<setcomp>)r r �list�
_all_tasks� RuntimeError�r! �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.<locals>.<setcomp>)r �get_event_loopr+ r, r- r. r" r r# �_all_tasks_compat@ s r1 c C s4 |d k r0z
| j }W n tk
r& Y n
X ||� d S r )�set_name�AttributeError)�task�namer2 r" r" r# �_set_task_nameX s
r6 c s� e Zd ZdZed$dd��Zed%dd��Zddd�� fdd �
Z� fd
d �Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd�dd�Zddd�d d �Zd d � Zd&� fd d!� Zd"d#� Z� ZS )'r TNc C s( t jdtdd� |d kr t�� }t|�S )NzVTask.current_task() is deprecated since Python 3.7, use asyncio.current_task() instead� ��
stacklevel)�warnings�warn�DeprecationWarningr r0 r ��clsr! r" r" r# r t s �zTask.current_taskc C s t jdtdd� t|�S )NzPTask.all_tasks() is deprecated since Python 3.7, use asyncio.all_tasks() insteadr7 r8 )r: r; r< r1 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�_name�str� _must_cancel� _fut_waiter�_coro� contextvarsZ copy_context�_context�_loop� call_soon� _Task__stepr )�self�coror! 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 r )r Z_task_repr_info�rS r" r" r# �
_repr_info� s zTask._repr_infoc C s | j S r )rM rY r" r" r# �get_coro� s z
Task.get_coroc C s | j S r )rI rY r" r" r# �get_name� s z
Task.get_namec C s t |�| _d S r )rJ rI )rS �valuer" r" r# r2 � s z
Task.set_namec C s t d��d S )Nz*Task does not support set_result operation�r- )rS �resultr" r" r# �
set_result� s zTask.set_resultc C s t d��d S )Nz-Task does not support set_exception operationr^ )rS � exceptionr" r" r# �
set_exception� s zTask.set_exception)�limitc C s t �| |�S r )r Z_task_get_stack)rS rc r" r" r# � get_stack� s zTask.get_stack)rc �filec C s t �| ||�S r )r Z_task_print_stack)rS rc re r" r" r# � print_stack� s zTask.print_stackc C s4 d| _ | �� rdS | jd k r*| j�� r*dS d| _dS �NFT)Z_log_tracebackr& rL �cancelrK rY r" r" r# rh � s
z Task.cancelc
s� | � � r t�d| �d|����| jr>t|tj�s8t�� }d| _| j}d | _t| j | � �zfz"|d krp|� d �}n
|� |�}W n� t
k
r� } z*| jr�d| _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 �r�td| �d|�d��}| j j| j|| j d� n�|�r|| k�r�td | ���}| j j| j|| j d� n8d|_ |j | j | j d� || _| j�r>| j�� �r>d| _n*td
| �d |���}| j j| j|| j d� n||d k�r`| j j| j| j d� n\t �!|��r�td | �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 �
isinstance�CancelledErrorrM rL r rP r �send�throw�
StopIterationrB rh r` r] �KeyboardInterrupt�
SystemExitrb �
BaseException�getattrr r% r- rQ rR rO ri �add_done_callback�
_Task__wakeup�inspectZ isgenerator)rS �excrT r_ Zblocking�new_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 r )r_ rq rR )rS �futurerv r" r" r# Z__wakeup[ s z
Task.__wakeup)N)N)N)�__name__�
__module__� __qualname__rF � classmethodr r rC rX rZ r[ r\ r2 r` rb rd rf rh rR rt �
__classcell__r" r" rU r# r b s$ !Tr )r5 c C s t �� }|�| �}t||� |S r )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|� ���� d krbt � � � nt
jdtdd� � fdd�t| �D �} t| ||� �I d H S ) Nz expect a list of futures, not z#Set of coroutines/Futures is empty.zInvalid return_when value: �[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.<locals>.<setcomp>)r �isfuturer rE rG �typery �
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 r )r& r` )�waiter�argsr" r" r# �_release_waiter� s r� r c
� s� |d krt �� }ntjdtdd� |d kr4| I d H S |dkr�t| |d�} | �� rX| �� S t| |d�I d H z | �� W n. t j
k
r� } zt � � |�W 5 d }~X Y n
X t � � �|� � }|�
|t|�}t�t|�}t| |d�} | �|� z�z|I d H W nP t j
k
�rF | �� �r$| �� Y W �dS | �|� t| |d�I d H � Y nX | �� �r^| �� W �*S | �|� t| |d�I d H t � � �W 5 |�� X d S )Nr� r7 r8 r r )r r r: r; r< r r& r_ �_cancel_and_waitr rk � TimeoutError�
create_future�
call_laterr� � functools�partialrs rh �remove_done_callback)�futr~ r! rv r� �timeout_handle�cbr" r" r# r � sL
�
r c
� s� |� � �d �|d k r"|�|t���t| �� � ���fdd�}| D ]}|�|� q@z�I d H W 5 �d k rp��� | D ]}|�|� qtX t� t� }}| D ]"}|�� r�|� |� q�|� |� q�||fS )Nc sZ � d8 � � dks4�t ks4�tkrV| �� sV| �� d k rV�d k rD��� ��� sV��d � d S )Nr r )r r � cancelledra rh r& r` �r� �Zcounterr r� r� r" r# �_on_completion s ���
�z _wait.<locals>._on_completion)
r� r� r� �lenrs rh r� r� r& �add)r� r~ r r! r� r� r& Zpendingr" r� r# r� � s( r� c � sF |� � }t�t|�}| �|� z| �� |I d H W 5 | �|� X d S r )r� r� r� r� rs r� rh )r� r! r� r� r" r" r# r� & s
r� )r! r~ c # s� t �| �st�| �r(tdt| �j� ���ddlm} |�d���d krPt �
� �nt j dt
dd� �fdd �t| �D ��d �� ��fd
d �}���fd d
�� �fdd�}�D ]}|�� � q��r�|d k r҈�||��tt���D ] }|� V q�d S )Nz#expect an iterable of futures, not r )�Queuer r� r7 r8 c s h | ]}t |� d ��qS r� r� r� r r" r# r* U s z as_completed.<locals>.<setcomp>c s* �D ]} | � � � ��d � q��� d S r )r� �
put_nowait�clearr� )r� r& �todor" r# � _on_timeoutX s
z!as_completed.<locals>._on_timeoutc s4 �sd S �� | � � �| � �s0�d k r0��� d S r )�remover� rh r� )r& r� r� r" r# r� ^ s
z$as_completed.<locals>._on_completionc � s$ � � � I d H } | d kr tj�| �� S r )r r r� r_ r� )r& r" r# �
_wait_for_onef s z#as_completed.<locals>._wait_for_one)r r� r rE rG r� ry Zqueuesr� r r0 r: r; r< r� rs r� �ranger� )r� r! r~ r� r� r� r� �_r" )r� r& r! r� r� r# r 7 s*
� r c c s
d V d S r r" r" r" r" r# �__sleep0u s r� c � sr | dkrt � I d H |S |d kr*t�� }ntjdtdd� |�� }|�| tj ||�}z|I d H W �S |�
� X d S )Nr r� r7 r8 ) r� r r r: r; r< r� r� r Z _set_result_unless_cancelledrh )Zdelayr_ r! rx �hr" r" r# r � s$
� �r c C s� t �| �r6|d krt�� }|�| �}|jr2|jd= |S t�| �rb|d k r^|t�| �k r^t d��| S t
� | �r|t t
| �|d�S td��d S )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 r0 r rD r r� r% r� ru Z isawaitabler �_wrap_awaitablerG )Zcoro_or_futurer! r4 r" r" r# r � s
r c c s | � � E d H S r )� __await__)Z awaitabler" r" r# r� � s r� c s* e Zd Zdd�� fdd�
Zdd� Z� ZS )�_GatheringFutureNr 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 rg )r& r� rh r� )rS ZretZchildr" r" r# rh � s
z_GatheringFuture.cancel)ry rz r{ rC rh r} r" r" rU r# r� � s r� F)r! �return_exceptionsc s� |s<| d krt �� } ntjdtdd� | �� ���g � �S � ����fdd�}i }g � d�d�|D ]f}||kr�t|| d�}| d kr�t� |�} ||k r�d|_
�d 7 �|||< |� |� n|| }� � |� qdt
� | d���S )
Nr� r7 r8 c s� �d7 ��� � r$| �� s | �� d S �sd| �� rFt�� }��|� d S | �� }|d k rd��|� d S ��kr�g }� D ]8} | �� r�t�� }n| �� }|d kr�| �� }|�|� qt�jrĈ�t�� � n
�� |� d S )Nr )
r& r� ra r rk rb r_ �appendr� r` )r� rv Zresults�res�r� Z nfinishedZnfuts�outerr� r" r# �_done_callback s4
z gather.<locals>._done_callbackr r Fr )r r0 r: r; r< r� r` r r r% rF rs r� r� )r! r� Zcoros_or_futuresr� Z
arg_to_fut�argr� r" r� r# r
� s:
�
1
r
c st |d k rt jdtdd� t| |d����� r0�S t���}|�� ��fdd�� � �fdd�}��� � ��|� �S ) Nr� r7 r8 r c s\ � � � r | � � s| �� d S | � � r.� �� n*| �� }|d k rJ� �|� n� �| �� � d S r )r� ra rh rb r` r_ )�innerrv �r� r" r# �_inner_done_callbacku s
z$shield.<locals>._inner_done_callbackc s �� � s��� � d S r )r& r� r� )r� r� r" r# �_outer_done_callback� s z$shield.<locals>._outer_done_callback) r: r; r< r r& r r% r� rs )r� r! r� r" )r� r� r� r# r P s �
r c s: t �� �std��tj�� �� ��fdd�}��|� �S )Nz 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 rp ro rq Z set_running_or_notify_cancelrb )rv �rT rx r! r" r# �callback� s
z*run_coroutine_threadsafe.<locals>.callback)r rE rG �
concurrentr �FutureZcall_soon_threadsafe)rT r! r� r" r� r# r
� s
r
c C s t �| � d S r )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|�d���t | = d S )Nz
Leaving task z! does not match the current task �.r� r� r" r" r# r � s
r c C s t �| � d S r )r, �discardr� r" r" r# r � s r )r r r r r, r )N)N)N)N)A�__all__Zconcurrent.futuresr� rN r� ru � itertools�typesr: �weakref� r r r r r r �count�__next__rH r r r1 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# �<module> s�
#H,>
x?$PK [�\@��/ �/ + __pycache__/transports.cpython-38.opt-1.pycnu �[��� U
e5d�( � @ s| d Z dZG dd� d�ZG dd� de�ZG dd� de�ZG dd � d ee�ZG d
d � d e�ZG d d
� d
e�ZG dd� de�ZdS )zAbstract Transport class.)�
BaseTransport�
ReadTransport�WriteTransport� Transport�DatagramTransport�SubprocessTransportc @ sH e Zd ZdZdZddd�Zddd�Zdd � Zd
d � Zd d
� Z dd� Z
dS )r zBase class for transports.��_extraNc C s |d kr i }|| _ d S �Nr )�self�extra� r �*/usr/lib64/python3.8/asyncio/transports.py�__init__ s zBaseTransport.__init__c C s | j �||�S )z#Get optional transport information.)r �get)r
�name�defaultr r r
�get_extra_info s z BaseTransport.get_extra_infoc C s t �dS )z2Return True if the transport is closing or closed.N��NotImplementedError�r
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 )z�Pause 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 )z�Resume 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 ZdZdZddd�Zdd� 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
�high�lowr 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 )z�Write 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 )z�Write 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 )z�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.
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 �z�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.
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 ZdZdZddd�Zdd� 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 )z�Get 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 )z�Send 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 )z�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
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 ddd�Z
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 | js�d| _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() failed��messageZ exceptionZ transportr )
r' r= r< � _protocolZ
pause_writing�
SystemExit�KeyboardInterrupt�
BaseExceptionr; �call_exception_handler)r
�size�excr 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
�<module> s %F6PK [�x��* * / __pycache__/format_helpers.cpython-38.opt-2.pycnu �[��� U
e5dd � @ sd d dl Z d dlZd dlZd dlZd dlZddlmZ dd� Zdd� Zdd � Z dd d �Z
dd
d�Z dS )� N� )� constantsc C sV t �| �} t �| �r&| j}|j|jfS t| tj�r<t | j
�S t| tj �rRt | j
�S d S �N) �inspectZunwrapZ
isfunction�__code__� co_filename�co_firstlineno�
isinstance� functools�partial�_get_function_source�func�
partialmethod)r
�code� r �./usr/lib64/python3.8/asyncio/format_helpers.pyr
s
r c C s8 t | |d �}t| �}|r4|d|d � d|d � �7 }|S )Nz at r �:r )�_format_callbackr )r
�args� func_repr�sourcer r r �_format_callback_source s
r c C sH g }| r |� dd� | D �� |r8|� dd� |�� D �� d�d�|��S )Nc s s | ]}t �|�V qd S r ��reprlib�repr)�.0�argr r r � <genexpr>& s z*_format_args_and_kwargs.<locals>.<genexpr>c s s& | ] \}}|� d t �|�� �V qdS )�=Nr )r �k�vr r r r ( s z({})z, )�extend�items�format�join)r �kwargsr" r r r �_format_args_and_kwargs s r& � c C s� t | tj�r.t||�| }t| j| j| j|�S t| d�rF| j rF| j }n t| d�r^| j
r^| j
}nt | �}|t||�7 }|r�||7 }|S )N� __qualname__�__name__) r r
r r& r r
r �keywords�hasattrr( 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� _getframe�f_backr ZDEBUG_STACK_DEPTH� traceback� StackSummary�extract�
walk_stack�reverse)�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 �<module> s
PK [�ar�$ �$ * __pycache__/base_subprocess.cpython-38.pycnu �[��� U
e5d�" � @ sx d dl Z d dlZd dlZddlmZ ddlmZ ddlmZ G dd� dej�Z G dd � d ej
�Z G d
d � d e ej �Z
dS ) � N� )� protocols)�
transports)�loggerc s� e Zd Zd0� fdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z e
j fdd�Z dd� Z
dd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Z� Z S )1�BaseSubprocessTransportNc
s& t � �|
� d| _|| _|| _d | _d | _d | _g | _t �
� | _ i | _ d| _
|tjkr`d | j d< |tjkrtd | j d< |tjkr�d | j d< z"| jf ||||||d�| �� W n | �� � Y nX | jj| _| j| jd< | j�� �rt|ttf�r�|} n|d } t�d| | j� | j�| �| �� d S )NFr r � )�args�shell�stdin�stdout�stderr�bufsize�
subprocesszprocess %r created: pid %s) �super�__init__�_closed� _protocol�_loop�_proc�_pid� _returncode�
_exit_waiters� collections�deque�_pending_calls�_pipes� _finishedr �PIPE�_start�close�pidZ_extra� get_debug�
isinstance�bytes�strr �debugZ create_task�_connect_pipes)
�self�loop�protocolr r r
r r r
�waiterZextra�kwargsZprogram�� __class__� �//usr/lib64/python3.8/asyncio/base_subprocess.pyr sL
��
�z BaseSubprocessTransport.__init__c C s | j jg}| jr|�d� | jd k r6|�d| j� �� | jd k rT|�d| j� �� n | jd k rj|�d� n
|�d� | j�d�}|d k r�|�d|j� �� | j�d�}| j�d �}|d k r�||kr�|�d
|j� �� n6|d k r�|�d |j� �� |d k �r |�d |j� �� d
� d�
|��S )N�closedzpid=z returncode=Zrunningz not startedr zstdin=r r zstdout=stderr=zstdout=zstderr=z<{}>� ) r- �__name__r �appendr r r �get�pipe�format�join)r' �infor
r r r. r. r/ �__repr__7 s,
z BaseSubprocessTransport.__repr__c K s t �d S �N)�NotImplementedError)r' r r r
r r r
r+ r. r. r/ r T s z BaseSubprocessTransport._startc C s
|| _ d S r: �r )r' r) r. r. r/ � set_protocolW s z$BaseSubprocessTransport.set_protocolc C s | j S r: r< �r' r. r. r/ � get_protocolZ s z$BaseSubprocessTransport.get_protocolc C s | j S r: )r r> r. r. r/ �
is_closing] s z"BaseSubprocessTransport.is_closingc C s� | j r
d S d| _ | j�� D ]}|d kr(q|j�� q| jd k r�| jd kr�| j�� d kr�| j� � rlt
� d| � z| j� � W n t
k
r� Y nX d S )NTz$Close running child process: kill %r)r r �valuesr5 r r r Zpollr r! r Zwarning�kill�ProcessLookupError)r' �protor. r. r/ r ` s$
� �
z BaseSubprocessTransport.closec C s& | j s"|d| ��t| d� | �� d S )Nzunclosed transport )�source)r �ResourceWarningr )r' Z_warnr. r. r/ �__del__{ s z BaseSubprocessTransport.__del__c C s | j S r: )r r> r. r. r/ �get_pid� s z BaseSubprocessTransport.get_pidc C s | j S r: )r r> r. r. r/ �get_returncode� s z&BaseSubprocessTransport.get_returncodec C s || j kr| j | jS d S d S r: )r r5 )r' �fdr. r. r/ �get_pipe_transport� s
z*BaseSubprocessTransport.get_pipe_transportc C s | j d krt� �d S r: )r rC r> r. r. r/ � _check_proc� s
z#BaseSubprocessTransport._check_procc C s | � � | j�|� d S r: )rL r � send_signal)r' �signalr. r. r/ rM � s z#BaseSubprocessTransport.send_signalc C s | � � | j�� d S r: )rL r � terminater> r. r. r/ rO � s z!BaseSubprocessTransport.terminatec C s | � � | j�� d S r: )rL r rB r> r. r. r/ rB � s z BaseSubprocessTransport.killc
� sp z� j }� j}|jd k rB|�� fdd�|j�I d H \}}|� jd< |jd k rv|�� fdd�|j�I d H \}}|� jd< |jd k r�|�� fdd�|j�I d H \}}|� jd< � jd k s�t �|�
� j j � � � jD ]\}}|j
|f|�� q�d � _W n\ t
tfk
�r � Y n` tk
�rL } z"|d k �r<|�� �s<|�|� W 5 d }~X Y n X |d k �rl|�� �sl|�d � d S )Nc s
t � d�S )Nr )�WriteSubprocessPipeProtor. r> r. r/ �<lambda>� � z8BaseSubprocessTransport._connect_pipes.<locals>.<lambda>r c s
t � d�S )Nr ��ReadSubprocessPipeProtor. r> r. r/ rQ � rR r c s
t � d�S )Nr rS r. r> r. r/ rQ � rR r )r r r
Zconnect_write_piper r Zconnect_read_piper r �AssertionError� call_soonr �connection_made�
SystemExit�KeyboardInterrupt�
BaseException� cancelledZ
set_exception�
set_result) r' r* �procr( �_r5 �callback�data�excr. r> r/ r& � sB
�
�
�
z&BaseSubprocessTransport._connect_pipesc G s2 | j d k r | j �||f� n| jj|f|�� d S r: )r r3 r rV )r' �cbr` r. r. r/ �_call� s
z BaseSubprocessTransport._callc C s | � | jj||� | �� d S r: )rc r Zpipe_connection_lost� _try_finish)r' rJ ra r. r. r/ �_pipe_connection_lost� s z-BaseSubprocessTransport._pipe_connection_lostc C s | � | jj||� d S r: )rc r Zpipe_data_received)r' rJ r` r. r. r/ �_pipe_data_received� s z+BaseSubprocessTransport._pipe_data_receivedc C s� |d k st |��| jd ks$t | j��| j�� r<t�d| |� || _| jjd krV|| j_| �| j j
� | � � | j D ]}|�
� sr|�|� qrd | _ d S )Nz %r exited with return code %r)rU r r r! r r8 r �
returncoderc r Zprocess_exitedrd r r[ r\ )r' rg r* r. r. r/ �_process_exited� s
z'BaseSubprocessTransport._process_exitedc � s0 | j dk r| j S | j�� }| j�|� |I dH S )zdWait until the process exit and return the process return code.
This method is a coroutine.N)r r Z
create_futurer r3 )r' r* r. r. r/ �_wait� s
z BaseSubprocessTransport._waitc C sH | j r
t�| jd krd S tdd� | j�� D ��rDd| _ | �| jd � d S )Nc s s | ]}|d k o|j V qd S r: )� disconnected)�.0�pr. r. r/ � <genexpr>� s �z6BaseSubprocessTransport._try_finish.<locals>.<genexpr>T)r rU r �allr rA rc �_call_connection_lostr> r. r. r/ rd � s
�z#BaseSubprocessTransport._try_finishc C s* z| j�|� W 5 d | _ d | _d | _X d S r: )r r r �connection_lost�r' ra r. r. r/ ro � s
z-BaseSubprocessTransport._call_connection_lost)NN) r2 �
__module__� __qualname__r r9 r r= r? r@ r �warnings�warnrG rH rI rK rL rM rO rB r& rc re rf rh ri rd ro �
__classcell__r. r. r, r/ r
s2 �+ & r c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
S )rP c C s || _ || _d | _d| _d S )NF)r] rJ r5 rj )r' r] rJ r. r. r/ r s z!WriteSubprocessPipeProto.__init__c C s
|| _ d S r: )r5 )r' Z transportr. r. r/ rW s z(WriteSubprocessPipeProto.connection_madec C s d| j j� d| j� d| j�d�S )N�<z fd=z pipe=�>)r- r2 rJ r5 r> r. r. r/ r9
s z!WriteSubprocessPipeProto.__repr__c C s d| _ | j�| j|� d | _d S )NT)rj r] re rJ rq r. r. r/ rp
s z(WriteSubprocessPipeProto.connection_lostc C s | j j�� d S r: )r] r �
pause_writingr> r. r. r/ ry s z&WriteSubprocessPipeProto.pause_writingc C s | j j�� d S r: )r] r �resume_writingr> r. r. r/ rz s z'WriteSubprocessPipeProto.resume_writingN) r2 rr rs r rW r9 rp ry rz r. r. r. r/ rP � s rP c @ s e Zd Zdd� ZdS )rT c C s | j �| j|� d S r: )r] rf rJ )r' r` r. r. r/ �
data_received s z%ReadSubprocessPipeProto.data_receivedN)r2 rr rs r{ r. r. r. r/ rT s rT )r r rt � r r �logr ZSubprocessTransportr Z BaseProtocolrP ZProtocolrT r. r. r. r/ �<module> s v �PK [���/$ $ 0 __pycache__/base_subprocess.cpython-38.opt-2.pycnu �[��� U
e5d�" � @ sx d dl Z d dlZd dlZddlmZ ddlmZ ddlmZ G dd� dej�Z G dd � d ej
�Z G d
d � d e ej �Z
dS ) � N� )� protocols)�
transports)�loggerc s� e Zd Zd0� fdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z e
j fdd�Z dd� Z
dd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Z� Z S )1�BaseSubprocessTransportNc
s& t � �|
� d| _|| _|| _d | _d | _d | _g | _t �
� | _ i | _ d| _
|tjkr`d | j d< |tjkrtd | j d< |tjkr�d | j d< z"| jf ||||||d�| �� W n | �� � Y nX | jj| _| j| jd< | j�� �rt|ttf�r�|} n|d } t�d| | j� | j�| �| �� d S )NFr r � )�args�shell�stdin�stdout�stderr�bufsize�
subprocesszprocess %r created: pid %s) �super�__init__�_closed� _protocol�_loop�_proc�_pid� _returncode�
_exit_waiters� collections�deque�_pending_calls�_pipes� _finishedr �PIPE�_start�close�pidZ_extra� get_debug�
isinstance�bytes�strr �debugZ create_task�_connect_pipes)
�self�loop�protocolr r r
r r r
�waiterZextra�kwargsZprogram�� __class__� �//usr/lib64/python3.8/asyncio/base_subprocess.pyr sL
��
�z BaseSubprocessTransport.__init__c C s | j jg}| jr|�d� | jd k r6|�d| j� �� | jd k rT|�d| j� �� n | jd k rj|�d� n
|�d� | j�d�}|d k r�|�d|j� �� | j�d�}| j�d �}|d k r�||kr�|�d
|j� �� n6|d k r�|�d |j� �� |d k �r |�d |j� �� d
� d�
|��S )N�closedzpid=z returncode=Zrunningz not startedr zstdin=r r zstdout=stderr=zstdout=zstderr=z<{}>� ) r- �__name__r �appendr r r �get�pipe�format�join)r' �infor
r r r. r. r/ �__repr__7 s,
z BaseSubprocessTransport.__repr__c K s t �d S �N)�NotImplementedError)r' r r r
r r r
r+ r. r. r/ r T s z BaseSubprocessTransport._startc C s
|| _ d S r: �r )r' r) r. r. r/ � set_protocolW s z$BaseSubprocessTransport.set_protocolc C s | j S r: r< �r' r. r. r/ � get_protocolZ s z$BaseSubprocessTransport.get_protocolc C s | j S r: )r r> r. r. r/ �
is_closing] s z"BaseSubprocessTransport.is_closingc C s� | j r
d S d| _ | j�� D ]}|d kr(q|j�� q| jd k r�| jd kr�| j�� d kr�| j� � rlt
� d| � z| j� � W n t
k
r� Y nX d S )NTz$Close running child process: kill %r)r r �valuesr5 r r r Zpollr r! r Zwarning�kill�ProcessLookupError)r' �protor. r. r/ r ` s$
� �
z BaseSubprocessTransport.closec C s& | j s"|d| ��t| d� | �� d S )Nzunclosed transport )�source)r �ResourceWarningr )r' Z_warnr. r. r/ �__del__{ s z BaseSubprocessTransport.__del__c C s | j S r: )r r> r. r. r/ �get_pid� s z BaseSubprocessTransport.get_pidc C s | j S r: )r r> r. r. r/ �get_returncode� s z&BaseSubprocessTransport.get_returncodec C s || j kr| j | jS d S d S r: )r r5 )r' �fdr. r. r/ �get_pipe_transport� s
z*BaseSubprocessTransport.get_pipe_transportc C s | j d krt� �d S r: )r rC r> r. r. r/ � _check_proc� s
z#BaseSubprocessTransport._check_procc C s | � � | j�|� d S r: )rL r � send_signal)r' �signalr. r. r/ rM � s z#BaseSubprocessTransport.send_signalc C s | � � | j�� d S r: )rL r � terminater> r. r. r/ rO � s z!BaseSubprocessTransport.terminatec C s | � � | j�� d S r: )rL r rB r> r. r. r/ rB � s z BaseSubprocessTransport.killc
� s` z� j }� j}|jd k rB|�� fdd�|j�I d H \}}|� jd< |jd k rv|�� fdd�|j�I d H \}}|� jd< |jd k r�|�� fdd�|j�I d H \}}|� jd< |�� j j
� � � j D ]\}}|j|f|�� q�d � _ W nZ t t
fk
r� � Y n` tk
�r< } z"|d k �r,|�� �s,|�|� W 5 d }~X Y n X |d k �r\|�� �s\|�d � d S )Nc s
t � d�S )Nr )�WriteSubprocessPipeProtor. r> r. r/ �<lambda>� � z8BaseSubprocessTransport._connect_pipes.<locals>.<lambda>r c s
t � d�S )Nr ��ReadSubprocessPipeProtor. r> r. r/ rQ � rR r c s
t � d�S )Nr rS r. r> r. r/ rQ � rR r )r r r
Zconnect_write_piper r Zconnect_read_piper � call_soonr �connection_mader �
SystemExit�KeyboardInterrupt�
BaseException� cancelledZ
set_exception�
set_result) r' r* �procr( �_r5 �callback�data�excr. r> r/ r& � s@
�
�
�
z&BaseSubprocessTransport._connect_pipesc G s2 | j d k r | j �||f� n| jj|f|�� d S r: )r r3 r rU )r' �cbr_ r. r. r/ �_call� s
z BaseSubprocessTransport._callc C s | � | jj||� | �� d S r: )rb r Zpipe_connection_lost� _try_finish)r' rJ r` r. r. r/ �_pipe_connection_lost� s z-BaseSubprocessTransport._pipe_connection_lostc C s | � | jj||� d S r: )rb r Zpipe_data_received)r' rJ r_ r. r. r/ �_pipe_data_received� s z+BaseSubprocessTransport._pipe_data_receivedc C sp | j �� rt�d| |� || _| jjd kr2|| j_| �| jj � | �
� | j D ]}|� � sN|�
|� qNd | _ d S )Nz %r exited with return code %r)r r! r r8 r r �
returncoderb r Zprocess_exitedrc r rZ r[ )r' rf r* r. r. r/ �_process_exited� s
z'BaseSubprocessTransport._process_exitedc � s0 | j d k r| j S | j�� }| j�|� |I d H S r: )r r Z
create_futurer r3 )r' r* r. r. r/ �_wait� s
z BaseSubprocessTransport._waitc C s> | j d krd S tdd� | j�� D ��r:d| _| �| jd � d S )Nc s s | ]}|d k o|j V qd S r: )� disconnected)�.0�pr. r. r/ � <genexpr>� s �z6BaseSubprocessTransport._try_finish.<locals>.<genexpr>T)r �allr rA r rb �_call_connection_lostr> r. r. r/ rc � s
�z#BaseSubprocessTransport._try_finishc C s* z| j�|� W 5 d | _ d | _d | _X d S r: )r r r �connection_lost�r' r` r. r. r/ rn � s
z-BaseSubprocessTransport._call_connection_lost)NN) r2 �
__module__� __qualname__r r9 r r= r? r@ r �warnings�warnrG rH rI rK rL rM rO rB r& rb rd re rg rh rc rn �
__classcell__r. r. r, r/ r
s2 �+ & r c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
S )rP c C s || _ || _d | _d| _d S )NF)r\ rJ r5 ri )r' r\ rJ r. r. r/ r s z!WriteSubprocessPipeProto.__init__c C s
|| _ d S r: )r5 )r' Z transportr. r. r/ rV s z(WriteSubprocessPipeProto.connection_madec C s d| j j� d| j� d| j�d�S )N�<z fd=z pipe=�>)r- r2 rJ r5 r> r. r. r/ r9
s z!WriteSubprocessPipeProto.__repr__c C s d| _ | j�| j|� d | _d S )NT)ri r\ rd rJ rp r. r. r/ ro
s z(WriteSubprocessPipeProto.connection_lostc C s | j j�� d S r: )r\ r �
pause_writingr> r. r. r/ rx s z&WriteSubprocessPipeProto.pause_writingc C s | j j�� d S r: )r\ r �resume_writingr> r. r. r/ ry s z'WriteSubprocessPipeProto.resume_writingN) r2 rq rr r rV r9 ro rx ry r. r. r. r/ rP � s rP c @ s e Zd Zdd� ZdS )rT c C s | j �| j|� d S r: )r\ re rJ )r' r_ r. r. r/ �
data_received s z%ReadSubprocessPipeProto.data_receivedN)r2 rq rr rz r. r. r. r/ rT s rT )r r rs � r r �logr ZSubprocessTransportr Z BaseProtocolrP ZProtocolrT r. r. r. r/ �<module> s v �PK [�H ��m �m ! __pycache__/events.cpython-38.pycnu �[��� U
e5d4f � @ s| d Z dZddlZddlZddlZddlZddlZddlZddlm Z ddlm
Z
G dd� d�Z G d d
� d
e �Z G d d � d �Z
G d
d� d�ZG dd� d�ZG dd� de�Zdae�� ZG dd� dej�Ze� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z d!d"� Z d#d$� Z d%d&� Z d'd(� Z d)d*� Z!eZ"eZ#eZ$e Z%z dd+l&mZmZmZm Z W n e'k
�rf Y nX eZ(eZ)eZ*e Z+dS ),z!Event loop and event loop policy.)�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�_get_running_loop� N� )�format_helpers)�
exceptionsc @ sF e Zd ZdZdZddd�Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
dS )r z1Object returned by callback registration methods.)� _callback�_args�
_cancelled�_loop�_source_traceback�_repr� __weakref__�_contextNc C s\ |d krt �� }|| _|| _|| _|| _d| _d | _| j�� rRt �
t � d��| _
nd | _
d S )NFr )� contextvarsZ copy_contextr r r r r r � get_debugr �
extract_stack�sys� _getframer )�self�callback�args�loop�context� r& �&/usr/lib64/python3.8/asyncio/events.py�__init__ s
�zHandle.__init__c C sl | j jg}| jr|�d� | jd k r:|�t�| j| j�� | jrh| jd }|�d|d � d|d � �� |S )N� cancelled���z created at r �:r ) � __class__�__name__r �appendr r �_format_callback_sourcer r )r! �info�framer& r& r' �
_repr_info/ s
�
zHandle._repr_infoc C s( | j d k r| j S | �� }d�d�|��S )Nz<{}>� )r r2 �format�join)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 exception�handleZsource_traceback) r �runr r �
SystemExit�KeyboardInterrupt�
BaseExceptionr r/ r r �call_exception_handler)r! �exc�cb�msgr% 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� fdd�Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
� fdd�Zdd� Z� ZS ) r z7Object returned by timed callback registration methods.�
_scheduled�_whenNc s< |d k s t �t� �||||� | jr,| jd= || _d| _d S )Nr* F)�AssertionError�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=)rN r2 r �insertrL )r! r0 �posrP r& r' r2 p s
zTimerHandle._repr_infoc C s
t | j�S 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__rW r& r& r' �__le__| s zTimerHandle.__le__c C s | j |j kS r; rV rW r& r& r' �__gt__� s zTimerHandle.__gt__c C s | j |j krdS | �|�S r7 rZ rW r& r& r' �__ge__� s zTimerHandle.__ge__c C s> t |t�r:| j|jko8| j|jko8| j|jko8| j|jkS tS r; )�
isinstancer rL r r r �NotImplementedrW r& r& r' r[ � s
�
�
�zTimerHandle.__eq__c C s | � |�}|tkrtS | S r; )r[ r` )r! rX Zequalr& r& r' �__ne__� s
zTimerHandle.__ne__c s | j s| j�| � t� �� d S r; )r r �_timer_handle_cancelledrN r: r9 rP r& r' r: � s zTimerHandle.cancelc C s | j S )z�Return a scheduled callback time.
The time is an absolute timestamp, using the same time
reference as loop.time().
rV r9 r& r& r' rO � s zTimerHandle.when)N)r- rG rH rI rJ r( r2 rU rY r\ r] r^ r[ ra r: rO �
__classcell__r& r& rP 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.N��NotImplementedErrorr9 r& r& r' �close� s zAbstractServer.closec C s t �dS )z4Get the event loop the Server object is attached to.Nrd r9 r& r& r' �get_loop� s zAbstractServer.get_loopc C s t �dS )z3Return True if the server is accepting connections.Nrd r9 r& r& r' �
is_serving� s zAbstractServer.is_servingc � s t �dS )z�Start accepting connections.
This method is idempotent, so it can be called when
the server is already being serving.
Nrd r9 r& r& r' �
start_serving� s z AbstractServer.start_servingc � s t �dS )z�Start accepting connections until the coroutine is cancelled.
The server is closed when the coroutine is cancelled.
Nrd r9 r& r& r' �
serve_forever� s z AbstractServer.serve_foreverc � s t �dS )z*Coroutine to wait until service is closed.Nrd 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; )rf rk )r! rC r& r& r' � __aexit__� s zAbstractServer.__aexit__N) r- rG rH rI rf rg rh ri rj rk rl rm 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� d2d3�Zdxd0d4�d5d6�Z d7d d d8�d9d:�Z dyd d d d d;�d<d=�Z dzd d/d d d0d>�d?d@�Z d{d&d&d&d d d d dA�dBdC�Z dDdE� Z!dFdG� Z"e#j$e#j$e#j$dH�dIdJ�Z%e#j$e#j$e#j$dH�dKdL�Z&dMdN� Z'dOdP� Z(dQdR� Z)dSdT� Z*dUdV� Z+dWdX� Z,dYdZ� Z-d[d\� Z.d]d^� Z/d|d d4�d_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.Nrd 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.
Nrd )r! Zfuturer& r& r' �run_until_complete� s z$AbstractEventLoop.run_until_completec C s t �dS )z�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.
Nrd r9 r& r& r' �stop� s zAbstractEventLoop.stopc C s t �dS )z3Return whether the event loop is currently running.Nrd r9 r& r& r' �
is_running� s z AbstractEventLoop.is_runningc C s t �dS )z*Returns True if the event loop was closed.Nrd r9 r& r& r' � is_closed� s zAbstractEventLoop.is_closedc C s t �dS )z�Close the loop.
The loop should not be running.
This is idempotent and irreversible.
No other methods should be called after this one.
Nrd r9 r& r& r' rf � s zAbstractEventLoop.closec � s t �dS )z,Shutdown all active asynchronous generators.Nrd r9 r& r& r' �shutdown_asyncgens� s z$AbstractEventLoop.shutdown_asyncgensc C s t �dS )z3Notification that a TimerHandle has been cancelled.Nrd )r! r= r& r& r' rb � s z)AbstractEventLoop._timer_handle_cancelledc G s | j d|f|�� S )Nr )�
call_later�r! r" r# r& r& r' � call_soon s zAbstractEventLoop.call_soonc G s t �d S r; rd )r! Zdelayr" r# r& r& r' rt s z AbstractEventLoop.call_laterc G s t �d S r; rd )r! rO r" r# r& r& r' �call_at s zAbstractEventLoop.call_atc C s t �d S r; rd r9 r& r& r' �time s zAbstractEventLoop.timec C s t �d S r; rd r9 r& r& r' �
create_future s z AbstractEventLoop.create_futureN)�namec C s t �d S r; rd )r! �cororz r& r& r' � create_task s z AbstractEventLoop.create_taskc G s t �d S r; rd ru r& r& r' �call_soon_threadsafe s z&AbstractEventLoop.call_soon_threadsafec G s t �d S r; rd )r! �executor�funcr# r& r& r' �run_in_executor s z!AbstractEventLoop.run_in_executorc C s t �d S r; rd )r! r~ r& r& r' �set_default_executor s z&AbstractEventLoop.set_default_executorr )�family�type�proto�flagsc � s t �d S r; rd )r! �host�portr� r� r� r� r& r& r' � getaddrinfo# s z AbstractEventLoop.getaddrinfoc � s t �d S r; rd )r! Zsockaddrr� r& r& r' � getnameinfo' s z AbstractEventLoop.getnameinfo)
�sslr� r� r� �sock�
local_addr�server_hostname�ssl_handshake_timeout�happy_eyeballs_delay�
interleavec
� s t �d S r; rd )r! �protocol_factoryr� r� r� r� r� r� r� r� r� r� r� r� r& r& r' �create_connection* s z#AbstractEventLoop.create_connection�d T) r� r� r� �backlogr� �
reuse_address�
reuse_portr� ri 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.
Nrd )
r! r� r� r� r� r� r� r� r� r� r� r� ri 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.
Nrd )r! � transport�file�offset�countr� 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.
Nrd )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; rd )r! r� �pathr� r� r� r� r& r& r' �create_unix_connection{ s z(AbstractEventLoop.create_unix_connection)r� r� r� r� ri 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.
Nrd )r! r� r� r� r� r� r� ri 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.
Nrd ) 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.Nrd �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.Nrd r� r& r& r' �connect_write_pipe� s z$AbstractEventLoop.connect_write_pipe)�stdin�stdout�stderrc � s t �d S r; rd )r! r� �cmdr� r� r� �kwargsr& r& r' �subprocess_shell� s z"AbstractEventLoop.subprocess_shellc � s t �d S r; rd )r! r� r� r� r� r# r� r& r& r' �subprocess_exec� s z!AbstractEventLoop.subprocess_execc G s t �d S r; rd �r! �fdr" r# r& r& r' �
add_reader� s z AbstractEventLoop.add_readerc C s t �d S r; rd �r! r� r& r& r' �
remove_reader� s z AbstractEventLoop.remove_readerc G s t �d S r; rd r� r& r& r' �
add_writer� s z AbstractEventLoop.add_writerc C s t �d S r; rd r� r& r& r' �
remove_writer� s z AbstractEventLoop.remove_writerc � s t �d S r; rd )r! r� �nbytesr& r& r' � sock_recv s zAbstractEventLoop.sock_recvc � s t �d S r; rd )r! r� Zbufr& r& r' �sock_recv_into s z AbstractEventLoop.sock_recv_intoc � s t �d S r; rd )r! r� �datar& r& r' � sock_sendall s z AbstractEventLoop.sock_sendallc � s t �d S r; rd )r! r� Zaddressr& r& r' � sock_connect s z AbstractEventLoop.sock_connectc � s t �d S r; rd )r! r� r& r& r' � sock_accept s z AbstractEventLoop.sock_acceptc � s t �d S r; rd )r! r� r� r� r� r� r& r& r' �
sock_sendfile s z AbstractEventLoop.sock_sendfilec G s t �d S r; rd )r! �sigr" r# r& r& r' �add_signal_handler s z$AbstractEventLoop.add_signal_handlerc C s t �d S r; rd )r! r� r& r& r' �remove_signal_handler s z'AbstractEventLoop.remove_signal_handlerc C s t �d S r; rd )r! �factoryr& r& r' �set_task_factory s z"AbstractEventLoop.set_task_factoryc C s t �d S r; rd r9 r& r& r' �get_task_factory" s z"AbstractEventLoop.get_task_factoryc C s t �d S r; rd r9 r& r& r' �get_exception_handler' s z'AbstractEventLoop.get_exception_handlerc C s t �d S r; rd )r! Zhandlerr& r& r' �set_exception_handler* s z'AbstractEventLoop.set_exception_handlerc C s t �d S r; rd �r! r% r& r& r' �default_exception_handler- s z+AbstractEventLoop.default_exception_handlerc C s t �d S r; rd r� r& r& r' rB 0 s z(AbstractEventLoop.call_exception_handlerc C s t �d S r; rd r9 r& r& r' r 5 s zAbstractEventLoop.get_debugc C s t �d S r; rd )r! Zenabledr& r& r' � set_debug8 s zAbstractEventLoop.set_debug)r )NN)NN)r N)N)N)NN)r N);r- rG rH rI rn ro rp rq rr rf rs rb rv rt rw rx ry r| r} r� r� r� r� r� �socketZ AF_UNSPECZ
AI_PASSIVEr� r� r� r� r� r� r� r� �
subprocess�PIPEr� 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.Nrd 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.Nrd �r! r$ r& r& r' r I s z&AbstractEventLoopPolicy.set_event_loopc C s t �dS )z�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.Nrd r9 r& r& r' r
M s z&AbstractEventLoopPolicy.new_event_loopc C s t �dS )z$Get the watcher for child processes.Nrd r9 r& r& r' r U s z)AbstractEventLoopPolicy.get_child_watcherc C s t �dS )z$Set the watcher for child processes.Nrd )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� dej�Zdd� 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�� tj�r2| �| �� � | 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
� RuntimeErrorrz r9 r& r& r' r t s �� �z)BaseDefaultEventLoopPolicy.get_event_loopc C s* d| j _|dks t|t�s t�|| j _dS )zSet the event loop.TN)r� r� r_ r rM 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 )z�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.
N)�
_running_loopr� �os�getpid)Z running_loop�pidr& r& r' r � s
r c C s | t �� ft_dS )z�Set 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 | dkst | t�st�| adS )zZSet the current event loop policy.
If policy is None, the default policy is restored.N)r_ r rM 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' �<module> sX J@* q"9
PK [�h�� � ( __pycache__/runners.cpython-38.opt-1.pycnu �[��� U
e5d � @ sB d Z ddlmZ ddlmZ ddlmZ dd�dd�Zd d
� ZdS ) )�run� )�
coroutines)�events)�tasksN)�debugc C s� t �� dk rtd��t�| �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�
ValueError�formatZnew_event_loopZset_event_loop�close�_cancel_all_tasks�run_until_completeZshutdown_asyncgensZ set_debug)�mainr �loop� r �'/usr/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� exception�task)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 �<module> s
.PK [i�.CH H ' __pycache__/queues.cpython-38.opt-2.pycnu �[��� U
e5d � @ s� d Z ddlZddlZddlZddlmZ ddlmZ G dd� de�ZG dd � d e�Z 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 �&/usr/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(dd�dd�Zdd� 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 N��loopc 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�_loop�warnings�warn�DeprecationWarning�_maxsize� collections�deque�_getters�_putters�_unfinished_tasksr ZEvent� _finished�set�_init)�self�maxsizer r r r �__init__! s �
zQueue.__init__c C s t �� | _d S �N)r r �_queue�r! r" r r r r 6 s z Queue._initc C s
| j �� S r$ )r% �popleft�r! r r r �_get9 s z
Queue._getc C s | j �|� d S r$ �r% �append�r! �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| �d�d| �� � d�S )N�<z at z#x� �>)�typer �id�_formatr( r r r �__repr__I s zQueue.__repr__c C s dt | �j� d| �� � d�S )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| j���7 }| jrH|dt| j�� d�7 }| jrd|dt| j�� d�7 }| jrz|d| j� �7 }|S )Nzmaxsize=r% z _queue=z
_getters[�]z
_putters[z tasks=)r �getattr�listr% r �lenr r )r! �resultr r r r6 O s z
Queue._formatc C s
t | j�S 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+ �cancel�remove�
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� Zejfdd�Zejfdd�ZdS )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 �<module> s KPK [6�8+� � ) __pycache__/__init__.cpython-38.opt-2.pycnu �[��� U
e5d� � @ 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 jdkr�ddlT eej7 ZnddlT eej7 ZdS )� N� )�*)�_all_tasks_compatZwin32)�sysZ base_eventsZ
coroutinesZevents�
exceptionsZfuturesZlocksZ protocolsZrunnersZqueuesZstreams�
subprocessZtasksZ
transportsr �__all__�platformZwindows_eventsZ unix_events� r
r
�(/usr/lib64/python3.8/asyncio/__init__.py�<module> sX �������� �
� � �
PK [wI<ws s + __pycache__/exceptions.cpython-38.opt-2.pycnu �[��� U
e5da � @ sh d Z G dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG d d
� d
e�Z G d d � d e�Z
d
S ))�CancelledError�InvalidStateError� TimeoutError�IncompleteReadError�LimitOverrunError�SendfileNotAvailableErrorc @ s e Zd ZdS )r N��__name__�
__module__� __qualname__� r r �*/usr/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� fdd�Zdd� 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)�repr�super�__init__�len�partial�expected)�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� fdd�Zdd� 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 �<module> s PK [ ? ��O �O ( __pycache__/streams.cpython-38.opt-1.pycnu �[��� U
e5d h � @ s& d Z ddlZddlZddlZddlZeed�r6e d7 Z ddlmZ ddlmZ ddlm Z dd lm
Z
dd
lm Z dd l m
Z
dd lmZ d
Zd ded�dd�Zd ded�dd�Zeed�r�d!ded�dd�Zd"ded�dd�ZG dd� de j�ZG dd� dee j�ZG dd � d �ZG d d � d �ZdS )#)� StreamReader� StreamWriter�StreamReaderProtocol�open_connection� start_server� NZAF_UNIX)�open_unix_connection�start_unix_server� )�
coroutines)�events)�
exceptions)�format_helpers)� protocols)�logger)�sleepi )�loop�limitc � 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.� ��
stacklevel�r r �r c s � S �N� r ��protocolr �'/usr/lib64/python3.8/asyncio/streams.py�<lambda>5 � z!open_connection.<locals>.<lambda>) r �get_event_loop�warnings�warn�DeprecationWarningr r Zcreate_connectionr ) �host�portr r �kwds�reader� 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.<locals>.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.<locals>.<lambda>) 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.<locals>.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 ZdZddd�Zdd� 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 t�d| � d S )NTz%r pauses writing)r5 r4 � get_debugr �debug�r8 r r r �
pause_writing� s
z FlowControlMixin.pause_writingc C sF d| _ | j�� r t�d| � | j}|d k rBd | _|�� sB|�d � d S )NFz%r resumes writing)r5 r4 r: r r; r6 �done�
set_result�r8 �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_exception�r8 �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 )�NotImplementedError�r8 �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 �weakref�ref�_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|�|� |�d�d k | _ | j
d k r�t || || j�| _ | �
|| j �}t
�|�r�| j�|� d | _d S )N�messagezpAn open stream was garbage collected prior to establishing network connection; call "stream.close()" explicitly.Zsource_tracebackZ
sslcontext)rY rW r4 Zcall_exception_handler�abortr[ ra �
set_transport�get_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| j�d � 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� Zddd�Zdd� 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�� | _| j�d � 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| j��g}| jd k r0|�d| j��� d�d�|��S )N�
transport=zreader=�<{}>� )r` rO r[ ru �append�format�join�r8 �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[ �write�r8 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 �name�defaultr r r re i s zStreamWriter.get_extra_infoc � sL | j dk r | j �� }|dk r |�| j�� r8td�I 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 ZdZedfdd�Zdd� 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
�t�d��| _d S )Nr zLimit cannot be <= 0Fr )�
ValueError�_limitr r r4 � bytearray�_buffer�_eof�_waiter�
_exceptionr[ r5 r: r
�
extract_stack�sys� _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 bytes�eofzlimit=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�||j�r�| 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 �IncompleteReadError�partial�LimitOverrunErrorr� �
startswith�consumed�clearr� r� �args)r8 �sep�seplen�line�er r r �readline s
zStreamReader.readliner� c � s� t |�}|dkrtd��| jdk r(| j�d}t | j�}|| |kr|| j�||�}|dkrZq�|d | }|| jkr|t�d|��| jr�t | j�}| j�
� t� |d��| � d�I dH q,|| jkr�t�d|��| 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 stringN���r 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� �offsetZbuflenZisep�chunkr r r r� ( s>
�
�zStreamReader.readuntilr� c � s� | j dk r| j �|dkr dS |dk rVg }| �| j�I dH }|s@qL|�|� q(d�|�S | jsr| jsr| �d�I 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 �nZblocks�blockrk 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�||��| � d�I dH q,t| j�|kr�t| 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 �<module> sF
� ! � '
� � DkPPK [���1N� N� & __pycache__/base_events.cpython-38.pycnu �[��� U
e5d� � @ 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 d�Z&dZ'e(� Z)dd� Z*dd� Z+dd� Z,d+dd �Z-d,d d �Z.d d � Z/e%e d!��r�d"d#� Z0nd$d#� Z0G d%d&� d&ej1�Z2G d'd(� d(ej3�Z4G d)d*� d*ej5�Z6dS )-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)�
BaseEventLoop�d g �?�AF_INET6i�Q c C s0 | j }tt|dd �tj�r$t|j�S t| �S d S )N�__self__)Z _callback�
isinstance�getattrr �Task�reprr �str)�handle�cb� r �+/usr/lib64/python3.8/asyncio/base_events.py�_format_handleJ s
r c C s( | t jkrdS | t jkr dS t| �S d S )Nz<pipe>z<stdout>)�
subprocess�PIPE�STDOUTr )�fdr r r � _format_pipeS s
r! c C sL t td�std��n4z| �tjtjd� W n tk
rF td��Y 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.)�hasattr�socket�
ValueError�
setsockopt�
SOL_SOCKETr" �OSError��sockr r r �_set_reuseport\ s
r+ c C s� t td�sd S |dtjtjhks(| d kr,d S |tjkr>tj}n|tjkrPtj}nd S |d krbd}nXt|t�rz|dkrzd}n@t|t�r�|dkr�d}n(z t |�}W n t
t fk
r� Y d S X |tj kr�tj
g}tr�|�tj� n|g}t| t�r�| �d�} d| k�rd S |D ]t}zVt�|| � t�rJ|tjk�rJ|||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_UNSPEC�AF_INET� _HAS_IPv6�appendr �decoder, r( ) �host�port�family�type�protoZflowinfoZscopeidZafs�afr 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� tj�tj |� �D �� |S )z-Interleave list of addrinfo tuples by family.r r Nc s s | ]}|d k r|V qd S �Nr )�.0�ar r r � <genexpr>� s �z(_interleave_addrinfos.<locals>.<genexpr>)
� collections� OrderedDictr9 �list�values�extend� itertools�chain�
from_iterable� zip_longest)Z addrinfosZfirst_address_family_countZaddrinfos_by_family�addrr= Zaddrinfos_listsZ reorderedr r r �_interleave_addrinfos� s"
��rP c C s4 | � � s"| �� }t|ttf�r"d S t�| ��� d S rB )� cancelled� exceptionr �
SystemExit�KeyboardInterruptr Z _get_loop�stop)�fut�excr 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 |tj�std��|| _|�� | _|�� | _|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)�self�transpr 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_closing�ConnectionErrorre )rf rV r r r �drain� s
z _SendfileFallbackProtocol.drainc C s t d��d 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 d��d S �Nz'Invalid state: reading should be pausedrl )rf �datar r r �
data_received� s z'_SendfileFallbackProtocol.data_receivedc C s t d��d 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 �loop�sockets�protocol_factoryZ ssl_context�backlog�ssl_handshake_timeoutr r r rh s zServer.__init__c C s d| j j� d| j�d�S )N�<z sockets=�>)� __class__r| r� rq r r r �__repr__ s zServer.__repr__c C s | j d k st�| jd7 _d S rZ )r� �AssertionErrorr� rq r r r �_attach# s zServer._attachc C s< | j dkst�| j d8 _ | j dkr8| jd kr8| �� d S )Nr r )r� r� r� �_wakeuprq r r r �_detach' s zServer._detachc C s, | j }d | _ |D ]}|�� s|�|� qd S rB )r� �doners )rf �waiters�waiterr 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.<locals>.<genexpr>)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| jd�I 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� Zdd�d d
�Zd d � Zd
d� Zd�ddd�dd�Z d�ddddddd�dd�Z
d�dd�Z d�dd�Z d�dd �Z
d�d d �Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Zd5d6� Zej fd7d8�Z d9d:� Z d;d<� Z dd=�d>d?�Z dd=�d@dA�Z!dd=�dBdC�Z"dDdE� Z#dFdG� Z$dHdI� Z%dd=�dJdK�Z&dLdM� Z'dNdO� Z(dPdQ� Z)dRdRdRdRdS�dTdU�Z*d�dVdW�Z+d�ddX�dYdZ�Z,d[d\� Z-d]d^� Z.d_d`� Z/d�dadb�Z0d�ddRdRdRdddddddc�
ddde�Z1d�dfdg�Z2d�ddX�dhdi�Z3djdk� Z4dldm� Z5ddddn�dodp�Z6d�dRdRdRe7ddddq�drds�Z8dRe9j:dRdRdS�dtdu�Z;dvdw� Z<d�e9j=e9j>ddxddddddy� dzd{�Z?ddd|�d}d~�Z@dd�� ZAd�d�� ZBd�d�� ZCeDjEeDjEeDjEdddRdddd�� d�d��ZFeDjEeDjEeDjEdddRdddd�� d�d��ZGd�d�� ZHd�d�� ZId�d�� ZJd�d�� ZKd�d�� ZLd�d�� ZMd�d�� ZNd�d�� ZOd�d�� ZPd�d�� ZQd�d�� ZRdS )�r c C s� d| _ d| _d| _t�� | _g | _d | _d| _d | _ t
� d�j | _
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_id�time�get_clock_infoZ
resolution�_clock_resolution�_exception_handler� set_debugr Z_is_debug_mode�slow_callback_duration�_current_handle�
_task_factory�"_coroutine_origin_tracking_enabled�&_coroutine_origin_tracking_saved_depth�weakrefZWeakSet�
_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| d�S )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<Return a task factory, or None if the default one is in use.)r� rq r r r �get_task_factory� s z BaseEventLoop.get_task_factory)�extra�serverc C s t �dS )zCreate socket transport.N��NotImplementedError)rf r* �protocolr� r� r� r r r �_make_socket_transport� s z$BaseEventLoop._make_socket_transportFT)� server_side�server_hostnamer� r� r� �call_connection_madec C s t �dS )zCreate SSL transport.Nr� ) rf Zrawsockr� �
sslcontextr� r� r� r� r� r� r� r r r �_make_ssl_transport� s z!BaseEventLoop._make_ssl_transportc C s t �dS )zCreate datagram transport.Nr� )rf r* r� �addressr� r� r r r �_make_datagram_transport� s z&BaseEventLoop._make_datagram_transportc C s t �dS )zCreate read pipe transport.Nr� �rf �piper� r� r� r r r �_make_read_pipe_transport� s z'BaseEventLoop._make_read_pipe_transportc C s t �dS )z Create write pipe transport.Nr� r� r r r �_make_write_pipe_transport� s z(BaseEventLoop._make_write_pipe_transportc
� s t �dS )z Create subprocess transport.Nr� )
rf r� �args�shell�stdin�stdout�stderr�bufsizer� �kwargsr r r �_make_subprocess_transport� s z(BaseEventLoop._make_subprocess_transportc C s t �dS )z�Write a byte to self-pipe, to wake up the event loop.
This may be called from a different thread.
The subclass is responsible for implementing the self-pipe.
Nr� rq r r r �_write_to_self� s z BaseEventLoop._write_to_selfc C s t �dS )zProcess selector events.Nr� )rf �
event_listr r r �_process_events� s z BaseEventLoop._process_eventsc C s | j rtd��d 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� �aclose�rf �agenr r r �_asyncgen_finalizer_hook� s z&BaseEventLoop._asyncgen_finalizer_hookc C s. | j r tjd|�d�t| d� | j�|� d S )Nzasynchronous generator z3 was scheduled after loop.shutdown_asyncgens() call��source)r� �warnings�warn�ResourceWarningr� �addr� r r r �_asyncgen_firstiter_hook s
�z&BaseEventLoop._asyncgen_firstiter_hookc � s� d| _ t| j�sdS t| j�}| j�� tjdd� |D �d| d��I dH }t||�D ]*\}}t|t �rT| �
d|��||d�� qTdS )z,Shutdown all active asynchronous generators.TNc S s g | ] }|� � �qS r )r� )rC Zagr r r �
<listcomp> s z4BaseEventLoop.shutdown_asyncgens.<locals>.<listcomp>)Zreturn_exceptionsr� z;an error occurred during closing of asynchronous generator )�messagerR Zasyncgen) r� �lenr� rH �clearr �gather�zipr � Exception�call_exception_handler)rf Z
closing_agensZresults�resultr� r r r �shutdown_asyncgens s"
�
�z BaseEventLoop.shutdown_asyncgensc C s( | � � rtd��t�� d k r$td��d 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� �sys�get_asyncgen_hooks�set_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<z | �
� W n* |rp|� � rp|� � sp|�
� � Y nX W 5 |� t� X |� � s�td��|�� S )a\ Run until the Future is done.
If the argument is a coroutine, it is wrapped in a Task.
WARNING: It would be disastrous to call run_until_complete()
with the same coroutine twice -- it would wrap it in two
different Tasks and that can't be good.
Return the Future's result, or raise its exception.
r� Fz+Event loop stopped before Future completed.)r� r� r Zisfuturer Z
ensure_futureZ_log_destroy_pendingZadd_done_callbackrX Zremove_done_callbackr r� rQ rR rm r� )rf ZfutureZnew_taskr r r �run_until_completeD s"
z BaseEventLoop.run_until_completec C s
d| _ dS )z�Stop running the event loop.
Every callback already scheduled will still run. This simply informs
run_forever to stop looping after a complete iteration.
TN)r� rq r r r rU j s zBaseEventLoop.stopc C sj | � � rtd��| jrdS | jr,t�d| � d| _| j�� | j�� | j }|dk rfd| _ |j
dd� dS )z�Close the event loop.
This clears the queues and shuts down the executor,
but does not wait for the executor to finish.
The event loop must not be running.
z!Cannot close a running event loopNzClose %rTF)�wait) r� rm r� r� r �debugr� r� r� r� Zshutdown�rf �executorr r r r� r s
zBaseEventLoop.closec C s | j S )z*Returns True if the event loop was closed.)r� rq r r r r� � s zBaseEventLoop.is_closedc C s0 | � � s,|d| ��t| d� | �� s,| �� d S )Nzunclosed event loop r� )r� r� r� r� )rf Z_warnr r r �__del__� s zBaseEventLoop.__del__c C s
| j dk S )z*Returns True if the event loop is running.N)r� rq r r r r� � s zBaseEventLoop.is_runningc C s t �� S )z�Return the time according to the event loop's clock.
This is a float expressed in seconds since an epoch, but the
epoch, precision, accuracy and drift are unspecified and may
differ per event loop.
)r� r� rq r r r r� � s zBaseEventLoop.time)�contextc G s2 | j | �� | |f|�d|i�}|jr.|jd= |S )a8 Arrange for a callback to be called at a given time.
Return a Handle: an opaque object with a cancel() method that
can be used to cancel the call.
The delay can be an int or float, expressed in seconds. It is
always relative to the current time.
Each callback will be called exactly once. If two callbacks
are scheduled for exactly the same time, it undefined which
will be called first.
Any positional arguments after the callback will be passed to
the callback when it is called.
r
r� )�call_atr� r� )rf Zdelay�callbackr
r� �timerr r r �
call_later� s �zBaseEventLoop.call_laterc G sZ | � � | jr"| �� | �|d� t�|||| |�}|jrB|jd= t�| j |� d|_ |S )z|Like call_later(), but uses an absolute time.
Absolute time corresponds to the event loop's time() method.
r r� T)
r� r� �
_check_thread�_check_callbackr � TimerHandler� �heapq�heappushr� )rf �whenr r
r� r r r r r � s zBaseEventLoop.call_atc G sB | � � | jr"| �� | �|d� | �|||�}|jr>|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|� d���t|�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 �Handler� r� r9 )rf r r� r
r r r r r � s
zBaseEventLoop._call_soonc C s, | j dkrdS t�� }|| j kr(td��dS )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|�� | d�S )N�run_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 |tjj�s t�dtd� || _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�|�}t�d|� | �� }t�||||||�} | �� | }
d|� d |
d
d �d | ��}|
| jkr�t�|� 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? �flags�msg�t0�addrinfo�dtr 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 r0 < 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* �file�offset�countr1 rW r r r �
sock_sendfile@ s � �zBaseEventLoop.sock_sendfilec � s t �d|�d���d S )Nz-syscall sendfile is not available for socket z and file {file!r} combination�r r4 �rf r* r6 r7 r8 r r r r3 N s
�z#BaseEventLoop._sock_sendfile_nativec
� s� |r|� |� |r t|tj�ntj}t|�}d}zt|rNt|| |�}|dkrNq�t|�d |� }| �d |j|�I d H } | szq�| � ||d | � �I d H || 7 }q2|W �S |dkr�t|d�r�|� || � X d S )Nr �seek)
r< �minr Z!SENDFILE_FALLBACK_READBUFFER_SIZE� bytearrayr# �
memoryviewr �readintoZ sock_sendall)
rf r* r6 r7 r8 � blocksize�buf�
total_sent�view�readr r r r5 U s,
��
z%BaseEventLoop._sock_sendfile_fallbackc C s� dt |dd�krtd��|jtjks,td��|d k rbt|t�sLtd�|���|dkrbtd�|���t|t�sztd�|���|dk r�td�|���d S )N�b�modez$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 �formatr; r r r r2 o s2
��
����z$BaseEventLoop._check_sendfile_paramsc � s@ g }|� |� |\}}}}} d}
z�tj|||d�}
|
�d� |dk r�|D ]r\}}}}} z|
�| � W q�W 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.N�r= r> r? Fz*error while attempting to bind on address �: ) r9 r$ � setblocking�bindr( �strerror�lower�errno�pop� 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 d���j||f|tj||�d�I dH }|s�td��| dk r܈j| |tj||�d�I dH ��s�td��nd�|
r�t||
�}g � | dk�rH|D ]D}z ��� |��I dH }W �qvW n tk
�r@ Y �q Y nX �q n.tj� ��fd d
�|D �| �d �I dH \}}}|dk�r d d
� � D �� t � �dk�r�� d �nJt
� d ��t �fdd
�� D ���r҈ d �td� d�
dd
� � D �����n.|dk�rt d��|jtjk�r t d|�����j||||
| d�I dH \}}�j�rd|�d�}t�d|||||� ||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 host�1ssl_handshake_timeout is only meaningful with sslr �8host/port and sock can not be specified at the same time�r= r> r? r) r� �!getaddrinfo() returned empty listc 3 s | ]}t ��j� |��V qd S rB )� functools�partialrS )rC r, )r � laddr_infosrf r r rE � s � �z2BaseEventLoop.create_connection.<locals>.<genexpr>r� c S s g | ]}|D ]}|�q qS r r )rC �subrW r r r r� � s z3BaseEventLoop.create_connection.<locals>.<listcomp>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` ra 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 rS r
Zstaggered_racer� r �allrH r& r> � _create_connection_transportr� �get_extra_infor r )rf r� r; r< rT r= r? r) r* rU r� r� rV rW �infosr, rR rn r� r )r r^ rb rf r �create_connection� s� �� � �
�
� �
�
�� �
�z BaseEventLoop.create_connectionc � s� |� d� |� }| �� }|rHt|t�r*d n|} | j||| ||||d�}
n| �|||�}
z|I d H W n |
�� � Y nX |
|fS )NF�r� r� r� )rK rd r �boolr� r� r� ) rf r* r� rT r� r� r� r� r� r� rn r r r rf % s*
�z*BaseEventLoop._create_connection_transportc
� s� |� � rtd��t|dtjj�}|tjjkr:td|����|tjjkr�z| �||||�I dH W S tj k
r� } z
|sx� W 5 d}~X Y nX |s�td|����| �
||||�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 r4 �_sendfile_fallback)rf rn r6 r7 r8 r1 rG rW r r r �sendfile? s4 � � � � �zBaseEventLoop.sendfilec � s t �d��d S )Nz!sendfile syscall is not supportedr: )rf rg r6 r7 r8 r r r rl n s �z BaseEventLoop._sendfile_nativec
� s� |r|� |� |r t|d�nd}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 |dkr�t|d�r�|� || � |�� I d H X d S )Ni @ r r< ) r< r= r> r\ r# r{ r? r r@ rk �write) rf rg r6 r7 r8 rA rB rC r? rD rE r r r rm r s*
z BaseEventLoop._sendfile_fallbackrj c
� s� t dkrtd��t|t j�s*td|����t|dd�sFtd|�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� )rT 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_port�allow_broadcastr* c � s |
dk r�|
j tjkr"td|
����� s>�s>|s>|s>|s>|s>| r~t� �|||||| d�} d�dd� | �� D ��} td| � d���|
�d � d}
�n� s��s�|d
kr�td ��||fd ff}�n�ttd
��r�|tj k�r�� �fD ] }|dk r�t
|t �s�t d��qڈ �rx� d
dk�rxz"t
�t�
� �j��r.t�� � W nF tk
�rF Y n2 tk
�rv } zt�d� |� W 5 d}~X Y nX ||f� �fff}n�i }d
� fd�ffD ]�\}}|dk �r�t
|t��r�t|�dk�s�td��| j||tj||| d�I dH }|�s td��|D ]:\}}}}}||f}||k�r0ddg||< ||| |< �q�q�� �fdd�|�� D �}|�sjtd��g }|tk �r�|�r�td��ntj dt dd� |D ]�\\}}\}}d}
d}
zxtj|tj|d �}
|�r�t |
� | �r�|
� tj tj!d� |
�d � � �r|
�"|� ��r*| �s&| �#|
|�I dH |}
W n^ tk
�rl } z |
dk �rR|
�$� |�%| � W 5 d} ~ X Y n& |
dk �r�|
�$� � Y nX �q��q�|d
�|� } | �&� } | �'|
| |
| �} | j(�r� �r�t�)d � �| | � nt�*d �| | � z| I dH W n | �$� � Y nX | | fS ) zCreate datagram connection.Nz A UDP Socket was expected, got )rU � remote_addrr= r? r) rr rs rt r% c s s$ | ] \}}|r|� d |� �V qdS )�=Nr )rC �k�vr r r rE � s z9BaseEventLoop.create_datagram_endpoint.<locals>.<genexpr>zKsocket modifier keyword arguments can not be used when sock is specified. (�)Fr zunexpected address family)NN�AF_UNIXzstring is expected)r � z2Unable to check or remove stale UNIX socket %r: %rr r! z2-tuple is expectedrZ r[ c s8 g | ]0\}}� r |d dks�r,|d dks||f�qS )r Nr r )rC �keyZ addr_pair�rU ru r r r� � s �z:BaseEventLoop.create_datagram_endpoint.<locals>.<listcomp>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.)�
stacklevelrI 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& �itemsrK r# rz r r r5 �stat�S_ISSOCK�os�st_mode�remove�FileNotFoundErrorr( r �errorr� r� r� rd �_unsetr� r� r" r+ r& r' Z SO_BROADCASTrL rQ r� r9 rd r� r� r( r ) rf r� rU ru r= r? r) rr rs rt r* ZoptsZproblemsZr_addrZaddr_pairs_inforO �errZ
addr_infos�idxrh ZfamrR Zpror� r| 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||||||d�I d H S d S )Nr! r/ )rA r' )
rf r� r= r> r? r) r� r; r< r( r r r rd L s �z BaseEventLoop._ensure_resolvedc � s8 | j ||f|tj|| d�I d H }|s4td|�d���|S )N)r= r> r) r� z getaddrinfo(z) returned empty list)rd r$ r1 r( )rf r; r< r= r) rh r r r �_create_server_getaddrinfoX s � z(BaseEventLoop._create_server_getaddrinfor ) r= r) r* r� rT rr rs r� r� c � s� t |t�rtd��| dk r*|dkr*td��|dk s<�dk �r"|dk rLtd��| dkrhtjdkoftjdk} g }
|dkr|dg}n$t |t�s�t |t j
j �s�|g}n|}� ���fdd �|D �}t j
|d
�i�I dH }ttj�|��}d }�z |D �]}|\}}}}}zt�|||�}W n8 tjk
�rH �j�r@tjd |||d
d� Y q�Y nX |
�|� | �rl|�tjtjd
� |
�rzt |� t �r�|tj k�r�t td��r�|�tj tj!d
� z|�"|� W q� t#k
�r� } z t#|j$d||j%�&� f �d�W 5 d}~X Y q�X q�d
}W 5 |�s |
D ]}|�� �qX n4|dk�r4td��|j'tj(k�rPtd|����|g}
|
D ]}|�)d � �qZt*�|
|||| �}| �r�|�+� t j,d�d�I dH �j�r�t�-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 NoneNrX rY �posix�cygwinr. c s g | ]}�j |�� �d ��qS ))r= r) )r� )rC r; �r= r) r< rf r r r� � s �
�z/BaseEventLoop.create_server.<locals>.<listcomp>r� Fz:create_server() failed to create socket.socket(%r, %r, %r)T��exc_info� IPPROTO_IPV6z0error while attempting to bind on address %r: %sz)Neither host/port nor sock were specifiedrc r r� z
%r is serving).r rk r5 r% r� r� r �platformr rF �abc�Iterabler r� �setrK rL rM r� r$ r� r� r �warningr9 r& r' Z SO_REUSEADDRr+ r8 r r# r� Z IPV6_V6ONLYrL r( rO rM rN r> r1 rK r r� r� r( )rf r� r; r< r= r) r* r� rT rr rs r� r� r� ZhostsZfsrh Z completed�resr@ Zsocktyper? Z canonnameZsar� r� r r� r �
create_server` s�
��
��
�
���� ��
� zBaseEventLoop.create_server)rT r� c � sv |j tjkrtd|����|dk r.|s.td��| j|||dd|d�I dH \}}| jrn|�d�}t�d|||� ||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.
rc NrX r. T)r� r� r$ z%r handled: (%r, %r)) r> r$ r1 r% rf r� rg r r )rf r� r* rT 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\t�d|�� ||� ||fS )Nz Read pipe %r connected: (%r, %r))rd r� r� r� r r �fileno�rf 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\t�d|�� ||� ||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|�� �� t�d�|�� 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� �encoding�errors�textc � s� t |ttf�std��|r"td��|s.td��|dkr>td��| rJtd��| d k rZtd��|
d k rjtd��|� }
d }| jr�d | }| �||||� | j|
|d
||||f| �I d H }| jr�|d k r�t�d ||� ||
fS ) Nzcmd must be a string� universal_newlines must be Falsezshell must be Truer �bufsize must be 0�text must be False�encoding must be None�errors 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 }| jr�d|��}| �||||� | j||d ||||f|
�I d H }| jr�|d k r�t�d
||� ||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|| }|dkr�d �t�|��}d
}||� � 7 }n2|dkr�d �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> r� rR r. z+Object created at (most recent call last):
z+Handle created at (most recent call last):
rJ �
r� )�getr> �
__traceback__r� r� �sortedr& � traceback� format_list�rstripr r9 r r� ) rf r
r� rR r� Z log_linesr| �value�tbr 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 q�X n�z| � | |� 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 rp r r� )rf r
rW r r r r� � s4
�� �z$BaseEventLoop.call_exception_handlerc C s> t |tj�std��|jr dS t |tj�r.t�| j�|� dS )z3Add a Handle to _scheduled (TimerHandle) or _ready.zA Handle is required hereN)r r r r� �
_cancelledr r� 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<d|_q*|�|� q*t�|� || _d| _n4| jr�| jd jr�| jd8 _t� | j�}d|_q`d}| j
s�| j r�d}n*| jr�| jd j }t
td|| �� �t�}| j�|�}| �|� | �� | j }| j�r:| jd }|j |k�r�q:t� | j�}d|_| j
�|� q�t | j
�}t|�D ]|} | j
�� }|j�rf�qL| j�r�zD|| _| �� }
|�� | �� |
} | | jk�r�t� dt |�| � W 5 d| _X n|�� �qLd}dS )z�Run one full iteration of the event loop.
This calls all currently ready callbacks, polls for I/O,
schedules the resulting callbacks, and finally schedules
'call_later' callbacks.
Fr r Nz Executing %s took %.3f seconds) r� r� � _MIN_SCHEDULED_TIMER_HANDLESr� �%_MIN_CANCELLED_TIMER_HANDLES_FRACTIONr� r9 r �heapify�heappopr� r� Z_whenr= �maxr� �MAXIMUM_SELECT_TIMEOUTZ _selectorZselectr� r� �range�popleftr� r� Z_runr� r r� r ) rf Z sched_countZ
new_scheduledr Ztimeoutr r� Zend_timeZntodo�ir+ r- r r r r � sj
��
�
zBaseEventLoop._run_oncec C sH t |�t | j�krd S |r2t�� | _t�tj� n t�| j� || _d S rB )rk r� r �#get_coroutine_origin_tracking_depthr� �#set_coroutine_origin_tracking_depthr ZDEBUG_STACK_DEPTH�rf Zenabledr r r r� F s ���z,BaseEventLoop._set_coroutine_origin_trackingc C s | j S rB )r� rq r r r r� U s zBaseEventLoop.get_debugc C s || _ | �� r | �| j|� d S rB )r� r� r� r� r� r r r r� X s zBaseEventLoop.set_debug)N)N)NNN)NN)NN)N)r )r N)N)NN)FN)r N)NN)NN)Sr| r} r~ rh r� rd r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r rU r� r� r� r� r r� r� r r r r r r r� r r# r. r' r0 r9 r3 r5 r2 rS ri rf rn rl rm rq r� r� r$ r1 rd r� r6 Z
AI_PASSIVEr� r� r� r� r� r r r� r� r� r� r� r� r� r� r� r r� r� r� r r r r r � sF � � �
�
�
�
�
&
�
�
% � � �
� /� / � � � �� w� � % � "29Nr )r r )r )7�__doc__rF Zcollections.abcZconcurrent.futuresr r\ r rK r� r$ r� r r r� r� r r� r� rT � ImportErrorr. r r r r r r r r
r r r
�logr �__all__r� r� r# r8 r� �objectr� r r! r+ rA rP rX r[ ZProtocolr\ ZAbstractServerr ZAbstractEventLoopr r r r r �<module> sd
;
DoPK [7�! �! $ __pycache__/protocols.cpython-38.pycnu �[��� U
e5d� � @ sb d Z dZG dd� d�ZG dd� de�ZG dd� de�ZG dd � d e�ZG d
d � d e�Zd d
� ZdS )z Abstract Protocol base classes.)� BaseProtocol�Protocol�DatagramProtocol�SubprocessProtocol�BufferedProtocolc @ 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 )z�Called 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 �)/usr/lib64/python3.8/asyncio/protocols.py�connection_made s z BaseProtocol.connection_madec C s dS )z�Called 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 �z�Called 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 <bufferobjects>`.
It is an error to return a zero-sized buffer.
Nr )r �sizehintr r r �
get_buffer� s zBufferedProtocol.get_bufferc C s dS )z�Called 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 )z�Called 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 )z�Called 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 �<module> s 9+9PK [�ۤ�Ym Ym 0 __pycache__/selector_events.cpython-38.opt-2.pycnu �[��� U
e5dT� � @ 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 j�ZG dd� dejej�ZG dd� de�Z G dd� de�Z 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_key�KeyError�boolr )�selector�fdZevent�key� r �//usr/lib64/python3.8/asyncio/selector_events.py�_test_selector_event s
r c C s t d k r t| t j�r td��d S )Nz"Socket cannot be of type SSLSocket)�ssl�
isinstanceZ SSLSocket� TypeError)�sockr r r �_check_ssl_socket+ s r c s� e Zd ZdR� fdd� ZdSddd�dd�ZdTddddejd�d d
�ZdUd d �Z� fd
d�Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdddejfdd�Zdddejfd d �Zddejfd d �Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Zd4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z d>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�� }t�d|jj� || _| � � t
� � | _ d S )NzUsing selector: %s)
�super�__init__� selectorsZDefaultSelectorr �debug� __class__�__name__� _selector�_make_self_pipe�weakrefZWeakValueDictionary� _transports)�selfr �r r r r 6 s
z BaseSelectorEventLoop.__init__��extra�serverc C s t | |||||�S �N)�_SelectorSocketTransport)r& r �protocol�waiterr) r* r r r �_make_socket_transport@ s
�z,BaseSelectorEventLoop._make_socket_transportF)� server_side�server_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�_ssock�filenor; �_csock�
_internal_fdsr< r r r r: b s
z&BaseSelectorEventLoop._close_self_pipec C sN t �� \| _| _| j�d� | j�d� | 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 �InterruptedError�BlockingIOErrorrF 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 socketT��exc_info)r@ �send�OSError�_debugr r )r& Zcsockr r r �_write_to_self� s �z$BaseSelectorEventLoop._write_to_self�d 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|�� \}} | jr0t�d|| |� |�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)�range�acceptrQ r r rC rK rJ �ConnectionAbortedErrorrP �errnoZEMFILEZENFILEZENOBUFSZENOMEM�call_exception_handlerr �TransportSocketr= r? Z
call_laterr ZACCEPT_RETRY_DELAYrW �_accept_connection2Z create_task)
r& rU r r3 r* rV r2 �_�conn�addr�excr) 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>| jr�d|
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; �
SystemExit�KeyboardInterruptrQ r_ ) r& rU rc r) r3 r* r2 r- rf r. re �contextr r r ra � sP � � �z)BaseSelectorEventLoop._accept_connection2c
C s� |}t |t�sJzt|�� �}W n* tttfk
rH td|���d �Y nX z| j| }W n tk
rl Y n X |�� s�t 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 �modify�cancel� r& r �callback�argsZhandler �mask�reader�writerr 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"td��z |�|�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_recv�add_done_callback� functools�partial�_sock_read_done)r& r �n�futr 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"td��z |�|�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"td��z|�|�}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 Zview�pos�startr� re r r r r� � s
z#BaseSelectorEventLoop._sock_sendallc � s� t |� | jr"|�� dkr"td��ttd�r8|jtjkrf| j||j|j | d�I d H }|d \}}}}}| �
� }| � |||� |I d H S )Nr r� �AF_UNIX)�family�proto�loop) 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|||dd�I d H W �S |�� |r^|�� || j |j< X d S )NF)Zfallback) r% �_sock_fd�
is_reading�
pause_reading�_make_empty_waiter�_reset_empty_waiter�resume_readingZ
sock_sendfile�_sock)r& Ztransp�file�offset�countr� 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
ejfdd�Zd dd�Zdd� Zdd� Zdd� Zd d � Z� ZS ) �_SelectorTransporti Nc s� t � �||� t�|�| jd< z|�� | jd< W n tk
rN d | jd< Y nX d| jkr�z|�� | 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�� s�t| jj | jt
j �}|rz|�d� n
|�d� t| jj | jt
j �}|r�d}nd}| �
� }|�d|� d |� d
�� d �d �|��S )
N�closed�closingzfd=z read=pollingz read=idle�pollingZidlezwrite=<z
, bufsize=�>z<{}>� )r r! r� �appendr� r� �_loopr9 r r" r rt r� �get_write_buffer_size�format�join)r& �infor� �state�bufsizer 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 |t�r(| 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 | j�S 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; �warnings�warnr� r� r� r� r� rD r� r r r' r r� ] s
r� c s� e Zd ZdZejjZd#� fdd� Z� fdd�Z 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 |tj�r| 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:t�d| � 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<t�d| � d S )NFz%r resumes reading) r� r� rD r� r� r� r� r r r< r r r r� s
z'_SelectorSocketTransport.resume_readingc C s | � � d S r+ )r� r< r r r r� $ s z$_SelectorSocketTransport._read_readyc
C s` | j r
d S z | j�d�}t|�s(td��W nL ttfk
rD � Y n4 tk
rv } z| �|d� W Y �d S d }~X Y nX z| j �
|�}W nd t t fk
r� Y d S ttfk
r� � Y n4 tk
r� } z| �|d� W Y �d S d }~X Y nX |�s | �
� d S z| j�|� W nJ ttfk
�r, � Y n0 tk
�rZ } z| �|d� W 5 d }~X Y nX d S )N���z%get_buffer() returned an empty bufferz/Fatal error: protocol.get_buffer() call failed.�$Fatal read error on socket transportz3Fatal error: protocol.buffer_updated() call failed.)r� r� Z
get_bufferr� r8 ri rj rh r� r� r� rK rJ �_read_ready__on_eofZbuffer_updated)r& r� re r� r r r r� ' sF � �z0_SelectorSocketTransport._read_ready__get_bufferc
C s� | j r
d S z| j�| j�}W nd ttfk
r6 Y d S ttfk
rN � Y n4 tk
r� } z| � |d� W Y �d S d }~X Y nX |s�| �
� d S z| j � |� W nF ttfk
r� � Y n. tk
r� } z| � |d� W 5 d }~X Y nX d S )Nr� z2Fatal error: protocol.data_received() call failed.)
r� r� rI r� rK rJ ri rj rh r� r� r� Z
data_received)r& rG re r r r r� L s. �z3_SelectorSocketTransport._read_ready__data_receivedc
C s� | j �� rt�d| � z| j�� }W nL ttfk
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 |tttf�s$tdt|�j����| jr2td��| j d k rDtd��|sLd S | j
rz| j
t j krht
�d� | j
d7 _
d S | j�s 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_ready�extend�_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 |�= | �� | j�s| j �
| j � | jd k r�| j�d � | jr�| �d � n| j�r| j�tj� 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*| j�tj� 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&| j�td�� 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| j�t
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 � <genexpr>� s zC_SelectorDatagramTransport.get_write_buffer_size.<locals>.<genexpr>)�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_received�r& rG rd re r r r r� � s z&_SelectorDatagramTransport._read_readyc
C s� t |tttf�s$tdt|�j����|s,d S | jrV|d | jfkrPtd| j� ���| j}| j r�| jr�| j t
j krxt �
d� | j d7 _ d S | j�slz,| 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 q�Y 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� | j�r| �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� � collections�dequer� 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 �<module> sD
1� oPK [� �? �? & __pycache__/locks.cpython-38.opt-1.pycnu �[��� U
e5d|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� d�Z
G dd� de �ZG dd� de �ZG dd� de�ZdS )zSynchronization primitives.)�Lock�Event� Condition� Semaphore�BoundedSemaphore� 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):
<block>
while failing loudly when accidentally using:
with lock:
<block>
Deprecated, use 'async with' statement:
async with lock:
<block>
c C s
|| _ d S �N)�_lock)�self�lock� r �%/usr/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 �release�r �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 d��d 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)�warnings�warn�DeprecationWarning�acquirer 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_type�exc�tbr 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 ZdZdd�dd�Z� fdd�Zdd � 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
...
N��loopc 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|� d�S � N�lockedZunlocked�
, waiters:�<r ���� [�]>)�super�__repr__r6 r5 �len�r �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 )z�Acquire 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)�.0�wr r r � <genexpr>� s z Lock.acquire.<locals>.<genexpr>T) r6 r5 �all� collections�dequer8 �
create_future�append�remover
�CancelledError�_wake_up_first�r �futr r r r& � s& �
z Lock.acquirec C s" | j rd| _ | �� ntd��dS )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 �next�iter�
StopIteration�done�
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 ZdZdd�dd�Z� fdd�Zdd � 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|� d�S ) N�setZunsetr< 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 )z�Set 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 )z�Reset 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 )z�Block 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 ZdZddd�dd�Z� fdd�Zdd � Zd
d � Zdd
d�Zdd� 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|� d�S 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 q�W q^ tjk
r� d}Y q^X q^|r�tj�X 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 )z�Wait 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 predicate�resultr r r �wait_for� s
zCondition.wait_forr c C sJ | � � std��d}| 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 �n�idxrU 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 ZdZddd�dd�Z� fdd�Zd 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|� d�S ) 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 )z�Release 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� fdd�Z� ZS )
r z�A 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 | jkrtd��t� �� 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 �<module> s "9 DzNPK [�5 B B ) __pycache__/__main__.cpython-38.opt-2.pycnu �[��� U
e5d
� @ sJ d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl Z ddl
m Z G dd� dej �Z
G dd� dej�Zedk�rFe�� Ze�e� d eiZd
D ]Ze� e ee< q�e
ee�Zdad az d dlZW n ek
r� Y nX e� Z d e _ e � � z e� � W n6 e k
�r> t�r6t�!� �s6t�"� d aY q�Y q�X �qFq�dS )
� N� )�futuresc s$ e Zd Z� fdd�Zdd� Z� ZS )�AsyncIOInteractiveConsolec s* t � �|� | jj jtjO _|| _d S )N)�super�__init__�compileZcompiler�flags�astZPyCF_ALLOW_TOP_LEVEL_AWAIT�loop)�self�localsr
�� __class__� �(/usr/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 t�t �� W n. tk
� r� } z��|� W 5 d }~X Y nX d S )NFT)� repl_future�repl_future_interrupted�types� FunctionTyper �
SystemExit�KeyboardInterruptZ
set_exception�
BaseException�inspectZ iscoroutineZ
set_resultr
Z create_taskr Z
_chain_future)�func�coroZex�exc��codeZfuturer r r �callback s,
z3AsyncIOInteractiveConsole.runcode.<locals>.callbackz
KeyboardInterrupt
) �
concurrentr ZFuturer
�call_soon_threadsafe�resultr 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� t�tj� X d S ) N�ignorez ^coroutine .* was never awaited$)�message�categoryz
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) �warnings�filterwarnings�RuntimeWarningr
r �stop�sys�version�platform�getattr�consoleZinteract)r r, r r r �runF s "��
�zREPLThread.runN)r$ r% r& r6 r r r r r( D s r( �__main__�asyncio> � __builtins__�__spec__r$ �__file__�
__loader__� __package__FT)#r r8 r Zconcurrent.futuresr r r1 Z threadingr r- � r ZInteractiveConsoler ZThreadr( r$ Znew_event_loopr
Zset_event_loopZ repl_locals�keyr r5 r r �readline� ImportErrorZ repl_threadZdaemon�startZ run_foreverr ZdoneZcancelr r r r �<module> sF 6
PK [� ��k k * __pycache__/staggered.cpython-38.opt-1.pycnu �[��� U
e5dh �
@ 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_fns�delayr �returnc � s� �p
t �� �t| ��d�d�g �g �tjtj dd�� �������fdd� ����d��}��|� z<d}|t
��kr�t � ��I dH \}}t
|�}ql���fW �S �D ] }|� � q�X 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
� s | d k r6t �tj�� t�| �� � �I d H W 5 Q R X zt��\}}W n tk
r\ Y d S X t �
� }�� �|��}�� |� �� d � z|� I d H }W nJ t
tfk
r� � Y n\ tk
r� } z|�|< |�� W 5 d }~X Y n,X |�|�t��D ]\}}||kr�|�� q�d S )N)�
contextlib�suppress�exceptions_mod� TimeoutErrorr Zwait_for�wait�next�
StopIterationr �Event� create_task�append�
SystemExit�KeyboardInterrupt�
BaseException�set� enumerate�cancel) r Z
this_indexZcoro_fnZ this_failedZ next_task�result�e�i�t�r
Z
enum_coro_fnsr r � run_one_coroZ
running_tasksZ winner_indexZ
winner_result� �)/usr/lib64/python3.8/asyncio/staggered.pyr" R s.
z$staggered_race.<locals>.run_one_coror )
r Zget_running_loopr �typing�Optionalr 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 �Iterable�Callable� Awaitabler& �floatZAbstractEventLoopZTupleZAny�intZList� Exceptionr r# r# r# r$ �<module> s& ����PK [��,� * __pycache__/staggered.cpython-38.opt-2.pycnu �[��� U
e5dh �
@ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddlmZ dd�ej ej
g ej f ej e
ejejejej e ejej e f d �d
d �ZdS ) )�staggered_race� N� )�events)�
exceptions)�locks)�tasks)�loop)�coro_fns�delayr �returnc � s� �p
t �� �t| ��d �d �g �g �tjtj d d�� �������fdd� ����d ��}��|� z<d}|t
��kr�t � ��I d H \}}t
|�}ql���fW �S �D ] }|� � q�X d S )N)�previous_failedr c
� s | d k r6t �tj�� t�| �� � �I d H W 5 Q R X zt��\}}W n tk
r\ Y d S X t �
� }�� �|��}�� |� �� d � z|� I d H }W nJ t
tfk
r� � Y n\ tk
r� } z|�|< |�� W 5 d }~X Y n,X |�|�t��D ]\}}||kr�|�� q�d S )N)�
contextlib�suppress�exceptions_mod� TimeoutErrorr Zwait_for�wait�next�
StopIterationr �Event� create_task�append�
SystemExit�KeyboardInterrupt�
BaseException�set� enumerate�cancel) r Z
this_indexZcoro_fnZ this_failedZ next_task�result�e�i�t�r
Z
enum_coro_fnsr r � run_one_coroZ
running_tasksZ winner_indexZ
winner_result� �)/usr/lib64/python3.8/asyncio/staggered.pyr" R s.
z$staggered_race.<locals>.run_one_coror )
r Zget_running_loopr �typing�Optionalr 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 �Iterable�Callable� Awaitabler& �floatZAbstractEventLoopZTupleZAny�intZList� Exceptionr r# r# r# r$ �<module> s$ ����PK [�N & % __pycache__/coroutines.cpython-38.pycnu �[��� U
e5d]" � @ 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 ))� coroutine�iscoroutinefunction� iscoroutine� N� )� base_futures)� constants)�format_helpers)�loggerc C s" t jjp t jj o ttj�d��S )NZPYTHONASYNCIODEBUG)�sys�flags�dev_mode�ignore_environment�bool�os�environ�get� r r �*/usr/lib64/python3.8/asyncio/coroutines.py�_is_debug_mode s �r c @ s� e Zd Zd dd�Zdd� 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 sZ t �|�s t �|�s t|��|| _|| _t�t� d��| _
t |dd �| _ t |dd �| _
d S )Nr �__name__� __qualname__)�inspect� isgeneratorr �AssertionError�gen�funcr �
extract_stackr
� _getframe�_source_traceback�getattrr r )�selfr r r r r �__init__' s zCoroWrapper.__init__c C sJ t | �}| jr4| jd }|d|d � d|d � �7 }d| jj� d|� d�S ) N���z
, created at r �:r �<� �>)�_format_coroutiner � __class__r )r! � coro_repr�framer 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- r0 )r! �valuer r r r1 = s zCoroWrapper.sendc C s | j �|||�S r- )r �throw)r! �typer3 � tracebackr r r r4 @ s zCoroWrapper.throwc C s
| j �� S r- )r �closer. r r r r7 C s zCoroWrapper.closec C s | j jS r- )r �gi_framer. r r r r8 F s zCoroWrapper.gi_framec C s | j jS r- )r �
gi_runningr. r r r r9 J s zCoroWrapper.gi_runningc C s | j jS r- )r �gi_coder. r r r r: 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 r< U s zCoroWrapper.gi_yieldfromc C s� t | dd �}t |dd �}|d k r||jdkr|| �d�}t | dd�}|rrd�t�|��}|dtj� d �7 }||�� 7 }t� |� d S )
Nr r8 r# z was never yielded fromr r � zB
Coroutine object created at (most recent call last, truncated to z last lines):
)
r �f_lasti�joinr6 � format_listr ZDEBUG_STACK_DEPTH�rstripr �error)r! r r+ �msg�tbr r r �__del__Y s
zCoroWrapper.__del__)N)NN)r �
__module__r r" r, r/ r2 r1 r4 r7 �propertyr8 r9 r: r; r< rE r r r r r $ s"
r c sz t jdtdd� t���r �S t���r.�� nt����fdd��� t� � �� t
sX� }nt���� �fdd��}t |_ |S )z�Decorator 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|t�r4|E d H }n:z
|j}W n tk
rR Y n X t|tj j
�rn|� E d H }|S r- ) r Zisfuturer r �
isinstancer r; �AttributeError� collections�abc� Awaitable)�args�kw�resZ
await_meth�r r r �coroz s
�
zcoroutine.<locals>.coroc s@ t � | |��d�}|jr |jd= t�dd �|_t�dd �|_|S )NrR r# r r )r r r r r )rO �kwds�w�rS r r r �wrapper� s zcoroutine.<locals>.wrapper) �warnings�warn�DeprecationWarningr r �isgeneratorfunction� functools�wraps�typesr �_DEBUG�
_is_coroutine)r rW r rV r r i s" �
r c C s t �| �pt| dd�tkS )z6Return True if func is a decorated coroutine function.r` N)r r r r` rR r r r r � s
�r c C s@ t | �tkrdS t| t�r8tt�dk r4t�t | �� dS dS dS )z)Return True if obj is a coroutine object.T�d FN)r5 �_iscoroutine_typecacherJ �_COROUTINE_TYPES�len�add)�objr r r r � s
r c
st t | �s t�t| t�� � fdd�}dd� }d }t| d�rF| jrF| j}nt| d�r\| jr\| j}|| �}|s~|| �rz|� d�S |S d }t| d�r�| jr�| j}nt| d �r�| jr�| j}|j p�d
}d }� �r0| j
d k �r0t � | j
��s0t
�| j
�}|d k r�|\}}|d k�r|� d |� d
|� �} n|� d|� d
|� �} n@|d k �rV|j}|� d|� d
|� �} n|j}|� d |� d
|� �} | S )Nc s` � rt �| jdi �S t| d�r,| jr,| j}n*t| d�rD| jrD| j}ndt| �j� d�}|� d�S )Nr r r r% z without __name__>z())r Z_format_callbackr �hasattrr r r5 )rS � coro_name�Zis_corowrapperr r �get_name� s z#_format_coroutine.<locals>.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_runningrK r9 )rS r r r �
is_running� s z%_format_coroutine.<locals>.is_running�cr_coder: z runningr8 �cr_framez<empty co_filename>r z done, defined at r$ z running, defined at z running at )r r rJ r rg rm r: r8 rn � co_filenamer r r[ r Z_get_function_source�f_lineno�co_firstlineno)
rS rj rl Z coro_coderh Z
coro_frame�filename�lineno�sourcer* r ri r r( � sL
�
�
r( ) �__all__Zcollections.abcrL r\ r r r
r6 r^ rX r= r r r �logr r r_ r r �objectr` r �
CoroutineType�
GeneratorTyperM � Coroutinerc �setrb r r( r r r r �<module> s2 E8 �PK [˼��-� -� , __pycache__/unix_events.cpython-38.opt-1.pycnu �[��� U
e5dۿ � @ 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
jdkr�e d��dd� 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)�SelectorEventLoop�AbstractChildWatcher�SafeChildWatcher�FastChildWatcher�MultiLoopChildWatcher�ThreadedChildWatcher�DefaultEventLoopPolicyZwin32z+Signals are not really supported on Windowsc C s dS )zDummy signal handler.N� )�signum�framer r �+/usr/lib64/python3.8/asyncio/unix_events.py�_sighandler_noop* s r c s� e Zd ZdZd)� fdd� Z� fdd�Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
d*dd�Z d+dd�Z d,dd�Z
dd� Zd-ddddd�dd�Zd.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)�self�selector�� __class__r r r 5 s z _UnixSelectorEventLoop.__init__c sZ t � �� t�� s.t| j�D ]}| �|� q n(| jrVtjd| �d�t | d� | j�
� d S )NzClosing the loop z@ on interpreter shutdown stage, skipping signal handlers removal��source) r �close�sys�
is_finalizing�listr �remove_signal_handler�warnings�warn�ResourceWarning�clear�r �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|= | j�szt�d� W n4 t
t fk
�r } zt�d|� W 5 d}~X Y nX |jtjk�r4t d|� d���n� W 5 d}~X Y nX dS )z�Add 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: %s�sig � cannot be caught)r Z iscoroutineZiscoroutinefunction� TypeError�
_check_signalZ
_check_closed�signal�
set_wakeup_fdZ_csock�fileno�
ValueError�OSError� RuntimeError�strr ZHandler r � siginterruptr
�info�errno�EINVAL)r r/ �callback�args�exc�handleZnexcr 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 kr�t
d|� d���n� W 5 d}~X Y nX | js�zt� 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 �SIGINT�default_int_handler�SIG_DFLr= rB rC r> r: r< r
rA )r r/ �handlerrF r r r r) � s(
z,_UnixSelectorEventLoop.remove_signal_handlerc C s6 t |t�std|����|t�� kr2td|� ���dS )z�Internal 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)�
isinstance�intr7 r9 �
valid_signalsr< r. r r r r8 � s
z$_UnixSelectorEventLoop._check_signalc C s t | ||||�S r )�_UnixReadPipeTransport�r �pipe�protocol�waiter�extrar 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�_UnixSubprocessTransport�add_child_handlerZget_pid�_child_watcher_callback�
SystemExit�KeyboardInterrupt�
BaseExceptionr% Z_wait)
r rU rE �shell�stdin�stdout�stderr�bufsizerW �kwargs�watcherrV �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)�ssl�sock�server_hostname�ssl_handshake_timeoutc � s
|r|d kr6t d��n |d k r&t d��|d k r6t d��|d k r�|d k rNt d��t�|�}t�tjtjd�}z |�d� | �||�I d H W q� |�� � Y q�X n@|d kr�t d��|j tjks�|j
tjkr�t d|����|�d� | j |||||d �I d H \}}||fS )
Nz/you have to pass server_hostname when using sslz+server_hostname is only meaningful with ssl�1ssl_handshake_timeout is only meaningful with ssl�3path and sock can not be specified at the same timer Fz no path and sock were specified�.A UNIX Domain Stream Socket was expected, got )rs ) r< �os�fspath�socket�AF_UNIX� SOCK_STREAM� setblockingZ sock_connectr% �family�typeZ _create_connection_transport) r �protocol_factory�pathrp rq rr rs � transportrU r r r �create_unix_connection� sR ���
��
�z-_UnixSelectorEventLoop.create_unix_connection�d T)rq �backlogrp rs �
start_servingc
� s� t |t�rtd��|d k r&|s&td��|d k �rH|d k r@td��t�|�}t�tjtj�}|d dkr�z t �
t� |�j �r�t� |� W nB t
k
r� Y n0 tk
r� } zt�d||� W 5 d }~X Y nX z|�|� W nl tk
�r0 } z8|�� | jtjk�r d|�d�}
ttj|
�d �n� W 5 d } ~ X Y n |�� � Y nX n<|d k�rZtd ��|jtjk�sv|jtjk�r�td
|����|�d � t�| |g||||�} |�r�| �� tj d| d �I d H | S )
Nz*ssl argument must be an SSLContext or Nonert ru r )r � z2Unable to check or remove stale UNIX socket %r: %rzAddress z is already in usez-path was not specified, and no sock specifiedrv F)�loop) rO �boolr7 r< rw rx ry rz r{ �stat�S_ISSOCK�st_mode�remove�FileNotFoundErrorr= r
�errorZbindr% rB Z
EADDRINUSEr} r~ r| r ZServerZ_start_servingr �sleep) r r r� rq r� rp rs r� �errrF �msgZserverr r r �create_unix_server sn
�
�
�
�
��
�z)_UnixSelectorEventLoop.create_unix_serverc
� s� z
t j W n, tk
r6 } zt�d��W 5 d }~X Y nX z |�� }W n2 ttjfk
rv } zt�d��W 5 d }~X Y nX zt �|�j }W n, t
k
r� } zt�d��W 5 d }~X Y nX |r�|n|} | s�dS | � � }
| � |
d ||||| d� |
I d H S )Nz os.sendfile() is not availableznot a regular filer )
rw �sendfile�AttributeErrorr �SendfileNotAvailableErrorr; �io�UnsupportedOperation�fstat�st_sizer= r] �_sock_sendfile_native_impl) r rq �file�offset�countrF r; r� Zfsize� blocksize�futr r r �_sock_sendfile_nativeJ s2
� �z,_UnixSelectorEventLoop._sock_sendfile_nativec C s, |� � } |d k r| �|� |�� r4| �|||� d S |rd|| }|dkrd| �|||� |�|� d S zt�| |||�}
W �nD ttfk
r� |d kr�| � ||� | �
| | j || ||||||�
Y �nb t k
�rj } z�|d k �r| j
t
jk�rt| �tk �rtdt
j�} | | _| } |dk�rBt�d�}
| �|||� |�|
� n| �|||� |�| � W 5 d } ~ X Y n� ttfk
�r� � Y n� tk
�r� } z | �|||� |�| � W 5 d } ~ X Y njX |
dk�r�| �|||� |�|� nD||
7 }||
7 }|d k�r
| � ||� | �
| | j || ||||||�
d S )Nr zsocket is not connectedzos.sendfile call failed)r; �
remove_writer� cancelled� _sock_sendfile_update_fileposZ
set_resultrw r� �BlockingIOError�InterruptedError� _sock_add_cancellation_callbackZ
add_writerr� r= rB ZENOTCONNr~ �ConnectionError� __cause__r r� Z
set_exceptionra rb rc )r r� Z
registered_fdrq r; r� r� r� �
total_sent�fdZsentrF �new_excr� r r r r� a s�
�
�
� �
�
�z1_UnixSelectorEventLoop._sock_sendfile_native_implc C s |dkrt �||t j� d S �Nr )rw �lseek�SEEK_SET)r r; r� r� r r r r� � s z4_UnixSelectorEventLoop._sock_sendfile_update_fileposc s � �fdd�}|� |� d S )Nc s& | � � r"��� }|dkr"� �|� d S )Nr3 )r� r; r� )r� r� �r rq r r �cb� s zB_UnixSelectorEventLoop._sock_add_cancellation_callback.<locals>.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
jfdd�Zd dd�Zdd� Zd d � Z� ZS ) rR i Nc s� t � �|� || jd< || _|| _|�� | _|| _d| _d| _ t
� | j�j }t
�|�s�t
�|�s�t
�|�s�d | _d | _d | _td��t
�| jd� | j�| jj| � | j�| jj| j| j� |d k r�| j�tj|d � d S )NrT Fz)Pipe transport is for pipes/sockets only.)r r �_extra�_loop�_piper; �_fileno� _protocol�_closing�_pausedrw r� r� r� �S_ISFIFOr� �S_ISCHRr< � set_blocking� call_soon�connection_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 r�t� || jt
j �}|r�|�d� q�|�d� n | jd k r�|�d� n
|�d� d� d �
|��S )
N�closed�closing�fd=� _selector�polling�idle�open�<{}>� )r" r� r� �appendr� r� �getattrr� r
�_test_selector_event� selectorsZ
EVENT_READ�format�join)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
� � r�t �
d| � d| _| j
�| j� | j
�| jj� | j
�| jd � d S )Nz"Fatal read error on pipe transport�%r was closed by peerT)rw �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:t�d| � d S )NTz%r pauses reading)r� r� r� r� r� r� r
�debug�r r r r �
pause_reading� s
z$_UnixReadPipeTransport.pause_readingc C sB | j s | jsd S d| _| j�| j| j� | j�� r>t�d| � 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 |t�r4|jtjkr4| j�� rLtjd| |dd� n| j�||| | j d�� | �
|� d S �Nz%r: %sT��exc_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� Zejfdd�Zd d � Zd&d d �Zd'd!d"�Zd#d$� Z� ZS )(rY Nc
s� t � �||� || jd< || _|�� | _|| _t� | _d| _ d| _
t � | j�j
}t�|�}t�|�}t�|�} |s�|s�| s�d | _d | _d | _td��t �| jd� | j�| jj| � | s�|r�tj�d�s�| j�| jj| j| j� |d k r�| j�t 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� rw 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 r�t� || 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_WRITE�get_write_buffer_sizer� r� )r rA r r� rh r r r r� d s,
�
z _UnixWritePipeTransport.__repr__c C s
t | j�S r )�lenr� r� r r r r� | s z-_UnixWritePipeTransport.get_write_buffer_sizec C s6 | j �� rt�d| � | jr*| �t� � n| �� d S )Nr� )r� r� r
rA r� r� �BrokenPipeErrorr� r r r r� s
z#_UnixWritePipeTransport._read_readyc
C s4 t |t�rt|�}|sd S | js&| jrN| jtjkr<t�d� | jd7 _d S | j �szt
� | j |�}W nt t
tfk
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 |dk�rt|�|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 r� �
memoryviewr� r� r Z!LOG_THRESHOLD_FOR_CONNLOST_WRITESr
�warningr� rw �writer� r� r� ra rb rc r� r� r� Z _add_writer� _write_readyZ_maybe_pause_protocol)r r1 �nrF r r r r � s6
z _UnixWritePipeTransport.writec
C s zt �| j| j�}W n� ttfk
r, Y n� ttfk
rD � Y n� tk
r� } z6| j� � | j
d7 _
| j � | j� | �
|d� W 5 d }~X Y nfX |t| j�kr�| j� � | j � | j� | �� | jr�| j �| j� | �d � d S |dkr�| jd |�= d S )Nr r r )rw r 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 s8 | j r
d S d| _ | js4| j�| j� | j�| jd � d S r� )r� 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 |t�r(| 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)
�
subprocess�PIPEry 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.
N��NotImplementedError�r rn rD rE r r r r_ 9 s z&AbstractChildWatcher.add_child_handlerc C s
t � �dS )z�Removes 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 )z�Attach 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 )z�Return ``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 �a�b�cr 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 )rw � WIFSIGNALED�WTERMSIG� 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 sf | j d k r$|d kr$| jr$t�dt� | j d k r<| j �tj� || _ |d k rb|�tj| j � | �
� d S )NzCA loop is being detached from a child watcher with pending handlers) r� r& r* r+ �RuntimeWarningr) r9 �SIGCHLDrH � _sig_chldr) r r r r r � s �
z BaseChildWatcher.attach_loopc
C s^ z | � � W nL ttfk
r& � Y n4 tk
rX } z| j�d|d�� W 5 d }~X Y nX d S )N�$Unknown exception in SIGCHLD handler)r� r� )r) ra rb rc r� r� r� r r r r, � s �zBaseChildWatcher._sig_chldN)
r� r� r� r r% r\ r( r) r r, r r r r r% s r% c sP e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
� Z S )r ad 'Safe' child watcher implementation.
This implementation avoids disrupting other code spawning processes by
polling explicitly each process in the SIGCHLD handler instead of calling
os.waitpid(-1).
This is a safe solution but it has a significant overhead when handling a
big number of children (O(n) each time SIGCHLD is raised)
c s | j �� t� �� d S r )r& r- r r% r� r! r r r% � s
zSafeChildWatcher.closec C s | S r r r� r r r r � s zSafeChildWatcher.__enter__c C s d S r r r r r r r � s zSafeChildWatcher.__exit__c G s ||f| j |< | �|� d S r )r& r( r r r r r_ � s z"SafeChildWatcher.add_child_handlerc C s* z| j |= W dS tk
r$ Y dS X d S �NTF�r& rJ r r r r r � s
z%SafeChildWatcher.remove_child_handlerc C s t | j�D ]}| �|� q
d S r �r( r& r( r r r r r) � s z SafeChildWatcher._do_waitpid_allc C s� zt �|t j�\}}W n( tk
r> |}d}t�d|� Y n.X |dkrLd S t|�}| j�� rlt� d||� z| j
� |�\}}W n. t k
r� | j�� r�tjd|dd� Y nX |||f|�� d S )N� �8Unknown child process pid %d, will report returncode 255r �$process %s exited with returncode %s�'Child watcher got an unexpected pid: %rTr� )
rw �waitpid�WNOHANG�ChildProcessErrorr
r r$ r� r� r� r& �poprJ )r r' rn r# ro rD rE r r r r( � s4 �
�
� z SafeChildWatcher._do_waitpid) r� r� r� r� r% r r r_ r r) r( r� r r r! r r � s
r c sT e Zd ZdZ� fdd�Z� fdd�Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
� Z S )r aW 'Fast' child watcher implementation.
This implementation reaps every terminated processes by calling
os.waitpid(-1) directly, possibly breaking other code spawning processes
and waiting for their termination.
There is no noticeable overhead when handling a big number of children
(O(1) each time a child terminates).
c s$ t � �� t�� | _i | _d| _d S r� )r r � threadingZLock�_lock�_zombies�_forksr� r! r r r s
zFastChildWatcher.__init__c s" | j �� | j�� t� �� d S r )r& r- r; 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 t�d|� 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 sf | j �F z| j�|�}W n. tk
rF ||f| j|< Y W 5 Q R � d S X W 5 Q R X |||f|�� d S r )r: r; r8 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 r. r/ 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 � � r�t
�d||� Y W 5 Q R � q d }Y nX | j � � r�t
�d||� W 5 Q R X |d kr�t
�d||� q |||f|�� q d S )Nr3 r z,unknown process %s exited with returncode %sr3 z8Caught subprocess termination from unknown pid: %d -> %d)rw r5 r6 r7 r$ r: r& r8 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 t�tj�}|| jkr:t�d� nt�tj| 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 r. r/ r r r r r � s
z*MultiLoopChildWatcher.remove_child_handlerc C sN | j d k rd S t�tj| j�| _ | j d kr<t�d� tj| _ t�tjd� d S )NzaPrevious SIGCHLD handler was set by non-Python code, restore to default handler on watcher close.F)r= r9 r+ r, r
r rM r@ r r r r r � s
z!MultiLoopChildWatcher.attach_loopc C s t | j�D ]}| �|� q
d S r r0 r r r r r) � s z%MultiLoopChildWatcher._do_waitpid_allc C s� zt �|t j�\}}W n, tk
rB |}d}t�d|� d}Y nX |dkrPd S t|�}d}z| j�|�\}}}W n$ t k
r� tjd|dd� Y nHX |�
� r�t�d||� n.|r�|� � r�t� d ||� |j
|||f|�� d S )
Nr1 r2 Fr Tr4 r� �%Loop %r that handles pid %r is closedr3 )rw r5 r6 r7 r
r r$ r& r8 rJ � is_closedr� r� rm ) r r' rn r# ro Z debug_logr� rD rE r r r r( � s: �
� �z!MultiLoopChildWatcher._do_waitpidc C sL z | � � W n: ttfk
r& � Y n" tk
rF tjddd� Y nX d S )Nr- Tr� )r) ra rb rc r
r )r r r r r r r, � s z MultiLoopChildWatcher._sig_chldN)r� r� r� r� r r\ r% r r r_ r r r) r( r, r r r r r g s %r c @ sn e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z e
j fdd�Z dd� Z
dd� Zdd� Zdd� ZdS )r aA Threaded child watcher implementation.
The watcher uses a thread per process
for waiting for the process finish.
It doesn't require subscription on POSIX signal
but a thread creation is not free.
The watcher has O(1) complexity, its performance doesn't depend
on amount of spawn processes.
c C s t �d�| _i | _d S r� )� itertoolsr� � _pid_counter�_threadsr� r r r r � s z ThreadedChildWatcher.__init__c C s dS r� r r� r r r r\ � s z ThreadedChildWatcher.is_activec C s | � � d S r )�
_join_threadsr� r r r r% � s zThreadedChildWatcher.closec C s. dd� t | j�� �D �}|D ] }|�� q dS )z%Internal: Join all non-daemon threadsc S s g | ]}|� � r|js|�qS r )�is_alive�daemon��.0�threadr r r �
<listcomp>� s �z6ThreadedChildWatcher._join_threads.<locals>.<listcomp>N)r( rF �valuesr� )r �threadsrL r r r rG � 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 r? r r r r s z ThreadedChildWatcher.__exit__c C s6 dd� t | j�� �D �}|r2|| j� d�t| d� d S )Nc S s g | ]}|� � r|�qS r )rH rJ r r r rM s �z0ThreadedChildWatcher.__del__.<locals>.<listcomp>z0 has registered but not finished child processesr# )r( rF rN r" r, )r r� rO r r r r� s �z ThreadedChildWatcher.__del__c G sF t �� }tj| jdt| j�� �||||fdd�}|| j|< |�� d S )Nzwaitpid-T)�target�namerE rI ) r rA r9 ZThreadr( �nextrE rF �start)r rn rD rE r� rL 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� zt �|d�\}}W n( tk
r< |}d}t�d|� Y n X t|�}|�� r\t�d||� |�� rtt�d||� n|j |||f|�� | j
� |� d S )Nr r1 r2 r3 rB ) rw r5 r7 r
r r$ r� r� rC rm rF r8 )r r� r' rD rE rn r# ro r r r r( " s& �
�z ThreadedChildWatcher._do_waitpidN)r� r� r� r� r r\ r% rG r r r* r+ r� r_ r r r( r r r r r � s r c sH e Zd ZdZeZ� fdd�Zdd� Z� fdd�Zdd � 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 j�8 | jd kr:t� | _tt�� tj�r:| j�| j j
� W 5 Q R X d S r ) r r: rU r rO r9 �current_thread� _MainThreadr �_localr� r� r r r �
_init_watcherE s
�z)_UnixDefaultEventLoopPolicy._init_watcherc s6 t � �|� | jdk r2tt�� tj�r2| j�|� dS )z�Set 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_looprU rO r9 rV rW r r r! r r rZ 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)rU rY r� r r r r[ [ s
z-_UnixDefaultEventLoopPolicy.get_child_watcherc C s | j dk r| j �� || _ dS )z$Set the watcher for child processes.N)rU r% )r rj r r r �set_child_watchere s
z-_UnixDefaultEventLoopPolicy.set_child_watcher) r� r� r� r� r Z
_loop_factoryr rY rZ r[ r[ r� r r r! r rT = s
rT )2r� rB r� rD rw r� r9 ry r� r r& r9 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 ZBaseDefaultEventLoopPolicyrT r r r r r r �<module> s`
� NO5Ji}Y3PK [� �? �? __pycache__/locks.cpython-38.pycnu �[��� U
e5d|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� d�Z
G dd� de �ZG dd� de �ZG dd� de�ZdS )zSynchronization primitives.)�Lock�Event� Condition� Semaphore�BoundedSemaphore� 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):
<block>
while failing loudly when accidentally using:
with lock:
<block>
Deprecated, use 'async with' statement:
async with lock:
<block>
c C s
|| _ d S �N)�_lock)�self�lock� r �%/usr/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 �release�r �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 d��d 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)�warnings�warn�DeprecationWarning�acquirer 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_type�exc�tbr 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 ZdZdd�dd�Z� fdd�Zdd � 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
...
N��loopc 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|� d�S � N�lockedZunlocked�
, waiters:�<r ���� [�]>)�super�__repr__r6 r5 �len�r �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 )z�Acquire 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)�.0�wr r r � <genexpr>� s z Lock.acquire.<locals>.<genexpr>T) r6 r5 �all� collections�dequer8 �
create_future�append�remover
�CancelledError�_wake_up_first�r �futr r r r& � s& �
z Lock.acquirec C s" | j rd| _ | �� ntd��dS )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 �next�iter�
StopIteration�done�
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 ZdZdd�dd�Z� fdd�Zdd � 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|� d�S ) N�setZunsetr< 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 )z�Set 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 )z�Reset 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 )z�Block 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 ZdZddd�dd�Z� fdd�Zdd � Zd
d � Zdd
d�Zdd� 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|� d�S 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 q�W q^ tjk
r� d}Y q^X q^|r�tj�X 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 )z�Wait 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 predicate�resultr r r �wait_for� s
zCondition.wait_forr c C sJ | � � std��d}| 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 �n�idxrU 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 ZdZddd�dd�Z� fdd�Zd 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|� d�S ) 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 )z�Release 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� fdd�Z� ZS )
r z�A 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 | jkrtd��t� �� 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 �<module> s "9 DzNPK [���+ �+ " __pycache__/futures.cpython-38.pycnu �[��� U
e5db3 � @ 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� Zdd�dd�Zz ddlZW n e k
r� Y n X ej ZZ dS )z.A Future class similar to the one in PEP 3148.)�Future� wrap_future�isfuture� N� )� base_futures)�events)�
exceptions)�format_helpersc @ s� e Zd ZdZeZdZdZdZdZ dZ
dZ dd�dd�Z 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.)
NF��loopc C s@ |dkrt �� | _n|| _g | _| j�� r<t�t�d��| _ dS )z�Initialize the future.
The optional event_loop argument allows explicitly setting the event
loop object used by the future. If it's not provided, the future uses
the default event loop.
Nr )
r �get_event_loop�_loop�
_callbacksZ get_debugr �
extract_stack�sys� _getframe�_source_traceback��selfr � r �'/usr/lib64/python3.8/asyncio/futures.py�__init__D s
�zFuture.__init__c C s d� | jjd�| �� ��S )Nz<{} {}>� )�format� __class__�__name__�join�
_repr_info�r 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� exception�futureZsource_traceback)�_Future__log_traceback�
_exceptionr r r r
Zcall_exception_handler)r �exc�contextr 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 |�rtd��d| _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 )z�Cancel the future and schedule callbacks.
If the future is already done or cancelled, return False. Otherwise,
change the future's state to cancelled, schedule the callbacks and
return True.
FT)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 )z�Internal: Ask the event loop to call all callbacks.
The callbacks are scheduled to be called as soon as possible. Also
clears the callback list.
N�r& )r r
� call_soon)r Z callbacks�callback�ctxr 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 )z�Return 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$t�d��d| _| 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� _FINISHED�InvalidStateErrorr# r$ �_resultr r r r �result� s
z
Future.resultc C s0 | j tkrtj�| j tkr$t�d��d| _| jS )a& Return the exception that was set on this future.
The exception (or None if no exception was set) is returned only if
the future is done. If the future has been cancelled, raises
CancelledError. If the future isn't done yet, raises
InvalidStateError.
zException is not set.F)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 )z�Add a callback to be run when the future becomes done.
The callback is called with a single argument - the future object. If
the future is already done when this is called, the callback is
scheduled with call_soon.
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||f�qS r r )�.0�fr7 �rA r r �
<listcomp>� s �z/Future.remove_done_callback.<locals>.<listcomp>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 )z�Mark 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|t�r0|� }t|�tkrDtd��|| _t | _ | �
� d| _ dS )z�Mark 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< �
isinstance�type�
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 �
concurrent�futuresr: 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 t�tjj�s td��t ��s<t�tjj�s<td��t ��rLt��nd�t ��r`t��nd�dd� � ���fdd�}� ���fdd �}��|� ��|� dS )
a Chain two futures so that when one completes, so does the other.
The result (or exception) of source will be copied to destination.
If destination is cancelled, source gets cancelled too.
Compatible with both asyncio.Future and concurrent.futures.Future.
z(A future is required for source argumentz-A future is required for destination argumentNc S s" t | �rt|| � n
t| |� d S r( )r re rc )r" �otherr r r �
_set_stateb s z!_chain_future.<locals>._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.<locals>._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.<locals>._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| tjj�s(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 �<module> s:
q *
PK [�?�`� � ( __pycache__/runners.cpython-38.opt-2.pycnu �[��� U
e5d � @ sB d Z ddlmZ ddlmZ ddlmZ dd�dd�Zd d
� ZdS ) )�run� )�
coroutines)�events)�tasksN)�debugc C s� t �� d k rtd��t�| �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�
ValueError�formatZnew_event_loopZset_event_loop�close�_cancel_all_tasks�run_until_completeZshutdown_asyncgensZ set_debug)�mainr �loop� r �'/usr/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� exception�task)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 �<module> s
.PK [� ��I �I ' __pycache__/events.cpython-38.opt-2.pycnu �[��� U
e5d4f � @ sx d Z ddlZddlZddlZddlZddlZddlZddlmZ ddlm Z G dd� d�Z
G dd � d e
�Z G d
d � d �Z G d d
� d
�Z
G dd� d�ZG dd� de�Zdae�� ZG dd� dej�Ze� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Z d"d#� Z d$d%� Z d&d'� Z d(d)� Z eZ!eZ"eZ#e Z$z dd*l%mZmZmZm Z W n e&k
�rb Y nX eZ'eZ(eZ)e Z*dS )+)�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�_get_running_loop� N� )�format_helpers)�
exceptionsc @ sB e Zd ZdZddd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dS )r )� _callback�_args�
_cancelled�_loop�_source_traceback�_repr� __weakref__�_contextNc C s\ |d krt �� }|| _|| _|| _|| _d| _d | _| j�� rRt �
t � d��| _
nd | _
d S )NFr )� contextvarsZ copy_contextr r r r r r � get_debugr �
extract_stack�sys� _getframer )�self�callback�args�loop�context� r& �&/usr/lib64/python3.8/asyncio/events.py�__init__ s
�zHandle.__init__c C sl | j jg}| jr|�d� | jd k r:|�t�| j| j�� | jrh| jd }|�d|d � d|d � �� |S )N� cancelled���z created at r �:r ) � __class__�__name__r �appendr r �_format_callback_sourcer r )r! �info�framer& r& r' �
_repr_info/ s
�
zHandle._repr_infoc C s( | j d k r| j S | �� }d�d�|��S )Nz<{}>� )r r2 �format�join)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 exception�handleZsource_traceback) r �runr r �
SystemExit�KeyboardInterrupt�
BaseExceptionr r/ r r �call_exception_handler)r! �exc�cb�msgr% r& r& r' �_runO s$ �
�
z Handle._run)N)
r- �
__module__� __qualname__� __slots__r( r2 r6 r: r) rF r& r& r& r' r s
r c s~ e Zd ZddgZd� fdd� Z� fdd�Zdd � Zd
d � Zd d
� Zdd� Z dd� Z
dd� Z dd� Z � fdd�Z
dd� Z� ZS )r �
_scheduled�_whenNc s0 t � �||||� | jr | jd= || _d| _d S )Nr* F)�superr( r rK rJ )r! �whenr" r# r$ r% �r, r& r' r( h s
zTimerHandle.__init__c s0 t � �� }| jrdnd}|�|d| j� �� |S )N� r zwhen=)rL r2 r �insertrK )r! r0 �posrN r& r' r2 p s
zTimerHandle._repr_infoc C s
t | j�S r; )�hashrK r9 r& r& r' �__hash__v s zTimerHandle.__hash__c C s | j |j k S r; �rK �r! �otherr& r& r' �__lt__y s zTimerHandle.__lt__c C s | j |j k rdS | �|�S r7 �rK �__eq__rU r& r& r' �__le__| s zTimerHandle.__le__c C s | j |j kS r; rT rU r& r& r' �__gt__� s zTimerHandle.__gt__c C s | j |j krdS | �|�S r7 rX rU r& r& r' �__ge__� s zTimerHandle.__ge__c C s> t |t�r:| j|jko8| j|jko8| j|jko8| j|jkS tS r; )�
isinstancer rK r r r �NotImplementedrU r& r& r' rY � s
�
�
�zTimerHandle.__eq__c C s | � |�}|tkrtS | S r; )rY r^ )r! rV Zequalr& r& r' �__ne__� s
zTimerHandle.__ne__c s | j s| j�| � t� �� d S r; )r r �_timer_handle_cancelledrL r: r9 rN r& r' r: � s zTimerHandle.cancelc C s | j S r; rT r9 r& r& r' rM � s zTimerHandle.when)N)r- rG rH rI r( r2 rS rW rZ r[ r\ rY r_ r: rM �
__classcell__r& r& rN r' r c s r c @ sL e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dS )r c C s t �d S r; ��NotImplementedErrorr9 r& r& r' �close� s zAbstractServer.closec C s t �d S r; rb r9 r& r& r' �get_loop� s zAbstractServer.get_loopc C s t �d S r; rb r9 r& r& r' �
is_serving� s zAbstractServer.is_servingc � s t �d S r; rb r9 r& r& r' �
start_serving� s z AbstractServer.start_servingc � s t �d S r; rb r9 r& r& r' �
serve_forever� s z AbstractServer.serve_foreverc � s t �d S r; rb 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; )rd ri )r! rC r& r& r' � __aexit__� s zAbstractServer.__aexit__N) r- rG rH rd re rf rg rh ri rj rk r& r& r& r' r � s r c @ sR e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd �d d �Zd d � Zd!d"� Zd#d$� Zd%d%d%d%d&�d'd(�Zdtd)d*�Zdudd%d%d%ddddddd+�
d,d-�Zdvejejdd.ddddd/d0� d1d2�Zdwd/d3�d4d5�Zd6ddd7�d8d9�Z dxddddd:�d;d<�Z dydd.ddd/d=�d>d?�Z dzd%d%d%ddddd@�dAdB�Z dCdD� Z dEdF� Z!e"j#e"j#e"j#dG�dHdI�Z$e"j#e"j#e"j#dG�dJdK�Z%dLdM� Z&dNdO� Z'dPdQ� Z(dRdS� Z)dTdU� Z*dVdW� Z+dXdY� Z,dZd[� Z-d\d]� Z.d{dd3�d^d_�Z/d`da� Z0dbdc� Z1ddde� Z2dfdg� Z3dhdi� Z4djdk� Z5dldm� Z6dndo� Z7dpdq� Z8drds� Z9dS )|r c C s t �d S r; rb r9 r& r& r' � run_forever� s z AbstractEventLoop.run_foreverc C s t �d S r; rb )r! Zfuturer& r& r' �run_until_complete� s z$AbstractEventLoop.run_until_completec C s t �d S r; rb r9 r& r& r' �stop� s zAbstractEventLoop.stopc C s t �d S r; rb r9 r& r& r' �
is_running� s z AbstractEventLoop.is_runningc C s t �d S r; rb r9 r& r& r' � is_closed� s zAbstractEventLoop.is_closedc C s t �d S r; rb r9 r& r& r' rd � s zAbstractEventLoop.closec � s t �d S r; rb r9 r& r& r' �shutdown_asyncgens� s z$AbstractEventLoop.shutdown_asyncgensc C s t �d S r; rb )r! r= r& r& r' r` � s z)AbstractEventLoop._timer_handle_cancelledc G s | j d|f|�� S )Nr )�
call_later�r! r" r# r& r& r' � call_soon s zAbstractEventLoop.call_soonc G s t �d S r; rb )r! Zdelayr" r# r& r& r' rr s z AbstractEventLoop.call_laterc G s t �d S r; rb )r! rM r" r# r& r& r' �call_at s zAbstractEventLoop.call_atc C s t �d S r; rb r9 r& r& r' �time s zAbstractEventLoop.timec C s t �d S r; rb r9 r& r& r' �
create_future s z AbstractEventLoop.create_futureN)�namec C s t �d S r; rb )r! �cororx r& r& r' � create_task s z AbstractEventLoop.create_taskc G s t �d S r; rb rs r& r& r' �call_soon_threadsafe s z&AbstractEventLoop.call_soon_threadsafec G s t �d S r; rb )r! �executor�funcr# r& r& r' �run_in_executor s z!AbstractEventLoop.run_in_executorc C s t �d S r; rb )r! r| r& r& r' �set_default_executor s z&AbstractEventLoop.set_default_executorr )�family�type�proto�flagsc � s t �d S r; rb )r! �host�portr� r� r� r� r& r& r' � getaddrinfo# s z AbstractEventLoop.getaddrinfoc � s t �d S r; rb )r! Zsockaddrr� r& r& r' � getnameinfo' s z AbstractEventLoop.getnameinfo)
�sslr� r� r� �sock�
local_addr�server_hostname�ssl_handshake_timeout�happy_eyeballs_delay�
interleavec
� s t �d S r; rb )r! �protocol_factoryr� r� r� r� r� r� r� r� r� r� r� r� r& r& r' �create_connection* s z#AbstractEventLoop.create_connection�d T) r� r� r� �backlogr� �
reuse_address�
reuse_portr� rg c
� s t �d S r; rb )
r! r� r� r� r� r� r� r� r� r� r� r� rg r& r& r' �
create_server3 s 3z AbstractEventLoop.create_server)�fallbackc � s t �d S r; rb )r! � transport�file�offset�countr� r& r& r' �sendfileh s zAbstractEventLoop.sendfileF)� server_sider� r� c � s t �d S r; rb )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; rb )r! r� �pathr� r� r� r� r& r& r' �create_unix_connection{ s z(AbstractEventLoop.create_unix_connection)r� r� r� r� rg c � s t �d S r; rb )r! r� r� r� r� r� r� rg r& r& r' �create_unix_server� s z$AbstractEventLoop.create_unix_server)r� r� r� r� r� �allow_broadcastr� c � s t �d S r; rb ) 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 �d S r; rb �r! r� �piper& r& r' �connect_read_pipe� s z#AbstractEventLoop.connect_read_pipec � s t �d S r; rb r� r& r& r' �connect_write_pipe� s z$AbstractEventLoop.connect_write_pipe)�stdin�stdout�stderrc � s t �d S r; rb )r! r� �cmdr� r� r� �kwargsr& r& r' �subprocess_shell� s z"AbstractEventLoop.subprocess_shellc � s t �d S r; rb )r! r� r� r� r� r# r� r& r& r' �subprocess_exec� s z!AbstractEventLoop.subprocess_execc G s t �d S r; rb �r! �fdr" r# r& r& r' �
add_reader� s z AbstractEventLoop.add_readerc C s t �d S r; rb �r! r� r& r& r' �
remove_reader� s z AbstractEventLoop.remove_readerc G s t �d S r; rb r� r& r& r' �
add_writer� s z AbstractEventLoop.add_writerc C s t �d S r; rb r� r& r& r' �
remove_writer� s z AbstractEventLoop.remove_writerc � s t �d S r; rb )r! r� �nbytesr& r& r' � sock_recv s zAbstractEventLoop.sock_recvc � s t �d S r; rb )r! r� Zbufr& r& r' �sock_recv_into s z AbstractEventLoop.sock_recv_intoc � s t �d S r; rb )r! r� �datar& r& r' � sock_sendall s z AbstractEventLoop.sock_sendallc � s t �d S r; rb )r! r� Zaddressr& r& r' � sock_connect s z AbstractEventLoop.sock_connectc � s t �d S r; rb )r! r� r& r& r' � sock_accept s z AbstractEventLoop.sock_acceptc � s t �d S r; rb )r! r� r� r� r� r� r& r& r' �
sock_sendfile s z AbstractEventLoop.sock_sendfilec G s t �d S r; rb )r! �sigr" r# r& r& r' �add_signal_handler s z$AbstractEventLoop.add_signal_handlerc C s t �d S r; rb )r! r� r& r& r' �remove_signal_handler s z'AbstractEventLoop.remove_signal_handlerc C s t �d S r; rb )r! �factoryr& r& r' �set_task_factory s z"AbstractEventLoop.set_task_factoryc C s t �d S r; rb r9 r& r& r' �get_task_factory" s z"AbstractEventLoop.get_task_factoryc C s t �d S r; rb r9 r& r& r' �get_exception_handler' s z'AbstractEventLoop.get_exception_handlerc C s t �d S r; rb )r! Zhandlerr& r& r' �set_exception_handler* s z'AbstractEventLoop.set_exception_handlerc C s t �d S r; rb �r! r% r& r& r' �default_exception_handler- s z+AbstractEventLoop.default_exception_handlerc C s t �d S r; rb r� r& r& r' rB 0 s z(AbstractEventLoop.call_exception_handlerc C s t �d S r; rb r9 r& r& r' r 5 s zAbstractEventLoop.get_debugc C s t �d S r; rb )r! Zenabledr& r& r' � set_debug8 s zAbstractEventLoop.set_debug)r )NN)NN)r N)N)N)NN)r N):r- rG rH rl rm rn ro rp rd rq r` rt rr ru rv rw rz r{ r~ r r� r� r� �socketZ AF_UNSPECZ
AI_PASSIVEr� r� r� r� r� r� r� r� �
subprocess�PIPEr� 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 @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd S ) r c C s t �d S r; rb r9 r& r& r' r ? s z&AbstractEventLoopPolicy.get_event_loopc C s t �d S r; rb �r! r$ r& r& r' r I s z&AbstractEventLoopPolicy.set_event_loopc C s t �d S r; rb r9 r& r& r' r
M s z&AbstractEventLoopPolicy.new_event_loopc C s t �d S r; rb r9 r& r& r' r U s z)AbstractEventLoopPolicy.get_child_watcherc C s t �d S r; rb )r! �watcherr& r& r' r Y s z)AbstractEventLoopPolicy.set_child_watcherN)r- rG rH r r r
r r r& r& r& r' r < s
r c @ sB e Zd ZdZG dd� dej�Zdd� Zdd� Zdd � Z d
d � Z
dS ) �BaseDefaultEventLoopPolicyNc @ 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 jd kr2| j js2tt�� tj�r2| �| �� � | j jd krPt dt�� j
��| j jS )Nz,There is no current event loop in thread %r.) r� r r� r] � threadingZcurrent_threadZ _MainThreadr r
� RuntimeErrorrx r9 r& r& r' r t s �� �z)BaseDefaultEventLoopPolicy.get_event_loopc C s d| j _|| j _d S r7 )r� r� r r� r& r& r' r � s z)BaseDefaultEventLoopPolicy.set_event_loopc C s | � � S r; )�
_loop_factoryr9 r& r& r' r
� s z)BaseDefaultEventLoopPolicy.new_event_loop) r- rG rH 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 � } | d krtd��| S )Nzno running event loop)r r� �r$ r& r& r' r � s r c C s& t j\} }| d k r"|t�� kr"| S d S r; )�
_running_loopr� �os�getpid)Z running_loop�pidr& r& r' r � s
r c C s | t �� ft_d S r; )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 d krt� t S r; )r� r� r& r& r& r' r � s r c C s | a d S r; )r� )Zpolicyr& r& r' r � s r c C s t � } | d k r| S t� �� S r; )r r r )Z current_loopr& r& r' r � s
r c C s t � �| � d S r; )r r r� r& r& r' r � s r c C s
t � �� S r; )r r
r& r& r& r' r
� s r
c C s
t � �� S r; )r r r& r& r& r' r � s r c C s t � �| �S r; )r r )r� r& r& r' r � s r )r r
r r )+�__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' �<module> sV J@* q"9
PK [\dks s . __pycache__/windows_utils.cpython-38.opt-2.pycnu �[��� U
e5d� � @ s� d dl Z e jdkred��d dlZd dlZd dlZd dlZd dlZd dlZd dl Z dZ
dZ ej Z ej
Z
e�� Zdde d�d d
�ZG d d � d �ZG d
d� dej�ZdS )� NZwin32z
win32 only)�pipe�Popen�PIPE�
PipeHandlei F)TT)�duplex�
overlapped�bufsizec
C s$ t jd�t�� tt��d�}| r>tj}tj tj
B }|| }}ntj }tj
}d| }}|tj O }|d rp|tj
O }|d r�tj
}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 � T�r )�tempfileZmktemp�format�os�getpid�next�
_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 ZaddressZopenmode�accessZobsizeZibsizeZflags_and_attribsZh1Zh2Zov� r �-/usr/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��_handle��self�handler r r �__init__V s zPipeHandle.__init__c C s2 | j d k rd| j ��}nd}d| jj� d|� d�S )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 �t�v�tbr r r �__exit__v s zPipeHandle.__exit__N)r# �
__module__� __qualname__r r$ �propertyr r' r r r( �warnings�warnr+ 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 kr�tdd�\} }t�|d�}n|tkr�|}n|}z�z t� j |f|||d�|�� W n0 | |
| fD ]}|d k r�t
� |� qւ Y n>X | d k �r
t | �| _
|
d k �r t |
�| _| d k �r2t | �| _W 5 |t k�rJt�|� |t k�r^t�|� |t k�rrt�|� X d S )N)FTT)r r )TFr r )�stdin�stdout�stderr)r r �msvcrtZopen_osfhandler �O_RDONLY�STDOUTr( �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_wh�h�r" r r r � sN ��
zPopen.__init__)NNN)r# r1 r2 r �
__classcell__r r r@ r r } s r )�sys�platform� ImportErrorr � itertoolsr9 r �
subprocessr r4 �__all__ZBUFSIZEr r; �countr r r r r r r r �<module> s"
1,PK [��q�l l - __pycache__/base_futures.cpython-38.opt-1.pycnu �[��� U
e5d
� @ 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 | jd�o| jdk S )z�Check for a Future.
This returns True when obj is a Future instance or is advertising
itself as duck-type compatible by setting _asyncio_future_blocking.
See comment in Future for more details.
�_asyncio_future_blockingN)�hasattr� __class__r )�objr r �,/usr/lib64/python3.8/asyncio/base_futures.py�isfuture s �r c C s� t | �}|sd} dd� }|dkr2|| d d �} n`|dkr`d�|| d d �|| d d ��} n2|dkr�d�|| d d �|d || d d ��} d
| � d �S ) �#helper function for Future.__repr__� c S s t �| d�S )Nr )r Z_format_callback_source)�callbackr r r
� format_cb s z$_format_callbacks.<locals>.format_cbr r � z{}, {}z{}, <{} more>, {}���zcb=[�])�len�format)�cb�sizer 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_state�lower� _FINISHEDZ
_exception�append�idr �
_repr_running�add�discard�reprlib�reprZ_resultZ
_callbacksr Z_source_traceback)Zfuture�info�key�result�framer r r
�_future_repr_info7 s$
r& )�__all__r �_threadr r
r Z_PENDINGZ
_CANCELLEDr r r �setr r& r r r r
�<module> s PK [ �?�/m /m ' __pycache__/events.cpython-38.opt-1.pycnu �[��� U
e5d4f � @ s| d Z dZddlZddlZddlZddlZddlZddlZddlm Z ddlm
Z
G dd� d�Z G d d
� d
e �Z G d d � d �Z
G d
d� d�ZG dd� d�ZG dd� de�Zdae�� ZG dd� dej�Ze� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z d!d"� Z d#d$� Z d%d&� Z d'd(� Z d)d*� Z!eZ"eZ#eZ$e Z%z dd+l&mZmZmZm Z W n e'k
�rf Y nX eZ(eZ)eZ*e Z+dS ),z!Event loop and event loop policy.)�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�_get_running_loop� N� )�format_helpers)�
exceptionsc @ sF e Zd ZdZdZddd�Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
dS )r z1Object returned by callback registration methods.)� _callback�_args�
_cancelled�_loop�_source_traceback�_repr� __weakref__�_contextNc C s\ |d krt �� }|| _|| _|| _|| _d| _d | _| j�� rRt �
t � d��| _
nd | _
d S )NFr )� contextvarsZ copy_contextr r r r r r � get_debugr �
extract_stack�sys� _getframer )�self�callback�args�loop�context� r& �&/usr/lib64/python3.8/asyncio/events.py�__init__ s
�zHandle.__init__c C sl | j jg}| jr|�d� | jd k r:|�t�| j| j�� | jrh| jd }|�d|d � d|d � �� |S )N� cancelled���z created at r �:r ) � __class__�__name__r �appendr r �_format_callback_sourcer r )r! �info�framer& r& r' �
_repr_info/ s
�
zHandle._repr_infoc C s( | j d k r| j S | �� }d�d�|��S )Nz<{}>� )r r2 �format�join)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 exception�handleZsource_traceback) r �runr r �
SystemExit�KeyboardInterrupt�
BaseExceptionr r/ r r �call_exception_handler)r! �exc�cb�msgr% 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� fdd�Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
� fdd�Zdd� 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 | j�S 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 |t�r:| 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 )z�Return 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.N��NotImplementedErrorr9 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 )z�Start 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 )z�Start 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� d2d3�Zdxd0d4�d5d6�Z d7d d d8�d9d:�Z dyd d d d d;�d<d=�Z dzd d/d d d0d>�d?d@�Z d{d&d&d&d d d d dA�dBdC�Z dDdE� Z!dFdG� Z"e#j$e#j$e#j$dH�dIdJ�Z%e#j$e#j$e#j$dH�dKdL�Z&dMdN� Z'dOdP� Z(dQdR� Z)dSdT� Z*dUdV� Z+dWdX� Z,dYdZ� Z-d[d\� Z.d]d^� Z/d|d d4�d_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 )z�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.
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 )z�Close 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_later�r! 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! �executor�funcr# 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 )�family�type�proto�flagsc � s t �d S r; rc )r! �host�portr� 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_addr�server_hostname�ssl_handshake_timeout�happy_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_connection�d 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! � transport�file�offset�countr� 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)�stdin�stdout�stderrc � 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� �
subprocess�PIPEr� 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 )z�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.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� dej�Zdd� 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�� tj�r2| �| �� � | 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 )z�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.
N)�
_running_loopr� �os�getpid)Z running_loop�pidr& r& r' r � s
r c C s | t �� ft_dS )z�Set 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' �<module> sX J@* q"9
PK [C��ktT tT # __pycache__/sslproto.cpython-38.pycnu �[��� U
e5dJj � @ 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� de�ZG dd� dejej�ZG dd� dej�ZdS )� N� )� base_events)� constants)� protocols)�
transports)�loggerc C s" | r t d��t�� }|s d|_|S )Nz(Server side SSL needs a valid SSLContextF)�
ValueError�sslZcreate_default_contextZcheck_hostname)� server_side�server_hostname�
sslcontext� r
�(/usr/lib64/python3.8/asyncio/sslproto.py�_create_transport_context s r Z UNWRAPPEDZ DO_HANDSHAKEZWRAPPEDZSHUTDOWNc @ s~ e Zd ZdZdZddd�Zedd� �Zedd � �Zed
d � �Z ed d
� �Z
ddd�Z d dd�Z dd� Z
d dd�Zd dd�ZdS ) �_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)�self�contextr
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 sb | j tkrtd��| jj| j| j| j| jd�| _ t
| _ || _ | j ddd�\}}t
|�dks^t�|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_handshaker )r r � RuntimeErrorr Zwrap_bior r r r r �
_DO_HANDSHAKEr � feed_ssldata�len�AssertionError�r �callback�ssldata�appdatar
r
r � do_handshakej s
�z_SSLPipe.do_handshakec C sj | j tkrtd��| j tkr$td��| j ttfks6t�t| _ || _| �d�\}}|g ksf|dgksft�|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+ r
r
r �shutdown s
z_SSLPipe.shutdownc C s2 | j �� | �d�\}}|g ks.|dgks.t�dS )z�Send 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
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 �}|� |� |s�q�q�nJ| j t
kr�| j�� d| _t| _ | jr�| �� n| j tkr�|� | j�
� � W nz tjtjfk
�rl } zRt|dd�}|tjtjtjfk�rP| j tk�rN| j �rN| � |� � |tjk| _W 5 d}~X Y nX | jj�r�|� | 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().
FN�errno)r r r r �writer' r r/ r" r �read�max_size�appendr0 Zunwrapr r �SSLError�CertificateError�getattr�SSL_ERROR_WANT_READ�SSL_ERROR_WANT_WRITE�SSL_ERROR_SYSCALLr �pending)r �datar% r. r- �chunk�exc� exc_errnor
r
r r( � sZ
�
z_SSLPipe.feed_ssldatar c
C s4 d| krt |�ks n t�| jtkrT|t |�k rD||d� g}ng }|t |�fS g }t|�}d| _z(|t |�k r�|| j�||d� �7 }W nh tj k
r� } zHt
|dd�}|j dkr�tj }|_
|tj tjtjfkrڂ |tj k| _W 5 d}~X Y nX | jj�r|�| j�� � |t |�k�s,| jr`�q,q`||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.
r NFr3 ZPROTOCOL_IS_SHUTDOWN)r) r* r r �
memoryviewr r r4 r r8 r: �reasonr; r3 r< r= r r> r7 r5 )r r? �offsetr- ZviewrA rB r
r
r � feed_appdata� s6
�
z_SSLPipe.feed_appdata)N)N)N)F)r )�__name__�
__module__� __qualname__�__doc__r6 r �propertyr r r! r# r/ r1 r2 r( rF r
r
r
r r $ s
Kr c @ s� e Zd ZejjZdd� Zd"dd�Zdd� Z dd � Z
d
d � Z d d
� Z e
jfdd�Zdd� Zdd� Zdd� Zd#dd�Zdd� 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.)rN �_get_extra_info�r �name�defaultr
r
r �get_extra_info' s z$_SSLProtocolTransport.get_extra_infoc C s | j �|� d S �N)rN �_set_app_protocol)r �protocolr
r
r � set_protocol+ s z"_SSLProtocolTransport.set_protocolc C s | j jS rV )rN �
_app_protocolr r
r
r � get_protocol. s z"_SSLProtocolTransport.get_protocolc C s | j S rV )rO 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)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�� dS )z�Pause the receiving end.
No data will be passed to the protocol's data_received()
method until resume_reading() is called.
N)rN rb �
pause_readingr r
r
r rd J s z#_SSLProtocolTransport.pause_readingc C s | j j�� dS )z�Resume the receiving end.
Data received will once again be passed to the protocol's
data_received() method.
N)rN rb �resume_readingr r
r
r re 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)rN rb �set_write_buffer_limits)r ZhighZlowr
r
r rf Z s z-_SSLProtocolTransport.set_write_buffer_limitsc C s | j j�� S )z,Return the current size of the write buffer.)rN rb �get_write_buffer_sizer r
r
r rg o s z+_SSLProtocolTransport.get_write_buffer_sizec C s
| j jjS rV )rN rb �_protocol_pausedr r
r
r rh s s z&_SSLProtocolTransport._protocol_pausedc C s< t |tttf�s$tdt|�j� ���|s,dS | j�|� dS )z�Write 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) �
isinstance�bytes� bytearrayrC � TypeError�typerG rN �_write_appdata�r r? r
r
r r4 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 )z�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.
TN)rN �_abortrO r r
r
r �abort� s
z_SSLProtocolTransport.abort)N)NN)rG rH rI r Z
_SendfileModeZFALLBACKZ_sendfile_compatibler rU rY r[ r\ r^ �warnings�warnra rc rd re rf rg rK rh r4 rp rr r
r
r
r rL s$
rL c @ s� e Zd ZdZd,dd�Zdd� Zd-d d
�Zd d � Zd
d� Zdd� Z dd� Z
dd� Z dd� Z d.dd�Z
dd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd/d&d'�Zd(d)� Zd*d+� ZdS )0� SSLProtocolz�SSL 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 � _sslcontext�dict�_extra� collections�deque�_write_backlog�_write_buffer_size�_waiterrM rW 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 rV )rZ ri r ZBufferedProtocol�_app_protocol_is_buffer)r r� r
r
r rW � s
�z SSLProtocol._set_app_protocolc C sD | j d krd S | j �� s:|d k r.| j �|� n | j �d � d | _ d S rV )r} Z cancelledZ
set_exceptionZ
set_result�r rA 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)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| jdk r2d| j_d| _d| _t| dd�rT| j �
� | � |� d| _d| _ dS )z�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).
FNT�_handshake_timeout_handle)
r� rM � call_soonrZ �connection_lostr~ rO rb r: 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)rZ �
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)rZ �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&| jr�t �
| j |� n | j � |� W nP ttfk
r� � Y n8 tk
�r
} z| �|d� W Y � dS d}~X Y nX q�| �
� �q q�dS )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( �
SystemExit�KeyboardInterrupt�
BaseException� _fatal_errorrb r4 r� r Z _feed_data_to_buffered_protorZ �
data_receivedr] )r r? r- r. �er@ Zexr
r
r r� s<
� � zSSLProtocol.data_receivedc C sT zB| j�� rt�d| � | �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) rb r^ rM � get_debugr �debugr� �ConnectionResetErrorr� rZ � 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 rV )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| r) �_process_write_backlogro r
r
r rn T s zSSLProtocol._write_appdatac C s\ | j �� r$t�d| � | j �� | _nd | _d| _| j�d� | 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 }t�d| |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 @�@)�peercert�cipher� 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� rZ 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 sP | j d ks| jd krd S z�tt| j��D ]�}| jd \}}|rR| j�||�\}}n*|rj| j�| j�}d}n| j�| j �}d}|D ]}| j �
|� q�|t|�k r�||f| jd< | jj s�t �| j j
r�| j �� q�| jd= | jt|�8 _q(W n^ ttfk
�r � Y nD tk
�rJ } z$| j�r.| �|� n | �|d� W 5 d }~X Y nX d S )Nr r z Fatal error on SSL transport)rb r �ranger) r{ rF r/ r� r1 � _finalizer4 r! r* Z_pausedre r| r� r� r� r� r� )r �ir? rE r- r@ rA r
r
r r� � s< �
z"SSLProtocol._process_write_backlog�Fatal error on transportc C sV t |t�r(| j�� r@tjd| |dd� n| j�||| j| d�� | jrR| j�|� d S )Nz%r: %sT)�exc_info)�messageZ exceptionr� rX ) 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 rV )r rb r^ r r
r
r r� � s
zSSLProtocol._finalizec C s( z| jd k r| j�� W 5 | � � X d S rV )r� rb rr r r
r
r rq � s
zSSLProtocol._abort)FNTN)N)N)r� )rG rH rI rJ r rW r� r� r� r� r� r� r� rQ r] rn r� r� r� r� r� r� rq r
r
r
r ru � s0 �
.
&
)+
ru )ry rs r � ImportError� r r r r �logr r r r' r" r0 �objectr Z_FlowControlMixinZ TransportrL ZProtocolru r
r
r
r �<module> s*
y�xPK [$��'� � + __pycache__/base_tasks.cpython-38.opt-2.pycnu �[��� U
e5d� � @ 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_cancel�insertZget_namer Z_format_coroutine�_coroZ _fut_waiter)�task�info�coro� r
�*/usr/lib64/python3.8/asyncio/base_tasks.py�_task_repr_info s
r c C s� g }t | jd�r| jj}n0t | jd�r0| jj}nt | jd�rF| 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�|dkr�q�|d8 }|�|j
� |j }q�|S )N�cr_frame�gi_frame�ag_framer r ) �hasattrr r r r �append�f_back�reverse�
_exception�
__traceback__�tb_frame�tb_next)r
�limitZframes�f�tbr
r
r �_task_get_stack s6
r c C s� g }t � }| j|d�D ]Z}|j}|j}|j}|j} ||krN|�|� t�|� t� |||j
�}
|� ||| |
f� q| j } |s�t
d| ��|d� n2| d k r�t
d| �d�|d� nt
d| �d�|d� tj||d� | d k r�t�| j| �D ]}
t
|
|dd� q�d S ) N)r z
No stack for )�filezTraceback for z (most recent call last):z
Stack for � )r �end)�setZ get_stack�f_lineno�f_code� co_filename�co_name�add� linecache�
checkcache�getline� f_globalsr r �print� traceback�
print_list�format_exception_only� __class__) r
r r �extracted_list�checkedr �lineno�co�filename�name�line�excr
r
r �_task_print_stack< s,
r9 )r( r- r r r r r r9 r
r
r
r �<module> s #PK [��q�l l ' __pycache__/base_futures.cpython-38.pycnu �[��� U
e5d
� @ 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 | jd�o| jdk S )z�Check for a Future.
This returns True when obj is a Future instance or is advertising
itself as duck-type compatible by setting _asyncio_future_blocking.
See comment in Future for more details.
�_asyncio_future_blockingN)�hasattr� __class__r )�objr r �,/usr/lib64/python3.8/asyncio/base_futures.py�isfuture s �r c C s� t | �}|sd} dd� }|dkr2|| d d �} n`|dkr`d�|| d d �|| d d ��} n2|dkr�d�|| d d �|d || d d ��} d
| � d �S ) �#helper function for Future.__repr__� c S s t �| d�S )Nr )r Z_format_callback_source)�callbackr r r
� format_cb s z$_format_callbacks.<locals>.format_cbr r � z{}, {}z{}, <{} more>, {}���zcb=[�])�len�format)�cb�sizer 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_state�lower� _FINISHEDZ
_exception�append�idr �
_repr_running�add�discard�reprlib�reprZ_resultZ
_callbacksr Z_source_traceback)Zfuture�info�key�result�framer r r
�_future_repr_info7 s$
r& )�__all__r �_threadr r
r Z_PENDINGZ
_CANCELLEDr r r �setr r& r r r r
�<module> s PK [rn n - __pycache__/base_futures.cpython-38.opt-2.pycnu �[��� U
e5d
� @ 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 | jd�o| jd k S )N�_asyncio_future_blocking)�hasattr� __class__r )�objr r �,/usr/lib64/python3.8/asyncio/base_futures.py�isfuture s �r c C s� t | �}|sd} dd� }|dkr2|| d d �} n`|dkr`d�|| d d �|| d d ��} n2|dkr�d�|| d d �|d || d d ��} d
| � d �S ) N� c S s t �| d�S )Nr )r Z_format_callback_source)�callbackr r r
� format_cb s z$_format_callbacks.<locals>.format_cbr r � z{}, {}z{}, <{} more>, {}���zcb=[�])�len�format)�cb�sizer 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_state�lower� _FINISHEDZ
_exception�append�idr �
_repr_running�add�discard�reprlib�reprZ_resultZ
_callbacksr Z_source_traceback)Zfuture�info�key�result�framer r r
�_future_repr_info7 s$
r% )�__all__r �_threadr r r Z_PENDINGZ
_CANCELLEDr r r �setr r% r r r r
�<module> s PK [�� +�[ �[ 0 __pycache__/proactor_events.cpython-38.opt-2.pycnu �[��� U
e5d<} � @ 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� dejej�ZG dd� deej�ZG dd� deej�ZG dd� de�ZG dd� de�Z 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| jkr�z|�
� | jd< W n tjk
r� d | jd< Y nX d S )N�socketZsocknamezgetsockname() failed on %rT��exc_info�peername) r �TransportSocket�_extraZ getsocknamer
�error�_loop� get_debugr �warningZ getpeername)� transport�sock� r �//usr/lib64/python3.8/asyncio/proactor_events.py�_set_socket_extra s
�
r c s~ e Zd Zd� fdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z e
j fdd�Z d dd�Z
dd� Zdd� Zdd� Z� ZS ) �_ProactorBasePipeTransportNc s� t � �||� | �|� || _| �|� || _d | _d | _d | _d| _ d| _
d| _ d| _ | jd k rl| j�
� | j�| jj| � |d k r�| j�tj|d � d S )Nr F)�super�__init__�
_set_extra�_sock� set_protocol�_server�_buffer� _read_fut�
_write_fut�_pending_write�
_conn_lost�_closing� _eof_writtenZ_attachr � call_soon� _protocolZconnection_mader Z _set_result_unless_cancelled��self�loopr �protocol�waiter�extra�server�� __class__r r r 2 s(
�z#_ProactorBasePipeTransport.__init__c C s� | j jg}| jd kr |�d� n| jr0|�d� | jd k rP|�d| j�� � �� | jd k rl|�d| j��� | jd k r�|�d| j��� | jr�|�dt | j�� �� | j
r�|�d� d� d � |��S )
N�closed�closingzfd=zread=zwrite=zwrite_bufsize=z EOF writtenz<{}>� )
r4 �__name__r �appendr( �filenor$ r% r# �lenr) �format�join)r- �infor r r �__repr__H s
z#_ProactorBasePipeTransport.__repr__c C s || j d< d S )N�pipe)r �r- r r r r r Z s z%_ProactorBasePipeTransport._set_extrac C s
|| _ d S �N�r+ )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|t�r*| j�� rBtjd| |dd� n| j�||| | jd�� W 5 | � |� X d S )Nz%r: %sTr )�message� exceptionr r/ ) � _force_close�
isinstance�OSErrorr r r �debug�call_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_waiter�done�
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 | jd�r,| j�tj� | j�� d | _| j}|d k rX|�� d | _X d S )N�shutdown)
�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| j�7 }|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 �warnings�warnrL 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
� Zddd�Z � 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,t�d| � 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 �� rt�d| � 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�
SystemExit�KeyboardInterrupt�
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| jtj�r�zt�| j|� W q� tt fk
rZ � Y q� t
k
r� } z| � |d� W Y �d S d }~X Y q�X 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�
� r�tjddd� 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> | j�s:� Y nX | j�sV| 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 � _proactor�recvr �ConnectionAbortedErrorrV r r rS �ConnectionResetErrorrP rR r �CancelledError�add_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� fdd�Zdd� Zddd�Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z � Z S )� _ProactorBaseWritePipeTransportTc s t � j||� d | _d S rB )r r rW �r- �args�kwr3 r r r G s z(_ProactorBaseWritePipeTransport.__init__c C s� t |tttf�s$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.| js�t|�| _| �� 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� TypeError�typer8 r) � RuntimeErrorrW r' r �!LOG_THRESHOLD_FOR_CONNLOST_WRITESr r r% �
_loop_writingr# �_maybe_pause_protocol�extendrj 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 �� s�t|�| _| j �| j� | �� n| j �| j� | jd k r�| j d kr�| j�d � 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� fdd�Zdd� 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
d�Z ddd�Z
� Z S )�_ProactorDatagramTransporti Nc s> || _ d | _t� j|||||d� t�� | _| j�| j � d S )N)r0 r1 )
�_addressrW r r � collections�dequer# 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 � <genexpr>� s zC_ProactorDatagramTransport.get_write_buffer_size.<locals>.<genexpr>)�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 |tttf�s 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.| j�tj� 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� fdd�Zd3dd�Zd4dddddd�dd �Zd5d
d �Zd6d d
�Zd7dd�Zd8dd�Z � fdd�Z
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 � �� t�d|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� threading�current_thread� main_thread�signal�
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_side�server_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�� kr6t�d� | �� | � � | 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> } zt�d��W 5 d }~X Y nX zt�|�j}W n, t k
r| } zt�d��W 5 d }~X Y nX |r�|n|}|s�dS t
|d�}|r�t
|| |�n|} t
||�}d}
zLt
| | |�}|dkr�|
W �0S | j �
||||�I d H ||7 }|
|7 }
q�W 5 |
dk�r"|� |� X d S )Nznot a regular filer l �� )r: �AttributeError�io�UnsupportedOperationr ZSendfileNotAvailableError�os�fstat�st_sizerR �min�seekrs �sendfile) r- r �file�offset�countr: �errZfsizeZ blocksizeZend_posZ
total_sentr r r �_sock_sendfile_native� s0
z+BaseProactorEventLoop._sock_sendfile_nativec � sZ |� � }|�� |�� I d H z | j|j|||dd�I 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 �� \| _| _| j�d� | j�d� | 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_self�d c s( d� ������fdd� � �� � � d S )Nc
s, z�| d k rn| � � \}}�jr,t�d�||� �� }�d k rX�j||�dd|i��d� n�j||d|i�d� ��� r|W d S �j���} W n� t k
r� } zH��
� dkrʈ� d|t �
��d�� ��� n�jr�tjd �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.<locals>.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 �<module> sP � � �n � �PK [7�! �! * __pycache__/protocols.cpython-38.opt-1.pycnu �[��� U
e5d� � @ sb d Z dZG dd� d�ZG dd� de�ZG dd� de�ZG dd � d e�ZG d
d � d e�Zd d
� ZdS )z Abstract Protocol base classes.)� BaseProtocol�Protocol�DatagramProtocol�SubprocessProtocol�BufferedProtocolc @ 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 )z�Called 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 �)/usr/lib64/python3.8/asyncio/protocols.py�connection_made s z BaseProtocol.connection_madec C s dS )z�Called 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 �z�Called 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 <bufferobjects>`.
It is an error to return a zero-sized buffer.
Nr )r �sizehintr r r �
get_buffer� s zBufferedProtocol.get_bufferc C s dS )z�Called 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 )z�Called 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 )z�Called 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 �<module> s 9+9PK [� �j$ j$ 0 __pycache__/base_subprocess.cpython-38.opt-1.pycnu �[��� U
e5d�" � @ sx d dl Z d dlZd dlZddlmZ ddlmZ ddlmZ G dd� dej�Z G dd � d ej
�Z G d
d � d e ej �Z
dS ) � N� )� protocols)�
transports)�loggerc s� e Zd Zd0� fdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Zdd� Z e
j fdd�Z dd� Z
dd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Z� Z S )1�BaseSubprocessTransportNc
s& t � �|
� d| _|| _|| _d | _d | _d | _g | _t �
� | _ i | _ d| _
|tjkr`d | j d< |tjkrtd | j d< |tjkr�d | j d< z"| jf ||||||d�| �� W n | �� � Y nX | jj| _| j| jd< | j�� �rt|ttf�r�|} n|d } t�d| | j� | j�| �| �� d S )NFr r � )�args�shell�stdin�stdout�stderr�bufsize�
subprocesszprocess %r created: pid %s) �super�__init__�_closed� _protocol�_loop�_proc�_pid� _returncode�
_exit_waiters� collections�deque�_pending_calls�_pipes� _finishedr �PIPE�_start�close�pidZ_extra� get_debug�
isinstance�bytes�strr �debugZ create_task�_connect_pipes)
�self�loop�protocolr r r
r r r
�waiterZextra�kwargsZprogram�� __class__� �//usr/lib64/python3.8/asyncio/base_subprocess.pyr sL
��
�z BaseSubprocessTransport.__init__c C s | j jg}| jr|�d� | jd k r6|�d| j� �� | jd k rT|�d| j� �� n | jd k rj|�d� n
|�d� | j�d�}|d k r�|�d|j� �� | j�d�}| j�d �}|d k r�||kr�|�d
|j� �� n6|d k r�|�d |j� �� |d k �r |�d |j� �� d
� d�
|��S )N�closedzpid=z returncode=Zrunningz not startedr zstdin=r r zstdout=stderr=zstdout=zstderr=z<{}>� ) r- �__name__r �appendr r r �get�pipe�format�join)r' �infor
r r r. r. r/ �__repr__7 s,
z BaseSubprocessTransport.__repr__c K s t �d S �N)�NotImplementedError)r' r r r
r r r
r+ r. r. r/ r T s z BaseSubprocessTransport._startc C s
|| _ d S r: �r )r' r) r. r. r/ � set_protocolW s z$BaseSubprocessTransport.set_protocolc C s | j S r: r< �r' r. r. r/ � get_protocolZ s z$BaseSubprocessTransport.get_protocolc C s | j S r: )r r> r. r. r/ �
is_closing] s z"BaseSubprocessTransport.is_closingc C s� | j r
d S d| _ | j�� D ]}|d kr(q|j�� q| jd k r�| jd kr�| j�� d kr�| j� � rlt
� d| � z| j� � W n t
k
r� Y nX d S )NTz$Close running child process: kill %r)r r �valuesr5 r r r Zpollr r! r Zwarning�kill�ProcessLookupError)r' �protor. r. r/ r ` s$
� �
z BaseSubprocessTransport.closec C s& | j s"|d| ��t| d� | �� d S )Nzunclosed transport )�source)r �ResourceWarningr )r' Z_warnr. r. r/ �__del__{ s z BaseSubprocessTransport.__del__c C s | j S r: )r r> r. r. r/ �get_pid� s z BaseSubprocessTransport.get_pidc C s | j S r: )r r> r. r. r/ �get_returncode� s z&BaseSubprocessTransport.get_returncodec C s || j kr| j | jS d S d S r: )r r5 )r' �fdr. r. r/ �get_pipe_transport� s
z*BaseSubprocessTransport.get_pipe_transportc C s | j d krt� �d S r: )r rC r> r. r. r/ � _check_proc� s
z#BaseSubprocessTransport._check_procc C s | � � | j�|� d S r: )rL r � send_signal)r' �signalr. r. r/ rM � s z#BaseSubprocessTransport.send_signalc C s | � � | j�� d S r: )rL r � terminater> r. r. r/ rO � s z!BaseSubprocessTransport.terminatec C s | � � | j�� d S r: )rL r rB r> r. r. r/ rB � s z BaseSubprocessTransport.killc
� s` z� j }� j}|jd k rB|�� fdd�|j�I d H \}}|� jd< |jd k rv|�� fdd�|j�I d H \}}|� jd< |jd k r�|�� fdd�|j�I d H \}}|� jd< |�� j j
� � � j D ]\}}|j|f|�� q�d � _ W nZ t t
fk
r� � Y n` tk
�r< } z"|d k �r,|�� �s,|�|� W 5 d }~X Y n X |d k �r\|�� �s\|�d � d S )Nc s
t � d�S )Nr )�WriteSubprocessPipeProtor. r> r. r/ �<lambda>� � z8BaseSubprocessTransport._connect_pipes.<locals>.<lambda>r c s
t � d�S )Nr ��ReadSubprocessPipeProtor. r> r. r/ rQ � rR r c s
t � d�S )Nr rS r. r> r. r/ rQ � rR r )r r r
Zconnect_write_piper r Zconnect_read_piper � call_soonr �connection_mader �
SystemExit�KeyboardInterrupt�
BaseException� cancelledZ
set_exception�
set_result) r' r* �procr( �_r5 �callback�data�excr. r> r/ r& � s@
�
�
�
z&BaseSubprocessTransport._connect_pipesc G s2 | j d k r | j �||f� n| jj|f|�� d S r: )r r3 r rU )r' �cbr_ r. r. r/ �_call� s
z BaseSubprocessTransport._callc C s | � | jj||� | �� d S r: )rb r Zpipe_connection_lost� _try_finish)r' rJ r` r. r. r/ �_pipe_connection_lost� s z-BaseSubprocessTransport._pipe_connection_lostc C s | � | jj||� d S r: )rb r Zpipe_data_received)r' rJ r_ r. r. r/ �_pipe_data_received� s z+BaseSubprocessTransport._pipe_data_receivedc C sp | j �� rt�d| |� || _| jjd kr2|| j_| �| jj � | �
� | j D ]}|� � sN|�
|� qNd | _ d S )Nz %r exited with return code %r)r r! r r8 r r �
returncoderb r Zprocess_exitedrc r rZ r[ )r' rf r* r. r. r/ �_process_exited� s
z'BaseSubprocessTransport._process_exitedc � s0 | j dk r| j S | j�� }| j�|� |I dH S )zdWait until the process exit and return the process return code.
This method is a coroutine.N)r r Z
create_futurer r3 )r' r* r. r. r/ �_wait� s
z BaseSubprocessTransport._waitc C s> | j d krd S tdd� | j�� D ��r:d| _| �| jd � d S )Nc s s | ]}|d k o|j V qd S r: )� disconnected)�.0�pr. r. r/ � <genexpr>� s �z6BaseSubprocessTransport._try_finish.<locals>.<genexpr>T)r �allr rA r rb �_call_connection_lostr> r. r. r/ rc � s
�z#BaseSubprocessTransport._try_finishc C s* z| j�|� W 5 d | _ d | _d | _X d S r: )r r r �connection_lost�r' r` r. r. r/ rn � s
z-BaseSubprocessTransport._call_connection_lost)NN) r2 �
__module__� __qualname__r r9 r r= r? r@ r �warnings�warnrG rH rI rK rL rM rO rB r& rb rd re rg rh rc rn �
__classcell__r. r. r, r/ r
s2 �+ & r c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
S )rP c C s || _ || _d | _d| _d S )NF)r\ rJ r5 ri )r' r\ rJ r. r. r/ r s z!WriteSubprocessPipeProto.__init__c C s
|| _ d S r: )r5 )r' Z transportr. r. r/ rV s z(WriteSubprocessPipeProto.connection_madec C s d| j j� d| j� d| j�d�S )N�<z fd=z pipe=�>)r- r2 rJ r5 r> r. r. r/ r9
s z!WriteSubprocessPipeProto.__repr__c C s d| _ | j�| j|� d | _d S )NT)ri r\ rd rJ rp r. r. r/ ro
s z(WriteSubprocessPipeProto.connection_lostc C s | j j�� d S r: )r\ r �
pause_writingr> r. r. r/ rx s z&WriteSubprocessPipeProto.pause_writingc C s | j j�� d S r: )r\ r �resume_writingr> r. r. r/ ry s z'WriteSubprocessPipeProto.resume_writingN) r2 rq rr r rV r9 ro rx ry r. r. r. r/ rP � s rP c @ s e Zd Zdd� ZdS )rT c C s | j �| j|� d S r: )r\ re rJ )r' r_ r. r. r/ �
data_received s z%ReadSubprocessPipeProto.data_receivedN)r2 rq rr rz r. r. r. r/ rT s rT )r r rs � r r �logr ZSubprocessTransportr Z BaseProtocolrP ZProtocolrT r. r. r. r/ �<module> s v �PK [�Ŀ � ' __pycache__/queues.cpython-38.opt-1.pycnu �[��� U
e5d � @ s� d Z ddlZddlZddlZddlmZ ddlmZ G dd� de�ZG dd � d e�Z 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 ZdZdS )r z;Raised when Queue.get_nowait() is called on an empty Queue.N��__name__�
__module__� __qualname__�__doc__� r r �&/usr/lib64/python3.8/asyncio/queues.pyr s r c @ s e Zd ZdZdS )r zDRaised when the Queue.put_nowait() method is called on a full Queue.Nr
r r r r r s r c @ s� e Zd ZdZd)dd�dd�Zdd� Zd d
� Zd d � Zd
d� Zdd� Z dd� Z
dd� Z dd� Z e
dd� �Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� ZdS )*r a A queue, useful for coordinating producer and consumer coroutines.
If maxsize is less than or equal to zero, the queue size is infinite. If it
is an integer greater than 0, then "await put()" will block when the
queue reaches maxsize, until an item is removed by get().
Unlike the standard library Queue, you can reliably know this Queue's size
with qsize(), since your single-threaded asyncio application won't be
interrupted between calling qsize() and doing an operation on the Queue.
r N��loopc 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�_loop�warnings�warn�DeprecationWarning�_maxsize� collections�deque�_getters�_putters�_unfinished_tasksr ZEvent� _finished�set�_init)�self�maxsizer r r r �__init__! s �
zQueue.__init__c C s t �� | _d S �N)r r �_queue�r" r# r r r r! 6 s z Queue._initc C s
| j �� S r% )r& �popleft�r" r r r �_get9 s z
Queue._getc C s | j �|� d S r% �r& �append�r" �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| �d�d| �� � d�S )N�<z at z#x� �>)�typer �id�_formatr) r r r �__repr__I s zQueue.__repr__c C s dt | �j� d| �� � d�S )Nr2 r3 r4 )r5 r r7 r) r r r �__str__L s z
Queue.__str__c C s~ d| j ��}t| dd �r,|dt| j���7 }| jrH|dt| j�� d�7 }| jrd|dt| j�� d�7 }| jrz|d| j� �7 }|S )Nzmaxsize=r& z _queue=z
_getters[�]z
_putters[z tasks=)r �getattr�listr& r �lenr r )r" �resultr r r r7 O s z
Queue._formatc C s
t | j�S )z Number of items in the queue.)r= r& r) r r r �qsize[ s z Queue.qsizec C s | j S )z%Number of items allowed in the queue.)r r) r r r r# _ s z
Queue.maxsizec C s | j S )z3Return True if the queue is empty, False otherwise.�r& r) r r r �emptyd s z Queue.emptyc C s | j dkrdS | �� | j kS dS )z�Return True if there are maxsize items in the queue.
Note: if the Queue was initialized with maxsize=0 (the default),
then full() is never True.
r FN)r r? r) r r r �fullh s
z
Queue.fullc � s� | � � r�| j�� }| j�|� z|I dH W q |�� z| j�|� W n tk
r` Y nX | � � s~|�� s~| � | j� � Y q X q | �
|�S )z�Put an item into the queue.
Put an item into the queue. If the queue is full, wait until a free
slot is available before adding item.
N) rB r �
create_futurer r, �cancel�remove�
ValueError� cancelledr1 �
put_nowait)r" r. Zputterr r r �puts s
z Queue.putc C s> | � � r t�| �|� | jd7 _| j�� | �| j� dS )zyPut an item into the queue without blocking.
If no free slot is immediately available, raise QueueFull.
r N)rB r r/ r r �clearr1 r r- r r r rH � s
zQueue.put_nowaitc � s� | � � r�| j�� }| j�|� z|I dH W q |�� z| j�|� W n tk
r` Y nX | � � s~|�� s~| � | j� � Y q X q | �
� S )zoRemove and return an item from the queue.
If queue is empty, wait until an item is available.
N) rA r rC r r, rD rE rF rG r1 �
get_nowait)r" �getterr r r �get� s
z Queue.getc C s$ | � � r t�| �� }| �| j� |S )z�Remove and return an item from the queue.
Return an item if one is immediately available, else raise QueueEmpty.
)rA r r* r1 r r- r r r rK � s
zQueue.get_nowaitc C s8 | j dkrtd��| j d8 _ | j dkr4| j�� dS )a$ Indicate that a formerly enqueued task is complete.
Used by queue consumers. For each get() used to fetch a task,
a subsequent call to task_done() tells the queue that the processing
on the task is complete.
If a join() is currently blocking, it will resume when all items have
been processed (meaning that a task_done() call was received for every
item that had been put() into the queue).
Raises ValueError if called more times than there were items placed in
the queue.
r z!task_done() called too many timesr N)r rF r r r) r r r � task_done� s
zQueue.task_donec � s | j dkr| j�� I dH dS )a Block until all items in the queue have been gotten and processed.
The count of unfinished tasks goes up whenever an item is added to the
queue. The count goes down whenever a consumer calls task_done() to
indicate that the item was retrieved and all work on it is complete.
When the count of unfinished tasks drops to zero, join() unblocks.
r N)r r �waitr) r r r �join� s
z
Queue.join)r )r r r
r r$ r! r* r/ r1 r8 r9 r7 r? �propertyr# rA rB rI rH rM rK rN rP r r r r r s(
r c @ s4 e Zd ZdZdd� Zejfdd�Zejfdd�Z dS ) r z�A subclass of Queue; retrieves entries in priority order (lowest first).
Entries are typically tuples of the form: (priority number, data).
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 r! �heapqrR r/ rS r* r r r r r � s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) r zEA subclass of Queue that retrieves most recently added entries first.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 r � s r )
�__all__r rT r � r r � Exceptionr r r r r r r r r �<module> s KPK [�T
� � $ __pycache__/log.cpython-38.opt-1.pycnu �[��� U
e5d| � @ s d Z ddlZe�e�ZdS )zLogging configuration.� N)�__doc__ZloggingZ getLogger� __package__Zlogger� r r �#/usr/lib64/python3.8/asyncio/log.py�<module> s PK [$��'� � + __pycache__/base_tasks.cpython-38.opt-1.pycnu �[��� U
e5d� � @ 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_cancel�insertZget_namer Z_format_coroutine�_coroZ _fut_waiter)�task�info�coro� r
�*/usr/lib64/python3.8/asyncio/base_tasks.py�_task_repr_info s
r c C s� g }t | jd�r| jj}n0t | jd�r0| jj}nt | jd�rF| 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�|dkr�q�|d8 }|�|j
� |j }q�|S )N�cr_frame�gi_frame�ag_framer r ) �hasattrr r r r �append�f_back�reverse�
_exception�
__traceback__�tb_frame�tb_next)r
�limitZframes�f�tbr
r
r �_task_get_stack s6
r c C s� g }t � }| j|d�D ]Z}|j}|j}|j}|j} ||krN|�|� t�|� t� |||j
�}
|� ||| |
f� q| j } |s�t
d| ��|d� n2| d k r�t
d| �d�|d� nt
d| �d�|d� tj||d� | d k r�t�| j| �D ]}
t
|
|dd� q�d S ) N)r z
No stack for )�filezTraceback for z (most recent call last):z
Stack for � )r �end)�setZ get_stack�f_lineno�f_code� co_filename�co_name�add� linecache�
checkcache�getline� f_globalsr r �print� traceback�
print_list�format_exception_only� __class__) r
r r �extracted_list�checkedr �lineno�co�filename�name�line�excr
r
r �_task_print_stack< s,
r9 )r( r- r r r r r r9 r
r
r
r �<module> s #PK [��� ( __pycache__/futures.cpython-38.opt-2.pycnu �[��� U
e5db3 � @ s� d Z ddlZddlZddlZddlZddlmZ ddlmZ ddlm Z ddlm
Z
ej Z ej Z ej
Z
ejZejd ZG dd � d �ZeZd
d � Zd d
� Zdd� Zdd� Zdd� Zdd� Zdd�dd�Zz ddlZW n ek
r� Y n X ej ZZ dS ))�Future� wrap_future�isfuture� N� )� base_futures)�events)�
exceptions)�format_helpersc @ s� e Zd ZeZdZdZdZdZdZ dZ
dd�dd�Z e j
Zdd� Zdd � Zed
d � �Zejd d � �Zd
d� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd�d d �Zd d � Z d d!� Z d"d#� Z d$d%� Z e Z dS )&r NF��loopc C s@ |d krt �� | _n|| _g | _| j�� r<t�t�d��| _ d S )Nr )
r �get_event_loop�_loop�
_callbacksZ get_debugr �
extract_stack�sys� _getframe�_source_traceback��selfr � r �'/usr/lib64/python3.8/asyncio/futures.py�__init__D s
�zFuture.__init__c C s d� | jjd�| �� ��S )Nz<{} {}>� )�format� __class__�__name__�join�
_repr_info�r 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� exception�futureZsource_traceback)�_Future__log_traceback�
_exceptionr r r r
Zcall_exception_handler)r �exc�contextr 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 |�rtd��d| _d S )Nz'_log_traceback can only be set to FalseF)�bool�
ValueErrorr# )r �valr r r r) n s c C s | j }|d krtd��|S )Nz!Future object is not initialized.)r
� RuntimeErrorr r r r �get_loopt s zFuture.get_loopc C s& d| _ | jtkrdS t| _| �� dS )NFT)r# �_state�_PENDING�
_CANCELLED�_Future__schedule_callbacksr r r r �cancel{ s
z
Future.cancelc C sH | j d d � }|sd S g | j d d �< |D ]\}}| jj|| |d� q(d S �N�r& )r r
� call_soon)r Z callbacks�callback�ctxr r r Z__schedule_callbacks� s zFuture.__schedule_callbacksc C s
| j tkS r( )r/ r1 r r r r � cancelled� s zFuture.cancelledc C s
| j tkS r( )r/ r0 r r r r �done� s z Future.donec C s@ | j tkrtj�| j tkr$t�d��d| _| jd k r:| j�| jS )NzResult is not ready.F) r/ r1 r �CancelledError� _FINISHED�InvalidStateErrorr# r$ �_resultr r r r �result� s
z
Future.resultc C s0 | j tkrtj�| j tkr$t�d��d| _| jS )NzException is not set.F)r/ r1 r r; r< r= r# r$ r r r r r! � s
zFuture.exceptionr5 c C sB | j tkr | jj|| |d� n |d kr.t�� }| j�||f� d S r4 )r/ r0 r
r6 � 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 d d �< |S )Nc s g | ]\}}|� kr||f�qS r r )�.0�fr8 �rB r r �
<listcomp>� s �z/Future.remove_done_callback.<locals>.<listcomp>)r �len)r rB Zfiltered_callbacksZ
removed_countr rF r �remove_done_callback� s
�zFuture.remove_done_callbackc C s8 | j tkr t�| j � d| ����|| _t| _ | �� d S )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|t�r0|� }t|�tkrDtd��|| _t | _ | �
� d| _ d S )NrJ zPStopIteration interacts badly with generators and cannot be raised into a FutureT) r/ r0 r r= �
isinstance�type�
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)r: �_asyncio_future_blockingr- r? r r r r � __await__ s zFuture.__await__)!r �
__module__� __qualname__r0 r/ r> r$ r
r rQ r# r r Z_future_repr_infor r r' �propertyr) �setterr. r3 r2 r9 r: r? r! rC rI rK rP rR �__iter__r r r r r s8
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 d S | �|� d S r( )r9 rK )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( )rM �
concurrent�futuresr; r �args� TimeoutErrorr= )r% Z exc_classr r r �_convert_future_exc# s r` c C sR |� � r| �� | �� s d S |�� }|d k r<| �t|�� n|�� }| �|� d S r( )r9 r3 Z set_running_or_notify_cancelr! rP r` r? rK )r\ �sourcer! r? r r r � _set_concurrent_future_state/ s rb c C sT |� � r d S | � � r |�� n2| �� }|d k r>|�t|�� n| �� }|�|� d S r( )r9 r3 r! rP r` r? rK )ra �destr! r? r r r �_copy_future_state> s
rd c s� t ��s t�tjj�s td��t ��s<t�tjj�s<td��t ��rLt��nd �t ��r`t��nd �dd� � ���fdd�}� ���fdd�}��|� ��|� d S ) Nz(A future is required for source argumentz-A future is required for destination argumentc S s" t | �rt|| � n
t| |� d S r( )r rd rb )r" �otherr r r �
_set_stateb s z!_chain_future.<locals>._set_statec s2 | � � r.�d ks�� kr"��� n ���j� d S r( )r9 r3 �call_soon_threadsafe)� destination)� dest_loopra � source_loopr r �_call_check_cancelh s
z)_chain_future.<locals>._call_check_cancelc sJ �� � r �d k r ��� r d S �d ks,��kr8� �| � n��� �| � d S r( )r9 Z is_closedrg )ra )rf ri rh rj r r �_call_set_stateo s �� z&_chain_future.<locals>._call_set_state)r rL r\ r] r rO rZ rC )ra rh rk rl r )rf ri rh ra rj r �
_chain_futureR s � �
rm r
c C s2 t | �r | S |d kr t�� }|�� }t| |� |S r( )r r r Z
create_futurerm )r" r Z
new_futurer r r r | s
r ) �__all__Zconcurrent.futuresr\ r@ Zloggingr � r r r r r r0 r1 r< �DEBUGZ STACK_DEBUGr Z _PyFuturerZ r[ r` rb rd rm r Z_asyncio� ImportErrorZ_CFuturer r r r �<module> s8
q *
PK [� u�
* __pycache__/protocols.cpython-38.opt-2.pycnu �[��� U
e5d� � @ s^ d Z G dd� d�ZG dd� de�ZG dd� de�ZG dd� de�ZG d d
� d
e�Zd d � Zd
S ))� BaseProtocol�Protocol�DatagramProtocol�SubprocessProtocol�BufferedProtocolc @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
S ) r � c C s d S �Nr )�selfZ transportr r �)/usr/lib64/python3.8/asyncio/protocols.py�connection_made s z BaseProtocol.connection_madec C s d S r r �r �excr r r �connection_lost s z BaseProtocol.connection_lostc C s d S r r �r r r r �
pause_writing% s zBaseProtocol.pause_writingc C s d S r r r r r r �resume_writing; s zBaseProtocol.resume_writingN)�__name__�
__module__� __qualname__� __slots__r
r
r r r r r r r s
r c @ s e Zd ZdZdd� Zdd� ZdS )r r c C s d S r r )r �datar r r �
data_received^ s zProtocol.data_receivedc C s d S r r r r r r � eof_receivedd s zProtocol.eof_receivedN)r r r r r r r r r r r B s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) r r c C s d S r r )r �sizehintr r r �
get_buffer� s zBufferedProtocol.get_bufferc C s d S r r )r �nbytesr r r �buffer_updated� s z BufferedProtocol.buffer_updatedc C s d S r r r r r r r � s z BufferedProtocol.eof_receivedN)r r r r r r r r r r r r m s r c @ s e Zd ZdZdd� Zdd� ZdS )r r c C s d S r r )r r Zaddrr r r �datagram_received� s z"DatagramProtocol.datagram_receivedc C s d S r r r r r r �error_received� s z DatagramProtocol.error_receivedN)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 d S r r )r �fdr r r r �pipe_data_received� s z%SubprocessProtocol.pipe_data_receivedc C s d S r r )r r r r r r �pipe_connection_lost� s z'SubprocessProtocol.pipe_connection_lostc C s d S r r r r r r �process_exited� s z!SubprocessProtocol.process_exitedN)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)�__all__r r r r r r% r r r r �<module> s 9+9PK [-w/� � ) __pycache__/__init__.cpython-38.opt-1.pycnu �[��� U
e5d� � @ 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 Zejdkr�ddlT 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 �(/usr/lib64/python3.8/asyncio/__init__.py�<module> sZ �������� �
� � �
PK [���
/ __pycache__/format_helpers.cpython-38.opt-1.pycnu �[��� U
e5dd � @ sd d dl Z d dlZd dlZd dlZd dlZddlmZ dd� Zdd� Zdd � Z dd d �Z
dd
d�Z dS )� N� )� constantsc C sV t �| �} t �| �r&| j}|j|jfS t| tj�r<t | j
�S t| tj �rRt | j
�S d S �N) �inspectZunwrapZ
isfunction�__code__� co_filename�co_firstlineno�
isinstance� functools�partial�_get_function_source�func�
partialmethod)r
�code� r �./usr/lib64/python3.8/asyncio/format_helpers.pyr
s
r c C s8 t | |d �}t| �}|r4|d|d � d|d � �7 }|S )Nz at r �:r )�_format_callbackr )r
�args� func_repr�sourcer r r �_format_callback_source s
r c C sH g }| r |� dd� | D �� |r8|� dd� |�� D �� d�d�|��S )z�Format function arguments and keyword arguments.
Special case for a single parameter: ('hello',) is formatted as ('hello').
c s s | ]}t �|�V qd S r ��reprlib�repr)�.0�argr r r � <genexpr>& s z*_format_args_and_kwargs.<locals>.<genexpr>c s s& | ] \}}|� d t �|�� �V qdS )�=Nr )r �k�vr r r r ( s z({})z, )�extend�items�format�join)r �kwargsr" r r r �_format_args_and_kwargs s r& � c C s� t | tj�r.t||�| }t| j| j| j|�S t| d�rF| j rF| j }n t| d�r^| j
r^| j
}nt | �}|t||�7 }|r�||7 }|S )N� __qualname__�__name__) r r
r r& r r
r �keywords�hasattrr( 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� _getframe�f_backr ZDEBUG_STACK_DEPTH� traceback� StackSummary�extract�
walk_stack�reverse)�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 �<module> s
PK [���� � + __pycache__/coroutines.cpython-38.opt-2.pycnu �[��� U
e5d]" � @ 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 ))� coroutine�iscoroutinefunction� iscoroutine� N� )� base_futures)� constants)�format_helpers)�loggerc C s" t jjp t jj o ttj�d��S )NZPYTHONASYNCIODEBUG)�sys�flags�dev_mode�ignore_environment�bool�os�environ�get� r r �*/usr/lib64/python3.8/asyncio/coroutines.py�_is_debug_mode s �r c @ s� e Zd Zd dd�Zdd� 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> || _ || _t�t�d��| _t|dd �| _t|dd �| _ d S )Nr �__name__� __qualname__)
�gen�funcr �
extract_stackr
� _getframe�_source_traceback�getattrr r )�selfr r r r r �__init__' s
zCoroWrapper.__init__c C sJ t | �}| jr4| jd }|d|d � d|d � �7 }d| jj� d|� d�S ) N���z
, created at r �:r �<� �>)�_format_coroutiner � __class__r )r � coro_repr�framer 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�}|rrd�t�|��}|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_lasti�joinr3 � format_listr ZDEBUG_STACK_DEPTH�rstripr �error)r r r( �msg�tbr 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� t���r �S t���r.�� nt����fdd��� t� � �� t
sX� }nt���� �fdd��}t |_ |S )NzN"@coroutine" decorator is deprecated since Python 3.8, use "async def" instead� )�
stacklevelc ? sr � | |�}t �|�s(t�|�s(t|t�r4|E d H }n:z
|j}W n tk
rR Y n X t|tj j
�rn|� E d H }|S r* ) r Zisfuture�inspectZ isgenerator�
isinstancer r8 �AttributeError� collections�abc� Awaitable)�args�kw�resZ
await_meth�r r r �coroz s
�
zcoroutine.<locals>.coroc s@ t � | |��d�}|jr |jd= t�dd �|_t�dd �|_|S )NrP r r r )r r r r r )rM �kwds�w�rQ r r r �wrapper� s zcoroutine.<locals>.wrapper) �warnings�warn�DeprecationWarningrG r �isgeneratorfunction� functools�wraps�typesr �_DEBUG�
_is_coroutine)r rU r rT r r i s" �
r c C s t �| �pt| dd �tkS )Nr^ )rG r r r^ rP r r r r � s
�r c C s@ t | �tkrdS t| t�r8tt�dk r4t�t | �� dS dS d S )NT�d F)r2 �_iscoroutine_typecacherH �_COROUTINE_TYPES�len�add)�objr r r r � s
r c
sh t | t�� � fdd�}dd� }d }t| d�r:| jr:| j}nt| d�rP| jrP| j}|| �}|sr|| �rn|� d�S |S d }t| d�r�| jr�| j}nt| d �r�| jr�| j}|jp�d
}d }� �r$| jd k �r$t �
| j��s$t � | j�}|d k r�|\}}|d k�r|� d |� d
|� �} n|� d|� d
|� �} n@|d k �rJ|j
}|� d|� d
|� �} n|j}|� d |� d
|� �} | S )Nc s` � rt �| jdi �S t| d�r,| jr,| j}n*t| d�rD| jrD| j}ndt| �j� d�}|� d�S )Nr r r r" z without __name__>z())r Z_format_callbackr �hasattrr r r2 )rQ � coro_name�Zis_corowrapperr r �get_name� s z#_format_coroutine.<locals>.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.<locals>.is_running�cr_coder7 z runningr5 �cr_framez<empty co_filename>r 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_source�f_lineno�co_firstlineno)
rQ rh rj Z coro_coderf Z
coro_frame�filename�lineno�sourcer' 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 �<module> s2 E8 �PK [�с�^ �^ & __pycache__/tasks.cpython-38.opt-1.pycnu �[��� U
e5d�� � @ sv d Z dZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl m Z ddl m
Z
ddl mZ ddl mZ dd l mZ dd
l
mZ e�d�jZdBd d �ZdCd
d�ZdDdd�Zdd� ZG dd� dej�ZeZz ddl Z W n e k
r� Y n X e j ZZ dd�dd�Z ejj Z ejj!Z!ejj"Z"dde"d�dd�Z#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/dd1d2�d3d4�Z0dd �d5d6�Z1d7d8� Z2e
�3� Z4i Z5d9d:� Z6d;d<� Z7d=d>� Z8d?d@� Z9e6Z:e9Z;e7Z<e8Z=z$ddAl m6Z6m9Z9m7Z7m8Z8m4Z4m5Z5 W n e k
�r` Y nX e6Z>e9Z?e7Z@e8ZAdS )Fz0Support for tasks, coroutines and the scheduler.)�Task� create_task�FIRST_COMPLETED�FIRST_EXCEPTION�
ALL_COMPLETED�wait�wait_for� as_completed�sleep�gather�shield�
ensure_future�run_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_tasks�get��loop� r! �%/usr/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_loop�done��.0�tr r! r" � <setcomp>< s �z all_tasks.<locals>.<setcomp>)r r �list�
_all_tasks� RuntimeError�r �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.<locals>.<setcomp>)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_name�AttributeError)�task�namer2 r! r! r" �_set_task_nameX s
r6 c s� e Zd ZdZdZed%dd��Zed&dd��Zddd�� fd d
�
Z� fd d �Z d
d� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd�dd�Zddd �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 )z�Return 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)�warnings�warn�DeprecationWarningr 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�_name�str� _must_cancel� _fut_waiter�_coro� contextvarsZ copy_context�_context�_loop� call_soon� _Task__stepr )�self�coror 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_info�rS 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 d��d S )Nz*Task does not support set_result operation�r, )rS �resultr! r! r" �
set_result� s zTask.set_resultc C s t d��d 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 t�d| �d|����| jr>t|tj�s8t�� }d| _| j}d | _t| j | � �zfz"|d krp|� d �}n
|� |�}W n� t
k
r� } z*| jr�d| _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 �r�td| �d|�d��}| j j| j|| j d� n�|�r|| k�r�td | ���}| j j| j|| j d� n8d|_ |j | j | j d� || _| j�r>| j�� �r>d| _n*td
| �d |���}| j j| j|| j d� n||d k�r`| j j| j| j d� n\t �!|��r�td | �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 �
isinstance�CancelledErrorrM rL r rP r �send�throw�
StopIterationrB rg r` r] �KeyboardInterrupt�
SystemExitrb �
BaseException�getattrr r$ r, rQ rR rO rh �add_done_callback�
_Task__wakeup�inspectZ isgenerator)rS �excrT r_ Zblocking�new_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.<locals>.<setcomp>)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` )�waiter�argsr! r! r" �_release_waiter� s r� r c
� s� |dkrt �� }ntjdtdd� |dkr4| I dH S |dkr�t| |d�} | �� rX| �� S t| |d�I dH z | �� W n. t j
k
r� } zt � � |�W 5 d}~X Y n
X t � � �|� � }|�
|t|�}t�t|�}t| |d�} | �|� z�z|I dH W nP t j
k
�rF | �� �r$| �� Y W �dS | �|� t| |d�I dH � Y nX | �� �r^| �� W �*S | �|� t| |d�I 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� � functools�partialrr rg �remove_done_callback)�futr~ r ru r� �timeout_handle�cbr! r! r" r � sL
�
r c
� s� |� � �d�|dk r"|�|t���t| �� � ���fdd�}| D ]}|�|� q@z�I dH W 5 �dk rp��� | D ]}|�|� qtX t� t� }}| D ]"}|�� r�|� |� q�|� |� q�||fS )zVInternal helper for wait().
The fs argument must be a collection of Futures.
Nc sZ � d8 � � dks4�t ks4�tkrV| �� sV| �� d k rV�d k rD��� ��� sV��d � d S )Nr r )r r � cancelledra rg r% r` �r� �Zcounterr r� r� r! r" �_on_completion s ���
�z _wait.<locals>._on_completion)
r� r� r� �lenrr rg r� r� r% �add)r� r~ r r r� r� r% Zpendingr! r� r" r� � s( r� c � sF |� � }t�t|�}| �|� z| �� |I dH W 5 | �|� X dS )z<Cancel the *fut* future or task and wait until it completes.N)r� r� r� r� rr r� rg )r� r r� r� r! r! r" r� & s
r� )r r~ c # s� t �| �st�| �r(tdt| �j� ���ddlm} |�d���dkrPt �
� �nt j dt
dd� �fd d
�t| �D ��d�� ��fd d �}���fd
d�� �fdd�}�D ]}|�� � q��r�|dk r҈�||��tt���D ] }|� V q�dS )a^ Return an iterator whose values are coroutines.
When waiting for the yielded coroutines you'll get the results (or
exceptions!) of the original Futures (or coroutines), in the order
in which and as soon as they complete.
This differs from PEP 3148; the proper way to use this is:
for f in as_completed(fs):
result = await f # The 'await' may raise.
# Use result.
If a timeout is specified, the 'await' will raise
TimeoutError when the timeout occurs before all Futures are done.
Note: The futures 'f' are not necessarily members of fs.
z#expect an iterable of futures, not r )�Queuer Nr� r7 r8 c s h | ]}t |� d ��qS r� r� r� r r! r" r) U s z as_completed.<locals>.<setcomp>c s* �D ]} | � � � ��d � q��� d S r1 )r� �
put_nowait�clearr� )r� r% �todor! r" � _on_timeoutX s
z!as_completed.<locals>._on_timeoutc s4 �sd S �� | � � �| � �s0�d k r0��� d S r1 )�remover� rg r� )r% r� r� r! r" r� ^ s
z$as_completed.<locals>._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.<locals>._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 )z�Skip 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
| �|d�S td��dS )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 )z�Helper 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 )�_GatheringFuturez�Helper 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 � d�d�|D ]f}||kr�t|| d�}| dkr�t� |�} ||k r�d |_
�d
7 �|||< |� |� n|| }� � |� qdt
� | d���S ) 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 ��kr�g }� D ]8} | �� r�t�� }n| �� }|d kr�| �� }|�|� qt�jrĈ�t�� � n
�� |� d S )Nr )
r% r� ra r rj rb r_ �appendr� r` )r� ru Zresults�res�r� Z nfinishedZnfuts�outerr� r! r" �_done_callback s4
z gather.<locals>._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_fut�argr� r! r� r" r
� s:
�
1
r
c st |dk rt jdtdd� t| |d����� r0�S 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.<locals>._inner_done_callbackc s �� � s��� � d S r1 )r% r� r� )r� r� r! r" �_outer_done_callback� s z$shield.<locals>._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 �� �std��tj�� �� ��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.<locals>.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|�d���t | = 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 � itertools�typesr: �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" �<module> s�
#H,>
x?$PK [2�
� � + __pycache__/transports.cpython-38.opt-2.pycnu �[��� U
e5d�( � @ sx d Z G dd� d�ZG dd� de�ZG dd� de�ZG dd� dee�ZG d d
� d
e�ZG d d � d e�ZG d
d� de�ZdS ))�
BaseTransport�
ReadTransport�WriteTransport� Transport�DatagramTransport�SubprocessTransportc @ sD e Zd ZdZddd�Zddd�Zdd� Zd d
� Zd d � Zd
d� Z dS )r ��_extraNc C s |d kr i }|| _ d S �Nr )�self�extra� r �*/usr/lib64/python3.8/asyncio/transports.py�__init__ s zBaseTransport.__init__c C s | j �||�S r )r �get)r
�name�defaultr r r
�get_extra_info s z BaseTransport.get_extra_infoc C s t �d S r ��NotImplementedError�r
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 ZdZddd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dS )r r Nc C s t �d S r r �r
�high�lowr 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 ZdZddd�Zdd� 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
d�Z 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 | js�d| _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() failed��messageZ exceptionZ transportr )
r& r; r: � _protocolZ
pause_writing�
SystemExit�KeyboardInterrupt�
BaseExceptionr9 �call_exception_handler)r
�size�excr 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
�<module> s %F6PK [�O�=] =] 0 __pycache__/proactor_events.cpython-38.opt-1.pycnu �[��� U
e5d<} � @ 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� dejej�ZG dd� deej�ZG dd� deej�ZG dd� de�Z G dd� de�Z G dd� deeej �Z G d d � d eeej �Z G d d � d e
j!�Z"dS ) z�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.
)�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| jkr�z|�
� | jd< W n tjk
r� d | jd< Y nX d S )N�socketZsocknamezgetsockname() failed on %rT��exc_info�peername) r �TransportSocket�_extraZ getsocknamer
�error�_loop� get_debugr �warningZ getpeername)� transport�sock� r �//usr/lib64/python3.8/asyncio/proactor_events.py�_set_socket_extra s
�
r c s� e Zd ZdZd � fdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
e j fdd�Z
d dd�Zdd� Zdd� Zdd� Z� ZS ) �_ProactorBasePipeTransportz*Base class for pipe and socket transports.Nc s� t � �||� | �|� || _| �|� || _d | _d | _d | _d| _ d| _
d| _ d| _ | jd k rl| j�
� | j�| jj| � |d k r�| j�tj|d � d S )Nr F)�super�__init__�
_set_extra�_sock� set_protocol�_server�_buffer� _read_fut�
_write_fut�_pending_write�
_conn_lost�_closing� _eof_writtenZ_attachr � call_soon� _protocolZconnection_mader Z _set_result_unless_cancelled��self�loopr �protocol�waiter�extra�server�� __class__r r r 2 s(
�z#_ProactorBasePipeTransport.__init__c C s� | j jg}| jd kr |�d� n| jr0|�d� | jd k rP|�d| j�� � �� | jd k rl|�d| j��� | jd k r�|�d| j��� | jr�|�dt | j�� �� | j
r�|�d� d� d � |��S )
N�closed�closingzfd=zread=zwrite=zwrite_bufsize=z EOF writtenz<{}>� )
r4 �__name__r �appendr( �filenor$ r% r# �lenr) �format�join)r- �infor r r �__repr__H s
z#_ProactorBasePipeTransport.__repr__c C s || j d< d S )N�pipe)r �r- r r r r r Z s z%_ProactorBasePipeTransport._set_extrac C s
|| _ d S �N�r+ )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|t�r*| j�� rBtjd| |dd� n| j�||| | jd�� W 5 | � |� X d S )Nz%r: %sTr )�message� exceptionr r/ ) � _force_close�
isinstance�OSErrorr r r �debug�call_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_waiter�done�
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 | jd�r,| j�tj� | j�� d | _| j}|d k rX|�� d | _X d S )N�shutdown)
�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| j�7 }|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 �warnings�warnrL 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 ddd�Z
� 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,t�d| � 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 �� rt�d| � 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�
SystemExit�KeyboardInterrupt�
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| jtj�r�zt�| j|� W q� tt fk
rZ � Y q� t
k
r� } z| � |d� W Y �d S d }~X Y q�X 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�
� r�tjddd� 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> | j�s:� Y nX | j�sV| 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 � _proactor�recvr �ConnectionAbortedErrorrV r r rS �ConnectionResetErrorrP rR r �CancelledError�add_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� fdd�Zdd� 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- �args�kwr3 r r r G s z(_ProactorBaseWritePipeTransport.__init__c C s� t |tttf�s$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.| js�t|�| _| �� 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� TypeError�typer8 r) � RuntimeErrorrW r' r �!LOG_THRESHOLD_FOR_CONNLOST_WRITESr r r% �
_loop_writingr# �_maybe_pause_protocol�extendrk 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 �� s�t|�| _| j �| j� | �� n| j �| j� | jd k r�| j d kr�| j�d � 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� fdd�Zdd� 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
d�Z ddd�Z
� Z S )�_ProactorDatagramTransporti Nc s> || _ d | _t� j|||||d� t�� | _| j�| j � d S )N)r0 r1 )
�_addressrW r r � collections�dequer# 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 � <genexpr>� s zC_ProactorDatagramTransport.get_write_buffer_size.<locals>.<genexpr>)�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 |tttf�s 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.| j�tj� 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� fdd�Zd3dd�Zd4dddddd�dd �Zd5d
d �Zd6d d
�Zd7dd�Zd8dd�Z � fdd�Z
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 � �� t�d|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� threading�current_thread� main_thread�signal�
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_side�server_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�� kr6t�d� | �� | � � | 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> } zt�d��W 5 d }~X Y nX zt�|�j}W n, t k
r| } zt�d��W 5 d }~X Y nX |r�|n|}|s�dS t
|d�}|r�t
|| |�n|} t
||�}d}
zLt
| | |�}|dkr�|
W �0S | j �
||||�I d H ||7 }|
|7 }
q�W 5 |
dk�r"|� |� X d S )Nznot a regular filer l �� )r: �AttributeError�io�UnsupportedOperationr ZSendfileNotAvailableError�os�fstat�st_sizerR �min�seekrt �sendfile) r- r �file�offset�countr: �errZfsizeZ blocksizeZend_posZ
total_sentr r r �_sock_sendfile_native� s0
z+BaseProactorEventLoop._sock_sendfile_nativec � sZ |� � }|�� |�� I d H z | j|j|||dd�I 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 �� \| _| _| j�d� | j�d� | 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_self�d c s( d� ������fdd� � �� � � d S )Nc
s, z�| d k rn| � � \}}�jr,t�d�||� �� }�d k rX�j||�dd|i��d� n�j||d|i�d� ��� r|W d S �j���} W n� t k
r� } zH��
� dkrʈ� d|t �
��d�� ��� n�jr�tjd �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.<locals>.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 �<module> sR � � �n � �PK [-w/� � # __pycache__/__init__.cpython-38.pycnu �[��� U
e5d� � @ 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 Zejdkr�ddlT 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 �(/usr/lib64/python3.8/asyncio/__init__.py�<module> sZ �������� �
� � �
PK [��gF � � , __pycache__/unix_events.cpython-38.opt-2.pycnu �[��� U
e5dۿ � @ s� d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl Z d dl
Z
d dl Z ddl m
Z
ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ dd l mZ dd
l mZ dd l mZ dd l mZ dd
lmZ dZe jdkr�ed��dd� Z G dd� dej �Z G dd� dej �Z G dd� dej!ej"�Z#G dd� dej$�Z%G dd � 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 Z/e.Z0dS )+� N� )� base_events)�base_subprocess)� constants)�
coroutines)�events)�
exceptions)�futures)�selector_events)�tasks)�
transports)�logger)�SelectorEventLoop�AbstractChildWatcher�SafeChildWatcher�FastChildWatcher�MultiLoopChildWatcher�ThreadedChildWatcher�DefaultEventLoopPolicyZwin32z+Signals are not really supported on Windowsc C s d S �N� )�signum�framer r �+/usr/lib64/python3.8/asyncio/unix_events.py�_sighandler_noop* s r c s� e Zd Zd(� fdd� Z� fdd�Zdd� Zdd � Zd
d � Zd d
� Zdd� Z d)dd�Z
d*dd�Z d+dd�Z dd� Z
d,ddddd�dd�Zd-ddddd d �d d �Zd d!� Zd"d#� Zd$d%� Zd&d'� Z� ZS ).�_UnixSelectorEventLoopNc s t � �|� i | _d S r )�super�__init__�_signal_handlers)�self�selector�� __class__r r r 5 s z _UnixSelectorEventLoop.__init__c sZ t � �� t�� s.t| j�D ]}| �|� q n(| jrVtjd| �d�t | d� | j�
� d S )NzClosing the loop z@ on interpreter shutdown stage, skipping signal handlers removal��source) r �close�sys�
is_finalizing�listr �remove_signal_handler�warnings�warn�ResourceWarning�clear�r �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|= | j�szt�d� W n4 t
t fk
�r } zt�d|� W 5 d }~X Y nX |jtjk�r4t d|� d���n� W 5 d }~X Y nX d S )Nz3coroutines cannot be used with add_signal_handler()F���� set_wakeup_fd(-1) failed: %s�sig � cannot be caught)r Z iscoroutineZiscoroutinefunction� TypeError�
_check_signalZ
_check_closed�signal�
set_wakeup_fdZ_csock�fileno�
ValueError�OSError� RuntimeError�strr ZHandler r � siginterruptr
�info�errno�EINVAL)r r/ �callback�args�exc�handleZnexcr r r �add_signal_handlerN s2
�
z)_UnixSelectorEventLoop.add_signal_handlerc C s8 | j �|�}|d krd S |jr*| �|� n
| �|� d S r )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 kr�t
d|� d���n� W 5 d }~X Y nX | js�zt� d� W n2 t tfk
r� } zt
�d|� W 5 d }~X Y nX dS )NFr5 r6 r3 r4 T)r8 r �KeyErrorr9 �SIGINT�default_int_handler�SIG_DFLr= rB rC r> r: r< r
rA )r r/ �handlerrF r r r r) � s(
z,_UnixSelectorEventLoop.remove_signal_handlerc C s6 t |t�std|����|t�� kr2td|� ���d S )Nzsig must be an int, not zinvalid signal number )�
isinstance�intr7 r9 �
valid_signalsr< r. r r r r8 � s
z$_UnixSelectorEventLoop._check_signalc C s t | ||||�S r )�_UnixReadPipeTransport�r �pipe�protocol�waiter�extrar 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�_UnixSubprocessTransport�add_child_handlerZget_pid�_child_watcher_callback�
SystemExit�KeyboardInterrupt�
BaseExceptionr% Z_wait)
r rU rE �shell�stdin�stdout�stderr�bufsizerW �kwargs�watcherrV �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)�ssl�sock�server_hostname�ssl_handshake_timeoutc � s
|r|d kr6t d��n |d k r&t d��|d k r6t d��|d k r�|d k rNt d��t�|�}t�tjtjd�}z |�d� | �||�I d H W q� |�� � Y q�X n@|d kr�t d��|j tjks�|j
tjkr�t d|����|�d� | j |||||d �I d H \}}||fS )
Nz/you have to pass server_hostname when using sslz+server_hostname is only meaningful with ssl�1ssl_handshake_timeout is only meaningful with ssl�3path and sock can not be specified at the same timer Fz no path and sock were specified�.A UNIX Domain Stream Socket was expected, got )rs ) r< �os�fspath�socket�AF_UNIX� SOCK_STREAM� setblockingZ sock_connectr% �family�typeZ _create_connection_transport) r �protocol_factory�pathrp rq rr rs � transportrU r r r �create_unix_connection� sR ���
��
�z-_UnixSelectorEventLoop.create_unix_connection�d T)rq �backlogrp rs �
start_servingc
� s� t |t�rtd��|d k r&|s&td��|d k �rH|d k r@td��t�|�}t�tjtj�}|d dkr�z t �
t� |�j �r�t� |� W nB t
k
r� Y n0 tk
r� } zt�d||� W 5 d }~X Y nX z|�|� W nl tk
�r0 } z8|�� | jtjk�r d|�d�}
ttj|
�d �n� W 5 d } ~ X Y n |�� � Y nX n<|d k�rZtd ��|jtjk�sv|jtjk�r�td
|����|�d � t�| |g||||�} |�r�| �� tj d| d �I d H | S )
Nz*ssl argument must be an SSLContext or Nonert ru r )r � z2Unable to check or remove stale UNIX socket %r: %rzAddress z is already in usez-path was not specified, and no sock specifiedrv F)�loop) rO �boolr7 r< rw rx ry rz r{ �stat�S_ISSOCK�st_mode�remove�FileNotFoundErrorr= r
�errorZbindr% rB Z
EADDRINUSEr} r~ r| r ZServerZ_start_servingr �sleep) r r r� rq r� rp rs r� �errrF �msgZserverr r r �create_unix_server sn
�
�
�
�
��
�z)_UnixSelectorEventLoop.create_unix_serverc
� s� z
t j W n, tk
r6 } zt�d��W 5 d }~X Y nX z |�� }W n2 ttjfk
rv } zt�d��W 5 d }~X Y nX zt �|�j }W n, t
k
r� } zt�d��W 5 d }~X Y nX |r�|n|} | s�dS | � � }
| � |
d ||||| d� |
I d H S )Nz os.sendfile() is not availableznot a regular filer )
rw �sendfile�AttributeErrorr �SendfileNotAvailableErrorr; �io�UnsupportedOperation�fstat�st_sizer= r] �_sock_sendfile_native_impl) r rq �file�offset�countrF r; r� Zfsize� blocksize�futr r r �_sock_sendfile_nativeJ s2
� �z,_UnixSelectorEventLoop._sock_sendfile_nativec C s, |� � } |d k r| �|� |�� r4| �|||� d S |rd|| }|dkrd| �|||� |�|� d S zt�| |||�}
W �nD ttfk
r� |d kr�| � ||� | �
| | j || ||||||�
Y �nb t k
�rj } z�|d k �r| j
t
jk�rt| �tk �rtdt
j�} | | _| } |dk�rBt�d�}
| �|||� |�|
� n| �|||� |�| � W 5 d } ~ X Y n� ttfk
�r� � Y n� tk
�r� } z | �|||� |�| � W 5 d } ~ X Y njX |
dk�r�| �|||� |�|� nD||
7 }||
7 }|d k�r
| � ||� | �
| | j || ||||||�
d S )Nr zsocket is not connectedzos.sendfile call failed)r; �
remove_writer� cancelled� _sock_sendfile_update_fileposZ
set_resultrw r� �BlockingIOError�InterruptedError� _sock_add_cancellation_callbackZ
add_writerr� r= rB ZENOTCONNr~ �ConnectionError� __cause__r r� Z
set_exceptionra rb rc )r r� Z
registered_fdrq r; r� r� r� �
total_sent�fdZsentrF �new_excr� r r r r� a s�
�
�
� �
�
�z1_UnixSelectorEventLoop._sock_sendfile_native_implc C s |dkrt �||t j� d S �Nr )rw �lseek�SEEK_SET)r r; r� r� r r r r� � s z4_UnixSelectorEventLoop._sock_sendfile_update_fileposc s � �fdd�}|� |� d S )Nc s& | � � r"��� }|dkr"� �|� d S )Nr3 )r� r; r� )r� r� �r rq r r �cb� s zB_UnixSelectorEventLoop._sock_add_cancellation_callback.<locals>.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__r r% r2 rH r0 r) r8 rX rZ rl r` r� r� r� r� r� r� �
__classcell__r r r! r r / sF -
�
�
�
� � . � � CFr c s� e Zd ZdZd � fdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z e
jfdd�Zd dd�Zdd� Zd d � Z� ZS ) rR i Nc s� t � �|� || jd< || _|| _|�� | _|| _d| _d| _ t
� | j�j }t
�|�s�t
�|�s�t
�|�s�d | _d | _d | _td��t
�| jd� | j�| jj| � | j�| jj| j| j� |d k r�| j�tj|d � d S )NrT Fz)Pipe transport is for pipes/sockets only.)r r �_extra�_loop�_piper; �_fileno� _protocol�_closing�_pausedrw r� r� r� �S_ISFIFOr� �S_ISCHRr< � set_blocking� call_soon�connection_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 r�t� || jt
j �}|r�|�d� q�|�d� n | jd k r�|�d� n
|�d� d� d �
|��S )
N�closed�closing�fd=� _selector�polling�idle�open�<{}>� )r" r� r� �appendr� r� �getattrr� r
�_test_selector_event� selectorsZ
EVENT_READ�format�join)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
� � r�t �
d| � d| _| j
�| j� | j
�| jj� | j
�| jd � d S )Nz"Fatal read error on pipe transport�%r was closed by peerT)rw �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:t�d| � d S )NTz%r pauses reading)r� r� r� r� r� r� r
�debug�r r r r �
pause_reading� s
z$_UnixReadPipeTransport.pause_readingc C sB | j s | jsd S d| _| j�| j| j� | j�� r>t�d| � 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 |t�r4|jtjkr4| j�� rLtjd| |dd� n| j�||| | j d�� | �
|� d S �Nz%r: %sT��exc_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� Zejfdd�Zd d � Zd&d d �Zd'd!d"�Zd#d$� Z� ZS )(rY Nc
s� t � �||� || jd< || _|�� | _|| _t� | _d| _ d| _
t � | j�j
}t�|�}t�|�}t�|�} |s�|s�| s�d | _d | _d | _td��t �| jd� | j�| jj| � | s�|r�tj�d�s�| j�| jj| j| j� |d k r�| j�t 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� rw 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 r�t� || 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_WRITE�get_write_buffer_sizer� r� )r rA r r� rh r r r r� d s,
�
z _UnixWritePipeTransport.__repr__c C s
t | j�S r )�lenr� r� r r r r� | s z-_UnixWritePipeTransport.get_write_buffer_sizec C s6 | j �� rt�d| � | jr*| �t� � n| �� d S )Nr� )r� r� r
rA r� r� �BrokenPipeErrorr� r r r r� s
z#_UnixWritePipeTransport._read_readyc
C s4 t |t�rt|�}|sd S | js&| jrN| jtjkr<t�d� | jd7 _d S | j �szt
� | j |�}W nt t
tfk
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 |dk�rt|�|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 r� �
memoryviewr� r� r Z!LOG_THRESHOLD_FOR_CONNLOST_WRITESr
�warningr� rw �writer� r� r� ra rb rc r� r� r� Z _add_writer� _write_readyZ_maybe_pause_protocol)r r1 �nrF r r r r � s6
z _UnixWritePipeTransport.writec
C s zt �| j| j�}W n� ttfk
r, Y n� ttfk
rD � Y n� tk
r� } z6| j� � | j
d7 _
| j � | j� | �
|d� W 5 d }~X Y nfX |t| j�kr�| j� � | j � | j� | �� | jr�| j �| j� | �d � d S |dkr�| jd |�= d S )Nr r� r )rw r 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 s8 | j r
d S d| _ | js4| j�| j� | j�| jd � d S r� )r� 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 |t�r(| 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)
�
subprocess�PIPEry 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 @ sD e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dS )r c G s
t � �d S r ��NotImplementedError�r rn rD rE r r r r_ 9 s z&AbstractChildWatcher.add_child_handlerc C s
t � �d S r r �r rn r r r �remove_child_handlerD s z)AbstractChildWatcher.remove_child_handlerc C s
t � �d S r r �r r� r r r � attach_loopL s z AbstractChildWatcher.attach_loopc C s
t � �d S r r r� r r r r% V s zAbstractChildWatcher.closec C s
t � �d S r r r� r r r r\ ] s z AbstractChildWatcher.is_activec C s
t � �d S r r r� r r r � __enter__f s z AbstractChildWatcher.__enter__c C s
t � �d S r r �r �a�b�cr r r �__exit__l s z AbstractChildWatcher.__exit__N)
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 )rw � WIFSIGNALED�WTERMSIG� 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 sf | j d k r$|d kr$| jr$t�dt� | j d k r<| j �tj� || _ |d k rb|�tj| j � | �
� d S )NzCA loop is being detached from a child watcher with pending handlers) r� r% r* r+ �RuntimeWarningr) r9 �SIGCHLDrH � _sig_chldr( r r r r r � s �
z BaseChildWatcher.attach_loopc
C s^ z | � � W nL ttfk
r& � Y n4 tk
rX } z| j�d|d�� W 5 d }~X Y nX d S )N�$Unknown exception in SIGCHLD handler)r� r� )r( ra rb rc r� r� r� r r r r+ � s �zBaseChildWatcher._sig_chldN)
r� r� r� r r% r\ r' r( r r+ r r r r r$ s r$ c sL e Zd Z� fdd�Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z � Z
S )r c s | j �� t� �� d S r )r% r- r r% r� r! r r r% � s
zSafeChildWatcher.closec C s | S r r r� r r r r � s zSafeChildWatcher.__enter__c C s d S r r r r r r r � s zSafeChildWatcher.__exit__c G s ||f| j |< | �|� d S r )r% r' r r r r r_ � s z"SafeChildWatcher.add_child_handlerc C s* z| j |= W dS tk
r$ Y dS X d S �NTF�r% rJ r r r r r � s
z%SafeChildWatcher.remove_child_handlerc C s t | j�D ]}| �|� q
d S r �r( r% r' r r r r r( � s z SafeChildWatcher._do_waitpid_allc C s� zt �|t j�\}}W n( tk
r> |}d}t�d|� Y n.X |dkrLd S t|�}| j�� rlt� d||� z| j
� |�\}}W n. t k
r� | j�� r�tjd|dd� Y nX |||f|�� d S )N� �8Unknown child process pid %d, will report returncode 255r �$process %s exited with returncode %s�'Child watcher got an unexpected pid: %rTr� )
rw �waitpid�WNOHANG�ChildProcessErrorr
r r# r� r� r� r% �poprJ )r r& rn r" ro rD rE r r r r' � s4 �
�
� z SafeChildWatcher._do_waitpid) r� r� r� r% r r r_ r r( r' r� r r r! r r � s r c sP e Zd Z� fdd�Z� fdd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z � Z
S )r c s$ t � �� t�� | _i | _d| _d S r� )r r � threadingZLock�_lock�_zombies�_forksr� r! r r r s
zFastChildWatcher.__init__c s" | j �� | j�� t� �� d S r )r% r- r: 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 )r9 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 t�d|� d S )Nr z5Caught subprocesses termination from unknown pids: %s)r9 r; r: r? r- r
r )r r r r Zcollateral_victimsr r r r s
�zFastChildWatcher.__exit__c G sf | j �F z| j�|�}W n. tk
rF ||f| j|< Y W 5 Q R � d S X W 5 Q R X |||f|�� d S r )r9 r: r7 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 r- r. 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 � � r�t
�d||� Y W 5 Q R � q d }Y nX | j � � r�t
�d||� W 5 Q R X |d kr�t
�d||� q |||f|�� q d S )Nr3 r z,unknown process %s exited with returncode %sr2 z8Caught subprocess termination from unknown pid: %d -> %d)rw r4 r5 r6 r# r9 r% r7 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 � s
r c @ sd e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
dS )r 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 t�tj�}|| jkr:t�d� nt�tj| 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 r- r. r r r r r � s
z*MultiLoopChildWatcher.remove_child_handlerc C sN | j d k rd S t�tj| j�| _ | j d kr<t�d� tj| _ t�tjd� d S )NzaPrevious SIGCHLD handler was set by non-Python code, restore to default handler on watcher close.F)r< r9 r* r+ r
r rM r@ r r r r r � s
z!MultiLoopChildWatcher.attach_loopc C s t | j�D ]}| �|� q
d S r r/ r r r r r( � s z%MultiLoopChildWatcher._do_waitpid_allc C s� zt �|t j�\}}W n, tk
rB |}d}t�d|� d}Y nX |dkrPd S t|�}d}z| j�|�\}}}W n$ t k
r� tjd|dd� Y nHX |�
� r�t�d||� n.|r�|� � r�t� d ||� |j
|||f|�� d S )
Nr0 r1 Fr Tr3 r� �%Loop %r that handles pid %r is closedr2 )rw r4 r5 r6 r
r r# r% r7 rJ � is_closedr� r� rm ) r r& rn r" ro Z debug_logr� rD rE r r r r' � s: �
� �z!MultiLoopChildWatcher._do_waitpidc C sL z | � � W n: ttfk
r& � Y n" tk
rF tjddd� Y nX d S )Nr, Tr� )r( ra rb rc r
r )r r r r r r r+ � s z MultiLoopChildWatcher._sig_chldN)r� r� r� r r\ r% r r r_ r r r( r' r+ r r r r r g s %r c @ sj e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Ze j
fd
d�Z dd� Z dd� Z
dd� Zdd� ZdS )r c C s t �d�| _i | _d S r� )� itertoolsr� � _pid_counter�_threadsr� r r r r � s z ThreadedChildWatcher.__init__c C s dS r� r r� r r r r\ � s z ThreadedChildWatcher.is_activec C s | � � d S r )�
_join_threadsr� r r r r% � s zThreadedChildWatcher.closec C s. dd� t | j�� �D �}|D ] }|�� q d S )Nc S s g | ]}|� � r|js|�qS r )�is_alive�daemon��.0�threadr r r �
<listcomp>� s �z6ThreadedChildWatcher._join_threads.<locals>.<listcomp>)r( rE �valuesr� )r �threadsrK r r r rF � 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 r> r r r r s z ThreadedChildWatcher.__exit__c C s6 dd� t | j�� �D �}|r2|| j� d�t| d� d S )Nc S s g | ]}|� � r|�qS r )rG rI r r r rL s �z0ThreadedChildWatcher.__del__.<locals>.<listcomp>z0 has registered but not finished child processesr# )r( rE rM r" r, )r r� rN r r r r� s �z ThreadedChildWatcher.__del__c G sF t �� }tj| jdt| j�� �||||fdd�}|| j|< |�� d S )Nzwaitpid-T)�target�namerE rH ) r r@ r8 ZThreadr' �nextrD rE �start)r rn rD rE r� rK 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� zt �|d�\}}W n( tk
r< |}d}t�d|� Y n X t|�}|�� r\t�d||� |�� rtt�d||� n|j |||f|�� | j
� |� d S )Nr r0 r1 r2 rA ) rw r4 r6 r
r r# r� r� rB rm rE r7 )r r� r& rD rE rn r" ro r r r r' " s& �
�z ThreadedChildWatcher._do_waitpidN)r� r� r� r r\ r% rF r r r* r+ r� r_ r r r' r r r r r � s
r c sD e Zd ZeZ� fdd�Zdd� Z� fdd�Zdd� Zd d
� Z � Z
S ) �_UnixDefaultEventLoopPolicyc s t � �� d | _d S r )r r �_watcherr� r! r r r A s
z$_UnixDefaultEventLoopPolicy.__init__c C sH t j�8 | jd kr:t� | _tt�� tj�r:| j�| j j
� W 5 Q R X d S r ) r r9 rT r rO r8 �current_thread� _MainThreadr �_localr� r� r r r �
_init_watcherE s
�z)_UnixDefaultEventLoopPolicy._init_watcherc s6 t � �|� | jd k r2tt�� tj�r2| j�|� d S r )r �set_event_looprT rO r8 rU rV r r r! r r rY M s
�z*_UnixDefaultEventLoopPolicy.set_event_loopc C s | j d kr| �� | j S r )rT rX r� r r r r[ [ s
z-_UnixDefaultEventLoopPolicy.get_child_watcherc C s | j d k r| j �� || _ d S r )rT r% )r rj r r r �set_child_watchere s
z-_UnixDefaultEventLoopPolicy.set_child_watcher) r� r� r� r Z
_loop_factoryr rX rY r[ rZ r� r r r! r rS = s
rS )1rB r� rC rw r� r9 ry r� r r& r8 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 ZBaseDefaultEventLoopPolicyrS r r r r r r �<module> s^
� NO5Ji}Y3PK [���b�s �s * __pycache__/selector_events.cpython-38.pycnu �[��� U
e5dT� � @ 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 j�ZG dd� dejej�Z G dd� de �Z G dd� de �Z dS )z�Event 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_key�KeyError�boolr )�selector�fdZevent�key� r �//usr/lib64/python3.8/asyncio/selector_events.py�_test_selector_event s
r c C s t d k r t| t j�r td��d S )Nz"Socket cannot be of type SSLSocket)�ssl�
isinstanceZ SSLSocket� TypeError)�sockr r r �_check_ssl_socket+ s r c s� e Zd ZdZdS� fdd� ZdTddd�dd�ZdUddddejd �d
d �ZdVd d
�Z � fdd�Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdddejfdd �Zdddejfd d �Zddejfd d �Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� 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+� Z,S )Wr zJSelector event loop.
See events.EventLoop for API specification.
Nc sF t � �� |d krt�� }t�d|jj� || _| � � t
� � | _ d S )NzUsing selector: %s)
�super�__init__� selectorsZDefaultSelectorr �debug� __class__�__name__� _selector�_make_self_pipe�weakrefZWeakValueDictionary� _transports)�selfr �r r r r 6 s
z BaseSelectorEventLoop.__init__��extra�serverc C s t | |||||�S �N)�_SelectorSocketTransport)r& r �protocol�waiterr) r* r r r �_make_socket_transport@ s
�z,BaseSelectorEventLoop._make_socket_transportF)� server_side�server_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�_ssock�filenor; �_csock�
_internal_fdsr< r r r r: b s
z&BaseSelectorEventLoop._close_self_pipec C sN t �� \| _| _| j�d� | j�d� | 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 �InterruptedError�BlockingIOErrorrF 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 socketT��exc_info)r@ �send�OSError�_debugr r )r& Zcsockr r r �_write_to_self� s �z$BaseSelectorEventLoop._write_to_self�d 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|�� \}} | jr0t�d|| |� |�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)�range�acceptrQ r r rC rK rJ �ConnectionAbortedErrorrP �errnoZEMFILEZENFILEZENOBUFSZENOMEM�call_exception_handlerr �TransportSocketr= r? Z
call_laterr ZACCEPT_RETRY_DELAYrW �_accept_connection2Z create_task)
r& rU r r3 r* rV r2 �_�conn�addr�excr) 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>| jr�d|
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; �
SystemExit�KeyboardInterruptrQ r_ ) r& rU rc r) r3 r* r2 r- rf r. re �contextr r r ra � sP � � �z)BaseSelectorEventLoop._accept_connection2c
C s� |}t |t�sJzt|�� �}W n* tttfk
rH td|���d �Y nX z| j| }W n tk
rl Y n X |�� s�t 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 �modify�cancel� r& r �callback�argsZhandler �mask�reader�writerr 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"td��z |�|�W S ttfk
rF Y nX | �� }|�� }| � || j
|||� |� t �
| j|�� |I dH S )z�Receive 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_recv�add_done_callback� functools�partial�_sock_read_done)r& r �n�futr 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"td��z |�|�W S ttfk
rF Y nX | �� }|�� }| � || j
|||� |� t �
| j|�� |I dH S )z�Receive 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"td��z|�|�}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 Zview�pos�startr� re r r r r� � s
z#BaseSelectorEventLoop._sock_sendallc � s� t |� | jr"|�� dkr"td��ttd�r8|jtjkrf| j||j|j | d�I dH }|d \}}}}}| �
� }| � |||� |I dH S )zTConnect to a remote socket at address.
This method is a coroutine.
r r� �AF_UNIX)�family�proto�loopN) 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|||dd�I d H W �S |�� |r^|�� || j |j< X d S )NF)Zfallback) r% �_sock_fd�
is_reading�
pause_reading�_make_empty_waiter�_reset_empty_waiter�resume_readingZ
sock_sendfile�_sock)r& Ztransp�file�offset�countr� 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
ejfdd�Zd dd�Zdd� Zdd� Zdd� Zd d � Z� ZS ) �_SelectorTransporti Nc s� t � �||� t�|�| jd< z|�� | jd< W n tk
rN d | jd< Y nX d| jkr�z|�� | 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�� s�t| jj | jt
j �}|rz|�d� n
|�d� t| jj | jt
j �}|r�d}nd}| �
� }|�d|� d |� d
�� d �d �|��S )
N�closed�closingzfd=z read=pollingz read=idle�pollingZidlezwrite=<z
, bufsize=�>z<{}>� )r r! r� �appendr� r� �_loopr9 r r" r rt r� �get_write_buffer_size�format�join)r& �infor� �state�bufsizer 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 |t�r(| 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 | j�S 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; �warnings�warnr� r� r� r� r� rD r� r r r' r r� ] s
r� c s� e Zd ZdZejjZd#� fdd� Z� fdd�Z 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 |tj�r| 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:t�d| � 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<t�d| � d S )NFz%r resumes reading) r� r� rD r� r� r� r� r r r< r r r r� s
z'_SelectorSocketTransport.resume_readingc C s | � � d S r+ )r� r< r r r r� $ s z$_SelectorSocketTransport._read_readyc
C s` | j r
d S z | j�d�}t|�s(td��W nL ttfk
rD � Y n4 tk
rv } z| �|d� W Y �d S d }~X Y nX z| j �
|�}W nd t t fk
r� Y d S ttfk
r� � Y n4 tk
r� } z| �|d� W Y �d S d }~X Y nX |�s | �
� d S z| j�|� W nJ ttfk
�r, � Y n0 tk
�rZ } z| �|d� W 5 d }~X Y nX d S )N���z%get_buffer() returned an empty bufferz/Fatal error: protocol.get_buffer() call failed.�$Fatal read error on socket transportz3Fatal error: protocol.buffer_updated() call failed.)r� r� Z
get_bufferr� r8 ri rj rh r� r� r� rK rJ �_read_ready__on_eofZbuffer_updated)r& r� re r� r r r r� ' sF � �z0_SelectorSocketTransport._read_ready__get_bufferc
C s� | j r
d S z| j�| j�}W nd ttfk
r6 Y d S ttfk
rN � Y n4 tk
r� } z| � |d� W Y �d S d }~X Y nX |s�| �
� d S z| j � |� W nF ttfk
r� � Y n. tk
r� } z| � |d� W 5 d }~X Y nX d S )Nr� z2Fatal error: protocol.data_received() call failed.)
r� r� rI r� rK rJ ri rj rh r� r� r� Z
data_received)r& rG re r r r r� L s. �z3_SelectorSocketTransport._read_ready__data_receivedc
C s� | j �� rt�d| � z| j�� }W nL ttfk
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 |tttf�s$tdt|�j����| jr2td��| j d k rDtd��|sLd S | j
rz| j
t j krht
�d� | j
d7 _
d S | j�s 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_ready�extend�_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�| j�d � | j�r| �d � n| j�r$| j�tj� 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*| j�tj� 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&| j�td�� 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| j�t
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 � <genexpr>� s zC_SelectorDatagramTransport.get_write_buffer_size.<locals>.<genexpr>)�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_received�r& rG rd re r r r r� � s z&_SelectorDatagramTransport._read_readyc
C s� t |tttf�s$tdt|�j����|s,d S | jrV|d | jfkrPtd| j� ���| j}| j r�| jr�| j t
j krxt �
d� | j d7 _ d S | j�slz,| 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 q�Y 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� | j�r| �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� � collections�dequer� 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 �<module> sF
1� oPK [9c��_ �_ / __pycache__/windows_events.cpython-38.opt-1.pycnu �[��� U
e5di� � @ 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)�SelectorEventLoop�ProactorEventLoop� IocpProactor�DefaultEventLoopPolicy� WindowsSelectorEventLoopPolicy� WindowsProactorEventLoopPolicy� �� i� i� g����MbP?g�������?c s^ e Zd ZdZdd�� fdd�
Z� fdd�Zdd � Z� fd
d �Z� fd d
�Z� fdd�Z � Z
S )�_OverlappedFuturez�Subclass of Future which represents an overlapped operation.
Cancelling it will immediately cancel the overlapped operation.
N��loopc s& t � j|d� | jr | jd= || _d S �Nr ���)�super�__init__�_source_traceback�_ov)�self�ovr �� __class__� �./usr/lib64/python3.8/asyncio/windows_events.pyr 1 s z_OverlappedFuture.__init__c sH t � �� }| jd k rD| jjr dnd}|�dd|� d| jjd�d�� |S )N�pendingZ completedr z overlapped=<z, �#x�>)r �
_repr_infor r" �insert�address�r �info�stater 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 failed��message� exception�future�source_traceback)r �cancel�OSErrorr �_loop�call_exception_handler)r �exc�contextr 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� fdd�Z � fdd�Z
� fdd�Z � 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 �| jd�t 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 �winerror�ERROR_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 d��d 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� fdd�Zdd� Z� ZS ) �_WaitHandleFutureNr c s< t � j||||d� || _d| _t�d 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)�_address�weakref�WeakSet�_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_FOREVER�NULL�
PipeHandlerg �add)r �first�flags�h�piper 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� fdd�Zdd� 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 sX z| �| j� t� �� W 5 | j d k rR| j j}| j �� |d k rL| j�|� d | _ X d S r7 ) Z_self_reading_futurer r0 r[ r` � call_soonZ_loop_self_readingr � run_forever�r r r r r! rz 8 s
z ProactorEventLoop.run_foreverc � s8 | j �|�}|I d H }|� }| j||d|id�}||fS )N�addr��extra)r[ � connect_pipe�_make_duplex_pipe_transport)r �protocol_factoryr' �frt �protocol�transr 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�� |�� n�j r�t
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.<locals>.loop_accept_pipe)N)rb ry )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�
SystemExit�KeyboardInterrupt�
BaseExceptionru Z_wait) r r� �args�shell�stdin�stdout�stderr�bufsizer~ �kwargsr� Ztranspr r r! �_make_subprocess_transport� s*
� ��z,ProactorEventLoop._make_subprocess_transport)N)N)
r> r? r@ rA r rz r� r� r� rB r r r r! r
0 s 0 �r
c @ s� e Zd ZdZd;dd�Zdd� Zdd� Zd d
� Zd<d d
�Zdd� Z d=dd�Z
d>dd�Z d?dd�Z d@dd�Z
dAdd�Zdd � Zd d � Zd d � Zd!d"� Zd#d$� ZdBd%d&�Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� ZdCd3d4�Zd5d6� Z d7d8� Z d9d:� Z d S )Dr z#Proactor implementation using IOCP.r c C sD d | _ g | _t�tjtd|�| _i | _t� � | _
g | _ t� � | _ d S rI )
r2 �_resultsrQ �CreateIoCompletionPort�INVALID_HANDLE_VALUErn �_iocp�_cachere rf rF �
_unregistered�_stopped_serving)r Z concurrencyr r r! r � s �
zIocpProactor.__init__c C s | j d krtd��d 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~ | � |� t�t�}z4t|tj�r6|�|�� ||� 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_ABORTED�ConnectionResetErrorr� �r� �keyr r4 r r r! � finish_recv� s
� z&IocpProactor.recv.<locals>.finish_recv) �_register_with_iocprQ �
Overlappedrn �
isinstance�socketZWSARecvr� ZReadFile�BrokenPipeErrorr� � _register�r �conn�nbytesrr r r� r r r! �recv� s
zIocpProactor.recvc C s~ | � |� t�t�}z4t|tj�r6|�|�� ||� 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.<locals>.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` | � |� t�t�}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.<locals>.finish_recv) r� rQ r� rn Z WSARecvFromr� r� r� r� r� r r r! �recvfrom� s
zIocpProactor.recvfromc C s> | � |� t�t�}|�|�� |||� 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.<locals>.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 | � |� t�t�}t|tj�r4|�|�� ||� 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.<locals>.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�� t�t�}|���� � �� � � �fdd�}dd� }| �|�|�}||� �}t j
|| j d� |S )Nc sD |� � t�d��� �}� �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.<locals>.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.<locals>.accept_coror ) r� �_get_accept_socket�familyrQ 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 t�t�}|�� �� |� � fdd�}| �|� |�S )Nr r c s |� � � �tjtjd� � S rI )r� r� r� r� rQ ZSO_UPDATE_CONNECT_CONTEXT�r� r� r �r� r r! �finish_connectV s �z,IocpProactor.connect.<locals>.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 | � |� t�t�}|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.<locals>.finish_sendfile) r� rQ r� rn Z TransmitFiler� �msvcrtZ
get_osfhandler� ) r Zsock�file�offset�countr Z
offset_lowZ offset_highr� r r r! �sendfile_ s
� zIocpProactor.sendfilec sJ | � � � t�t�}|�� �� �}|r0| �� �S � fdd�}| �|� |�S )Nc s |� � � S r7 )r� r� �rt r r! �finish_accept_pipe s z4IocpProactor.accept_pipe.<locals>.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_BUSY�min�CONNECT_PIPE_MAX_DELAYr �sleepr
ro )r r' ZdelayrG r4 r r r! r � s
zIocpProactor.connect_pipec C s | � ||d�S )z�Wait 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 �}t�t�}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.<locals>.finish_wait_for_handler )r� rJ �INFINITE�math�ceilrQ r� rn ZRegisterWaitWithQueuer� r' rV r2 rZ r r� )r rG r� Z
_is_cancel�msr 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 td��n t�|d �}|t kr>td��t�| j|�}|d krX�qZd}|\}}}}z| j�|�\}} }
} W nX t k
r� | j
� � r�| j
� dd||||f d�� |dtj
fkr�t�|� 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� �pop�KeyErrorr2 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|t�rBq z |�� W q tk
r� } z6| j d k r�d||d�}|j
r�|j
|d< | j � |� W 5 d }~X Y q X q d}t �
� } | | }
| jr�|
t �
� kr�t�d| t �
� | � t �
� | }
| �|� q�g | _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�}� jj�t� 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.<locals>.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! �<module> sR 0J4;e `PK [�h�� � " __pycache__/runners.cpython-38.pycnu �[��� U
e5d � @ sB d Z ddlmZ ddlmZ ddlmZ dd�dd�Zd d
� ZdS ) )�run� )�
coroutines)�events)�tasksN)�debugc C s� t �� dk rtd��t�| �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�
ValueError�formatZnew_event_loopZset_event_loop�close�_cancel_all_tasks�run_until_completeZshutdown_asyncgensZ set_debug)�mainr �loop� r �'/usr/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� exception�task)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 �<module> s
.PK [l[˅ ` ` ) __pycache__/windows_events.cpython-38.pycnu �[��� U
e5di� � @ 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)�SelectorEventLoop�ProactorEventLoop� IocpProactor�DefaultEventLoopPolicy� WindowsSelectorEventLoopPolicy� WindowsProactorEventLoopPolicy� �� i� i� g����MbP?g�������?c s^ e Zd ZdZdd�� fdd�
Z� fdd�Zdd � Z� fd
d �Z� fd d
�Z� fdd�Z � Z
S )�_OverlappedFuturez�Subclass of Future which represents an overlapped operation.
Cancelling it will immediately cancel the overlapped operation.
N��loopc s& t � j|d� | jr | jd= || _d S �Nr ���)�super�__init__�_source_traceback�_ov)�self�ovr �� __class__� �./usr/lib64/python3.8/asyncio/windows_events.pyr 1 s z_OverlappedFuture.__init__c sH t � �� }| jd k rD| jjr dnd}|�dd|� d| jjd�d�� |S )N�pendingZ completedr z overlapped=<z, �#x�>)r �
_repr_infor r" �insert�address�r �info�stater 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 failed��message� exception�future�source_traceback)r �cancel�OSErrorr �_loop�call_exception_handler)r �exc�contextr 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� fdd�Z � fdd�Z
� fdd�Z � 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 �| jd�t 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 �winerror�ERROR_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 d��d 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� fdd�Zdd� Z� ZS ) �_WaitHandleFutureNr c s< t � j||||d� || _d| _t�d 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)�_address�weakref�WeakSet�_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_FOREVER�NULL�
PipeHandlerg �add)r �first�flags�h�piper 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� fdd�Zdd� 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 sf z(| j d kst�| �| j� t� � � W 5 | j d k r`| j j}| j �� |d k rZ| j�|� d | _ X d S r7 )
Z_self_reading_futurer r0 r[ r` �AssertionError� call_soonZ_loop_self_readingr � run_forever�r r r r r! r{ 8 s
z ProactorEventLoop.run_foreverc � s8 | j �|�}|I d H }|� }| j||d|id�}||fS )N�addr��extra)r[ � connect_pipe�_make_duplex_pipe_transport)r �protocol_factoryr' �frt �protocol�transr 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�� |�� n�j r�t
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.<locals>.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�
SystemExit�KeyboardInterrupt�
BaseExceptionru Z_wait) r r� �args�shell�stdin�stdout�stderr�bufsizer �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;dd�Zdd� Zdd� Zd d
� Zd<d d
�Zdd� Z d=dd�Z
d>dd�Z d?dd�Z d@dd�Z
dAdd�Zdd � Zd d � Zd d � Zd!d"� Zd#d$� ZdBd%d&�Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� ZdCd3d4�Zd5d6� Z d7d8� Z d9d:� Z d S )Dr z#Proactor implementation using IOCP.r c C sD d | _ g | _t�tjtd|�| _i | _t� � | _
g | _ t� � | _ d S rI )
r2 �_resultsrQ �CreateIoCompletionPort�INVALID_HANDLE_VALUErn �_iocp�_cachere rf rF �
_unregistered�_stopped_serving)r Z concurrencyr r r! r � s �
zIocpProactor.__init__c C s | j d krtd��d 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~ | � |� t�t�}z4t|tj�r6|�|�� ||� 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_ABORTED�ConnectionResetErrorr� �r� �keyr r4 r r r! � finish_recv� s
� z&IocpProactor.recv.<locals>.finish_recv) �_register_with_iocprQ �
Overlappedrn �
isinstance�socketZWSARecvr� ZReadFile�BrokenPipeErrorr� � _register�r �conn�nbytesrr r r� r r r! �recv� s
zIocpProactor.recvc C s~ | � |� t�t�}z4t|tj�r6|�|�� ||� 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.<locals>.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` | � |� t�t�}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.<locals>.finish_recv) r� rQ r� rn Z WSARecvFromr� r� r� r� r� r r r! �recvfrom� s
zIocpProactor.recvfromc C s> | � |� t�t�}|�|�� |||� 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.<locals>.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 | � |� t�t�}t|tj�r4|�|�� ||� 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.<locals>.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�� t�t�}|���� � �� � � �fdd�}dd� }| �|�|�}||� �}t j
|| j d� |S )Nc sD |� � t�d��� �}� �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.<locals>.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.<locals>.accept_coror ) r� �_get_accept_socket�familyrQ 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 t�t�}|�� �� |� � fdd�}| �|� |�S )Nr r c s |� � � �tjtjd� � S rI )r� r� r� r� rQ ZSO_UPDATE_CONNECT_CONTEXT�r� r� r �r� r r! �finish_connectV s �z,IocpProactor.connect.<locals>.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 | � |� t�t�}|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.<locals>.finish_sendfile) r� rQ r� rn Z TransmitFiler� �msvcrtZ
get_osfhandler� ) r Zsock�file�offset�countr Z
offset_lowZ offset_highr� r r r! �sendfile_ s
� zIocpProactor.sendfilec sJ | � � � t�t�}|�� �� �}|r0| �� �S � fdd�}| �|� |�S )Nc s |� � � S r7 )r� r� �rt r r! �finish_accept_pipe s z4IocpProactor.accept_pipe.<locals>.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_BUSY�min�CONNECT_PIPE_MAX_DELAYr �sleepr
ro )r r' ZdelayrG r4 r r r! r� � s
zIocpProactor.connect_pipec C s | � ||d�S )z�Wait 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 �}t�t�}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.<locals>.finish_wait_for_handler )r� rJ �INFINITE�math�ceilrQ r� rn ZRegisterWaitWithQueuer� r' rV r2 rZ r r� )r rG r� Z
_is_cancel�msr 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 td��n t�|d �}|t kr>td��t�| j|�}|d krX�qZd}|\}}}}z| j�|�\}} }
} W nX t k
r� | j
� � r�| j
� dd||||f d�� |dtj
fkr�t�|� 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� �pop�KeyErrorr2 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|t�rBq z |�� W q tk
r� } z6| j d k r�d||d�}|j
r�|j
|d< | j � |� W 5 d }~X Y q X q d}t �
� } | | }
| jr�|
t �
� kr�t�d| t �
� | � t �
� | }
| �|� q�g | _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�}� jj�t� 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.<locals>.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! �<module> sR 0J4;e `PK [ٗ '9 9 ) __pycache__/sslproto.cpython-38.opt-2.pycnu �[��� U
e5dJj � @ 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� de�ZG dd� dejej�ZG dd� dej�ZdS )� N� )� base_events)� constants)� protocols)�
transports)�loggerc C s" | r t d��t�� }|s d|_|S )Nz(Server side SSL needs a valid SSLContextF)�
ValueError�sslZcreate_default_contextZcheck_hostname)� server_side�server_hostname�
sslcontext� r
�(/usr/lib64/python3.8/asyncio/sslproto.py�_create_transport_context s r Z UNWRAPPEDZ DO_HANDSHAKEZWRAPPEDZSHUTDOWNc @ sz e Zd ZdZddd�Zedd� �Zedd� �Zed d
� �Zed d � �Z dd
d�Z
ddd�Z dd� Z d dd�Z
d dd�ZdS ) �_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)�self�contextr
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_ssldata�r �callback�ssldata�appdatar
r
r � do_handshakej s
�z_SSLPipe.do_handshakec C sB | j tkrtd��| j tkr$td��t| _ || _| �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 �}|� |� |s�q�q�nJ| j t
kr�| j�� d | _t| _ | jr�| �� n| j tkr�|� | j�
� � W nz tjtjfk
�rl } zRt|dd �}|tjtjtjfk�rP| j tk�rN| j �rN| � |� � |tjk| _W 5 d }~X Y nX | jj�r�|� | j�
� � ||fS )NF�errno)r r r r �writer) r r/ r$ r �read�max_size�appendr0 Zunwrapr r �SSLError�CertificateError�getattr�SSL_ERROR_WANT_READ�SSL_ERROR_WANT_WRITE�SSL_ERROR_SYSCALLr �pending)r �datar' r. r- �chunk�exc� 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
dkr�tj }|_ |tj tj
tjfkr�� |tj k| _W 5 d }~X Y nX | jjr�|�| j�� � |t|�k�s | jrB�q 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"dd�Zdd� Z dd � Z
d
d � Z d d
� Z e
jfdd�Zdd� Zdd� Zdd� Zd#dd�Zdd� 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_info�r �name�defaultr
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 |tttf�s$tdt|�j� ���|s,d S | j�|� d S )Nz+data: expecting a bytes-like instance, got ) �
isinstance�bytes� bytearrayrD � TypeError�typerH rN �_write_appdata�r 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^ �warnings�warnra rc rd re rf rg rK rh r4 rp rr r
r
r
r rL s$
rL c @ s� e Zd Zd+dd�Zdd� Zd,dd �Zd
d � Zd d
� Zdd� Zdd� Z dd� Z
dd� Z d-dd�Z 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 � _sslcontext�dict�_extra� collections�deque�_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_result�r 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&| jr�t �
| j |� n | j � |� W nP ttfk
r� � Y n8 tk
�r
} z| �|d� W Y � d S d }~X Y nX q�| �
� �q q�d S )NzSSL error in data receivedz/application protocol failed to receive SSL data)r r* �
SystemExit�KeyboardInterrupt�
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�� rt�d| � | �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$t�d| � | j �� | _nd | _d| _| j�d� | 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 }t�d| |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 @�@)�peercert�cipher� 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 z�tt| j��D ]�}| 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$| j�r | �|� 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_backlog�Fatal error on transportc C sV t |t�r(| 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 �<module> s*
y�xPK [H�� �[ �[ / __pycache__/windows_events.cpython-38.opt-2.pycnu �[��� U
e5di� � @ s� d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlZddl m
Z
ddl m Z ddl m Z ddl m
Z
ddl mZ ddl mZ dd l mZ dd
l mZ dd lmZ d Zd Zd
ZdZdZdZdZG dd� de j�Z G dd� de j�Z G dd� de �Z G dd� de �Z G dd� de �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 )(� N� )�events)�base_subprocess)�futures)�
exceptions)�proactor_events)�selector_events)�tasks)�
windows_utils)�logger)�SelectorEventLoop�ProactorEventLoop� IocpProactor�DefaultEventLoopPolicy� WindowsSelectorEventLoopPolicy� WindowsProactorEventLoopPolicy� �� i� i� g����MbP?g�������?c sZ e Zd Zdd�� fdd�
Z� fdd�Zdd� Z� fd d
�Z� fd d �Z� fd
d�Z� Z S )�_OverlappedFutureN��loopc s& t � j|d� | jr | jd= || _d S �Nr ���)�super�__init__�_source_traceback�_ov)�self�ovr �� __class__� �./usr/lib64/python3.8/asyncio/windows_events.pyr 1 s z_OverlappedFuture.__init__c sH t � �� }| jd k rD| jjr dnd}|�dd|� d| jjd�d�� |S )N�pendingZ completedr z overlapped=<z, �#x�>)r �
_repr_infor r" �insert�address�r �info�stater 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 failed��message� exception�future�source_traceback)r �cancel�OSErrorr �_loop�call_exception_handler)r �exc�contextr 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__r r% r6 r0 r9 r; �
__classcell__r r r r! r + s r c sj e Zd Zdd�� fdd�
Zdd� Z� fdd�Zd d
� Zd d � Z� fd
d�Z� fdd�Z � fdd�Z
� Z S )�_BaseWaitHandleFutureNr 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 �| jd�t jkS �Nr )�_winapiZWaitForSingleObjectrC 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% �appendrC rJ rD 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/ ) rE rD � _overlappedZUnregisterWaitr1 �winerror�ERROR_IO_PENDINGr r2 r3 rN �r rG r4 r5 r r r! �_unregister_wait� s$ �
z&_BaseWaitHandleFuture._unregister_waitc s | � � t� �� S r7 )rT r r0 r8 r r r! r0 � s z _BaseWaitHandleFuture.cancelc s | � � t� �|� d S r7 )rT r r9 r: r r r! r9 � s z#_BaseWaitHandleFuture.set_exceptionc s | � � t� �|� d S r7 )rT r r; r< r r r! r; � s z _BaseWaitHandleFuture.set_result) r> r? r@ r rJ r% rN rT r0 r9 r; rA r r r r! rB [ s
rB c sB e Zd Zdd�� fdd�
Zdd� Z� fdd�Z� fd d
�Z� ZS ) �_WaitCancelFutureNr c s t � j||||d� d | _d S )Nr )r r �_done_callback)r r �eventrG r r r r! r � s z_WaitCancelFuture.__init__c C s t d��d 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; rV r< r r r! r; � s
z _WaitCancelFuture.set_resultc s$ t � �|� | jd k r | �| � d S r7 )r r9 rV r: r r r! r9 � s
z _WaitCancelFuture.set_exception)r> r? r@ r r0 r; r9 rA r r r r! rU � s rU c s6 e Zd Zdd�� fdd�
Z� fdd�Zdd� Z� ZS ) �_WaitHandleFutureNr c s< t � j||||d� || _d| _t�d ddd �| _d | _d S )Nr TF)r r � _proactorZ_unregister_proactorrP Z CreateEvent�_event�
_event_fut)r r rF rG �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[ rI � CloseHandler\ rZ � _unregisterr r rN rL r r r! rN � 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 rO )rE rD rP ZUnregisterWaitExr[ r1 rQ rR r r2 r3 rZ � _wait_cancelrN r\ rS r r r! rT � s( �
�z"_WaitHandleFuture._unregister_wait)r> r? r@ r rN rT rA r r r r! rY � s rY c @ s8 e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� ZeZd S ) �
PipeServerc C s, || _ t�� | _d | _d | _| �d�| _d S �NT)�_address�weakref�WeakSet�_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)rg ri )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 )�closedrI ZPIPE_ACCESS_DUPLEXZFILE_FLAG_OVERLAPPEDZ FILE_FLAG_FIRST_PIPE_INSTANCEZCreateNamedPiperc ZPIPE_TYPE_MESSAGEZPIPE_READMODE_MESSAGEZ PIPE_WAITZPIPE_UNLIMITED_INSTANCESr
ZBUFSIZEZNMPWAIT_WAIT_FOREVER�NULL�
PipeHandlerf �add)r �first�flags�h�piper r r! ri s(
� �
z PipeServer._server_pipe_handlec C s
| j d kS r7 )rc 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 )rh r0 rc rf �closerg �clear)r rt r r r! ru s
zPipeServer.closeN) r> r? r@ r rl ri rm ru �__del__r r r r! ra � s
ra c @ s e Zd ZdS )�_WindowsSelectorEventLoopN)r> r? r@ r r r r! rx , s rx c sD e Zd Zd � fdd� Z� fdd�Zdd� Zdd � Zd
d
d �Z� ZS )r
Nc s |d krt � }t� �|� d S r7 )r r r )r r] r r r! r 3 s zProactorEventLoop.__init__c sX z| �| j� t� �� W 5 | j d k rR| j j}| j �� |d k rL| j�|� d | _ X d S r7 ) Z_self_reading_futurer r0 rZ r_ � call_soonZ_loop_self_readingr � run_forever�r r r r r! rz 8 s
z ProactorEventLoop.run_foreverc � s8 | j �|�}|I d H }|� }| j||d|id�}||fS )N�addr��extra)rZ � connect_pipe�_make_duplex_pipe_transport)r �protocol_factoryr' �frt �protocol�transr 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�� |�� n�j r�t
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= rf �discardrm ru r� rl rZ � accept_piper1 �filenor3 Z_debugr Zwarningr �CancelledErrorrh �add_done_callback)r� rt r� r4 �r' �loop_accept_piper� r Zserverr r! r� V sH ��
�z>ProactorEventLoop.start_serving_pipe.<locals>.loop_accept_pipe)N)ra ry )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�
SystemExit�KeyboardInterrupt�
BaseExceptionru Z_wait) r r� �args�shell�stdin�stdout�stderr�bufsizer~ �kwargsr� Ztranspr r r! �_make_subprocess_transport� s*
� ��z,ProactorEventLoop._make_subprocess_transport)N)N) r> r? r@ r rz r� r� r� rA r r r r! r
0 s 0 �r
c @ s� e Zd Zd:dd�Zdd� Zdd� Zdd � Zd;d d �Zd
d� Zd<dd�Z d=dd�Z
d>dd�Z d?dd�Z d@dd�Z
dd� Zd d � Zd d � Zd d!� Zd"d#� ZdAd$d%�Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� ZdBd2d3�Zd4d5� Zd6d7� Z d8d9� Z d
S )Cr r c C sD d | _ g | _t�tjtd|�| _i | _t� � | _
g | _ t� � | _ d S rH )
r2 �_resultsrP �CreateIoCompletionPort�INVALID_HANDLE_VALUErn �_iocp�_cacherd re rE �
_unregistered�_stopped_serving)r Z concurrencyr r r! r � s �
zIocpProactor.__init__c C s | j d krtd��d S )NzIocpProactor is closed)r� rX 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� rK 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� rJ )r �timeoutrk r r r! �select� s
zIocpProactor.selectc C s | j �� }|�|� |S r7 )r2 r� r; )r �valuerM r r r! �_result� s
zIocpProactor._resultr c C s~ | � |� t�t�}z4t|tj�r6|�|�� ||� 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 rQ rP ZERROR_NETNAME_DELETEDZERROR_OPERATION_ABORTED�ConnectionResetErrorr� �r� �keyr r4 r r r! � finish_recv� s
� z&IocpProactor.recv.<locals>.finish_recv) �_register_with_iocprP �
Overlappedrn �
isinstance�socketZWSARecvr� ZReadFile�BrokenPipeErrorr� � _register�r �conn�nbytesrr r r� r r r! �recv� s
zIocpProactor.recvc C s~ | � |� t�t�}z4t|tj�r6|�|�� ||� 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.<locals>.finish_recv) r� rP 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` | � |� t�t�}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.<locals>.finish_recv) r� rP r� rn Z WSARecvFromr� r� r� r� r� r r r! �recvfrom� s
zIocpProactor.recvfromc C s> | � |� t�t�}|�|�� |||� 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.<locals>.finish_send)r� rP r� rn Z WSASendTor� r� )r r� r� rr r| r r� r r r! �sendto� s
zIocpProactor.sendtoc C sZ | � |� t�t�}t|tj�r4|�|�� ||� 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.<locals>.finish_send)
r� rP r� rn r� r� ZWSASendr� Z WriteFiler� )r r� r� rr r r� r r r! �send s
zIocpProactor.sendc sv | � �� | ��j�� t�t�}|���� � �� � � �fdd�}dd� }| �|�|�}||� �}t j
|| j d� |S )Nc sD |� � t�d��� �}� �tjtj|� � � ��
� � � � � � fS )Nz@P) r� �structZpackr� �
setsockoptr� �
SOL_SOCKETrP ZSO_UPDATE_ACCEPT_CONTEXT�
settimeoutZ
gettimeoutZ getpeername)r� r� r r� �r� �listenerr r! �
finish_accept* s �z*IocpProactor.accept.<locals>.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.<locals>.accept_coror ) r� �_get_accept_socket�familyrP 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 t�t�}|�� �� |� � fdd�}| �|� |�S )Nr r c s |� � � �tjtjd� � S rH )r� r� r� r� rP ZSO_UPDATE_CONNECT_CONTEXT�r� r� r �r� r r! �finish_connectV s �z,IocpProactor.connect.<locals>.finish_connect)�typer� Z
SOCK_DGRAMrP Z
WSAConnectr� r2 r� r; r� Z BindLocalr� r1 rQ �errnoZ WSAEINVALZ getsocknamer� rn Z ConnectExr� )r r� r' rM �er r� r r� r! �connect@ s"
zIocpProactor.connectc C sb | � |� t�t�}|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.<locals>.finish_sendfile) r� rP r� rn Z TransmitFiler� �msvcrtZ
get_osfhandler� ) r Zsock�file�offset�countr Z
offset_lowZ offset_highr� r r r! �sendfile_ s
� zIocpProactor.sendfilec sJ | � � � t�t�}|�� �� �}|r0| �� �S � fdd�}| �|� |�S )Nc s |� � � S r7 )r� r� �rt r r! �finish_accept_pipe s z4IocpProactor.accept_pipe.<locals>.finish_accept_pipe)r� rP 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_DELAYrP Z ConnectPiper1 rQ ZERROR_PIPE_BUSY�min�CONNECT_PIPE_MAX_DELAYr �sleepr
ro )r r' ZdelayrF r4 r r r! r � s
zIocpProactor.connect_pipec C s | � ||d�S rj )�_wait_for_handle)r rF r� r r r! �wait_for_handle� s z IocpProactor.wait_for_handlec C s | � |d d�}||_|S rb )r� rV )r rW Z
done_callbackrM r r r! r` � s zIocpProactor._wait_cancelc s� | � � |d krtj}nt�|d �}t�t�}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 )rJ r� �r� r r! �finish_wait_for_handle� s z=IocpProactor._wait_for_handle.<locals>.finish_wait_for_handler )r� rI �INFINITE�math�ceilrP r� rn ZRegisterWaitWithQueuer� r' rU r2 rY r r� )r rF r� Z
_is_cancel�msr rG r� r r� r! r� � s*
�
� z IocpProactor._wait_for_handlec C s0 || j kr,| j �|� t�|�� | jdd� d S rH )rE rp rP 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�|� d S r7 )r� r� rK r{ r r r! r_ � s zIocpProactor._unregisterc C s t � |�}|�d� |S rH )r� r� )r r� �sr r r! r� � s
z IocpProactor._get_accept_socketc C s� |d krt }n0|dk r td��n t�|d �}|t kr>td��t�| j|�}|d krX�qZd}|\}}}}z| j�|�\}} }
} W nX t k
r� | j
� � r�| j
� dd||||f d�� |dtj
fkr�t�|� 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� rP ZGetQueuedCompletionStatusr� r� �pop�KeyErrorr2 Z get_debugr3 r� rI r^ r� r0 Zdoner1 r9 r� rK r; r� r' rv )r r� r� r� �errZ transferredr� r' r� r r� r� r� r� r r r! rJ 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|t�rBq z |�� W q tk
r� } z6| j d k r�d||d�}|j
r�|j
|d< | j � |� W 5 d }~X Y q X q d}t �
� } | | }
| jr�|
t �
� kr�t�d| t �
� | � t �
� | }
| �|� q�g | _t�| j � d | _ d S )NzCancelling a future failedr+ r/ g �?z,%r is running after closing for %.1f seconds)r� �listr� �itemsZ cancelledr� rU r0 r1 r2 r r3 �time� monotonicr �debugrJ r� rI r^ ) r r' rM 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@ r r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r� r` r� r� r� r_ r� rJ r� ru rw r r r r! r � s6
"
7/r c @ s e Zd Zdd� ZdS )r� c
sP t j|f|||||d�|��� _� fdd�}� jj�t� 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.<locals>.callback) r
�Popenr� r2 rZ r� �intrC 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 ).rP rI r� r� r� r� r� r� rd � r r r r r r r r
�logr �__all__rn r� ZERROR_CONNECTION_REFUSEDZERROR_CONNECTION_ABORTEDr� r� ZFuturer rB rU rY �objectra ZBaseSelectorEventLooprx ZBaseProactorEventLoopr
r ZBaseSubprocessTransportr� r ZBaseDefaultEventLoopPolicyr r r r r r r! �<module> sP 0J4;e `PK [�o2y�/ �/ % __pycache__/transports.cpython-38.pycnu �[��� U
e5d�( � @ s| d Z dZG dd� d�ZG dd� de�ZG dd� de�ZG dd � d ee�ZG d
d � d e�ZG d d
� d
e�ZG dd� de�ZdS )zAbstract Transport class.)�
BaseTransport�
ReadTransport�WriteTransport� Transport�DatagramTransport�SubprocessTransportc @ sH e Zd ZdZdZddd�Zddd�Zdd � Zd
d � Zd d
� Z dd� Z
dS )r zBase class for transports.��_extraNc C s |d kr i }|| _ d S �Nr )�self�extra� r �*/usr/lib64/python3.8/asyncio/transports.py�__init__ s zBaseTransport.__init__c C s | j �||�S )z#Get optional transport information.)r �get)r
�name�defaultr r r
�get_extra_info s z BaseTransport.get_extra_infoc C s t �dS )z2Return True if the transport is closing or closed.N��NotImplementedError�r
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 )z�Pause 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 )z�Resume 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 ZdZdZddd�Zdd� 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
�high�lowr 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 )z�Write 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 )z�Write 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 )z�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.
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 �z�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.
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 ZdZdZddd�Zdd� 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 )z�Get 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 )z�Send 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 )z�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
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 ddd�Z
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 | js�d| _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() failed��messageZ exceptionZ transportr )
r' r= r< � _protocolZ
pause_writing�
SystemExit�KeyboardInterrupt�
BaseExceptionr; �call_exception_handler)r
�size�excr 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
�<module> s %F6PK [�;j% % . __pycache__/windows_utils.cpython-38.opt-1.pycnu �[��� U
e5d� � @ s� d Z ddlZejdkr ed��ddlZddlZddlZddlZddlZddl Z ddl
Z
dZ dZ ej
Z
ejZe�� Zdde d �d
d �ZG d d
� d
�ZG dd� dej�ZdS )z)Various Windows specific bits and pieces.� NZwin32z
win32 only)�pipe�Popen�PIPE�
PipeHandlei F)TT)�duplex�
overlapped�bufsizec
C s$ t jd�t�� tt��d�}| r>tj}tj tj
B }|| }}ntj }tj
}d| }}|tj O }|d rp|tj
O }|d r�tj
}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 � NT�r )�tempfileZmktemp�format�os�getpid�next�
_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 ZaddressZopenmode�accessZobsizeZibsizeZflags_and_attribsZh1Zh2Zov� r �-/usr/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
d�Zdd� Zdd� ZdS )r z�Wrapper 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��_handle��self�handler r r �__init__V s zPipeHandle.__init__c C s2 | j d k rd| j ��}nd}d| jj� d|� d�S )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 �t�v�tbr r r �__exit__v s zPipeHandle.__exit__N)r# �
__module__� __qualname__�__doc__r r$ �propertyr r' r r r( �warnings�warnr+ r, r0 r r r r r Q s
r c s" e Zd ZdZd� fdd� Z� ZS )r z�Replacement for subprocess.Popen using overlapped pipe handles.
The stdin, stdout, stderr are None or instances of PipeHandle.
Nc sx d } }}d } }
} |t kr@tddd�\} } t�| tj�}n|}|t krhtdd�\}
}
t�|
d�}n|}|t kr�tdd�\} }t�|d�}n|tkr�|}n|}z�z t� j |f|||d�|�� W n0 | |
| fD ]}|d k r�t
� |� qւ Y n>X | d k �r
t | �| _
|
d k �r t |
�| _| d k �r2t | �| _W 5 |t k�rJt�|� |t k�r^t�|� |t k�rrt�|� X d S )N)FTT)r r )TFr r )�stdin�stdout�stderr)r r �msvcrtZopen_osfhandler �O_RDONLY�STDOUTr( �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_wh�h�r" r r r � sN ��
zPopen.__init__)NNN)r# r1 r2 r3 r �
__classcell__r r rA r r } s r )r3 �sys�platform� ImportErrorr � itertoolsr: r �
subprocessr r5 �__all__ZBUFSIZEr r< �countr r r r r r r r �<module> s$
1,PK [��Kl� l� , __pycache__/base_events.cpython-38.opt-1.pycnu �[��� U
e5d� � @ 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 d�Z&dZ'e(� Z)dd� Z*dd� Z+dd� Z,d+dd �Z-d,d d �Z.d d � Z/e%e d!��r�d"d#� Z0nd$d#� Z0G d%d&� d&ej1�Z2G d'd(� d(ej3�Z4G d)d*� d*ej5�Z6dS )-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)�
BaseEventLoop�d g �?�AF_INET6i�Q c C s0 | j }tt|dd �tj�r$t|j�S t| �S d S )N�__self__)Z _callback�
isinstance�getattrr �Task�reprr �str)�handle�cb� r �+/usr/lib64/python3.8/asyncio/base_events.py�_format_handleJ s
r c C s( | t jkrdS | t jkr dS t| �S d S )Nz<pipe>z<stdout>)�
subprocess�PIPE�STDOUTr )�fdr r r � _format_pipeS s
r! c C sL t td�std��n4z| �tjtjd� W n tk
rF td��Y 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.)�hasattr�socket�
ValueError�
setsockopt�
SOL_SOCKETr" �OSError��sockr r r �_set_reuseport\ s
r+ c C s� t td�sd S |dtjtjhks(| d kr,d S |tjkr>tj}n|tjkrPtj}nd S |d krbd}nXt|t�rz|dkrzd}n@t|t�r�|dkr�d}n(z t |�}W n t
t fk
r� Y d S X |tj kr�tj
g}tr�|�tj� n|g}t| t�r�| �d�} d| k�rd S |D ]t}zVt�|| � t�rJ|tjk�rJ|||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_UNSPEC�AF_INET� _HAS_IPv6�appendr �decoder, r( ) �host�port�family�type�protoZflowinfoZscopeidZafs�afr 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� tj�tj |� �D �� |S )z-Interleave list of addrinfo tuples by family.r r Nc s s | ]}|d k r|V qd S �Nr )�.0�ar r r � <genexpr>� s �z(_interleave_addrinfos.<locals>.<genexpr>)
� collections� OrderedDictr9 �list�values�extend� itertools�chain�
from_iterable� zip_longest)Z addrinfosZfirst_address_family_countZaddrinfos_by_family�addrr= Zaddrinfos_listsZ reorderedr r r �_interleave_addrinfos� s"
��rP c C s4 | � � s"| �� }t|ttf�r"d S t�| ��� d S rB )� cancelled� exceptionr �
SystemExit�KeyboardInterruptr Z _get_loop�stop)�fut�excr 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 |tj�std��|| _|�� | _|�� | _|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)�self�transpr 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_closing�ConnectionErrorre )rf rV r r r �drain� s
z _SendfileFallbackProtocol.drainc C s t d��d 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 d��d S �Nz'Invalid state: reading should be pausedrl )rf �datar r r �
data_received� s z'_SendfileFallbackProtocol.data_receivedc C s t d��d 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 �loop�sockets�protocol_factoryZ ssl_context�backlog�ssl_handshake_timeoutr r r rh s zServer.__init__c C s d| j j� d| j�d�S )N�<z sockets=�>)� __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 �waiters�waiterr 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.<locals>.<genexpr>)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| jd�I 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� Zdd�d d
�Zd d � Zd
d� Zd�ddd�dd�Z d�ddddddd�dd�Z
d�dd�Z d�dd�Z d�dd �Z
d�d d �Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Zd5d6� Zej fd7d8�Z d9d:� Z d;d<� Z dd=�d>d?�Z dd=�d@dA�Z!dd=�dBdC�Z"dDdE� Z#dFdG� Z$dHdI� Z%dd=�dJdK�Z&dLdM� Z'dNdO� Z(dPdQ� Z)dRdRdRdRdS�dTdU�Z*d�dVdW�Z+d�ddX�dYdZ�Z,d[d\� Z-d]d^� Z.d_d`� Z/d�dadb�Z0d�ddRdRdRdddddddc�
ddde�Z1d�dfdg�Z2d�ddX�dhdi�Z3djdk� Z4dldm� Z5ddddn�dodp�Z6d�dRdRdRe7ddddq�drds�Z8dRe9j:dRdRdS�dtdu�Z;dvdw� Z<d�e9j=e9j>ddxddddddy� dzd{�Z?ddd|�d}d~�Z@dd�� ZAd�d�� ZBd�d�� ZCeDjEeDjEeDjEdddRdddd�� d�d��ZFeDjEeDjEeDjEdddRdddd�� d�d��ZGd�d�� ZHd�d�� ZId�d�� ZJd�d�� ZKd�d�� ZLd�d�� ZMd�d�� ZNd�d�� ZOd�d�� ZPd�d�� ZQd�d�� ZRdS )�r c C s� d| _ d| _d| _t�� | _g | _d | _d| _d | _ t
� d�j | _
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_id�time�get_clock_infoZ
resolution�_clock_resolution�_exception_handler� set_debugr Z_is_debug_mode�slow_callback_duration�_current_handle�
_task_factory�"_coroutine_origin_tracking_enabled�&_coroutine_origin_tracking_saved_depth�weakrefZWeakSet�
_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| d�S )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<Return a task factory, or None if the default one is in use.)r� rq r r r �get_task_factory� s z BaseEventLoop.get_task_factory)�extra�serverc C s t �dS )zCreate socket transport.N��NotImplementedError)rf r* �protocolr� r� r� r r r �_make_socket_transport� s z$BaseEventLoop._make_socket_transportFT)� server_side�server_hostnamer� r� r� �call_connection_madec C s t �dS )zCreate SSL transport.Nr� ) rf Zrawsockr� �
sslcontextr� r� r� r� r� r� r� r r r �_make_ssl_transport� s z!BaseEventLoop._make_ssl_transportc C s t �dS )zCreate datagram transport.Nr� )rf r* r� �addressr� r� r r r �_make_datagram_transport� s z&BaseEventLoop._make_datagram_transportc C s t �dS )zCreate read pipe transport.Nr� �rf �piper� r� r� r r r �_make_read_pipe_transport� s z'BaseEventLoop._make_read_pipe_transportc C s t �dS )z Create write pipe transport.Nr� r� r r r �_make_write_pipe_transport� s z(BaseEventLoop._make_write_pipe_transportc
� s t �dS )z Create subprocess transport.Nr� )
rf r� �args�shell�stdin�stdout�stderr�bufsizer� �kwargsr r r �_make_subprocess_transport� s z(BaseEventLoop._make_subprocess_transportc C s t �dS )z�Write a byte to self-pipe, to wake up the event loop.
This may be called from a different thread.
The subclass is responsible for implementing the self-pipe.
Nr� rq r r r �_write_to_self� s z BaseEventLoop._write_to_selfc C s t �dS )zProcess selector events.Nr� )rf �
event_listr r r �_process_events� s z BaseEventLoop._process_eventsc C s | j rtd��d 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� �aclose�rf �agenr r r �_asyncgen_finalizer_hook� s z&BaseEventLoop._asyncgen_finalizer_hookc C s. | j r tjd|�d�t| d� | j�|� d S )Nzasynchronous generator z3 was scheduled after loop.shutdown_asyncgens() call��source)r� �warnings�warn�ResourceWarningr� �addr� r r r �_asyncgen_firstiter_hook s
�z&BaseEventLoop._asyncgen_firstiter_hookc � s� d| _ t| j�sdS t| j�}| j�� tjdd� |D �d| d��I dH }t||�D ]*\}}t|t �rT| �
d|��||d�� qTdS )z,Shutdown all active asynchronous generators.TNc S s g | ] }|� � �qS r )r� )rC Zagr r r �
<listcomp> s z4BaseEventLoop.shutdown_asyncgens.<locals>.<listcomp>)Zreturn_exceptionsr� z;an error occurred during closing of asynchronous generator )�messagerR Zasyncgen) r� �lenr� rH �clearr �gather�zipr � Exception�call_exception_handler)rf Z
closing_agensZresults�resultr� r r r �shutdown_asyncgens s"
�
�z BaseEventLoop.shutdown_asyncgensc C s( | � � rtd��t�� d k r$td��d 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� �sys�get_asyncgen_hooks�set_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<z | �
� W n* |rp|� � rp|� � sp|�
� � Y nX W 5 |� t� X |� � s�td��|�� S )a\ Run until the Future is done.
If the argument is a coroutine, it is wrapped in a Task.
WARNING: It would be disastrous to call run_until_complete()
with the same coroutine twice -- it would wrap it in two
different Tasks and that can't be good.
Return the Future's result, or raise its exception.
r� Fz+Event loop stopped before Future completed.)r� r� r Zisfuturer Z
ensure_futureZ_log_destroy_pendingZadd_done_callbackrX Zremove_done_callbackr r� rQ rR rm r� )rf ZfutureZnew_taskr r r �run_until_completeD s"
z BaseEventLoop.run_until_completec C s
d| _ dS )z�Stop running the event loop.
Every callback already scheduled will still run. This simply informs
run_forever to stop looping after a complete iteration.
TN)r� rq r r r rU j s zBaseEventLoop.stopc C sj | � � rtd��| jrdS | jr,t�d| � d| _| j�� | j�� | j }|dk rfd| _ |j
dd� dS )z�Close the event loop.
This clears the queues and shuts down the executor,
but does not wait for the executor to finish.
The event loop must not be running.
z!Cannot close a running event loopNzClose %rTF)�wait) r� rm r� r� r �debugr� r� r� r� Zshutdown�rf �executorr r r r� r s
zBaseEventLoop.closec C s | j S )z*Returns True if the event loop was closed.)r� rq r r r r� � s zBaseEventLoop.is_closedc C s0 | � � s,|d| ��t| d� | �� s,| �� d S )Nzunclosed event loop r� )r� r� r� r� )rf Z_warnr r r �__del__� s zBaseEventLoop.__del__c C s
| j dk S )z*Returns True if the event loop is running.N)r� rq r r r r� � s zBaseEventLoop.is_runningc C s t �� S )z�Return the time according to the event loop's clock.
This is a float expressed in seconds since an epoch, but the
epoch, precision, accuracy and drift are unspecified and may
differ per event loop.
)r� r� rq r r r r� � s zBaseEventLoop.time)�contextc G s2 | j | �� | |f|�d|i�}|jr.|jd= |S )a8 Arrange for a callback to be called at a given time.
Return a Handle: an opaque object with a cancel() method that
can be used to cancel the call.
The delay can be an int or float, expressed in seconds. It is
always relative to the current time.
Each callback will be called exactly once. If two callbacks
are scheduled for exactly the same time, it undefined which
will be called first.
Any positional arguments after the callback will be passed to
the callback when it is called.
r r� )�call_atr� r� )rf Zdelay�callbackr r� �timerr r r �
call_later� s �zBaseEventLoop.call_laterc G sZ | � � | jr"| �� | �|d� t�|||| |�}|jrB|jd= t�| j |� d|_ |S )z|Like call_later(), but uses an absolute time.
Absolute time corresponds to the event loop's time() method.
r
r� T)
r� r� �
_check_thread�_check_callbackr Z TimerHandler� �heapq�heappushr� )rf �whenr r r� r r r r r
� s zBaseEventLoop.call_atc G sB | � � | jr"| �� | �|d� | �|||�}|jr>|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|� d���t|�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(td��dS )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|�� | d�S )N�run_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 |tjj�s t�dtd� || _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�|�}t�d|� | �� }t�||||||�} | �� | }
d|� d |
d
d �d | ��}|
| jkr�t�|� 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? �flags�msg�t0�addrinfo�dtr 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* �file�offset�countr. rW r r r �
sock_sendfile@ s � �zBaseEventLoop.sock_sendfilec � s t �d|�d���d S )Nz-syscall sendfile is not available for socket z and file {file!r} combination�r r1 �rf r* r3 r4 r5 r r r r0 N s
�z#BaseEventLoop._sock_sendfile_nativec
� s� |r|� |� |r t|tj�ntj}t|�}d}zt|rNt|| |�}|dkrNq�t|�d |� }| �d |j|�I d H } | szq�| � ||d | � �I d H || 7 }q2|W �S |dkr�t|d�r�|� || � X d S )Nr �seek)
r9 �minr Z!SENDFILE_FALLBACK_READBUFFER_SIZE� bytearrayr# �
memoryviewr �readintoZ sock_sendall)
rf r* r3 r4 r5 � blocksize�buf�
total_sent�view�readr r r r2 U s,
��
z%BaseEventLoop._sock_sendfile_fallbackc C s� dt |dd�krtd��|jtjks,td��|d k rbt|t�sLtd�|���|dkrbtd�|���t|t�sztd�|���|dk r�td�|���d S )N�b�modez$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}
z�tj|||d�}
|
�d� |dk r�|D ]r\}}}}} z|
�| � W q�W 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.N�r= r> r? Fz*error while attempting to bind on address �: ) r9 r$ � setblocking�bindr( �strerror�lower�errno�pop� 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 d���j||f|tj||�d�I dH }|s�td��| dk r܈j| |tj||�d�I dH ��s�td��nd�|
r�t||
�}g � | dk�rH|D ]D}z ��� |��I dH }W �qvW n tk
�r@ Y �q Y nX �q n.tj� ��fd d
�|D �| �d �I dH \}}}|dk�r d d
� � D �� t � �dk�r�� d �nJt
� d ��t �fdd
�� D ���r҈ d �td� d�
dd
� � D �����n.|dk�rt d��|jtjk�r t d|�����j||||
| d�I dH \}}�j�rd|�d�}t�d|||||� ||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 host�1ssl_handshake_timeout is only meaningful with sslr �8host/port and sock can not be specified at the same time�r= r> r? r& r� �!getaddrinfo() returned empty listc 3 s | ]}t ��j� |��V qd S rB )� functools�partialrP )rC r) )r � laddr_infosrf r r rE � s � �z2BaseEventLoop.create_connection.<locals>.<genexpr>r� c S s g | ]}|D ]}|�q qS r r )rC �subrW r r r r� � s z3BaseEventLoop.create_connection.<locals>.<listcomp>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|t�r*d n|} | j||| ||||d�}
n| �|||�}
z|I d H W n |
�� � Y nX |
|fS )NF�r� 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� |� � rtd��t|dtjj�}|tjjkr:td|����|tjjkr�z| �||||�I dH W S tj k
r� } z
|sx� W 5 d}~X Y nX |s�td|����| �
||||�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 �d��d 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|d�nd}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 |dkr�t|d�r�|� || � |�� 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 dkrtd��t|t j�s*td|����t|dd�sFtd|�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_port�allow_broadcastr* c � s� |
dk r�|
j tjkr"td|
����� s>�s>|s>|s>|s>|s>| r~t� �|||||| d�} d�dd� | �� D ��} td| � d���|
�d � d}
�n� s��s�|d
kr�td ��||fd ff}�n�ttd
��r�|tj k�r�� �fD ] }|dk r�t
|t �s�t d��qڈ �rx� d
dk�rxz"t
�t�
� �j��r.t�� � W nF tk
�rF Y n2 tk
�rv } zt�d� |� W 5 d}~X Y nX ||f� �fff}n�i }d
� fd�ffD ]�\}}|dk �r�| j||tj||| d�I dH }|�s�td��|D ]:\}}}}}||f}||k�rddg||< ||| |< �q�q�� �fdd�|�� D �}|�sHtd��g }|tk �rv|�rftd��ntjdtdd� |D ]�\\}}\}}d}
d}
zxtj|tj|d�}
|�r�t|
� | �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̈ �r�t�&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 �k�vr r r rE � s z9BaseEventLoop.create_datagram_endpoint.<locals>.<genexpr>zKsocket modifier keyword arguments can not be used when sock is specified. (�)Fr zunexpected address family)NN�AF_UNIXzstring is expected)r � z2Unable to check or remove stale UNIX socket %r: %rr rW rX c s8 g | ]0\}}� r |d dks�r,|d dks||f�qS )r Nr r )rC �keyZ addr_pair�rR rr r r r� � s �z:BaseEventLoop.create_datagram_endpoint.<locals>.<listcomp>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 �stat�S_ISSOCK�os�st_mode�remove�FileNotFoundErrorr( 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_infos�idxre 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||||||d�I 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|| d�I 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 |t�rtd��| dk r*|dkr*td��|dk s<�dk �r"|dk rLtd��| dkrhtjdkoftjdk} g }
|dkr|dg}n$t |t�s�t |t j
j �s�|g}n|}� ���fdd �|D �}t j
|d
�i�I dH }ttj�|��}d }�z |D �]}|\}}}}}zt�|||�}W n8 tjk
�rH �j�r@tjd |||d
d� Y q�Y nX |
�|� | �rl|�tjtjd
� |
�rzt |� t �r�|tj k�r�t td��r�|�tj tj!d
� z|�"|� W q� t#k
�r� } z t#|j$d||j%�&� f �d�W 5 d}~X Y q�X q�d
}W 5 |�s |
D ]}|�� �qX n4|dk�r4td��|j'tj(k�rPtd|����|g}
|
D ]}|�)d � �qZt*�|
|||| �}| �r�|�+� t j,d�d�I dH �j�r�t�-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 �posix�cygwinr. c s g | ]}�j |�� �d ��qS ))r= r& )r� )rC r; �r= r& r< rf r r r� � s �
�z/BaseEventLoop.create_server.<locals>.<listcomp>r� Fz:create_server() failed to create socket.socket(%r, %r, %r)T��exc_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 �abc�Iterabler 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 completed�resr@ 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|d�I dH \}}| jrn|�d�}t�d|||� ||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\t�d|�� ||� ||fS )Nz Read pipe %r connected: (%r, %r))rd r� r� r� r r �fileno�rf 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\t�d|�� ||� ||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|�� �� t�d�|�� 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� �encoding�errors�textc � s� t |ttf�std��|r"td��|s.td��|dkr>td��| rJtd��| d k rZtd��|
d k rjtd��|� }
d }| jr�d | }| �||||� | j|
|d
||||f| �I d H }| jr�|d k r�t�d ||� ||
fS ) Nzcmd must be a string� universal_newlines must be Falsezshell must be Truer �bufsize must be 0�text must be False�encoding must be None�errors 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 }| jr�d|��}| �||||� | j||d ||||f|
�I d H }| jr�|d k r�t�d
||� ||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|| }|dkr�d �t�|��}d
}||� � 7 }n2|dkr�d �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> r� rR 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_list�rstripr r9 r r� ) rf r r� rR r� Z log_linesry �value�tbr 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 q�X n�z| � | |� 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<d|_q*|�|� q*t�|� || _d| _n4| jr�| jd jr�| jd8 _t� | j�}d|_q`d}| j
s�| j r�d}n*| jr�| jd j }t
td|| �� �t�}| j�|�}| �|� | �� | j }| j�r:| jd }|j |k�r�q:t� | j�}d|_| j
�|� q�t | j
�}t|�D ]|} | j
�� }|j�rf�qL| j�r�zD|| _| �� }
|�� | �� |
} | | jk�r�t� dt |�| � W 5 d| _X n|�� �qLd}dS )z�Run one full iteration of the event loop.
This calls all currently ready callbacks, polls for I/O,
schedules the resulting callbacks, and finally schedules
'call_later' callbacks.
Fr r Nz Executing %s took %.3f seconds) r� r� � _MIN_SCHEDULED_TIMER_HANDLESr� �%_MIN_CANCELLED_TIMER_HANDLES_FRACTIONr� r9 r �heapify�heappopr� r� Z_whenr: �maxr� �MAXIMUM_SELECT_TIMEOUTZ _selectorZselectr� r� �range�popleftr� r� Z_runr� r r� r ) rf Z sched_countZ
new_scheduledr Ztimeoutr r� Zend_timeZntodo�ir( r* r r r r � sj
��
�
zBaseEventLoop._run_oncec C sH t |�t | j�krd S |r2t�� | _t�tj� n t�| j� || _d S rB )rh r� r �#get_coroutine_origin_tracking_depthr� �#set_coroutine_origin_tracking_depthr ZDEBUG_STACK_DEPTH�rf Zenabledr r r r� F s ���z,BaseEventLoop._set_coroutine_origin_trackingc C s | j S rB )r� rq r r r r� U s zBaseEventLoop.get_debugc C s || _ | �� r | �| j|� d S rB )r� r� r� r� r� r r r r� X s zBaseEventLoop.set_debug)N)N)NNN)NN)NN)N)r )r N)N)NN)FN)r N)NN)NN)Sr| r} r~ rh r� rd r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r rU r� r� r� r� r r� r� r r
r r r r r� r r r+ r$ r- r6 r0 r2 r/ rP rf rc rk ri rj rn r� r� r$ r1 ra r� r6 Z
AI_PASSIVEr� r� r� r� r� r r r� r� r� r� r� r� r� r� r� r r� r� r� r r r r r � sF � � �
�
�
�
�
&
�
�
% � � �
� /� / � � � �� w� � % � "29Nr )r r )r )7�__doc__rF Zcollections.abcZconcurrent.futuresr rY r rK r� r$ r~ r r� r� r� r r� r� rQ � ImportErrorr. r r r r r r r r
r r r
�logr �__all__r� r� r# r8 r� �objectr� r r! r+ rA rP rX r[ ZProtocolr\ ZAbstractServerr ZAbstractEventLoopr r r r r �<module> sd
;
DoPK [�T
� � __pycache__/log.cpython-38.pycnu �[��� U
e5d| � @ s d Z ddlZe�e�ZdS )zLogging configuration.� N)�__doc__ZloggingZ getLogger� __package__Zlogger� r r �#/usr/lib64/python3.8/asyncio/log.py�<module> s PK [)��(& (& & __pycache__/locks.cpython-38.opt-2.pycnu �[��� U
e5d|C � @ s� d Z ddlZddlZddlZddlmZ ddlmZ ddlmZ ddlmZ G dd � d �Z G d
d � d �Z
G d d
� d
e
�Z G dd� d�Z G dd� de
�Z
G dd� de
�ZG dd� de�ZdS ))�Lock�Event� Condition� Semaphore�BoundedSemaphore� N� )�events)�futures)�
exceptions)�
coroutinesc @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�_ContextManagerc C s
|| _ d S �N)�_lock)�self�lock� r �%/usr/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 �release�r �argsr r r �__exit__* s z_ContextManager.__exit__N)�__name__�
__module__� __qualname__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 d��d 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)�warnings�warn�DeprecationWarning�acquirer 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_type�exc�tbr 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 sJ e Zd Zdd�dd�Z� fdd�Zdd� Zd d
� Zd d � Zd
d� Z� Z S )r N��loopc 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 r1 r r r r � s �z
Lock.__init__c sL t � �� }| jrdnd}| jr2|� dt| j�� �}d|dd� � d|� d�S � N�lockedZunlocked�
, waiters:�<r ���� [�]>)�super�__repr__r5 r4 �len�r �resZextra�� __class__r r rA � s
z
Lock.__repr__c C s | j S r
)r5 r r r r r: � s z Lock.lockedc � s� | j s.| jd ks$tdd� | jD ��r.d| _ dS | jd krBt�� | _| j�� }| j�|� z"z|I d H W 5 | j�|� X W n& t j
k
r� | j s�| � � � Y nX d| _ dS )Nc s s | ]}|� � V qd S r
)� cancelled)�.0�wr r r � <genexpr>� s z Lock.acquire.<locals>.<genexpr>T) r5 r4 �all� collections�dequer7 �
create_future�append�remover
�CancelledError�_wake_up_first�r �futr r r r% � s& �
z Lock.acquirec C s" | j rd| _ | �� ntd��d S )NFzLock is not acquired.)r5 rR r r r r r r � s
z Lock.releasec C sJ | j s
d S ztt| j ��}W n tk
r2 Y d S X |�� sF|�d� d S �NT)r4 �next�iter�
StopIteration�done�
set_resultrS r r r rR � s zLock._wake_up_first)
r r r r rA r: r% r rR �
__classcell__r r rE r r j s 6 r c sJ e Zd Zdd�dd�Z� fdd�Zdd� Zd d
� Zd d � Zd
d� Z� Z S )r Nr0 c C s> t �� | _d| _|d kr$t�� | _n|| _tjdt dd� d S r2 )
rL rM r4 �_valuer r6 r7 r" r# r$ r8 r r r r s
�zEvent.__init__c sL t � �� }| jrdnd}| jr2|� dt| j�� �}d|dd� � d|� d�S ) N�setZunsetr; r< r r= r> r? )r@ rA r\ r4 rB rC rE r r rA s
zEvent.__repr__c C s | j S r
�r\ r r r r �is_set s z Event.is_setc C s. | j s*d| _ | jD ]}|�� s|�d� qd S rU )r\ r4 rY rZ rS r r r r] s
z Event.setc C s
d| _ d S )NFr^ r r r r �clear" s z Event.clearc � sF | j r
dS | j�� }| j�|� z|I d H W �dS | j�|� X d S rU )r\ r7 rN r4 rO rP rS r r r �wait( s
z
Event.wait)
r r r r rA r_ r] r` ra r[ r r rE r r � s r c sN e Zd Zddd�dd�Z� fdd�Zdd� Zd d
� Zdd d
�Zdd� Z� Z S )r Nr0 c C s~ |d krt �� | _n|| _tjdtdd� |d kr>t|d�}n|j| jk rRtd��|| _|j | _ |j
| _
|j | _ t �
� | _d S )Nr3 r r r0 z"loop argument must agree with lock)r r6 r7 r" r# r$ r �
ValueErrorr r: r% r rL rM r4 )r r r1 r r r r E s � zCondition.__init__c sN t � �� }| �� rdnd}| jr4|� dt| j�� �}d|dd� � d|� d�S r9 )r@ rA r: r4 rB rC rE r r rA [ s
zCondition.__repr__c � s� | � � std��| �� z@| j�� }| j� |� z|I d H W �W �dS | j�
|� X W 5 d}z| �� I d H W q�W q^ tjk
r� d}Y q^X q^|r�tj�X d S )Nz cannot wait on un-acquired lockFT) r: r r r% r
rQ r7 rN r4 rO rP )r rG rT r r r ra b s$
zCondition.waitc � s$ |� }|s | � � I d H |� }q|S r
)ra )r Z predicate�resultr r r �wait_for� s
zCondition.wait_forr c C sJ | � � std��d}| jD ]*}||kr* qF|�� s|d7 }|�d� qd S )Nz!cannot notify on un-acquired lockr r F)r: r r4 rY rZ )r �n�idxrT r r r �notify� s
zCondition.notifyc C s | � t| j�� d S r
)rg rB r4 r r r r �
notify_all� s zCondition.notify_all)N)r )
r r r r rA ra rd rg rh r[ r r rE r r ; s
%
r c sL e Zd Zddd�dd�Z� fdd�Zdd � Zd
d � Zd d
� Zdd� Z� Z S )r r Nr0 c C sN |dk rt d��|| _t�� | _|d kr4t�� | _n|| _tj dt
dd� d S )Nr z$Semaphore initial value must be >= 0r3 r r ) rb r\ rL rM r4 r r6 r7 r" r# r$ �r �valuer1 r r r r � s
�zSemaphore.__init__c sV t � �� }| �� rdn
d| j� �}| jr<|� dt| j�� �}d|dd� � d|� d�S ) Nr: zunlocked, value:r; r< r r= r> r? )r@ rA r: r\ r4 rB rC rE r r rA � s
zSemaphore.__repr__c C s, | j r(| j �� }|�� s |�d � d S q d S r
)r4 �popleftrY rZ )r Zwaiterr r r �
_wake_up_next� s
zSemaphore._wake_up_nextc C s
| j dkS )Nr r^ r r r r r: � s zSemaphore.lockedc � st | j dkrb| j�� }| j�|� z|I d H W q |�� | j dkrX|�� sX| �� � Y q X q | j d8 _ dS )Nr r T)r\ r7 rN r4 rO ZcancelrG rl rS r r r r% � s
zSemaphore.acquirec C s | j d7 _ | �� d S )Nr )r\ rl r r r r r � s zSemaphore.release)r )
r r r r rA rl r: r% r r[ r r rE r r � s
r c s0 e Zd Zddd�� fdd� Z� fdd�Z� ZS ) r r Nr0 c s. |rt jdtdd� || _t� j||d� d S )Nr3 r r r0 )r" r# r$ � _bound_valuer@ r ri rE r r r
s �zBoundedSemaphore.__init__c s" | j | jkrtd��t� �� d S )Nz(BoundedSemaphore released too many times)r\ rm rb r@ r r rE r r r s zBoundedSemaphore.release)r )r r r r r r[ r r rE r r s r )�__all__rL r. r" � r r r
r r r r r r r r r r r r �<module> s "9 DzNPK [��X6G G * __pycache__/constants.cpython-38.opt-1.pycnu �[��� U
e5dx � @ s2 d dl Z dZdZdZdZdZG dd� de j�ZdS ) � N� � �
g N@i c @ s$ e Zd Ze�� Ze�� Ze�� ZdS )�
_SendfileModeN)�__name__�
__module__� __qualname__�enum�autoZ UNSUPPORTEDZ
TRY_NATIVEZFALLBACK� r r �)/usr/lib64/python3.8/asyncio/constants.pyr s r )r Z!LOG_THRESHOLD_FOR_CONNLOST_WRITESZACCEPT_RETRY_DELAYZDEBUG_STACK_DEPTHZSSL_HANDSHAKE_TIMEOUTZ!SENDFILE_FALLBACK_READBUFFER_SIZE�Enumr r r r r �<module> s PK [���
) __pycache__/format_helpers.cpython-38.pycnu �[��� U
e5dd � @ sd d dl Z d dlZd dlZd dlZd dlZddlmZ dd� Zdd� Zdd � Z dd d �Z
dd
d�Z dS )� N� )� constantsc C sV t �| �} t �| �r&| j}|j|jfS t| tj�r<t | j
�S t| tj �rRt | j
�S d S �N) �inspectZunwrapZ
isfunction�__code__� co_filename�co_firstlineno�
isinstance� functools�partial�_get_function_source�func�
partialmethod)r
�code� r �./usr/lib64/python3.8/asyncio/format_helpers.pyr
s
r c C s8 t | |d �}t| �}|r4|d|d � d|d � �7 }|S )Nz at r �:r )�_format_callbackr )r
�args� func_repr�sourcer r r �_format_callback_source s
r c C sH g }| r |� dd� | D �� |r8|� dd� |�� D �� d�d�|��S )z�Format function arguments and keyword arguments.
Special case for a single parameter: ('hello',) is formatted as ('hello').
c s s | ]}t �|�V qd S r ��reprlib�repr)�.0�argr r r � <genexpr>& s z*_format_args_and_kwargs.<locals>.<genexpr>c s s& | ] \}}|� d t �|�� �V qdS )�=Nr )r �k�vr r r r ( s z({})z, )�extend�items�format�join)r �kwargsr" r r r �_format_args_and_kwargs s r& � c C s� t | tj�r.t||�| }t| j| j| j|�S t| d�rF| j rF| j }n t| d�r^| j
r^| j
}nt | �}|t||�7 }|r�||7 }|S )N� __qualname__�__name__) r r
r r& r r
r �keywords�hasattrr( 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� _getframe�f_backr ZDEBUG_STACK_DEPTH� traceback� StackSummary�extract�
walk_stack�reverse)�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 �<module> s
PK [�� � � + __pycache__/subprocess.cpython-38.opt-1.pycnu �[��� U
e5d� � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ej
Z
ej Z ej Z G d d
� d
ej
ej�ZG d d � d �Zddddejfd
d�Zddddejd�dd�ZdS ))�create_subprocess_exec�create_subprocess_shell� N� )�events)� protocols)�streams)�tasks)�loggerc sX e Zd ZdZ� fdd�Zdd� 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 )N��loopF) �super�__init__�_limit�stdin�stdout�stderr�
_transport�_process_exited� _pipe_fds�_loopZ
create_future�
_stdin_closed)�self�limitr �� __class__� �*/usr/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��� d�d�|��S )Nzstdin=zstdout=zstderr=z<{}>� )r �__name__r �appendr r �format�join)r �infor r r �__repr__ s
z!SubprocessStreamProtocol.__repr__c C s� || _ |�d�}|d k rDtj| j| jd�| _| j�|� | j� d� |�d�}|d k r�tj| j| jd�| _
| j
�|� | j� d� |�d�}|d k r�tj || d | jd�| _ d S )Nr �r r � r )�protocol�readerr )
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 �fd�datar( r r r �pipe_data_receivedA s z+SubprocessStreamProtocol.pipe_data_receivedc C s� |dkrN| j }|d k r |�� | �|� |d kr>| j�d � 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. �exc�piper( 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 | j�dkr$| 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
ddd�ZdS )�Processc C s8 || _ || _|| _|j| _|j| _|j| _|�� | _d S r: )r Z _protocolr r r r Zget_pid�pid)r r, r' r r r r r u s zProcess.__init__c C s d| j j� d| j� d�S )N�<r �>)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,t�d| t|�� z| j�� I d H W n8 tt fk
rx } z|rht�d| |� W 5 d }~X Y nX |r�t�d| � | 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 Zdrain�BrokenPipeError�ConnectionResetErrorr1 )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}t�d| |� |�� I d H }| j�� r�|dkrndnd}t�d| |� |� � |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; �name�outputr r r � _read_stream� s
zProcess._read_streamNc � s� |d k r| � |�}n| �� }| jd k r2| �d�}n| �� }| jd k rP| �d�}n| �� }tj|||| jd�I 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 )N�ZThe loop argument is deprecated since Python 3.8 and scheduled for removal in Python 3.10.r& ��
stacklevelc s t � �d�S �Nr% �r
r r% r r �<lambda>� s �z)create_subprocess_shell.<locals>.<lambda>�r r r )r �get_event_loop�warnings�warn�DeprecationWarningZsubprocess_shellrA )
�cmdr r r r r �kwds�protocol_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 � �d�S r\ r] r r% r r r^ � s �z(create_subprocess_exec.<locals>.<lambda>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 �<module> s. �bV �
�PK [��X6G G $ __pycache__/constants.cpython-38.pycnu �[��� U
e5dx � @ s2 d dl Z dZdZdZdZdZG dd� de j�ZdS ) � N� � �
g N@i c @ s$ e Zd Ze�� Ze�� Ze�� ZdS )�
_SendfileModeN)�__name__�
__module__� __qualname__�enum�autoZ UNSUPPORTEDZ
TRY_NATIVEZFALLBACK� r r �)/usr/lib64/python3.8/asyncio/constants.pyr s r )r Z!LOG_THRESHOLD_FOR_CONNLOST_WRITESZACCEPT_RETRY_DELAYZDEBUG_STACK_DEPTHZSSL_HANDSHAKE_TIMEOUTZ!SENDFILE_FALLBACK_READBUFFER_SIZE�Enumr r r r r �<module> s PK [k*� � + __pycache__/exceptions.cpython-38.opt-1.pycnu �[��� U
e5da � @ sl d Z dZG dd� de�ZG dd� de�ZG dd� de�ZG dd � d e�ZG d
d � d e �Z
G d d
� d
e�Z dS )zasyncio exceptions.)�CancelledError�InvalidStateError� TimeoutError�IncompleteReadError�LimitOverrunError�SendfileNotAvailableErrorc @ s e Zd ZdZdS )r z!The Future or Task was cancelled.N��__name__�
__module__� __qualname__�__doc__� r r �*/usr/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� fdd�Zdd� 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)�repr�super�__init__�len�partial�expected)�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� fdd�Zdd� Z� ZS )r z�Reached 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
�<module> s PK [��X6G G * __pycache__/constants.cpython-38.opt-2.pycnu �[��� U
e5dx � @ s2 d dl Z dZdZdZdZdZG dd� de j�ZdS ) � N� � �
g N@i c @ s$ e Zd Ze�� Ze�� Ze�� ZdS )�
_SendfileModeN)�__name__�
__module__� __qualname__�enum�autoZ UNSUPPORTEDZ
TRY_NATIVEZFALLBACK� r r �)/usr/lib64/python3.8/asyncio/constants.pyr s r )r Z!LOG_THRESHOLD_FOR_CONNLOST_WRITESZACCEPT_RETRY_DELAYZDEBUG_STACK_DEPTHZSSL_HANDSHAKE_TIMEOUTZ!SENDFILE_FALLBACK_READBUFFER_SIZE�Enumr r r r r �<module> s PK [��y y ( __pycache__/windows_utils.cpython-38.pycnu �[��� U
e5d� � @ s� d Z ddlZejdkr ed��ddlZddlZddlZddlZddlZddl Z ddl
Z
dZ dZ ej
Z
ejZe�� Zdde d �d
d �ZG d d
� d
�ZG dd� dej�ZdS )z)Various Windows specific bits and pieces.� NZwin32z
win32 only)�pipe�Popen�PIPE�
PipeHandlei F)TT)�duplex�
overlapped�bufsizec
C s$ t jd�t�� tt��d�}| r>tj}tj tj
B }|| }}ntj }tj
}d| }}|tj O }|d rp|tj
O }|d r�tj
}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 � NT�r )�tempfileZmktemp�format�os�getpid�next�
_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 ZaddressZopenmode�accessZobsizeZibsizeZflags_and_attribsZh1Zh2Zov� r �-/usr/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
d�Zdd� Zdd� ZdS )r z�Wrapper 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��_handle��self�handler r r �__init__V s zPipeHandle.__init__c C s2 | j d k rd| j ��}nd}d| jj� d|� d�S )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 �t�v�tbr r r �__exit__v s zPipeHandle.__exit__N)r# �
__module__� __qualname__�__doc__r r$ �propertyr r' r r r( �warnings�warnr+ r, r0 r r r r r Q s
r c s" e Zd ZdZd� fdd� Z� ZS )r z�Replacement for subprocess.Popen using overlapped pipe handles.
The stdin, stdout, stderr are None or instances of PipeHandle.
Nc s� |� d�rt�|� dd�dks"t�d } }}d } }
} |tkrbtddd�\} } t�| tj�}n|}|tkr�tdd�\}
}
t�|
d�}n|}|tkr�tdd�\} }t�|d�}n|tkr�|}n|}z�z t
� j |f|||d �|�� W n0 | |
| fD ]}|d k r�t �
|� q�� Y n>X | d k �r,t| �| _|
d k �r@t|
�| _| d k �rTt| �| _W 5 |tk�rlt� |� |tk�r�t� |� |tk�r�t� |� X d S )
NZuniversal_newlinesr r )FTT)r r )TFr )�stdin�stdout�stderr)�get�AssertionErrorr r �msvcrtZopen_osfhandler �O_RDONLY�STDOUTr( �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_wh�h�r" r r r � sR ��
zPopen.__init__)NNN)r# r1 r2 r3 r �
__classcell__r r rC r r } s r )r3 �sys�platform� ImportErrorr � itertoolsr< r �
subprocessr r5 �__all__ZBUFSIZEr r> �countr r r r r r r r �<module> s$
1,PK [�Ŀ � ! __pycache__/queues.cpython-38.pycnu �[��� U
e5d � @ s� d Z ddlZddlZddlZddlmZ ddlmZ G dd� de�ZG dd � d e�Z 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 ZdZdS )r z;Raised when Queue.get_nowait() is called on an empty Queue.N��__name__�
__module__� __qualname__�__doc__� r r �&/usr/lib64/python3.8/asyncio/queues.pyr s r c @ s e Zd ZdZdS )r zDRaised when the Queue.put_nowait() method is called on a full Queue.Nr
r r r r r s r c @ s� e Zd ZdZd)dd�dd�Zdd� Zd d
� Zd d � Zd
d� Zdd� Z dd� Z
dd� Z dd� Z e
dd� �Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� ZdS )*r a A queue, useful for coordinating producer and consumer coroutines.
If maxsize is less than or equal to zero, the queue size is infinite. If it
is an integer greater than 0, then "await put()" will block when the
queue reaches maxsize, until an item is removed by get().
Unlike the standard library Queue, you can reliably know this Queue's size
with qsize(), since your single-threaded asyncio application won't be
interrupted between calling qsize() and doing an operation on the Queue.
r N��loopc 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�_loop�warnings�warn�DeprecationWarning�_maxsize� collections�deque�_getters�_putters�_unfinished_tasksr ZEvent� _finished�set�_init)�self�maxsizer r r r �__init__! s �
zQueue.__init__c C s t �� | _d S �N)r r �_queue�r" r# r r r r! 6 s z Queue._initc C s
| j �� S r% )r& �popleft�r" r r r �_get9 s z
Queue._getc C s | j �|� d S r% �r& �append�r" �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| �d�d| �� � d�S )N�<z at z#x� �>)�typer �id�_formatr) r r r �__repr__I s zQueue.__repr__c C s dt | �j� d| �� � d�S )Nr2 r3 r4 )r5 r r7 r) r r r �__str__L s z
Queue.__str__c C s~ d| j ��}t| dd �r,|dt| j���7 }| jrH|dt| j�� d�7 }| jrd|dt| j�� d�7 }| jrz|d| j� �7 }|S )Nzmaxsize=r& z _queue=z
_getters[�]z
_putters[z tasks=)r �getattr�listr& r �lenr r )r" �resultr r r r7 O s z
Queue._formatc C s
t | j�S )z Number of items in the queue.)r= r& r) r r r �qsize[ s z Queue.qsizec C s | j S )z%Number of items allowed in the queue.)r r) r r r r# _ s z
Queue.maxsizec C s | j S )z3Return True if the queue is empty, False otherwise.�r& r) r r r �emptyd s z Queue.emptyc C s | j dkrdS | �� | j kS dS )z�Return True if there are maxsize items in the queue.
Note: if the Queue was initialized with maxsize=0 (the default),
then full() is never True.
r FN)r r? r) r r r �fullh s
z
Queue.fullc � s� | � � r�| j�� }| j�|� z|I dH W q |�� z| j�|� W n tk
r` Y nX | � � s~|�� s~| � | j� � Y q X q | �
|�S )z�Put an item into the queue.
Put an item into the queue. If the queue is full, wait until a free
slot is available before adding item.
N) rB r �
create_futurer r, �cancel�remove�
ValueError� cancelledr1 �
put_nowait)r" r. Zputterr r r �puts s
z Queue.putc C s> | � � r t�| �|� | jd7 _| j�� | �| j� dS )zyPut an item into the queue without blocking.
If no free slot is immediately available, raise QueueFull.
r N)rB r r/ r r �clearr1 r r- r r r rH � s
zQueue.put_nowaitc � s� | � � r�| j�� }| j�|� z|I dH W q |�� z| j�|� W n tk
r` Y nX | � � s~|�� s~| � | j� � Y q X q | �
� S )zoRemove and return an item from the queue.
If queue is empty, wait until an item is available.
N) rA r rC r r, rD rE rF rG r1 �
get_nowait)r" �getterr r r �get� s
z Queue.getc C s$ | � � r t�| �� }| �| j� |S )z�Remove and return an item from the queue.
Return an item if one is immediately available, else raise QueueEmpty.
)rA r r* r1 r r- r r r rK � s
zQueue.get_nowaitc C s8 | j dkrtd��| j d8 _ | j dkr4| j�� dS )a$ Indicate that a formerly enqueued task is complete.
Used by queue consumers. For each get() used to fetch a task,
a subsequent call to task_done() tells the queue that the processing
on the task is complete.
If a join() is currently blocking, it will resume when all items have
been processed (meaning that a task_done() call was received for every
item that had been put() into the queue).
Raises ValueError if called more times than there were items placed in
the queue.
r z!task_done() called too many timesr N)r rF r r r) r r r � task_done� s
zQueue.task_donec � s | j dkr| j�� I dH dS )a Block until all items in the queue have been gotten and processed.
The count of unfinished tasks goes up whenever an item is added to the
queue. The count goes down whenever a consumer calls task_done() to
indicate that the item was retrieved and all work on it is complete.
When the count of unfinished tasks drops to zero, join() unblocks.
r N)r r �waitr) r r r �join� s
z
Queue.join)r )r r r
r r$ r! r* r/ r1 r8 r9 r7 r? �propertyr# rA rB rI rH rM rK rN rP r r r r r s(
r c @ s4 e Zd ZdZdd� Zejfdd�Zejfdd�Z dS ) r z�A subclass of Queue; retrieves entries in priority order (lowest first).
Entries are typically tuples of the form: (priority number, data).
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 r! �heapqrR r/ rS r* r r r r r � s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) r zEA subclass of Queue that retrieves most recently added entries first.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 r � s r )
�__all__r rT r � r r � Exceptionr r r r r r r r r �<module> s KPK [�]���� �� & __pycache__/unix_events.cpython-38.pycnu �[��� U
e5dۿ � @ 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
jdkr�e d��dd� 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)�SelectorEventLoop�AbstractChildWatcher�SafeChildWatcher�FastChildWatcher�MultiLoopChildWatcher�ThreadedChildWatcher�DefaultEventLoopPolicyZwin32z+Signals are not really supported on Windowsc C s dS )zDummy signal handler.N� )�signum�framer r �+/usr/lib64/python3.8/asyncio/unix_events.py�_sighandler_noop* s r c s� e Zd ZdZd)� fdd� Z� fdd�Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
d*dd�Z d+dd�Z d,dd�Z
dd� Zd-ddddd�dd�Zd.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)�self�selector�� __class__r r r 5 s z _UnixSelectorEventLoop.__init__c sZ t � �� t�� s.t| j�D ]}| �|� q n(| jrVtjd| �d�t | d� | j�
� d S )NzClosing the loop z@ on interpreter shutdown stage, skipping signal handlers removal��source) r �close�sys�
is_finalizing�listr �remove_signal_handler�warnings�warn�ResourceWarning�clear�r �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|= | j�szt�d� W n4 t
t fk
�r } zt�d|� W 5 d}~X Y nX |jtjk�r4t d|� d���n� W 5 d}~X Y nX dS )z�Add 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: %s�sig � cannot be caught)r Z iscoroutineZiscoroutinefunction� TypeError�
_check_signalZ
_check_closed�signal�
set_wakeup_fdZ_csock�fileno�
ValueError�OSError� RuntimeError�strr ZHandler r � siginterruptr
�info�errno�EINVAL)r r/ �callback�args�exc�handleZnexcr 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 kr�t
d|� d���n� W 5 d}~X Y nX | js�zt� 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 �SIGINT�default_int_handler�SIG_DFLr= rB rC r> r: r< r
rA )r r/ �handlerrF r r r r) � s(
z,_UnixSelectorEventLoop.remove_signal_handlerc C s6 t |t�std|����|t�� kr2td|� ���dS )z�Internal 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)�
isinstance�intr7 r9 �
valid_signalsr< r. r r r r8 � s
z$_UnixSelectorEventLoop._check_signalc C s t | ||||�S r )�_UnixReadPipeTransport�r �pipe�protocol�waiter�extrar 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�_UnixSubprocessTransport�add_child_handlerZget_pid�_child_watcher_callback�
SystemExit�KeyboardInterrupt�
BaseExceptionr% Z_wait)
r rU rE �shell�stdin�stdout�stderr�bufsizerW �kwargs�watcherrV �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)�ssl�sock�server_hostname�ssl_handshake_timeoutc � s |d kst |t�st�|r,|d krLtd��n |d k r<td��|d k rLtd��|d k r�|d k rdtd��t�|�}t�tjtjd�}z |� d� | �
||�I d H W q� |� � � Y q�X n@|d kr�td��|j tjks�|j
tjkr�td|����|� d� | j|||||d �I d H \}}||fS )
Nz/you have to pass server_hostname when using sslz+server_hostname is only meaningful with ssl�1ssl_handshake_timeout is only meaningful with ssl�3path and sock can not be specified at the same timer Fz no path and sock were specified�.A UNIX Domain Stream Socket was expected, got )rs )rO r? �AssertionErrorr< �os�fspath�socket�AF_UNIX� SOCK_STREAM� setblockingZ sock_connectr% �family�typeZ _create_connection_transport) r �protocol_factory�pathrp rq rr rs � transportrU r r r �create_unix_connection� sT ���
��
�z-_UnixSelectorEventLoop.create_unix_connection�d T)rq �backlogrp rs �
start_servingc
� s� t |t�rtd��|d k r&|s&td��|d k �rH|d k r@td��t�|�}t�tjtj�}|d dkr�z t �
t� |�j �r�t� |� W nB t
k
r� Y n0 tk
r� } zt�d||� W 5 d }~X Y nX z|�|� W nl tk
�r0 } z8|�� | jtjk�r d|�d�}
ttj|
�d �n� W 5 d } ~ X Y n |�� � Y nX n<|d k�rZtd ��|jtjk�sv|jtjk�r�td
|����|�d � t�| |g||||�} |�r�| �� tj d| d �I d H | S )
Nz*ssl argument must be an SSLContext or Nonert ru r )r � z2Unable to check or remove stale UNIX socket %r: %rzAddress z is already in usez-path was not specified, and no sock specifiedrv F)�loop) rO �boolr7 r< rx ry rz r{ r| �stat�S_ISSOCK�st_mode�remove�FileNotFoundErrorr= r
�errorZbindr% rB Z
EADDRINUSEr~ r r} r ZServerZ_start_servingr �sleep) r r� r� rq r� rp rs r� �errrF �msgZserverr r r �create_unix_server sn
�
�
�
�
��
�z)_UnixSelectorEventLoop.create_unix_serverc
� s� z
t j W n, tk
r6 } zt�d��W 5 d }~X Y nX z |�� }W n2 ttjfk
rv } zt�d��W 5 d }~X Y nX zt �|�j }W n, t
k
r� } zt�d��W 5 d }~X Y nX |r�|n|} | s�dS | � � }
| � |
d ||||| d� |
I d H S )Nz os.sendfile() is not availableznot a regular filer )
rx �sendfile�AttributeErrorr �SendfileNotAvailableErrorr; �io�UnsupportedOperation�fstat�st_sizer= r] �_sock_sendfile_native_impl) r rq �file�offset�countrF r; r� Zfsize� blocksize�futr r r �_sock_sendfile_nativeJ s2
� �z,_UnixSelectorEventLoop._sock_sendfile_nativec C s, |� � } |d k r| �|� |�� r4| �|||� d S |rd|| }|dkrd| �|||� |�|� d S zt�| |||�}
W �nD ttfk
r� |d kr�| � ||� | �
| | j || ||||||�
Y �nb t k
�rj } z�|d k �r| j
t
jk�rt| �tk �rtdt
j�} | | _| } |dk�rBt�d�}
| �|||� |�|
� n| �|||� |�| � W 5 d } ~ X Y n� ttfk
�r� � Y n� tk
�r� } z | �|||� |�| � W 5 d } ~ X Y njX |
dk�r�| �|||� |�|� nD||
7 }||
7 }|d k�r
| � ||� | �
| | j || ||||||�
d S )Nr zsocket is not connectedzos.sendfile call failed)r; �
remove_writer� cancelled� _sock_sendfile_update_fileposZ
set_resultrx r� �BlockingIOError�InterruptedError� _sock_add_cancellation_callbackZ
add_writerr� r= rB ZENOTCONNr �ConnectionError� __cause__r r� Z
set_exceptionra rb rc )r r� Z
registered_fdrq r; r� r� r� �
total_sent�fdZsentrF �new_excr� r r r r� a s�
�
�
� �
�
�z1_UnixSelectorEventLoop._sock_sendfile_native_implc C s |dkrt �||t j� d S �Nr )rx �lseek�SEEK_SET)r r; r� r� r r r r� � s z4_UnixSelectorEventLoop._sock_sendfile_update_fileposc s � �fdd�}|� |� d S )Nc s& | � � r"��� }|dkr"� �|� d S )Nr3 )r� r; r� )r� r� �r rq r r �cb� s zB_UnixSelectorEventLoop._sock_add_cancellation_callback.<locals>.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
jfdd�Zd dd�Zdd� Zd d � Z� ZS ) rR i Nc s� t � �|� || jd< || _|| _|�� | _|| _d| _d| _ t
� | j�j }t
�|�s�t
�|�s�t
�|�s�d | _d | _d | _td��t
�| jd� | j�| jj| � | j�| jj| j| j� |d k r�| j�tj|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_soon�connection_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 r�t� || jt
j �}|r�|�d� q�|�d� n | jd k r�|�d� n
|�d� d� d �
|��S )
N�closed�closing�fd=� _selector�polling�idle�open�<{}>� )r" r� r� �appendr� r� �getattrr� r
�_test_selector_event� selectorsZ
EVENT_READ�format�join)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
� � r�t �
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:t�d| � d S )NTz%r pauses reading)r� r� r� r� r� r� r
�debug�r r r r �
pause_reading� s
z$_UnixReadPipeTransport.pause_readingc C sB | j s | jsd S d| _| j�| j| j� | j�� r>t�d| � 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 |t�r4|jtjkr4| j�� rLtjd| |dd� n| j�||| | j d�� | �
|� d S �Nz%r: %sT��exc_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� Zejfdd�Zd d � Zd&d d �Zd'd!d"�Zd#d$� Z� ZS )(rY Nc
s� t � �||� || jd< || _|�� | _|| _t� | _d| _ d| _
t � | j�j
}t�|�}t�|�}t�|�} |s�|s�| s�d | _d | _d | _td��t �| jd� | j�| jj| � | s�|r�tj�d�s�| j�| jj| j| j� |d k r�| j�t 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 r�t� || 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_WRITE�get_write_buffer_sizer� r� )r rA r r� rh r r r r� d s,
�
z _UnixWritePipeTransport.__repr__c C s
t | j�S r )�lenr� r� r r r r� | s z-_UnixWritePipeTransport.get_write_buffer_sizec C s6 | j �� rt�d| � | 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 |tttf�s tt|���t |t�r.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|�k�r d S |dk�r&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 std��zt�| 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 |dk�r | 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 | jst�d| _ | 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 |t�r(| 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)
�
subprocess�PIPErz 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.
N��NotImplementedError�r rn rD rE r r r r_ 9 s z&AbstractChildWatcher.add_child_handlerc C s
t � �dS )z�Removes 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 )z�Attach 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 )z�Return ``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 �a�b�cr 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 � WIFSIGNALED�WTERMSIG� 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 |tj�st�| jd k r<|d kr<| jr<t�dt� | jd k rT| j� t
j � || _|d k rz|� t
j | j
� | �� d S )NzCA loop is being detached from a child watcher with pending handlers)rO r ZAbstractEventLooprw r� r) r* r+ �RuntimeWarningr) r9 �SIGCHLDrH � _sig_chldr, r r r r r � s �
z BaseChildWatcher.attach_loopc
C s^ z | � � W nL ttfk
r& � Y n4 tk
rX } z| j�d|d�� W 5 d }~X Y nX d S )N�$Unknown exception in SIGCHLD handler)r� r� )r, ra rb rc r� r� r� r r r r/ � s �zBaseChildWatcher._sig_chldN)
r� r� r� r r% r\ r+ r, r r/ r r r r r( s r( c sP e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
� Z S )r ad 'Safe' child watcher implementation.
This implementation avoids disrupting other code spawning processes by
polling explicitly each process in the SIGCHLD handler instead of calling
os.waitpid(-1).
This is a safe solution but it has a significant overhead when handling a
big number of children (O(n) each time SIGCHLD is raised)
c s | j �� t� �� d S r )r) r- r r% r� r! r r r% � s
zSafeChildWatcher.closec C s | S r r r� r r r r � s zSafeChildWatcher.__enter__c C s d S r r r r r r r! � s zSafeChildWatcher.__exit__c G s ||f| j |< | �|� d S r )r) r+ r r r r r_ � s z"SafeChildWatcher.add_child_handlerc C s* z| j |= W dS tk
r$ Y dS X d S �NTF�r) rJ r r r r r � s
z%SafeChildWatcher.remove_child_handlerc C s t | j�D ]}| �|� q
d S r �r( r) r+ r r r r r, � s z SafeChildWatcher._do_waitpid_allc C s� |dks t �zt�|tj�\}}W n( tk
rJ |}d}t�d|� Y n.X |dkrXd S t|�}| j� � rxt�
d||� z| j � |�\}}W n. t
k
r� | j� � r�tjd|dd� Y nX |||f|�� d S )Nr � �8Unknown child process pid %d, will report returncode 255�$process %s exited with returncode %s�'Child watcher got an unexpected pid: %rTr� )rw rx �waitpid�WNOHANG�ChildProcessErrorr
r r' r� r� r� r) �poprJ )r r* rn r& ro rD rE r r r r+ � s6 �
�
� z SafeChildWatcher._do_waitpid) r� r� r� r� r% r r! r_ r r, r+ r� r r r! r r � s
r c sT e Zd ZdZ� fdd�Z� fdd�Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
� Z S )r aW 'Fast' child watcher implementation.
This implementation reaps every terminated processes by calling
os.waitpid(-1) directly, possibly breaking other code spawning processes
and waiting for their termination.
There is no noticeable overhead when handling a big number of children
(O(1) each time a child terminates).
c s$ t � �� t�� | _i | _d| _d S r� )r r � threadingZLock�_lock�_zombies�_forksr� r! r r r s
zFastChildWatcher.__init__c s" | j �� | j�� t� �� d S r )r) r- r> 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 t�d|� 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��| j�F 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 � � r�t
�d||� Y W 5 Q R � q d }Y nX | j � � r�t
�d||� W 5 Q R X |d kr�t
�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 t�tj�}|| jkr:t�d� nt�tj| 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 t�tj| j�| _ | j d kr<t�d� tj| _ t�tjd� d S )NzaPrevious SIGCHLD handler was set by non-Python code, restore to default handler on watcher close.F)r@ r9 r. r/ r
r rM r@ r r r r r � s
z!MultiLoopChildWatcher.attach_loopc C s t | j�D ]}| �|� q
d S r r3 r r r r r, � s z%MultiLoopChildWatcher._do_waitpid_allc C s� |dks t �zt�|tj�\}}W n, tk
rN |}d}t�d|� d}Y nX |dkr\d S t|�}d}z| j� |�\}}}W n$ t
k
r� tjd|dd� Y nHX |� � r�t�d||� n.|r�|� � r�t�
d ||� |j|||f|�� d S )
Nr r4 r5 FTr7 r� �%Loop %r that handles pid %r is closedr6 )rw rx r8 r9 r: r
r r' r) r; rJ � is_closedr� r� rm ) r r* rn r& ro Z debug_logr� rD rE r r r r+ � s< �
� �z!MultiLoopChildWatcher._do_waitpidc C sL z | � � W n: ttfk
r& � Y n" tk
rF tjddd� Y nX d S )Nr0 Tr� )r, ra rb rc r
r )r r r r r r r/ � s z MultiLoopChildWatcher._sig_chldN)r� r� r� r� r r\ r% r r! r_ r r r, r+ r/ r r r r r g s %r c @ sn e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z e
j fdd�Z dd� Z
dd� Zdd� Zdd� ZdS )r aA Threaded child watcher implementation.
The watcher uses a thread per process
for waiting for the process finish.
It doesn't require subscription on POSIX signal
but a thread creation is not free.
The watcher has O(1) complexity, its performance doesn't depend
on amount of spawn processes.
c C s t �d�| _i | _d S r� )� itertoolsr� � _pid_counter�_threadsr� r r r r � s z ThreadedChildWatcher.__init__c C s dS r� r r� r r r r\ � s z ThreadedChildWatcher.is_activec C s | � � d S r )�
_join_threadsr� r r r r% � s zThreadedChildWatcher.closec C s. dd� t | j�� �D �}|D ] }|�� q dS )z%Internal: Join all non-daemon threadsc S s g | ]}|� � r|js|�qS r )�is_alive�daemon��.0�threadr r r �
<listcomp>� s �z6ThreadedChildWatcher._join_threads.<locals>.<listcomp>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� d�t| d� d S )Nc S s g | ]}|� � r|�qS r )rK rM r r r rP s �z0ThreadedChildWatcher.__del__.<locals>.<listcomp>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)�target�namerE 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}t�d|� Y n X t|�}|�� rht�d||� |� � r�t�d||� 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� fdd�Zdd� Z� fdd�Zdd � 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 j�8 | jd kr:t� | _tt�� tj�r:| 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�� tj�r2| j�|� dS )z�Set 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 |t�st�| 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 �<module> s`
� NO5Ji}Y3PK [`��S �S ) __pycache__/sslproto.cpython-38.opt-1.pycnu �[��� U
e5dJj � @ 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� de�ZG dd� dejej�ZG dd� dej�ZdS )� N� )� base_events)� constants)� protocols)�
transports)�loggerc C s" | r t d��t�� }|s d|_|S )Nz(Server side SSL needs a valid SSLContextF)�
ValueError�sslZcreate_default_contextZcheck_hostname)� server_side�server_hostname�
sslcontext� r
�(/usr/lib64/python3.8/asyncio/sslproto.py�_create_transport_context s r Z UNWRAPPEDZ DO_HANDSHAKEZWRAPPEDZSHUTDOWNc @ s~ e Zd ZdZdZddd�Zedd� �Zedd � �Zed
d � �Z ed d
� �Z
ddd�Z d dd�Z dd� Z
d dd�Zd dd�ZdS ) �_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)�self�contextr
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_ssldata�r �callback�ssldata�appdatar
r
r � do_handshakej s
�z_SSLPipe.do_handshakec C sB | j tkrtd��| j tkr$td��t| _ || _| �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 )z�Send 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 �}|� |� |s�q�q�nJ| j t
kr�| j�� d| _t| _ | jr�| �� n| j tkr�|� | j�
� � W nz tjtjfk
�rl } zRt|dd�}|tjtjtjfk�rP| j tk�rN| j �rN| � |� � |tjk| _W 5 d}~X Y nX | jj�r�|� | 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().
FN�errno)r r r r �writer' r r- r" r �read�max_size�appendr. Zunwrapr r �SSLError�CertificateError�getattr�SSL_ERROR_WANT_READ�SSL_ERROR_WANT_WRITE�SSL_ERROR_SYSCALLr �pending)r �datar% r, r+ �chunk�exc� 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
dkr�tj }|_ |tj tj
tjfkr�� |tj k| _W 5 d}~X Y nX | jjr�|�| j�� � |t|�k�s | jrB�q 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"dd�Zdd� Z dd � Z
d
d � Z d d
� Z e
jfdd�Zdd� Zdd� Zdd� Zd#dd�Zdd� 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_info�r �name�defaultr
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 )z�Pause 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 )z�Resume 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 |tttf�s$tdt|�j� ���|s,dS | j�|� dS )z�Write 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) �
isinstance�bytes� bytearrayrB � TypeError�typerF rM �_write_appdata�r 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 )z�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.
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] �warnings�warnr` rb rc rd re rf rJ rg r2 ro rq r
r
r
r rK s$
rK c @ s� e Zd ZdZd,dd�Zdd� Zd-d d
�Zd d � Zd
d� Zdd� Z dd� Z
dd� Z dd� Z d.dd�Z
dd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd/d&d'�Zd(d)� Zd*d+� ZdS )0� SSLProtocolz�SSL 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 � _sslcontext�dict�_extra� collections�deque�_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_result�r 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| dd�rT| j �
� | � |� d| _d| _ dS )z�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).
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&| jr�t �
| j |� n | j � |� W nP ttfk
r� � Y n8 tk
�r
} z| �|d� W Y � dS d}~X Y nX q�| �
� �q q�dS )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( �
SystemExit�KeyboardInterrupt�
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�� rt�d| � | �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$t�d| � | j �� | _nd | _d| _| j�d� | 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 }t�d| |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 @�@)�peercert�cipher� 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 z�tt| j��D ]�}| 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$| j�r | �|� 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_backlog�Fatal error on transportc C sV t |t�r(| 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 �<module> s*
y�xPK [���E $ __pycache__/staggered.cpython-38.pycnu �[��� U
e5dh �
@ 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_fns�delayr �returnc � s� �p
t �� �t| ��d�d�g �g �tjtj dd�� �������fdd� ����d��}��|� zfd}|t
��kr�t � ��I dH \}}t
|�}|D ]$}|�
� r�|�� s�|�� r�|�� �q�ql���fW �S �D ] }|� � q�X 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 ks�t��� d � t
��|d ks�t�z|� I d H }W nL ttfk
r� � Y np tk
�r } z|�|< |�� W 5 d }~X Y n>X �d k�s t�|�|�t��D ] \}}||k�r,|�� �q,d S )N� r )�
contextlib�suppress�exceptions_mod� TimeoutErrorr Zwait_for�wait�next�
StopIterationr �Event� create_task�append�len�AssertionError�
SystemExit�KeyboardInterrupt�
BaseException�set� enumerate�cancel) r Z
this_indexZcoro_fnZ this_failedZ next_task�result�e�i�t�r
Z
enum_coro_fnsr r � run_one_coroZ
running_tasksZ winner_indexZ
winner_result� �)/usr/lib64/python3.8/asyncio/staggered.pyr% R s4
z$staggered_race.<locals>.run_one_coror )r Zget_running_loopr �typing�Optionalr 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 �Iterable�Callable� Awaitabler) �floatZAbstractEventLoopZTupleZAny�intZList� Exceptionr r& r& r& r' �<module> s& ����PK [g<2��^ �^ __pycache__/tasks.cpython-38.pycnu �[��� U
e5d�� � @ sv d Z dZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl m Z ddl m
Z
ddl mZ ddl mZ dd l mZ dd
l
mZ e�d�jZdBd d �ZdCd
d�ZdDdd�Zdd� ZG dd� dej�ZeZz ddl Z W n e k
r� Y n X e j ZZ dd�dd�Z ejj Z ejj!Z!ejj"Z"dde"d�dd�Z#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/dd1d2�d3d4�Z0dd �d5d6�Z1d7d8� Z2e
�3� Z4i Z5d9d:� Z6d;d<� Z7d=d>� Z8d?d@� Z9e6Z:e9Z;e7Z<e8Z=z$ddAl m6Z6m9Z9m7Z7m8Z8m4Z4m5Z5 W n e k
�r` Y nX e6Z>e9Z?e7Z@e8ZAdS )Fz0Support for tasks, coroutines and the scheduler.)�Task� create_task�FIRST_COMPLETED�FIRST_EXCEPTION�
ALL_COMPLETED�wait�wait_for� as_completed�sleep�gather�shield�
ensure_future�run_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_tasks�get��loop� r! �%/usr/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_loop�done��.0�tr r! r" � <setcomp>< s �z all_tasks.<locals>.<setcomp>)r r �list�
_all_tasks� RuntimeError�r �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.<locals>.<setcomp>)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_name�AttributeError)�task�namer2 r! r! r" �_set_task_nameX s
r6 c s� e Zd ZdZdZed%dd��Zed&dd��Zddd�� fd d
�
Z� fd d �Z d
d� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd�dd�Zddd �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 )z�Return 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)�warnings�warn�DeprecationWarningr 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�_name�str� _must_cancel� _fut_waiter�_coro� contextvarsZ copy_context�_context�_loop� call_soon� _Task__stepr )�self�coror 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_info�rS 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 d��d S )Nz*Task does not support set_result operation�r, )rS �resultr! r! r" �
set_result� s zTask.set_resultc C s t d��d 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 t�d| �d|����| jr>t|tj�s8t�� }d| _| j}d | _t| j | � �zfz"|d krp|� d �}n
|� |�}W n� t
k
r� } z*| jr�d| _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 �r�td| �d|�d��}| j j| j|| j d� n�|�r|| k�r�td | ���}| j j| j|| j d� n8d|_ |j | j | j d� || _| j�r>| j�� �r>d| _n*td
| �d |���}| j j| j|| j d� n||d k�r`| j j| j| j d� n\t �!|��r�td | �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 �
isinstance�CancelledErrorrM rL r rP r �send�throw�
StopIterationrB rg r` r] �KeyboardInterrupt�
SystemExitrb �
BaseException�getattrr r$ r, rQ rR rO rh �add_done_callback�
_Task__wakeup�inspectZ isgenerator)rS �excrT r_ Zblocking�new_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.<locals>.<setcomp>)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` )�waiter�argsr! r! r" �_release_waiter� s r� r c
� s� |dkrt �� }ntjdtdd� |dkr4| I dH S |dkr�t| |d�} | �� rX| �� S t| |d�I dH z | �� W n. t j
k
r� } zt � � |�W 5 d}~X Y n
X t � � �|� � }|�
|t|�}t�t|�}t| |d�} | �|� z�z|I dH W nP t j
k
�rF | �� �r$| �� Y W �dS | �|� t| |d�I dH � Y nX | �� �r^| �� W �*S | �|� t| |d�I 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� � functools�partialrr rg �remove_done_callback)�futr~ r ru r� �timeout_handle�cbr! r! r" r � sL
�
r c
� s� | s t d��|�� �d�|dk r.|�|t���t| �� � ���fdd�}| D ]}|�|� qLz�I dH W 5 �dk r|��� | D ]}|�|� q�X 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 � � dks4�t ks4�tkrV| �� sV| �� d k rV�d k rD��� ��� sV��d � d S )Nr r )r r � cancelledra rg r% r` �r� �Zcounterr r� r� r! r" �_on_completion s ���
�z _wait.<locals>._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 |� � }t�t|�}| �|� z| �� |I dH W 5 | �|� X dS )z<Cancel the *fut* future or task and wait until it completes.N)r� r� r� r� rr r� rg )r� r r� r� r! r! r" r� & s
r� )r r~ c # s� t �| �st�| �r(tdt| �j� ���ddlm} |�d���dkrPt �
� �nt j dt
dd� �fd d
�t| �D ��d�� ��fd d �}���fd
d�� �fdd�}�D ]}|�� � q��r�|dk r҈�||��tt���D ] }|� V q�dS )a^ Return an iterator whose values are coroutines.
When waiting for the yielded coroutines you'll get the results (or
exceptions!) of the original Futures (or coroutines), in the order
in which and as soon as they complete.
This differs from PEP 3148; the proper way to use this is:
for f in as_completed(fs):
result = await f # The 'await' may raise.
# Use result.
If a timeout is specified, the 'await' will raise
TimeoutError when the timeout occurs before all Futures are done.
Note: The futures 'f' are not necessarily members of fs.
z#expect an iterable of futures, not r )�Queuer Nr� r7 r8 c s h | ]}t |� d ��qS r� r� r� r r! r" r) U s z as_completed.<locals>.<setcomp>c s* �D ]} | � � � ��d � q��� d S r1 )r� �
put_nowait�clearr� )r� r% �todor! r" � _on_timeoutX s
z!as_completed.<locals>._on_timeoutc s4 �sd S �� | � � �| � �s0�d k r0��� d S r1 )�remover� rg r� )r% r� r� r! r" r� ^ s
z$as_completed.<locals>._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.<locals>._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 )z�Skip 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
| �|d�S td��dS )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 )z�Helper 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 )�_GatheringFuturez�Helper 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 � d�d�|D ]f}||kr�t|| d�}| dkr�t� |�} ||k r�d |_
�d
7 �|||< |� |� n|| }� � |� qdt
� | d���S ) 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 ��kr�g }� D ]8} | �� r�t�� }n| �� }|d kr�| �� }|�|� qt�jrĈ�t�� � n
�� |� d S )Nr )
r% r� ra r rj rb r_ �appendr� r` )r� ru Zresults�res�r� Z nfinishedZnfuts�outerr� r! r" �_done_callback s4
z gather.<locals>._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_fut�argr� r! r� r" r
� s:
�
1
r
c st |dk rt jdtdd� t| |d����� r0�S 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.<locals>._inner_done_callbackc s �� � s��� � d S r1 )r% r� r� )r� r� r! r" �_outer_done_callback� s z$shield.<locals>._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 �� �std��tj�� �� ��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.<locals>.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|�d���t | = 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 � itertools�typesr: �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" �<module> s�
#H,>
x?$PK [�S�Y�s �s 0 __pycache__/selector_events.cpython-38.opt-1.pycnu �[��� U
e5dT� � @ 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 j�ZG dd� dejej�Z G dd� de �Z G dd� de �Z dS )z�Event 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_key�KeyError�boolr )�selector�fdZevent�key� r �//usr/lib64/python3.8/asyncio/selector_events.py�_test_selector_event s
r c C s t d k r t| t j�r td��d S )Nz"Socket cannot be of type SSLSocket)�ssl�
isinstanceZ SSLSocket� TypeError)�sockr r r �_check_ssl_socket+ s r c s� e Zd ZdZdS� fdd� ZdTddd�dd�ZdUddddejd �d
d �ZdVd d
�Z � fdd�Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdddejfdd �Zdddejfd d �Zddejfd d �Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� 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+� Z,S )Wr zJSelector event loop.
See events.EventLoop for API specification.
Nc sF t � �� |d krt�� }t�d|jj� || _| � � t
� � | _ d S )NzUsing selector: %s)
�super�__init__� selectorsZDefaultSelectorr �debug� __class__�__name__� _selector�_make_self_pipe�weakrefZWeakValueDictionary� _transports)�selfr �r r r r 6 s
z BaseSelectorEventLoop.__init__��extra�serverc C s t | |||||�S �N)�_SelectorSocketTransport)r& r �protocol�waiterr) r* r r r �_make_socket_transport@ s
�z,BaseSelectorEventLoop._make_socket_transportF)� server_side�server_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�_ssock�filenor; �_csock�
_internal_fdsr< r r r r: b s
z&BaseSelectorEventLoop._close_self_pipec C sN t �� \| _| _| j�d� | j�d� | 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 �InterruptedError�BlockingIOErrorrF 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 socketT��exc_info)r@ �send�OSError�_debugr r )r& Zcsockr r r �_write_to_self� s �z$BaseSelectorEventLoop._write_to_self�d 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|�� \}} | jr0t�d|| |� |�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)�range�acceptrQ r r rC rK rJ �ConnectionAbortedErrorrP �errnoZEMFILEZENFILEZENOBUFSZENOMEM�call_exception_handlerr �TransportSocketr= r? Z
call_laterr ZACCEPT_RETRY_DELAYrW �_accept_connection2Z create_task)
r& rU r r3 r* rV r2 �_�conn�addr�excr) 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>| jr�d|
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; �
SystemExit�KeyboardInterruptrQ r_ ) r& rU rc r) r3 r* r2 r- rf r. re �contextr r r ra � sP � � �z)BaseSelectorEventLoop._accept_connection2c
C s� |}t |t�sJzt|�� �}W n* tttfk
rH td|���d �Y nX z| j| }W n tk
rl Y n X |�� s�t 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 �modify�cancel� r& r �callback�argsZhandler �mask�reader�writerr 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"td��z |�|�W S ttfk
rF Y nX | �� }|�� }| � || j
|||� |� t �
| j|�� |I dH S )z�Receive 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_recv�add_done_callback� functools�partial�_sock_read_done)r& r �n�futr 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"td��z |�|�W S ttfk
rF Y nX | �� }|�� }| � || j
|||� |� t �
| j|�� |I dH S )z�Receive 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"td��z|�|�}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 Zview�pos�startr� re r r r r� � s
z#BaseSelectorEventLoop._sock_sendallc � s� t |� | jr"|�� dkr"td��ttd�r8|jtjkrf| j||j|j | d�I dH }|d \}}}}}| �
� }| � |||� |I dH S )zTConnect to a remote socket at address.
This method is a coroutine.
r r� �AF_UNIX)�family�proto�loopN) 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|||dd�I d H W �S |�� |r^|�� || j |j< X d S )NF)Zfallback) r% �_sock_fd�
is_reading�
pause_reading�_make_empty_waiter�_reset_empty_waiter�resume_readingZ
sock_sendfile�_sock)r& Ztransp�file�offset�countr� 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
ejfdd�Zd dd�Zdd� Zdd� Zdd� Zd d � Z� ZS ) �_SelectorTransporti Nc s� t � �||� t�|�| jd< z|�� | jd< W n tk
rN d | jd< Y nX d| jkr�z|�� | 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�� s�t| jj | jt
j �}|rz|�d� n
|�d� t| jj | jt
j �}|r�d}nd}| �
� }|�d|� d |� d
�� d �d �|��S )
N�closed�closingzfd=z read=pollingz read=idle�pollingZidlezwrite=<z
, bufsize=�>z<{}>� )r r! r� �appendr� r� �_loopr9 r r" r rt r� �get_write_buffer_size�format�join)r& �infor� �state�bufsizer 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 |t�r(| 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 | j�S 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; �warnings�warnr� r� r� r� r� rD r� r r r' r r� ] s
r� c s� e Zd ZdZejjZd#� fdd� Z� fdd�Z 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 |tj�r| 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:t�d| � 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<t�d| � d S )NFz%r resumes reading) r� r� rD r� r� r� r� r r r< r r r r� s
z'_SelectorSocketTransport.resume_readingc C s | � � d S r+ )r� r< r r r r� $ s z$_SelectorSocketTransport._read_readyc
C s` | j r
d S z | j�d�}t|�s(td��W nL ttfk
rD � Y n4 tk
rv } z| �|d� W Y �d S d }~X Y nX z| j �
|�}W nd t t fk
r� Y d S ttfk
r� � Y n4 tk
r� } z| �|d� W Y �d S d }~X Y nX |�s | �
� d S z| j�|� W nJ ttfk
�r, � Y n0 tk
�rZ } z| �|d� W 5 d }~X Y nX d S )N���z%get_buffer() returned an empty bufferz/Fatal error: protocol.get_buffer() call failed.�$Fatal read error on socket transportz3Fatal error: protocol.buffer_updated() call failed.)r� r� Z
get_bufferr� r8 ri rj rh r� r� r� rK rJ �_read_ready__on_eofZbuffer_updated)r& r� re r� r r r r� ' sF � �z0_SelectorSocketTransport._read_ready__get_bufferc
C s� | j r
d S z| j�| j�}W nd ttfk
r6 Y d S ttfk
rN � Y n4 tk
r� } z| � |d� W Y �d S d }~X Y nX |s�| �
� d S z| j � |� W nF ttfk
r� � Y n. tk
r� } z| � |d� W 5 d }~X Y nX d S )Nr� z2Fatal error: protocol.data_received() call failed.)
r� r� rI r� rK rJ ri rj rh r� r� r� Z
data_received)r& rG re r r r r� L s. �z3_SelectorSocketTransport._read_ready__data_receivedc
C s� | j �� rt�d| � z| j�� }W nL ttfk
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 |tttf�s$tdt|�j����| jr2td��| j d k rDtd��|sLd S | j
rz| j
t j krht
�d� | j
d7 _
d S | j�s 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_ready�extend�_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 |�= | �� | j�s| j �
| j � | jd k r�| j�d � | jr�| �d � n| j�r| j�tj� 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*| j�tj� 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&| j�td�� 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| j�t
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 � <genexpr>� s zC_SelectorDatagramTransport.get_write_buffer_size.<locals>.<genexpr>)�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_received�r& rG rd re r r r r� � s z&_SelectorDatagramTransport._read_readyc
C s� t |tttf�s$tdt|�j����|s,d S | jrV|d | jfkrPtd| j� ���| j}| j r�| jr�| j t
j krxt �
d� | j d7 _ d S | j�slz,| 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 q�Y 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� | j�r| �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� � collections�dequer� 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 �<module> sF
1� oPK [��M�" " + __pycache__/subprocess.cpython-38.opt-2.pycnu �[��� U
e5d� � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ej
Z
ej Z ej Z G d d
� d
ej
ej�ZG d d � d �Zddddejfd
d�Zddddejd�dd�ZdS ))�create_subprocess_exec�create_subprocess_shell� N� )�events)� protocols)�streams)�tasks)�loggerc sT e Zd Z� fdd�Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
� Z S )�SubprocessStreamProtocolc sH t � j|d� || _d | _ | _| _d | _d| _g | _| j �
� | _ d S )N��loopF) �super�__init__�_limit�stdin�stdout�stderr�
_transport�_process_exited� _pipe_fds�_loopZ
create_future�
_stdin_closed)�self�limitr �� __class__� �*/usr/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��� d�d�|��S )Nzstdin=zstdout=zstderr=z<{}>� )r �__name__r �appendr r �format�join)r �infor r r �__repr__ s
z!SubprocessStreamProtocol.__repr__c C s� || _ |�d�}|d k rDtj| j| jd�| _| j�|� | j� d� |�d�}|d k r�tj| j| jd�| _
| j
�|� | j� d� |�d�}|d k r�tj || d | jd�| _ d S )Nr �r r � r )�protocol�readerr )
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 �fd�datar( r r r �pipe_data_receivedA s z+SubprocessStreamProtocol.pipe_data_receivedc C s� |dkrN| j }|d k r |�� | �|� |d kr>| j�d � 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. �exc�piper( 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 | j�dkr$| 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__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
ddd�ZdS )�Processc C s8 || _ || _|| _|j| _|j| _|j| _|�� | _d S r: )r Z _protocolr r r r Zget_pid�pid)r r, r' r r r r r u s zProcess.__init__c C s d| j j� d| j� d�S )N�<r �>)r r rA 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 d H S r: )r Z_waitr7 r r r �wait� s z Process.waitc C s | j �|� d S r: )r � send_signal)r �signalr r r rF � s zProcess.send_signalc C s | j �� d S r: )r � terminater7 r r r rH � s zProcess.terminatec C s | j �� d S r: )r �killr7 r r r rI � s z Process.killc
� s� | j �� }| j�|� |r,t�d| t|�� z| j�� I d H W n8 tt fk
rx } z|rht�d| |� W 5 d }~X Y nX |r�t�d| � | 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 Zdrain�BrokenPipeError�ConnectionResetErrorr1 )r �inputrL 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}t�d| |� |�� I d H }| j�� r�|dkrndnd}t�d| |� |� � |S )Nr& r r r z%r communicate: read %sz%r communicate: close %s)
r r) r r r rJ r rL �readr1 )r r. r, r; �name�outputr r r � _read_stream� s
zProcess._read_streamNc � s� |d k r| � |�}n| �� }| jd k r2| �d�}n| �� }| jd k rP| �d�}n| �� }tj|||| jd�I d H \}}}| �� I d H ||fS )Nr r& r ) rP rQ r rU r r Zgatherr rE )r rO r r r r r r � communicate� s
�zProcess.communicate)N)r r= r> r r$ �propertyrD rE rF rH rI rP rQ rU rV r r r r r@ t s
r@ c
� sb �d krt �� �ntjdtdd� � �fdd�}�j|| f|||d�|��I d H \}} t|| ��S )N�ZThe loop argument is deprecated since Python 3.8 and scheduled for removal in Python 3.10.r& ��
stacklevelc s t � �d�S �Nr% �r
r r% r r �<lambda>� s �z)create_subprocess_shell.<locals>.<lambda>�r r r )r �get_event_loop�warnings�warn�DeprecationWarningZsubprocess_shellr@ )
�cmdr r r r r �kwds�protocol_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 )NrX r& rY c s t � �d�S r[ r\ r r% r r r] � s �z(create_subprocess_exec.<locals>.<lambda>r^ )r r_ r` ra rb Zsubprocess_execr@ ) Zprogramr r r r r �argsrd re r, r' r r% r r � s(
��� ��r )�__all__�
subprocessr` � r r r r �logr �PIPEZSTDOUTZDEVNULLZFlowControlMixinZSubprocessProtocolr
r@ Z_DEFAULT_LIMITr r r r r r �<module> s. �bV �
�PK [�� � � + __pycache__/coroutines.cpython-38.opt-1.pycnu �[��� U
e5d]" � @ 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 ))� coroutine�iscoroutinefunction� iscoroutine� N� )� base_futures)� constants)�format_helpers)�loggerc C s" t jjp t jj o ttj�d��S )NZPYTHONASYNCIODEBUG)�sys�flags�dev_mode�ignore_environment�bool�os�environ�get� r r �*/usr/lib64/python3.8/asyncio/coroutines.py�_is_debug_mode s �r c @ s� e Zd Zd dd�Zdd� 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> || _ || _t�t�d��| _t|dd �| _t|dd �| _ d S )Nr �__name__� __qualname__)
�gen�funcr �
extract_stackr
� _getframe�_source_traceback�getattrr r )�selfr r r r r �__init__' s
zCoroWrapper.__init__c C sJ t | �}| jr4| jd }|d|d � d|d � �7 }d| jj� d|� d�S ) N���z
, created at r �:r �<� �>)�_format_coroutiner � __class__r )r � coro_repr�framer 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�}|rrd�t�|��}|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_lasti�joinr3 � format_listr ZDEBUG_STACK_DEPTH�rstripr �error)r r r( �msg�tbr 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� t���r �S t���r.�� nt����fdd��� t� � �� t
sX� }nt���� �fdd��}t |_ |S )z�Decorator 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|t�r4|E d H }n:z
|j}W n tk
rR Y n X t|tj j
�rn|� E d H }|S r* ) r Zisfuture�inspectZ isgenerator�
isinstancer r8 �AttributeError� collections�abc� Awaitable)�args�kw�resZ
await_meth�r r r �coroz s
�
zcoroutine.<locals>.coroc s@ t � | |��d�}|jr |jd= t�dd �|_t�dd �|_|S )NrP r r r )r r r r r )rM �kwds�w�rQ r r r �wrapper� s zcoroutine.<locals>.wrapper) �warnings�warn�DeprecationWarningrG r �isgeneratorfunction� functools�wraps�typesr �_DEBUG�
_is_coroutine)r rU r rT r r i s" �
r c C s t �| �pt| dd�tkS )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| t�r8tt�dk r4t�t | �� dS dS dS )z)Return True if obj is a coroutine object.T�d FN)r2 �_iscoroutine_typecacherH �_COROUTINE_TYPES�len�add)�objr r r r � s
r c
sh t | t�� � fdd�}dd� }d }t| d�r:| jr:| j}nt| d�rP| jrP| j}|| �}|sr|| �rn|� d�S |S d }t| d�r�| jr�| j}nt| d �r�| jr�| j}|jp�d
}d }� �r$| jd k �r$t �
| j��s$t � | j�}|d k r�|\}}|d k�r|� d |� d
|� �} n|� d|� d
|� �} n@|d k �rJ|j
}|� d|� d
|� �} n|j}|� d |� d
|� �} | S )Nc s` � rt �| jdi �S t| d�r,| jr,| j}n*t| d�rD| jrD| j}ndt| �j� d�}|� d�S )Nr r r r" z without __name__>z())r Z_format_callbackr �hasattrr r r2 )rQ � coro_name�Zis_corowrapperr r �get_name� s z#_format_coroutine.<locals>.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.<locals>.is_running�cr_coder7 z runningr5 �cr_framez<empty co_filename>r 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_source�f_lineno�co_firstlineno)
rQ rh rj Z coro_coderf Z
coro_frame�filename�lineno�sourcer' 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 �<module> s2 E8 �PK [*�J;� � $ __pycache__/log.cpython-38.opt-2.pycnu �[��� U
e5d| � @ s d dl Z e �e�ZdS )� N)ZloggingZ getLogger� __package__Zlogger� r r �#/usr/lib64/python3.8/asyncio/log.py�<module> s PK [�m���8 �8 ( __pycache__/streams.cpython-38.opt-2.pycnu �[��� U
e5d h � @ s& d Z ddlZddlZddlZddlZeed�r6e d7 Z ddlmZ ddlmZ ddlm Z dd lm
Z
dd
lm Z dd l m
Z
dd lmZ d
Zd ded�dd�Zd ded�dd�Zeed�r�d!ded�dd�Zd"ded�dd�ZG dd� de j�ZG dd� dee j�ZG dd � d �ZG d d � d �ZdS )#)� StreamReader� StreamWriter�StreamReaderProtocol�open_connection� start_server� NZAF_UNIX)�open_unix_connection�start_unix_server� )�
coroutines)�events)�
exceptions)�format_helpers)� protocols)�logger)�sleepi )�loop�limitc � 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.� ��
stacklevel�r r �r c s � S �N� r ��protocolr �'/usr/lib64/python3.8/asyncio/streams.py�<lambda>5 � z!open_connection.<locals>.<lambda>) r �get_event_loop�warnings�warn�DeprecationWarningr r Zcreate_connectionr ) �host�portr r �kwds�reader� 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.<locals>.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.<locals>.<lambda>) 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.<locals>.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 Zddd�Zdd� 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 t�d| � d S )NTz%r pauses writing)r5 r4 � get_debugr �debug�r8 r r r �
pause_writing� s
z FlowControlMixin.pause_writingc C sF d| _ | j�� r t�d| � | j}|d k rBd | _|�� sB|�d � d S )NFz%r resumes writing)r5 r4 r: r r; r6 �done�
set_result�r8 �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_exception�r8 �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 )�NotImplementedError�r8 �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 �weakref�ref�_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|�|� |�d�d k | _ | j
d k r�t || || j�| _ | �
|| j �}t
�|�r�| j�|� d | _d S )N�messagezpAn open stream was garbage collected prior to establishing network connection; call "stream.close()" explicitly.Zsource_tracebackZ
sslcontext)rX rV r4 Zcall_exception_handler�abortrZ r` �
set_transport�get_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| j�d � 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
ddd�Zdd� ZdS )r c C s4 || _ || _|| _|| _| j�� | _| j�d � 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| j��g}| jd k r0|�d| j��� d�d�|��S )N�
transport=zreader=�<{}>� )r_ rO rZ rt �append�format�join�r8 �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 �write�r8 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 �name�defaultr r r rd i s zStreamWriter.get_extra_infoc � sL | j d k r | j �� }|d k r |�| j�� r8td�I 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 ZdZedfdd�Zdd� 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
�t�d��| _d S )Nr zLimit cannot be <= 0Fr )�
ValueError�_limitr r r4 � bytearray�_buffer�_eof�_waiter�
_exceptionrZ r5 r: r
�
extract_stack�sys� _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 bytes�eofzlimit=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�||j�r�| jd |j| �= n
| j� � | �
� t |j d ��W 5 d }~X Y nX |S )N�
r )
r� � readuntilr �IncompleteReadError�partial�LimitOverrunErrorr� �
startswith�consumed�clearr� r� �args)r8 �sep�seplen�line�er r r �readline s
zStreamReader.readliner� c � s� t |�}|dkrtd��| jd k r(| j�d}t | j�}|| |kr|| j�||�}|dkrZq�|d | }|| jkr|t�d|��| jr�t | j�}| j�
� t� |d ��| � d�I d H q,|| jkr�t�d|��| jd || � }| jd || �= | �
� t |�S )Nr z,Separator should be at least one-byte string���r 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� �offsetZbuflenZisep�chunkr r r r� ( s>
�
�zStreamReader.readuntilr� c � s� | j d k r| j �|dkr dS |dk rVg }| �| j�I d H }|s@qL|�|� q(d�|�S | jsr| jsr| �d�I d H t| jd |� �}| jd |�= | � � |S )Nr r �read)
r� r� r� rx rz r� r� r� r� r� )r8 �nZblocks�blockrj 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�||��| � d�I d H q,t| j�|kr�t| 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 �<module> sF
� ! � '
� � DkPPK [T=T\W� W� , __pycache__/base_events.cpython-38.opt-2.pycnu �[��� U
e5d� � @ 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$ed�Z%dZ&e'� Z(dd� Z)dd� Z*dd� Z+d*dd�Z,d+d d �Z-d d � Z.e$ed ��r�d!d"� Z/nd#d"� Z/G d$d%� d%ej0�Z1G d&d'� d'ej2�Z3G d(d)� d)ej4�Z5dS ),� N� )� constants)�
coroutines)�events)�
exceptions)�futures)� protocols)�sslproto)� staggered)�tasks)�
transports)�trsock)�logger)�
BaseEventLoop�d g �?�AF_INET6i�Q c C s0 | j }tt|dd �tj�r$t|j�S t| �S d S )N�__self__)Z _callback�
isinstance�getattrr �Task�reprr �str)�handle�cb� r �+/usr/lib64/python3.8/asyncio/base_events.py�_format_handleJ s
r c C s( | t jkrdS | t jkr dS t| �S d S )Nz<pipe>z<stdout>)�
subprocess�PIPE�STDOUTr )�fdr r r � _format_pipeS s
r! c C sL t td�std��n4z| �tjtjd� W n tk
rF td��Y 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.)�hasattr�socket�
ValueError�
setsockopt�
SOL_SOCKETr" �OSError��sockr r r �_set_reuseport\ s
r+ c C s� t td�sd S |dtjtjhks(| d kr,d S |tjkr>tj}n|tjkrPtj}nd S |d krbd}nXt|t�rz|dkrzd}n@t|t�r�|dkr�d}n(z t |�}W n t
t fk
r� Y d S X |tj kr�tj
g}tr�|�tj� n|g}t| t�r�| �d�} d| k�rd S |D ]t}zVt�|| � t�rJ|tjk�rJ|||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_UNSPEC�AF_INET� _HAS_IPv6�appendr �decoder, r( ) �host�port�family�type�protoZflowinfoZscopeidZafs�afr 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� tj�tj |� �D �� |S )Nr r c s s | ]}|d k r|V qd S �Nr )�.0�ar r r � <genexpr>� s �z(_interleave_addrinfos.<locals>.<genexpr>)
� collections� OrderedDictr9 �list�values�extend� itertools�chain�
from_iterable� zip_longest)Z addrinfosZfirst_address_family_countZaddrinfos_by_family�addrr= Zaddrinfos_listsZ reorderedr r r �_interleave_addrinfos� s"
��rP c C s4 | � � s"| �� }t|ttf�r"d S t�| ��� d S rB )� cancelled� exceptionr �
SystemExit�KeyboardInterruptr Z _get_loop�stop)�fut�excr 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 |tj�std��|| _|�� | _|�� | _|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)�self�transpr 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_closing�ConnectionErrorre )rf rV r r r �drain� s
z _SendfileFallbackProtocol.drainc C s t d��d 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 d��d S �Nz'Invalid state: reading should be pausedrl )rf �datar r r �
data_received� s z'_SendfileFallbackProtocol.data_receivedc C s t d��d 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 �loop�sockets�protocol_factoryZ ssl_context�backlog�ssl_handshake_timeoutr r r rh s zServer.__init__c C s d| j j� d| j�d�S )N�<z sockets=�>)� __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 �waiters�waiterr 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.<locals>.<genexpr>)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| jd�I 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� Zdd�d d
�Zd d � Zd
d� Zd�ddd�dd�Z d�ddddddd�dd�Z
d�dd�Z d�dd�Z d�dd �Z
d�d d �Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Zd5d6� Zej fd7d8�Z d9d:� Z d;d<� Z dd=�d>d?�Z dd=�d@dA�Z!dd=�dBdC�Z"dDdE� Z#dFdG� Z$dHdI� Z%dd=�dJdK�Z&dLdM� Z'dNdO� Z(dPdQ� Z)dRdRdRdRdS�dTdU�Z*d�dVdW�Z+d�ddX�dYdZ�Z,d[d\� Z-d]d^� Z.d_d`� Z/d�dadb�Z0d�ddRdRdRdddddddc�
ddde�Z1d�dfdg�Z2d�ddX�dhdi�Z3djdk� Z4dldm� Z5ddddn�dodp�Z6d�dRdRdRe7ddddq�drds�Z8dRe9j:dRdRdS�dtdu�Z;dvdw� Z<d�e9j=e9j>ddxddddddy� dzd{�Z?ddd|�d}d~�Z@dd�� ZAd�d�� ZBd�d�� ZCeDjEeDjEeDjEdddRdddd�� d�d��ZFeDjEeDjEeDjEdddRdddd�� d�d��ZGd�d�� ZHd�d�� ZId�d�� ZJd�d�� ZKd�d�� ZLd�d�� ZMd�d�� ZNd�d�� ZOd�d�� ZPd�d�� ZQd�d�� ZRdS )�r c C s� d| _ d| _d| _t�� | _g | _d | _d| _d | _ t
� d�j | _
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_id�time�get_clock_infoZ
resolution�_clock_resolution�_exception_handler� set_debugr Z_is_debug_mode�slow_callback_duration�_current_handle�
_task_factory�"_coroutine_origin_tracking_enabled�&_coroutine_origin_tracking_saved_depth�weakrefZWeakSet�
_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| d�S )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)�extra�serverc 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_side�server_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� �args�shell�stdin�stdout�stderr�bufsizer� �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 rtd��d 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� �aclose�rf �agenr r r �_asyncgen_finalizer_hook� s z&BaseEventLoop._asyncgen_finalizer_hookc C s. | j r tjd|�d�t| d� | j�|� d S )Nzasynchronous generator z3 was scheduled after loop.shutdown_asyncgens() call��source)r� �warnings�warn�ResourceWarningr� �addr� r r r �_asyncgen_firstiter_hook s
�z&BaseEventLoop._asyncgen_firstiter_hookc � s� d| _ t| j�sd S t| j�}| j�� tjdd� |D �d| d��I d H }t||�D ]*\}}t|t �rT| �
d|��||d�� qTd S )NTc S s g | ] }|� � �qS r )r� )rC Zagr r r �
<listcomp> s z4BaseEventLoop.shutdown_asyncgens.<locals>.<listcomp>)Zreturn_exceptionsr� z;an error occurred during closing of asynchronous generator )�messagerR Zasyncgen) r� �lenr� rH �clearr �gather�zipr � Exception�call_exception_handler)rf Z
closing_agensZresults�resultr� r r r �shutdown_asyncgens s"
�
�z BaseEventLoop.shutdown_asyncgensc C s( | � � rtd��t�� d k r$td��d 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� �sys�get_asyncgen_hooks�set_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<z | �
� W n* |rp|� � rp|� � sp|�
� � Y nX W 5 |� t� X |� � s�td��|�� S )Nr� Fz+Event loop stopped before Future completed.)r� r� r Zisfuturer Z
ensure_futureZ_log_destroy_pendingZadd_done_callbackrX Zremove_done_callbackr r� rQ rR rm r� )rf ZfutureZnew_taskr r r �run_until_completeD s"
z BaseEventLoop.run_until_completec C s
d| _ d S r� )r� rq r r r rU j s zBaseEventLoop.stopc C sj | � � rtd��| jrd S | jr,t�d| � d| _| j�� | j�� | j }|d k rfd | _ |j
dd� d S )Nz!Cannot close a running event loopzClose %rTF)�wait) r� rm r� r� r �debugr� r� r� r� Zshutdown�rf �executorr r r r� r s
zBaseEventLoop.closec C s | j S rB )r� rq r r r r� � s zBaseEventLoop.is_closedc C s0 | � � s,|d| ��t| d� | �� s,| �� d S )Nzunclosed event loop r� )r� r� r� r� )rf Z_warnr r r �__del__� s zBaseEventLoop.__del__c C s
| j d k S rB )r� rq r r r r� � s zBaseEventLoop.is_runningc C s t �� S rB )r� r� rq r r r r� � s zBaseEventLoop.time)�contextc G s2 | j | �� | |f|�d|i�}|jr.|jd= |S )Nr
r� )�call_atr� r� )rf Zdelay�callbackr
r� �timerr r r �
call_later� s �zBaseEventLoop.call_laterc G sZ | � � | jr"| �� | �|d� t�|||| |�}|jrB|jd= t�| j |� d|_ |S )Nr r� T)
r� r� �
_check_thread�_check_callbackr Z TimerHandler� �heapq�heappushr� )rf �whenr r
r� r r r r r � s zBaseEventLoop.call_atc G sB | � � | jr"| �� | �|d� | �|||�}|jr>|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|� d���t|�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(td��d 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|�� | d�S )N�run_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 |tjj�s t�dtd� || _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�|�}t�d|� | �� }t�||||||�} | �� | }
d|� d |
d
d �d | ��}|
| jkr�t�|� 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? �flags�msg�t0�addrinfo�dtr 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* �file�offset�countr/ rW r r r �
sock_sendfile@ s � �zBaseEventLoop.sock_sendfilec � s t �d|�d���d S )Nz-syscall sendfile is not available for socket z and file {file!r} combination�r r2 �rf r* r4 r5 r6 r r r r1 N s
�z#BaseEventLoop._sock_sendfile_nativec
� s� |r|� |� |r t|tj�ntj}t|�}d}zt|rNt|| |�}|dkrNq�t|�d |� }| �d |j|�I d H } | szq�| � ||d | � �I d H || 7 }q2|W �S |dkr�t|d�r�|� || � X d S )Nr �seek)
r: �minr Z!SENDFILE_FALLBACK_READBUFFER_SIZE� bytearrayr# �
memoryviewr �readintoZ sock_sendall)
rf r* r4 r5 r6 � blocksize�buf�
total_sent�view�readr r r r3 U s,
��
z%BaseEventLoop._sock_sendfile_fallbackc C s� dt |dd�krtd��|jtjks,td��|d k rbt|t�sLtd�|���|dkrbtd�|���t|t�sztd�|���|dk r�td�|���d S )N�b�modez$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 }
z�tj|||d�}
|
�d� |d k r�|D ]r\}}}}} z|
�| � W q�W 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 )N�r= r> r? Fz*error while attempting to bind on address �: ) r9 r$ � setblocking�bindr( �strerror�lower�errno�pop� 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 d���j||f|tj||�d�I d H }|s�td��| d k r܈j| |tj||�d�I d H ��s�td��nd �|
r�t||
�}g � | d k�rH|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 k�r d d � � D �� t � �dk�r�� d
�nJt
� d
��t �fdd �� D ���r҈ d
�td� d�
dd � � D �����n.|d k�rt d��|jtjk�r t d|�����j||||
| d�I d H \}}�j�rd|�d�}t�d|||||� ||fS )Nz+server_hostname is only meaningful with sslz:You must set server_hostname when using ssl without a host�1ssl_handshake_timeout is only meaningful with sslr �8host/port and sock can not be specified at the same time�r= r> r? r' r� �!getaddrinfo() returned empty listc 3 s | ]}t ��j� |��V qd S rB )� functools�partialrQ )rC r* )r � laddr_infosrf r r rE � s � �z2BaseEventLoop.create_connection.<locals>.<genexpr>r� c S s g | ]}|D ]}|�q qS r r )rC �subrW r r r r� � s z3BaseEventLoop.create_connection.<locals>.<listcomp>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|t�r*d n|} | j||| ||||d�}
n| �|||�}
z|I d H W n |
�� � Y nX |
|fS )NF�r� 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� |� � rtd��t|dtjj�}|tjjkr:td|����|tjjkr�z| �||||�I d H W S tj k
r� } z
|sx� W 5 d }~X Y nX |s�td|����| �
||||�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 �d��d 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|d�nd}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 |dkr�t|d�r�|� || � |�� 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 krtd��t|t j�s*td|����t|dd�sFtd|�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_port�allow_broadcastr* c � s� |
d k r�|
j tjkr"td|
����� s>�s>|s>|s>|s>|s>| r~t� �|||||| d�} d�dd� | �� D ��} td| � d���|
�d� d }
�n� s��s�|d kr�td
��||fd ff}�n�ttd ��r�|tj k�r�� �fD ] }|d k r�t
|t �s�t d
��qڈ �rx� d dk�rxz"t
�t�
� �j��r.t�� � W nF tk
�rF Y n2 tk
�rv } zt�d� |� W 5 d }~X Y nX ||f� �fff}n�i }d � fd�ffD ]�\}}|d k �r�| j||tj||| d�I d H }|�s�td��|D ]:\}}}}}||f}||k�rd d g||< ||| |< �q�q�� �fdd�|�� D �}|�sHtd��g }|tk �rv|�rftd��ntjdtdd� |D ]�\\}}\}}d }
d }
zxtj|tj|d�}
|�r�t|
� | �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̈ �r�t�&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 �k�vr r r rE � s z9BaseEventLoop.create_datagram_endpoint.<locals>.<genexpr>zKsocket modifier keyword arguments can not be used when sock is specified. (�)Fr zunexpected address family)NN�AF_UNIXzstring is expected)r � z2Unable to check or remove stale UNIX socket %r: %rr rX rY c s8 g | ]0\}}� r |d dks�r,|d dks||f�qS )r Nr r )rC �keyZ addr_pair�rS rs r r r� � s �z:BaseEventLoop.create_datagram_endpoint.<locals>.<listcomp>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 �stat�S_ISSOCK�os�st_mode�remove�FileNotFoundErrorr( 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_infos�idxrf 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||||||d�I 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|| d�I 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 |t�rtd��| d k r*|d kr*td��|d k s<�d k �r"|d k rLtd��| d krhtjdkoftjdk} g }
|dkr|d g}n$t |t�s�t |t j
j �s�|g}n|}� ���fdd�|D �}t j
|d �i�I d H }ttj�|��}d
}�z |D �]}|\}}}}}zt�|||�}W n8 tjk
�rH �j�r@tjd |||d d
� Y q�Y nX |
�|� | �rl|�tjtjd � |
�rzt |� t �r�|tj k�r�t td��r�|�tj tj!d � z|�"|� W q� t#k
�r� } z t#|j$d||j%�&� f �d �W 5 d }~X Y q�X q�d }W 5 |�s |
D ]}|�� �qX n4|d k�r4td��|j'tj(k�rPtd|����|g}
|
D ]}|�)d
� �qZt*�|
|||| �}| �r�|�+� t j,d�d�I d H �j�r�t�-d|� |S )Nz*ssl argument must be an SSLContext or NonerV rW �posix�cygwinr. c s g | ]}�j |�� �d ��qS ))r= r' )r� )rC r; �r= r' r< rf r r r� � s �
�z/BaseEventLoop.create_server.<locals>.<listcomp>r� Fz:create_server() failed to create socket.socket(%r, %r, %r)T��exc_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 �abc�Iterabler 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 completed�resr@ 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|d�I d H \}}| jrn|�d�}t�d|||� ||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\t�d|�� ||� ||fS )Nz Read pipe %r connected: (%r, %r))rd r� r� r� r r �fileno�rf 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\t�d|�� ||� ||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|�� �� t�d�|�� 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� �encoding�errors�textc � s� t |ttf�std��|r"td��|s.td��|dkr>td��| rJtd��| d k rZtd��|
d k rjtd��|� }
d }| jr�d | }| �||||� | j|
|d
||||f| �I d H }| jr�|d k r�t�d ||� ||
fS ) Nzcmd must be a string� universal_newlines must be Falsezshell must be Truer �bufsize must be 0�text must be False�encoding must be None�errors 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 }| jr�d|��}| �||||� | j||d ||||f|
�I d H }| jr�|d k r�t�d
||� ||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|| }|dkr�d�t�|��}d }||� � 7 }n2|dkr�d�t�|��}d
}||� � 7 }nt
|�}|� |� d |� �� qnt j
d �|�|d
� d S )Nr� z!Unhandled exception in event looprR FZsource_tracebackZhandle_traceback> r� rR 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_list�rstripr r9 r r� ) rf r
r� rR r� Z log_linesrz �value�tbr 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 q�X n�z| � | |� 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<d|_q*|�|� q*t�|� || _d| _n4| jr�| jd jr�| jd8 _t� | j�}d|_q`d }| j
s�| j r�d}n*| jr�| jd j }t
td|| �� �t�}| j�|�}| �|� | �� | j }| j�r:| jd }|j |k�r�q:t� | j�}d|_| j
�|� q�t | j
�}t|�D ]|} | j
�� }|j�rf�qL| j�r�zD|| _| �� }
|�� | �� |
} | | jk�r�t� dt |�| � W 5 d | _X n|�� �qLd }d S )NFr r z Executing %s took %.3f seconds) r� r� � _MIN_SCHEDULED_TIMER_HANDLESr� �%_MIN_CANCELLED_TIMER_HANDLES_FRACTIONr� r9 r �heapify�heappopr� r� Z_whenr; �maxr� �MAXIMUM_SELECT_TIMEOUTZ _selectorZselectr� r� �range�popleftr� r� Z_runr� r r� r ) rf Z sched_countZ
new_scheduledr Ztimeoutr r� Zend_timeZntodo�ir) r+ r r r r � sj
��
�
zBaseEventLoop._run_oncec C sH t |�t | j�krd S |r2t�� | _t�tj� n t�| j� || _d S rB )ri r� r �#get_coroutine_origin_tracking_depthr� �#set_coroutine_origin_tracking_depthr ZDEBUG_STACK_DEPTH�rf Zenabledr r r r� F s ���z,BaseEventLoop._set_coroutine_origin_trackingc C s | j S rB )r� rq r r r r� U s zBaseEventLoop.get_debugc C s || _ | �� r | �| j|� d S rB )r� r� r� r� r� r r r r� X s zBaseEventLoop.set_debug)N)N)NNN)NN)NN)N)r )r N)N)NN)FN)r N)NN)NN)Sr| r} r~ rh r� rd r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r rU r� r� r� r� r r� r� r r r r r r r� r r! r, r% r. r7 r1 r3 r0 rQ rg rd rl rj rk ro r� r� r$ r1 rb r� r6 Z
AI_PASSIVEr� r� r� r� r� r r r� r� r� r� r� r� r� r� r� r r� r� r� r r r r r � sF � � �
�
�
�
�
&
�
�
% � � �
� /� / � � � �� w� � % � "29Nr )r r )r )6rF Zcollections.abcZconcurrent.futuresr rZ r rK r� r$ r r r r� r� r r� r� rR � ImportErrorr. r r r r r r r r
r r r
�logr �__all__r� r� r# r8 r� �objectr� r r! r+ rA rP rX r[ ZProtocolr\ ZAbstractServerr ZAbstractEventLoopr r r r r �<module> sb
;
DoPK [ۂ�U
+
+ ( __pycache__/futures.cpython-38.opt-1.pycnu �[��� U
e5db3 � @ 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� Zdd�dd�Zz ddlZW n e k
r� Y n X ej ZZ dS )z.A Future class similar to the one in PEP 3148.)�Future� wrap_future�isfuture� N� )� base_futures)�events)�
exceptions)�format_helpersc @ s� e Zd ZdZeZdZdZdZdZ dZ
dZ dd�dd�Z 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.)
NF��loopc C s@ |dkrt �� | _n|| _g | _| j�� r<t�t�d��| _ dS )z�Initialize the future.
The optional event_loop argument allows explicitly setting the event
loop object used by the future. If it's not provided, the future uses
the default event loop.
Nr )
r �get_event_loop�_loop�
_callbacksZ get_debugr �
extract_stack�sys� _getframe�_source_traceback��selfr � r �'/usr/lib64/python3.8/asyncio/futures.py�__init__D s
�zFuture.__init__c C s d� | jjd�| �� ��S )Nz<{} {}>� )�format� __class__�__name__�join�
_repr_info�r 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� exception�futureZsource_traceback)�_Future__log_traceback�
_exceptionr r r r
Zcall_exception_handler)r �exc�contextr 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 |�rtd��d| _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 )z�Cancel the future and schedule callbacks.
If the future is already done or cancelled, return False. Otherwise,
change the future's state to cancelled, schedule the callbacks and
return True.
FT)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 )z�Internal: Ask the event loop to call all callbacks.
The callbacks are scheduled to be called as soon as possible. Also
clears the callback list.
N�r& )r r
� call_soon)r Z callbacks�callback�ctxr 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 )z�Return 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$t�d��d| _| 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� _FINISHED�InvalidStateErrorr# r$ �_resultr r r r �result� s
z
Future.resultc C s0 | j tkrtj�| j tkr$t�d��d| _| jS )a& Return the exception that was set on this future.
The exception (or None if no exception was set) is returned only if
the future is done. If the future has been cancelled, raises
CancelledError. If the future isn't done yet, raises
InvalidStateError.
zException is not set.F)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 )z�Add a callback to be run when the future becomes done.
The callback is called with a single argument - the future object. If
the future is already done when this is called, the callback is
scheduled with call_soon.
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||f�qS r r )�.0�fr7 �rA r r �
<listcomp>� s �z/Future.remove_done_callback.<locals>.<listcomp>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 )z�Mark 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|t�r0|� }t|�tkrDtd��|| _t | _ | �
� d| _ dS )z�Mark 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< �
isinstance�type�
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 �
concurrent�futuresr: r �args� TimeoutErrorr< )r% Z exc_classr r r �_convert_future_exc# s r` c C sR |� � r| �� | �� s dS |�� }|dk r<| �t|�� n|�� }| �|� dS )z8Copy state from a future to a concurrent.futures.Future.N)r8 r3 Z set_running_or_notify_cancelr! rO r` r> rJ )r\ �sourcer! r> r r r � _set_concurrent_future_state/ s rb c C sT |� � r dS | � � r |�� n2| �� }|dk r>|�t|�� n| �� }|�|� dS )zqInternal helper to copy state from another Future.
The other Future may be a concurrent.futures.Future.
N)r8 r3 r! rO r` r> rJ )ra �destr! r> r r r �_copy_future_state> s
rd c s� t ��s t�tjj�s td��t ��s<t�tjj�s<td��t ��rLt��nd�t ��r`t��nd�dd� � ���fdd�}� ���fdd �}��|� ��|� dS )
a Chain two futures so that when one completes, so does the other.
The result (or exception) of source will be copied to destination.
If destination is cancelled, source gets cancelled too.
Compatible with both asyncio.Future and concurrent.futures.Future.
z(A future is required for source argumentz-A future is required for destination argumentNc S s" t | �rt|| � n
t| |� d S r( )r rd rb )r" �otherr r r �
_set_stateb s z!_chain_future.<locals>._set_statec s2 | � � r.�d ks�� kr"��� n ���j� d S r( )r8 r3 �call_soon_threadsafe)� destination)� dest_loopra � source_loopr r �_call_check_cancelh s
z)_chain_future.<locals>._call_check_cancelc sJ �� � r �d k r ��� r d S �d ks,��kr8� �| � n��� �| � d S r( )r8 Z is_closedrg )ra )rf ri rh rj r r �_call_set_stateo s �� z&_chain_future.<locals>._call_set_state)r rK r\ r] r rN rZ rB )ra rh rk rl r )rf ri rh ra rj r �
_chain_futureR s � �
rm r
c C s2 t | �r | S |dkr t�� }|�� }t| |� |S )z&Wrap concurrent.futures.Future object.N)r r r Z
create_futurerm )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` rb rd rm r Z_asyncio� ImportErrorZ_CFuturer r r r �<module> s:
q *
PK [��b� � % __pycache__/subprocess.cpython-38.pycnu �[��� U
e5d� � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ej
Z
ej Z ej Z G d d
� d
ej
ej�ZG d d � d �Zddddejfd
d�Zddddejd�dd�ZdS ))�create_subprocess_exec�create_subprocess_shell� N� )�events)� protocols)�streams)�tasks)�loggerc sX e Zd ZdZ� fdd�Zdd� 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 )N��loopF) �super�__init__�_limit�stdin�stdout�stderr�
_transport�_process_exited� _pipe_fds�_loopZ
create_future�
_stdin_closed)�self�limitr �� __class__� �*/usr/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��� d�d�|��S )Nzstdin=zstdout=zstderr=z<{}>� )r �__name__r �appendr r �format�join)r �infor r r �__repr__ s
z!SubprocessStreamProtocol.__repr__c C s� || _ |�d�}|d k rDtj| j| jd�| _| j�|� | j� d� |�d�}|d k r�tj| j| jd�| _
| j
�|� | j� d� |�d�}|d k r�tj || d | jd�| _ d S )Nr �r r � r )�protocol�readerr )
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 �fd�datar( r r r �pipe_data_receivedA s z+SubprocessStreamProtocol.pipe_data_receivedc C s� |dkrN| j }|d k r |�� | �|� |d kr>| j�d � 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. �exc�piper( 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 | j�dkr$| 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
ddd�ZdS )�Processc C s8 || _ || _|| _|j| _|j| _|j| _|�� | _d S r: )r Z _protocolr r r r Zget_pid�pid)r r, r' r r r r r u s zProcess.__init__c C s d| j j� d| j� d�S )N�<r �>)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,t�d| t|�� z| j�� I d H W n8 tt fk
rx } z|rht�d| |� W 5 d }~X Y nX |r�t�d| � | 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 Zdrain�BrokenPipeError�ConnectionResetErrorr1 )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}t�d| |� |� � I d H }| j�� r�|dkrzdnd}t�d| |� |�
� |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; �name�outputr r r � _read_stream� s
zProcess._read_streamNc � s� |d k r| � |�}n| �� }| jd k r2| �d�}n| �� }| jd k rP| �d�}n| �� }tj|||| jd�I 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 )N�ZThe loop argument is deprecated since Python 3.8 and scheduled for removal in Python 3.10.r& ��
stacklevelc s t � �d�S �Nr% �r
r r% r r �<lambda>� s �z)create_subprocess_shell.<locals>.<lambda>�r r r )r �get_event_loop�warnings�warn�DeprecationWarningZsubprocess_shellrA )
�cmdr r r r r �kwds�protocol_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 � �d�S r] r^ r r% r r r_ � s �z(create_subprocess_exec.<locals>.<lambda>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 �<module> s. �bV �
�PK [$��'� � % __pycache__/base_tasks.cpython-38.pycnu �[��� U
e5d� � @ 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_cancel�insertZget_namer Z_format_coroutine�_coroZ _fut_waiter)�task�info�coro� r
�*/usr/lib64/python3.8/asyncio/base_tasks.py�_task_repr_info s
r c C s� g }t | jd�r| jj}n0t | jd�r0| jj}nt | jd�rF| 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�|dkr�q�|d8 }|�|j
� |j }q�|S )N�cr_frame�gi_frame�ag_framer r ) �hasattrr r r r �append�f_back�reverse�
_exception�
__traceback__�tb_frame�tb_next)r
�limitZframes�f�tbr
r
r �_task_get_stack s6
r c C s� g }t � }| j|d�D ]Z}|j}|j}|j}|j} ||krN|�|� t�|� t� |||j
�}
|� ||| |
f� q| j } |s�t
d| ��|d� n2| d k r�t
d| �d�|d� nt
d| �d�|d� tj||d� | d k r�t�| j| �D ]}
t
|
|dd� q�d S ) N)r z
No stack for )�filezTraceback for z (most recent call last):z
Stack for � )r �end)�setZ get_stack�f_lineno�f_code� co_filename�co_name�add� linecache�
checkcache�getline� f_globalsr r �print� traceback�
print_list�format_exception_only� __class__) r
r r �extracted_list�checkedr �lineno�co�filename�name�line�excr
r
r �_task_print_stack< s,
r9 )r( r- r r r r r r9 r
r
r
r �<module> s #PK [�5 B B ) __pycache__/__main__.cpython-38.opt-1.pycnu �[��� U
e5d
� @ sJ d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl Z ddl
m Z G dd� dej �Z
G dd� dej�Zedk�rFe�� Ze�e� d eiZd
D ]Ze� e ee< q�e
ee�Zdad az d dlZW n ek
r� Y nX e� Z d e _ e � � z e� � W n6 e k
�r> t�r6t�!� �s6t�"� d aY q�Y q�X �qFq�dS )
� N� )�futuresc s$ e Zd Z� fdd�Zdd� Z� ZS )�AsyncIOInteractiveConsolec s* t � �|� | jj jtjO _|| _d S )N)�super�__init__�compileZcompiler�flags�astZPyCF_ALLOW_TOP_LEVEL_AWAIT�loop)�self�localsr
�� __class__� �(/usr/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 t�t �� W n. tk
� r� } z��|� W 5 d }~X Y nX d S )NFT)� repl_future�repl_future_interrupted�types� FunctionTyper �
SystemExit�KeyboardInterruptZ
set_exception�
BaseException�inspectZ iscoroutineZ
set_resultr
Z create_taskr Z
_chain_future)�func�coroZex�exc��codeZfuturer r r �callback s,
z3AsyncIOInteractiveConsole.runcode.<locals>.callbackz
KeyboardInterrupt
) �
concurrentr ZFuturer
�call_soon_threadsafe�resultr 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� t�tj� X d S ) N�ignorez ^coroutine .* was never awaited$)�message�categoryz
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) �warnings�filterwarnings�RuntimeWarningr
r �stop�sys�version�platform�getattr�consoleZinteract)r r, r r r �runF s "��
�zREPLThread.runN)r$ r% r& r6 r r r r r( D s r( �__main__�asyncio> � __builtins__�__spec__r$ �__file__�
__loader__� __package__FT)#r r8 r Zconcurrent.futuresr r r1 Z threadingr r- � r ZInteractiveConsoler ZThreadr( r$ Znew_event_loopr
Zset_event_loopZ repl_locals�keyr r5 r r �readline� ImportErrorZ repl_threadZdaemon�startZ run_foreverr ZdoneZcancelr r r r �<module> sF 6
PK [ ��M%! %! ! __pycache__/trsock.cpython-38.pycnu �[��� U
e5d� � @ s" d dl Z d dlZG dd� d�ZdS )� Nc @ s� e Zd ZdZdZejd�dd�Zdd� 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"d<d=� Z#d>d?� 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 )]�TransportSocketz�A 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 �&/usr/lib64/python3.8/asyncio/trsock.py�__init__ s zTransportSocket.__init__c C s t jd|� d�t| 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)�warnings�warn�DeprecationWarning)r Zwhatr r r �_na s
�zTransportSocket._nac C s | j jS r )r �family�r 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| j�d| j�d| j� �}| � � dkr�z | �� }|rN|� d|� �}W n tjk
rf Y nX z | �� }|r�|� d|� �}W n tjk
r� Y nX |� d�S ) Nz <asyncio.TransportSocket fd=z , family=z, type=z, proto=���z, laddr=z, raddr=�>)�filenor r r � getsockname�socket�error� getpeername)r �sZladdrZraddrr r r �__repr__& s $� zTransportSocket.__repr__c C s t d��d 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 �
getsockopt�r �args�kwargsr 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 d��d S )Nr z<settimeout(): only 0 timeout is allowed on transport sockets��
ValueError)r �valuer r r �
settimeout� s
�zTransportSocket.settimeoutc C s dS )Nr r r r r r �
gettimeout� s zTransportSocket.gettimeoutc C s |sd S t d��d S )Nz3setblocking(): transport sockets cannot be blockingr? )r �flagr r r � setblocking� s
�zTransportSocket.setblockingc C s | � d� | j�� S �Nzcontext manager protocol)r r � __enter__r r r r rG � s
zTransportSocket.__enter__c G s | � d� | jj|� S rF )r r �__exit__)r �errr r r rH � s
zTransportSocket.__exit__N)3�__name__�
__module__� __qualname__�__doc__� __slots__r r
r �propertyr r r r r r r r r! r" r& r r r' r( r) r* r+ r, r- r. r/ r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r: r; r< r= r> rB rC rE rG rH r r r r r sb
r )r r r r r r r �<module> s PK [�5 B B # __pycache__/__main__.cpython-38.pycnu �[��� U
e5d
� @ sJ d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl Z ddl
m Z G dd� dej �Z
G dd� dej�Zedk�rFe�� Ze�e� d eiZd
D ]Ze� e ee< q�e
ee�Zdad az d dlZW n ek
r� Y nX e� Z d e _ e � � z e� � W n6 e k
�r> t�r6t�!� �s6t�"� d aY q�Y q�X �qFq�dS )
� N� )�futuresc s$ e Zd Z� fdd�Zdd� Z� ZS )�AsyncIOInteractiveConsolec s* t � �|� | jj jtjO _|| _d S )N)�super�__init__�compileZcompiler�flags�astZPyCF_ALLOW_TOP_LEVEL_AWAIT�loop)�self�localsr
�� __class__� �(/usr/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 t�t �� W n. tk
� r� } z��|� W 5 d }~X Y nX d S )NFT)� repl_future�repl_future_interrupted�types� FunctionTyper �
SystemExit�KeyboardInterruptZ
set_exception�
BaseException�inspectZ iscoroutineZ
set_resultr
Z create_taskr Z
_chain_future)�func�coroZex�exc��codeZfuturer r r �callback s,
z3AsyncIOInteractiveConsole.runcode.<locals>.callbackz
KeyboardInterrupt
) �
concurrentr ZFuturer
�call_soon_threadsafe�resultr 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� t�tj� X d S ) N�ignorez ^coroutine .* was never awaited$)�message�categoryz
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) �warnings�filterwarnings�RuntimeWarningr
r �stop�sys�version�platform�getattr�consoleZinteract)r r, r r r �runF s "��
�zREPLThread.runN)r$ r% r& r6 r r r r r( D s r( �__main__�asyncio> � __builtins__�__spec__r$ �__file__�
__loader__� __package__FT)#r r8 r Zconcurrent.futuresr r r1 Z threadingr r- � r ZInteractiveConsoler ZThreadr( r$ Znew_event_loopr
Zset_event_loopZ repl_locals�keyr r5 r r �readline� ImportErrorZ repl_threadZdaemon�startZ run_foreverr ZdoneZcancelr r r r �<module> sF 6
PK [ft�,S^ S^ * __pycache__/proactor_events.cpython-38.pycnu �[��� U
e5d<} � @ 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� dejej�ZG dd� deej�ZG dd� deej�ZG dd� de�Z G dd� de�Z G dd� deeej �Z G d d � d eeej �Z G d d � d e
j!�Z"dS ) z�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.
)�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| jkr�z|�
� | jd< W n tjk
r� d | jd< Y nX d S )N�socketZsocknamezgetsockname() failed on %rT��exc_info�peername) r �TransportSocket�_extraZ getsocknamer
�error�_loop� get_debugr �warningZ getpeername)� transport�sock� r �//usr/lib64/python3.8/asyncio/proactor_events.py�_set_socket_extra s
�
r c s� e Zd ZdZd � fdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
e j fdd�Z
d dd�Zdd� Zdd� Zdd� Z� ZS ) �_ProactorBasePipeTransportz*Base class for pipe and socket transports.Nc s� t � �||� | �|� || _| �|� || _d | _d | _d | _d| _ d| _
d| _ d| _ | jd k rl| j�
� | j�| jj| � |d k r�| j�tj|d � d S )Nr F)�super�__init__�
_set_extra�_sock� set_protocol�_server�_buffer� _read_fut�
_write_fut�_pending_write�
_conn_lost�_closing� _eof_writtenZ_attachr � call_soon� _protocolZconnection_mader Z _set_result_unless_cancelled��self�loopr �protocol�waiter�extra�server�� __class__r r r 2 s(
�z#_ProactorBasePipeTransport.__init__c C s� | j jg}| jd kr |�d� n| jr0|�d� | jd k rP|�d| j�� � �� | jd k rl|�d| j��� | jd k r�|�d| j��� | jr�|�dt | j�� �� | j
r�|�d� d� d � |��S )
N�closed�closingzfd=zread=zwrite=zwrite_bufsize=z EOF writtenz<{}>� )
r4 �__name__r �appendr( �filenor$ r% r# �lenr) �format�join)r- �infor r r �__repr__H s
z#_ProactorBasePipeTransport.__repr__c C s || j d< d S )N�pipe)r �r- r r r r r Z s z%_ProactorBasePipeTransport._set_extrac C s
|| _ d S �N�r+ )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|t�r*| j�� rBtjd| |dd� n| j�||| | jd�� W 5 | � |� X d S )Nz%r: %sTr )�message� exceptionr r/ ) � _force_close�
isinstance�OSErrorr r r �debug�call_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_waiter�done�
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 | jd�r,| j�tj� | j�� d | _| j}|d k rX|�� d | _X d S )N�shutdown)
�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| j�7 }|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 �warnings�warnrL 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 ddd�Z
� 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,t�d| � 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 �� rt�d| � 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�
SystemExit�KeyboardInterrupt�
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| jtj�r�zt�| j|� W q� t t
fk
rh � Y q� t k
r� } z| � |d� W Y �d S d }~X Y q�X 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,| js0t�d | _|�� 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�� r�tjddd� 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^ | j�sZ� Y nX | j�sv| 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 � _proactor�recvr �ConnectionAbortedErrorrV r r rS �ConnectionResetErrorrP rR r �CancelledError�add_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� fdd�Zdd� 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- �args�kwr3 r r r G s z(_ProactorBaseWritePipeTransport.__init__c C s� t |tttf�s$tdt|�j� ���| jr2td��| j d k rDtd��|sLd S | j
rz| j
t j krht
�d� | j
d7 _
d S | jd kr�| jd ks�t�| jt|�d� n.| js�t|�| _| �� 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� TypeError�typer8 r) � RuntimeErrorrW r' r �!LOG_THRESHOLD_FOR_CONNLOST_WRITESr r r% r# rr �
_loop_writing�_maybe_pause_protocol�extendrk r r r �writeK s. �
z%_ProactorBaseWritePipeTransport.writeNc
C sx �z|d k r"| j d kr"| jr"W d S || j ks0t�d | _ d| _|rH|�� |d kr\| j}d | _|s�| jrv| j�| jd � | j r�| j
� t j
� | �� n\| jj�| j
|�| _ | j �� s�| jdks�t�t|�| _| j �| j� | �� n| j �| j� | jd k �r| j d k�r| j�d � 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� fdd�Zdd� 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 ks0t�d S || jksLt|| jf��d | _| 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
d�Z ddd�Z
� Z S )�_ProactorDatagramTransporti Nc s> || _ d | _t� j|||||d� t�� | _| j�| j � d S )N)r0 r1 )
�_addressrW r r � collections�dequer# 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 � <genexpr>� s zC_ProactorDatagramTransport.get_write_buffer_size.<locals>.<genexpr>)�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 |tttf�s 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 t�d | _|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:t�d | _|d k r�|�� }| jrdd }W W ��d S | jd k r||| j }}n|\}}| jr�W 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 | j�s� 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.| j�tj� 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� fdd�Zd3dd�Zd4dddddd�dd �Zd5d
d �Zd6d d
�Zd7dd�Zd8dd�Z � fdd�Z
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 � �� t�d|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� threading�current_thread� main_thread�signal�
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_side�server_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�� kr6t�d� | �� | � � | 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> } zt�d��W 5 d }~X Y nX zt�|�j}W n, t k
r| } zt�d��W 5 d }~X Y nX |r�|n|}|s�dS t
|d�}|r�t
|| |�n|} t
||�}d}
zLt
| | |�}|dkr�|
W �0S | j �
||||�I d H ||7 }|
|7 }
q�W 5 |
dk�r"|� |� X d S )Nznot a regular filer l �� )r: �AttributeError�io�UnsupportedOperationr ZSendfileNotAvailableError�os�fstat�st_sizerR �min�seekru �sendfile) r- r �file�offset�countr: �errZfsizeZ blocksizeZend_posZ
total_sentr r r �_sock_sendfile_native� s0
z+BaseProactorEventLoop._sock_sendfile_nativec � sZ |� � }|�� |�� I d H z | j|j|||dd�I 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 �� \| _| _| j�d� | j�d� | 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_self�d c s( d� ������fdd� � �� � � d S )Nc
s, z�| d k rn| � � \}}�jr,t�d�||� �� }�d k rX�j||�dd|i��d� n�j||d|i�d� ��� r|W d S �j���} W n� t k
r� } zH��
� dkrʈ� d|t �
��d�� ��� n�jr�tjd �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.<locals>.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 �<module> sR � � �n � �PK [�P�% % ' __pycache__/trsock.cpython-38.opt-2.pycnu �[��� U
e5d� � @ s" d dl Z d dlZG dd� d�ZdS )� Nc @ s� e Zd ZdZejd�dd�Zdd� 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 �&/usr/lib64/python3.8/asyncio/trsock.py�__init__ s zTransportSocket.__init__c C s t jd|� d�t| 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)�warnings�warn�DeprecationWarning)r Zwhatr r r �_na s
�zTransportSocket._nac C s | j jS r )r �family�r 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| j�d| j�d| j� �}| � � dkr�z | �� }|rN|� d|� �}W n tjk
rf Y nX z | �� }|r�|� d|� �}W n tjk
r� Y nX |� d�S ) Nz <asyncio.TransportSocket fd=z , family=z, type=z, proto=���z, laddr=z, raddr=�>)�filenor r r � getsockname�socket�error� getpeername)r �sZladdrZraddrr r r �__repr__& s $� zTransportSocket.__repr__c C s t d��d 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 �
getsockopt�r �args�kwargsr 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 d��d S )Nr z<settimeout(): only 0 timeout is allowed on transport sockets��
ValueError)r �valuer r r �
settimeout� s
�zTransportSocket.settimeoutc C s dS )Nr r r r r r �
gettimeout� s zTransportSocket.gettimeoutc C s |sd S t d��d S )Nz3setblocking(): transport sockets cannot be blockingr? )r �flagr r r � setblocking� s
�zTransportSocket.setblockingc C s | � d� | j�� S �Nzcontext manager protocol)r r � __enter__r r r r rG � s
zTransportSocket.__enter__c G s | � d� | jj|� S rF )r r �__exit__)r �errr r r rH � s
zTransportSocket.__exit__N)2�__name__�
__module__� __qualname__� __slots__r r
r �propertyr r r r r r r r r! r" r& r r r' r( r) r* r+ r, r- r. r/ r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r: r; r< r= r> rB rC rE rG rH r r r r r s`
r )r r r r r r r �<module> s PK [k*� � % __pycache__/exceptions.cpython-38.pycnu �[��� U
e5da � @ sl d Z dZG dd� de�ZG dd� de�ZG dd� de�ZG dd � d e�ZG d
d � d e �Z
G d d
� d
e�Z dS )zasyncio exceptions.)�CancelledError�InvalidStateError� TimeoutError�IncompleteReadError�LimitOverrunError�SendfileNotAvailableErrorc @ s e Zd ZdZdS )r z!The Future or Task was cancelled.N��__name__�
__module__� __qualname__�__doc__� r r �*/usr/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� fdd�Zdd� 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)�repr�super�__init__�len�partial�expected)�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� fdd�Zdd� Z� ZS )r z�Reached 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
�<module> s PK [Yy�L
__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__':
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 [ّ>h h staggered.pynu �[��� """Support for running coroutines in parallel with staggered start times."""
__all__ = 'staggered_race',
import contextlib
import typing
from . import events
from . import exceptions as exceptions_mod
from . import locks
from . import tasks
async def staggered_race(
coro_fns: typing.Iterable[typing.Callable[[], typing.Awaitable]],
delay: typing.Optional[float],
*,
loop: events.AbstractEventLoop = None,
) -> typing.Tuple[
typing.Any,
typing.Optional[int],
typing.List[typing.Optional[Exception]]
]:
"""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``.
"""
# TODO: when we have aiter() and anext(), allow async iterables in coro_fns.
loop = loop or events.get_running_loop()
enum_coro_fns = enumerate(coro_fns)
winner_result = None
winner_index = None
exceptions = []
running_tasks = []
async def run_one_coro(
previous_failed: typing.Optional[locks.Event]) -> None:
# Wait for the previous task to finish, or for delay seconds
if previous_failed is not None:
with contextlib.suppress(exceptions_mod.TimeoutError):
# Use asyncio.wait_for() instead of asyncio.wait() here, so
# that if we get cancelled at this point, Event.wait() is also
# cancelled, otherwise there will be a "Task destroyed but it is
# pending" later.
await tasks.wait_for(previous_failed.wait(), delay)
# Get the next coroutine to run
try:
this_index, coro_fn = next(enum_coro_fns)
except StopIteration:
return
# Start task that will run the next coroutine
this_failed = locks.Event()
next_task = loop.create_task(run_one_coro(this_failed))
running_tasks.append(next_task)
assert len(running_tasks) == this_index + 2
# Prepare place to put this coroutine's exceptions if not won
exceptions.append(None)
assert len(exceptions) == this_index + 1
try:
result = await coro_fn()
except (SystemExit, KeyboardInterrupt):
raise
except BaseException as e:
exceptions[this_index] = e
this_failed.set() # Kickstart the next coroutine
else:
# Store winner's results
nonlocal winner_index, winner_result
assert winner_index is None
winner_index = this_index
winner_result = result
# Cancel all other tasks. We take care to not cancel the current
# task as well. If we do so, then since there is no `await` after
# here and CancelledError are usually thrown at one, we will
# encounter a curious corner case where the current task will end
# up as done() == True, cancelled() == False, exception() ==
# asyncio.CancelledError. This behavior is specified in
# https://bugs.python.org/issue30048
for i, t in enumerate(running_tasks):
if i != this_index:
t.cancel()
first_task = loop.create_task(run_one_coro(None))
running_tasks.append(first_task)
try:
# Wait for a growing list of tasks to all finish: poor man's version of
# curio's TaskGroup or trio's nursery
done_count = 0
while done_count != len(running_tasks):
done, _ = await tasks.wait(running_tasks)
done_count = len(done)
# If run_one_coro raises an unhandled exception, it's probably a
# programming error, and I want to see it.
if __debug__:
for d in done:
if d.done() and not d.cancelled() and d.exception():
raise d.exception()
return winner_result, winner_index, exceptions
finally:
# Make sure no tasks are left running if we leave this function
for t in running_tasks:
t.cancel()
PK [���
� � trsock.pynu �[��� import socket
import warnings
class TransportSocket:
"""A 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.
"""
__slots__ = ('_sock',)
def __init__(self, sock: socket.socket):
self._sock = sock
def _na(self, what):
warnings.warn(
f"Using {what} on sockets returned from get_extra_info('socket') "
f"will be prohibited in asyncio 3.9. Please report your use case "
f"to bugs.python.org.",
DeprecationWarning, source=self)
@property
def family(self):
return self._sock.family
@property
def type(self):
return self._sock.type
@property
def proto(self):
return self._sock.proto
def __repr__(self):
s = (
f"<asyncio.TransportSocket fd={self.fileno()}, "
f"family={self.family!s}, type={self.type!s}, "
f"proto={self.proto}"
)
if self.fileno() != -1:
try:
laddr = self.getsockname()
if laddr:
s = f"{s}, laddr={laddr}"
except socket.error:
pass
try:
raddr = self.getpeername()
if raddr:
s = f"{s}, raddr={raddr}"
except socket.error:
pass
return f"{s}>"
def __getstate__(self):
raise TypeError("Cannot serialize asyncio.TransportSocket object")
def fileno(self):
return self._sock.fileno()
def dup(self):
return self._sock.dup()
def get_inheritable(self):
return self._sock.get_inheritable()
def shutdown(self, how):
# asyncio doesn't currently provide a high-level transport API
# to shutdown the connection.
self._sock.shutdown(how)
def getsockopt(self, *args, **kwargs):
return self._sock.getsockopt(*args, **kwargs)
def setsockopt(self, *args, **kwargs):
self._sock.setsockopt(*args, **kwargs)
def getpeername(self):
return self._sock.getpeername()
def getsockname(self):
return self._sock.getsockname()
def getsockbyname(self):
return self._sock.getsockbyname()
def accept(self):
self._na('accept() method')
return self._sock.accept()
def connect(self, *args, **kwargs):
self._na('connect() method')
return self._sock.connect(*args, **kwargs)
def connect_ex(self, *args, **kwargs):
self._na('connect_ex() method')
return self._sock.connect_ex(*args, **kwargs)
def bind(self, *args, **kwargs):
self._na('bind() method')
return self._sock.bind(*args, **kwargs)
def ioctl(self, *args, **kwargs):
self._na('ioctl() method')
return self._sock.ioctl(*args, **kwargs)
def listen(self, *args, **kwargs):
self._na('listen() method')
return self._sock.listen(*args, **kwargs)
def makefile(self):
self._na('makefile() method')
return self._sock.makefile()
def sendfile(self, *args, **kwargs):
self._na('sendfile() method')
return self._sock.sendfile(*args, **kwargs)
def close(self):
self._na('close() method')
return self._sock.close()
def detach(self):
self._na('detach() method')
return self._sock.detach()
def sendmsg_afalg(self, *args, **kwargs):
self._na('sendmsg_afalg() method')
return self._sock.sendmsg_afalg(*args, **kwargs)
def sendmsg(self, *args, **kwargs):
self._na('sendmsg() method')
return self._sock.sendmsg(*args, **kwargs)
def sendto(self, *args, **kwargs):
self._na('sendto() method')
return self._sock.sendto(*args, **kwargs)
def send(self, *args, **kwargs):
self._na('send() method')
return self._sock.send(*args, **kwargs)
def sendall(self, *args, **kwargs):
self._na('sendall() method')
return self._sock.sendall(*args, **kwargs)
def set_inheritable(self, *args, **kwargs):
self._na('set_inheritable() method')
return self._sock.set_inheritable(*args, **kwargs)
def share(self, process_id):
self._na('share() method')
return self._sock.share(process_id)
def recv_into(self, *args, **kwargs):
self._na('recv_into() method')
return self._sock.recv_into(*args, **kwargs)
def recvfrom_into(self, *args, **kwargs):
self._na('recvfrom_into() method')
return self._sock.recvfrom_into(*args, **kwargs)
def recvmsg_into(self, *args, **kwargs):
self._na('recvmsg_into() method')
return self._sock.recvmsg_into(*args, **kwargs)
def recvmsg(self, *args, **kwargs):
self._na('recvmsg() method')
return self._sock.recvmsg(*args, **kwargs)
def recvfrom(self, *args, **kwargs):
self._na('recvfrom() method')
return self._sock.recvfrom(*args, **kwargs)
def recv(self, *args, **kwargs):
self._na('recv() method')
return self._sock.recv(*args, **kwargs)
def settimeout(self, value):
if value == 0:
return
raise ValueError(
'settimeout(): only 0 timeout is allowed on transport sockets')
def gettimeout(self):
return 0
def setblocking(self, flag):
if not flag:
return
raise ValueError(
'setblocking(): transport sockets cannot be blocking')
def __enter__(self):
self._na('context manager protocol')
return self._sock.__enter__()
def __exit__(self, *err):
self._na('context manager protocol')
return self._sock.__exit__(*err)
PK [ v��4f 4f events.pynu �[��� PK [��,��( �(
mf transports.pynu �[��� PK [#ƅ� h h
�� streams.pynu �[��� PK [�xD�Jj Jj �� sslproto.pynu �[��� PK [�4/�" �" b base_subprocess.pynu �[��� PK [l5Z
�: �:
L� test_utils.pynu �[��� PK [�pCP |� compat.pynu �[��� PK [=�|C |C �� locks.pynu �[��� PK [V�CC� � � windows_utils.pynu �[��� PK [l���� �� � tasks.pynu �[��� PK [�h�� �
G� subprocess.pynu �[��� PK [(s8�x x � constants.pynu �[��� PK [��yT� T� �� selector_events.pynu �[��� PK [6߾ê � % R[ __pycache__/subprocess.cpython-36.pycnu �[��� PK [��)� ) Qv __pycache__/__init__.cpython-36.opt-1.pycnu �[��� PK [@!�)Ř Ř , �y __pycache__/base_events.cpython-36.opt-1.pycnu �[��� PK [P�\~z z , � __pycache__/base_events.cpython-36.opt-2.pycnu �[��� PK [�f� �I �I & L� __pycache__/tasks.cpython-36.opt-1.pycnu �[��� PK [�X��" �" & �� __pycache__/locks.cpython-36.opt-2.pycnu �[��� PK [ ��o�5 �5 " �� __pycache__/futures.cpython-36.pycnu �[��� PK [�%�O�S �S ) �0 __pycache__/windows_events.cpython-36.pycnu �[��� PK [� H�O �O / � __pycache__/windows_events.cpython-36.opt-2.pycnu �[��� PK [6����D �D ' � __pycache__/events.cpython-36.opt-2.pycnu �[��� PK [���� � ' T __pycache__/compat.cpython-36.opt-1.pycnu �[��� PK [�a��Z< Z< & � __pycache__/locks.cpython-36.opt-1.pycnu �[��� PK [mʀ��L �L ( 9Z __pycache__/streams.cpython-36.opt-1.pycnu �[��� PK [vԊ�� �� & E� __pycache__/base_events.cpython-36.pycnu �[��� PK [���� � $ NA __pycache__/log.cpython-36.opt-1.pycnu �[��� PK [K�[ [ * ~B __pycache__/protocols.cpython-36.opt-1.pycnu �[��� PK ["4�� � ' 3Z __pycache__/queues.cpython-36.opt-2.pycnu �[��� PK [��yO yO # 1p __pycache__/sslproto.cpython-36.pycnu �[��� PK [��ь� � * �� __pycache__/constants.cpython-36.opt-1.pycnu �[��� PK [Ea�#m m 0 T� __pycache__/selector_events.cpython-36.opt-2.pycnu �[��� PK [��ь� � $ �. __pycache__/constants.cpython-36.pycnu �[��� PK [3'~� � - 0 __pycache__/base_futures.cpython-36.opt-2.pycnu �[��� PK [Y��� � ( 7 __pycache__/futures.cpython-36.opt-2.pycnu �[��� PK [7� +� � ) EU __pycache__/__init__.cpython-36.opt-2.pycnu �[��� PK [ D��o? o? 0 rX __pycache__/proactor_events.cpython-36.opt-2.pycnu �[��� PK [��)� # A� __pycache__/__init__.cpython-36.pycnu �[��� PK [P�f�# �# 0 �� __pycache__/base_subprocess.cpython-36.opt-1.pycnu �[��� PK [VWX�E E % п __pycache__/test_utils.cpython-36.pycnu �[��� PK [�;�.4 .4 ( 8 __pycache__/streams.cpython-36.opt-2.pycnu �[��� PK [�`�� � * �9 __pycache__/protocols.cpython-36.opt-2.pycnu �[��� PK [��t�Gs Gs 0 �B __pycache__/selector_events.cpython-36.opt-1.pycnu �[��� PK [����j# j# 0 m� __pycache__/base_subprocess.cpython-36.opt-2.pycnu �[��� PK [�#�~� � ! 7� __pycache__/queues.cpython-36.pycnu �[��� PK [1<���J �J ^� __pycache__/tasks.cpython-36.pycnu �[��� PK [ϤУ ' EF
__pycache__/base_futures.cpython-36.pycnu �[��� PK [�pä�b �b ! �N
__pycache__/events.cpython-36.pycnu �[��� PK [�ny�0$ 0$ * �
__pycache__/base_subprocess.cpython-36.pycnu �[��� PK [h8�"� � . t�
__pycache__/windows_utils.cpython-36.opt-1.pycnu �[��� PK [4]�j! j! % ��
__pycache__/coroutines.cpython-36.pycnu �[��� PK [{fU�� � * ?
__pycache__/constants.cpython-36.opt-2.pycnu �[��� PK [�>B� + { __pycache__/transports.cpython-36.opt-2.pycnu �[��� PK [���� � ! �' __pycache__/compat.cpython-36.pycnu �[��� PK [C�s / / + + __pycache__/transports.cpython-36.opt-1.pycnu �[��� PK [G��4G G % oZ __pycache__/base_tasks.cpython-36.pycnu �[��� PK [ϤУ - b __pycache__/base_futures.cpython-36.opt-1.pycnu �[��� PK [/F\: ( ij __pycache__/windows_utils.cpython-36.pycnu �[��� PK [ ��z�4 �4 ( � __pycache__/futures.cpython-36.opt-1.pycnu �[��� PK [�� � � + � __pycache__/coroutines.cpython-36.opt-1.pycnu �[��� PK [5 �h�@ �@ 0 :� __pycache__/proactor_events.cpython-36.opt-1.pycnu �[��� PK [ ��� � $ � __pycache__/log.cpython-36.opt-2.pycnu �[��� PK [�%�O�S �S / � __pycache__/windows_events.cpython-36.opt-1.pycnu �[��� PK [�gғg �g , �l __pycache__/unix_events.cpython-36.opt-2.pycnu �[��� PK [����M �M " �� __pycache__/streams.cpython-36.pycnu �[��� PK [G��4G G + #
__pycache__/base_tasks.cpython-36.opt-1.pycnu �[��� PK [�a��Z< Z< �*
__pycache__/locks.cpython-36.pycnu �[��� PK [�x�mD mD + Sg
__pycache__/test_utils.cpython-36.opt-1.pycnu �[��� PK [�E(�g g ' �
__pycache__/compat.cpython-36.opt-2.pycnu �[��� PK [#���]w ]w & ٮ
__pycache__/unix_events.cpython-36.pycnu �[��� PK [ U��4 4 ) �& __pycache__/sslproto.cpython-36.opt-2.pycnu �[��� PK [��ېb �b ' �Z __pycache__/events.cpython-36.opt-1.pycnu �[��� PK [�#�~� � ' ͽ __pycache__/queues.cpython-36.opt-1.pycnu �[��� PK [��� �N �N ) �� __pycache__/sslproto.cpython-36.opt-1.pycnu �[��� PK [�R�ӸA �A * . __pycache__/proactor_events.cpython-36.pycnu �[��� PK [$��dv v , p __pycache__/unix_events.cpython-36.opt-1.pycnu �[��� PK [�»� � + v� __pycache__/subprocess.cpython-36.opt-1.pycnu �[��� PK [ ��[? [? + ] __pycache__/test_utils.cpython-36.opt-2.pycnu �[��� PK [���� � A __pycache__/log.cpython-36.pycnu �[��� PK [G��4G G + =B __pycache__/base_tasks.cpython-36.opt-2.pycnu �[��� PK [s�58�s �s * �I __pycache__/selector_events.cpython-36.pycnu �[��� PK [K�[ [ $ �� __pycache__/protocols.cpython-36.pycnu �[��� PK [i|MZ�. �. & i� __pycache__/tasks.cpython-36.opt-2.pycnu �[��� PK [H�V1 + � __pycache__/coroutines.cpython-36.opt-2.pycnu �[��� PK [���e e . % __pycache__/windows_utils.cpython-36.opt-2.pycnu �[��� PK [����� � + �7 __pycache__/subprocess.cpython-36.opt-2.pycnu �[��� PK [Q*_ / / % !R __pycache__/transports.cpython-36.pycnu �[��� PK [̡��b3 b3
�� futures.pynu �[��� PK [a��ۿ ۿ 0� unix_events.pynu �[��� PK [����
Iu base_futures.pynu �[��� PK [E{C�| | � log.pynu �[��� PK [��n� �
H� base_tasks.pynu �[��� PK ['J��i� i� (� windows_events.pynu �[��� PK [����� � �
__init__.pynu �[��� PK [0�� � queues.pynu �[��� PK [VW�<} <} 00 proactor_events.pynu �[��� PK [�H��� � �� base_events.pynu �[��� PK [���]" ]"
�� coroutines.pynu �[��� PK [|�q�� � 3� protocols.pynu �[��� PK [��Zd d O format_helpers.pynu �[��� PK [z/%:
� runners.pynu �[��� PK [yPa a
4 exceptions.pynu �[��� PK [ ��M%! %! ' � __pycache__/trsock.cpython-38.opt-1.pycnu �[��� PK [ߋ�ѢP �P " NB __pycache__/streams.cpython-38.pycnu �[��� PK [[k�A A & B� __pycache__/tasks.cpython-38.opt-2.pycnu �[��� PK [�\@��/ �/ + �� __pycache__/transports.cpython-38.opt-1.pycnu �[��� PK [�x��* * / � __pycache__/format_helpers.cpython-38.opt-2.pycnu �[��� PK [�ar�$ �$ * G
__pycache__/base_subprocess.cpython-38.pycnu �[��� PK [���/$ $ 0 k2 __pycache__/base_subprocess.cpython-38.opt-2.pycnu �[��� PK [�H ��m �m ! �V __pycache__/events.cpython-38.pycnu �[��� PK [�h�� � ( �� __pycache__/runners.cpython-38.opt-1.pycnu �[��� PK [i�.CH H ' �� __pycache__/queues.cpython-38.opt-2.pycnu �[��� PK [6�8+� � ) Q� __pycache__/__init__.cpython-38.opt-2.pycnu �[��� PK [wI<ws s + b� __pycache__/exceptions.cpython-38.opt-2.pycnu �[��� PK [ ? ��O �O ( 0� __pycache__/streams.cpython-38.opt-1.pycnu �[��� PK [���1N� N� & > __pycache__/base_events.cpython-38.pycnu �[��� PK [7�! �! $ � __pycache__/protocols.cpython-38.pycnu �[��� PK [�ۤ�Ym Ym 0 �' __pycache__/selector_events.cpython-38.opt-2.pycnu �[��� PK [� �? �? & p� __pycache__/locks.cpython-38.opt-1.pycnu �[��� PK [�5 B B ) �� __pycache__/__main__.cpython-38.opt-2.pycnu �[��� PK [� ��k k * S� __pycache__/staggered.cpython-38.opt-1.pycnu �[��� PK [��,� * � __pycache__/staggered.cpython-38.opt-2.pycnu �[��� PK [�N & % �� __pycache__/coroutines.cpython-38.pycnu �[��� PK [˼��-� -� , � __pycache__/unix_events.cpython-38.opt-1.pycnu �[��� PK [� �? �? f� __pycache__/locks.cpython-38.pycnu �[��� PK [���+ �+ " �� __pycache__/futures.cpython-38.pycnu �[��� PK [�?�`� � ( � __pycache__/runners.cpython-38.opt-2.pycnu �[��� PK [� ��I �I ' __pycache__/events.cpython-38.opt-2.pycnu �[��� PK [\dks s . *h __pycache__/windows_utils.cpython-38.opt-2.pycnu �[��� PK [��q�l l - �w __pycache__/base_futures.cpython-38.opt-1.pycnu �[��� PK [ �?�/m /m ' � __pycache__/events.cpython-38.opt-1.pycnu �[��� PK [C��ktT tT # J� __pycache__/sslproto.cpython-38.pycnu �[��� PK [$��'� � + B __pycache__/base_tasks.cpython-38.opt-2.pycnu �[��� PK [��q�l l ' J __pycache__/base_futures.cpython-38.pycnu �[��� PK [rn n - �Q __pycache__/base_futures.cpython-38.opt-2.pycnu �[��� PK [�� +�[ �[ 0 �X __pycache__/proactor_events.cpython-38.opt-2.pycnu �[��� PK [7�! �! * �� __pycache__/protocols.cpython-38.opt-1.pycnu �[��� PK [� �j$ j$ 0 �� __pycache__/base_subprocess.cpython-38.opt-1.pycnu �[��� PK [�Ŀ � ' m� __pycache__/queues.cpython-38.opt-1.pycnu �[��� PK [�T
� � $ � __pycache__/log.cpython-38.opt-1.pycnu �[��� PK [$��'� � + � __pycache__/base_tasks.cpython-38.opt-1.pycnu �[��� PK [��� ( �% __pycache__/futures.cpython-38.opt-2.pycnu �[��� PK [� u�
* (D __pycache__/protocols.cpython-38.opt-2.pycnu �[��� PK [-w/� � ) �Q __pycache__/__init__.cpython-38.opt-1.pycnu �[��� PK [���
/ �T __pycache__/format_helpers.cpython-38.opt-1.pycnu �[��� PK [���� � + e^ __pycache__/coroutines.cpython-38.opt-2.pycnu �[��� PK [�с�^ �^ & �w __pycache__/tasks.cpython-38.opt-1.pycnu �[��� PK [2�
� � + |� __pycache__/transports.cpython-38.opt-2.pycnu �[��� PK [�O�=] =] 0 �� __pycache__/proactor_events.cpython-38.opt-1.pycnu �[��� PK [-w/� � # %O __pycache__/__init__.cpython-38.pycnu �[��� PK [��gF � � , hR __pycache__/unix_events.cpython-38.opt-2.pycnu �[��� PK [���b�s �s * �� __pycache__/selector_events.cpython-38.pycnu �[��� PK [9c��_ �_ / !M __pycache__/windows_events.cpython-38.opt-1.pycnu �[��� PK [�h�� � " i� __pycache__/runners.cpython-38.pycnu �[��� PK [l[˅ ` ` ) X� __pycache__/windows_events.cpython-38.pycnu �[��� PK [ٗ '9 9 ) � __pycache__/sslproto.cpython-38.opt-2.pycnu �[��� PK [H�� �[ �[ / ,O __pycache__/windows_events.cpython-38.opt-2.pycnu �[��� PK [�o2y�/ �/ % !� __pycache__/transports.cpython-38.pycnu �[��� PK [�;j% % . ^� __pycache__/windows_utils.cpython-38.opt-1.pycnu �[��� PK [��Kl� l� , �� __pycache__/base_events.cpython-38.opt-1.pycnu �[��� PK [�T
� � �� __pycache__/log.cpython-38.pycnu �[��� PK [)��(& (& & ۴ __pycache__/locks.cpython-38.opt-2.pycnu �[��� PK [��X6G G * Y� __pycache__/constants.cpython-38.opt-1.pycnu �[��� PK [���
) �� __pycache__/format_helpers.cpython-38.pycnu �[��� PK [�� � � + q� __pycache__/subprocess.cpython-38.opt-1.pycnu �[��� PK [��X6G G $ n! __pycache__/constants.cpython-38.pycnu �[��� PK [k*� � + ! __pycache__/exceptions.cpython-38.opt-1.pycnu �[��� PK [��X6G G * [! __pycache__/constants.cpython-38.opt-2.pycnu �[��� PK [��y y ( �! __pycache__/windows_utils.cpython-38.pycnu �[��� PK [�Ŀ � ! �%! __pycache__/queues.cpython-38.pycnu �[��� PK [�]���� �� & �F! __pycache__/unix_events.cpython-38.pycnu �[��� PK [`��S �S ) ��! __pycache__/sslproto.cpython-38.opt-1.pycnu �[��� PK [���E $ �4" __pycache__/staggered.cpython-38.pycnu �[��� PK [g<2��^ �^ NE" __pycache__/tasks.cpython-38.pycnu �[��� PK [�S�Y�s �s 0 y�" __pycache__/selector_events.cpython-38.opt-1.pycnu �[��� PK [��M�" " + �# __pycache__/subprocess.cpython-38.opt-2.pycnu �[��� PK [�� � � + 5# __pycache__/coroutines.cpython-38.opt-1.pycnu �[��� PK [*�J;� � $ O# __pycache__/log.cpython-38.opt-2.pycnu �[��� PK [�m���8 �8 ( (P# __pycache__/streams.cpython-38.opt-2.pycnu �[��� PK [T=T\W� W� , �# __pycache__/base_events.cpython-38.opt-2.pycnu �[��� PK [ۂ�U
+
+ ( �,$ __pycache__/futures.cpython-38.opt-1.pycnu �[��� PK [��b� � % X$ __pycache__/subprocess.cpython-38.pycnu �[��� PK [$��'� � % 3u$ __pycache__/base_tasks.cpython-38.pycnu �[��� PK [�5 B B ) "}$ __pycache__/__main__.cpython-38.opt-1.pycnu �[��� PK [ ��M%! %! ! ��$ __pycache__/trsock.cpython-38.pycnu �[��� PK [�5 B B # 3�$ __pycache__/__main__.cpython-38.pycnu �[��� PK [ft�,S^ S^ * ȷ$ __pycache__/proactor_events.cpython-38.pycnu �[��� PK [�P�% % ' u% __pycache__/trsock.cpython-38.opt-2.pycnu �[��� PK [k*� � % �6% __pycache__/exceptions.cpython-38.pycnu �[��� PK [Yy�L
=A% __main__.pynu �[��� PK [ّ>h h �N% staggered.pynu �[��� PK [���
� � +f% trsock.pynu �[��� PK � � PK X}%
