{
    "content": [
        {
            "type": "text",
            "text": "# asyncio (pydoc)\n\n**Summary:** asyncio - The asyncio package, tracking PEP 3156.\n\n## Section Outline\n\n- **NAME** (2 lines)\n- **MODULE REFERENCE** (8 lines)\n- **PACKAGE CONTENTS** (31 lines)\n- **CLASSES** (64 lines) — 45 subsections\n  - class AbstractChildWatcher (74 lines)\n  - class AbstractEventLoop (254 lines)\n  - class AbstractEventLoopPolicy (36 lines)\n  - class AbstractServer (40 lines)\n  - class BaseEventLoop (334 lines)\n  - class BaseProtocol (50 lines)\n  - class BaseTransport (29 lines)\n  - class BoundedSemaphore (59 lines)\n  - class BufferedProtocol (95 lines)\n  - class CancelledError (65 lines)\n  - class Condition (76 lines)\n  - class DatagramProtocol (60 lines)\n  - class DatagramTransport (104 lines)\n  - class Event (51 lines)\n  - class FastChildWatcher (74 lines)\n  - class Future (101 lines)\n  - class Handle (22 lines)\n  - class IncompleteReadError (75 lines)\n  - class InvalidStateError (69 lines)\n  - class LifoQueue (99 lines)\n  - class LimitOverrunError (74 lines)\n  - class Lock (103 lines)\n  - class MultiLoopChildWatcher (71 lines)\n  - class PidfdChildWatcher (71 lines)\n  - class PriorityQueue (101 lines)\n  - class Protocol (86 lines)\n  - class Queue (106 lines)\n  - class QueueEmpty (69 lines)\n  - class QueueFull (69 lines)\n  - class ReadTransport (52 lines)\n  - class SafeChildWatcher (456 lines)\n  - class Semaphore (63 lines)\n  - class SendfileNotAvailableError (73 lines)\n  - class Server (59 lines)\n  - class StreamReader (109 lines)\n  - class StreamReaderProtocol (87 lines)\n  - class StreamWriter (56 lines)\n  - class SubprocessProtocol (67 lines)\n  - class SubprocessTransport (74 lines)\n  - class Task (147 lines)\n  - class ThreadedChildWatcher (74 lines)\n  - class TimeoutError (69 lines)\n  - class TimerHandle (54 lines)\n  - class Transport (130 lines)\n  - class WriteTransport (93 lines)\n- **FUNCTIONS** (36 lines) — 22 subsections\n  - all_tasks (2 lines)\n  - as_completed (17 lines)\n  - coroutine (9 lines)\n  - create_task (4 lines)\n  - current_task (2 lines)\n  - ensure_future (4 lines)\n  - gather (29 lines)\n  - get_child_watcher (2 lines)\n  - get_event_loop (9 lines)\n  - get_event_loop_policy (2 lines)\n  - get_running_loop (4 lines)\n  - iscoroutine (2 lines)\n  - iscoroutinefunction (2 lines)\n  - isfuture (6 lines)\n  - new_event_loop (23 lines)\n  - run (23 lines)\n  - run_coroutine_threadsafe (4 lines)\n  - set_child_watcher (3 lines)\n  - set_event_loop (2 lines)\n  - set_event_loop_policy (4 lines)\n  - shield (99 lines)\n  - wrap_future (2 lines)\n- **DATA** (5 lines)\n- **FILE** (3 lines)\n\n## Full Content\n\n### NAME\n\nasyncio - The asyncio package, tracking PEP 3156.\n\n### MODULE REFERENCE\n\nhttps://docs.python.org/3.10/library/asyncio.html\n\nThe following documentation is automatically generated from the Python\nsource files.  It may be incomplete, incorrect or include features that\nare considered implementation detail and may vary between Python\nimplementations.  When in doubt, consult the module reference at the\nlocation listed above.\n\n### PACKAGE CONTENTS\n\nmain\nbaseevents\nbasefutures\nbasesubprocess\nbasetasks\nconstants\ncoroutines\nevents\nexceptions\nformathelpers\nfutures\nlocks\nlog\nmixins\nproactorevents\nprotocols\nqueues\nrunners\nselectorevents\nsslproto\nstaggered\nstreams\nsubprocess\ntasks\nthreads\ntransports\ntrsock\nunixevents\nwindowsevents\nwindowsutils\n\n### CLASSES\n\nasyncio.events.BaseDefaultEventLoopPolicy(asyncio.events.AbstractEventLoopPolicy)\nasyncio.unixevents.UnixDefaultEventLoopPolicy\nasyncio.locks.ContextManagerMixin(builtins.object)\nasyncio.locks.Condition(asyncio.locks.ContextManagerMixin, asyncio.mixins.LoopBoundMixin)\nasyncio.locks.Lock(asyncio.locks.ContextManagerMixin, asyncio.mixins.LoopBoundMixin)\nasyncio.locks.Semaphore(asyncio.locks.ContextManagerMixin, asyncio.mixins.LoopBoundMixin)\nasyncio.locks.BoundedSemaphore\nasyncio.mixins.LoopBoundMixin(builtins.object)\nasyncio.locks.Condition(asyncio.locks.ContextManagerMixin, asyncio.mixins.LoopBoundMixin)\nasyncio.locks.Event\nasyncio.locks.Lock(asyncio.locks.ContextManagerMixin, asyncio.mixins.LoopBoundMixin)\nasyncio.locks.Semaphore(asyncio.locks.ContextManagerMixin, asyncio.mixins.LoopBoundMixin)\nasyncio.locks.BoundedSemaphore\nasyncio.queues.Queue\nasyncio.queues.LifoQueue\nasyncio.queues.PriorityQueue\nasyncio.selectorevents.BaseSelectorEventLoop(asyncio.baseevents.BaseEventLoop)\nasyncio.unixevents.UnixSelectorEventLoop\nasyncio.streams.FlowControlMixin(asyncio.protocols.Protocol)\nasyncio.streams.StreamReaderProtocol(asyncio.streams.FlowControlMixin, asyncio.protocols.Protocol)\nasyncio.unixevents.BaseChildWatcher(asyncio.unixevents.AbstractChildWatcher)\nasyncio.unixevents.FastChildWatcher\nasyncio.unixevents.SafeChildWatcher\nbuiltins.BaseException(builtins.object)\nasyncio.exceptions.CancelledError\nbuiltins.EOFError(builtins.Exception)\nasyncio.exceptions.IncompleteReadError\nbuiltins.Exception(builtins.BaseException)\nasyncio.exceptions.InvalidStateError\nasyncio.exceptions.LimitOverrunError\nasyncio.exceptions.TimeoutError\nasyncio.queues.QueueEmpty\nasyncio.queues.QueueFull\nbuiltins.RuntimeError(builtins.Exception)\nasyncio.exceptions.SendfileNotAvailableError\nbuiltins.object\nasyncio.Future\nasyncio.Task\nasyncio.events.AbstractEventLoop\nasyncio.baseevents.BaseEventLoop\nasyncio.events.AbstractEventLoopPolicy\nasyncio.events.AbstractServer\nasyncio.baseevents.Server\nasyncio.events.Handle\nasyncio.events.TimerHandle\nasyncio.protocols.BaseProtocol\nasyncio.protocols.BufferedProtocol\nasyncio.protocols.DatagramProtocol\nasyncio.protocols.Protocol\nasyncio.streams.StreamReaderProtocol(asyncio.streams.FlowControlMixin, asyncio.protocols.Protocol)\nasyncio.protocols.SubprocessProtocol\nasyncio.streams.StreamReader\nasyncio.streams.StreamWriter\nasyncio.transports.BaseTransport\nasyncio.transports.DatagramTransport\nasyncio.transports.ReadTransport\nasyncio.transports.Transport(asyncio.transports.ReadTransport, asyncio.transports.WriteTransport)\nasyncio.transports.SubprocessTransport\nasyncio.transports.WriteTransport\nasyncio.unixevents.AbstractChildWatcher\nasyncio.unixevents.MultiLoopChildWatcher\nasyncio.unixevents.PidfdChildWatcher\nasyncio.unixevents.ThreadedChildWatcher\n\n#### class AbstractChildWatcher\n\n|  Abstract base class for monitoring child processes.\n|\n|  Objects derived from this class monitor a collection of subprocesses and\n|  report their termination or interruption by a signal.\n|\n|  New callbacks are registered with .addchildhandler(). Starting a new\n|  process must be done within a 'with' block to allow the watcher to suspend\n|  its activity until the new process if fully registered (this is needed to\n|  prevent a race condition in some implementations).\n|\n|  Example:\n|      with watcher:\n|          proc = subprocess.Popen(\"sleep 1\")\n|          watcher.addchildhandler(proc.pid, callback)\n|\n|  Notes:\n|      Implementations of this class must be thread-safe.\n|\n|      Since child watcher objects may catch the SIGCHLD signal and call\n|      waitpid(-1), there should be only one active object per process.\n|\n|  Methods defined here:\n|\n|  enter(self)\n|      Enter the watcher's context and allow starting new processes\n|\n|      This function must return self\n|\n|  exit(self, a, b, c)\n|      Exit the watcher's context\n|\n|  addchildhandler(self, pid, callback, *args)\n|      Register a new child handler.\n|\n|      Arrange for callback(pid, returncode, *args) to be called when\n|      process 'pid' terminates. Specifying another callback for the same\n|      process replaces the previous handler.\n|\n|      Note: callback() must be thread-safe.\n|\n|  attachloop(self, loop)\n|      Attach the watcher to an event loop.\n|\n|      If the watcher was previously attached to an event loop, then it is\n|      first detached before attaching to the new loop.\n|\n|      Note: loop may be None.\n|\n|  close(self)\n|      Close the watcher.\n|\n|      This must be called to make sure that any underlying resource is freed.\n|\n|  isactive(self)\n|      Return ``True`` if the watcher is active and is used by the event loop.\n|\n|      Return True if the watcher is installed and ready to handle process exit\n|      notifications.\n|\n|  removechildhandler(self, pid)\n|      Removes the handler for process 'pid'.\n|\n|      The function returns True if the handler was successfully removed,\n|      False if there was nothing to remove.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors defined here:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class AbstractEventLoop\n\n|  Abstract event loop.\n|\n|  Methods defined here:\n|\n|  addreader(self, fd, callback, *args)\n|\n|  addsignalhandler(self, sig, callback, *args)\n|\n|  addwriter(self, fd, callback, *args)\n|\n|  callat(self, when, callback, *args, context=None)\n|\n|  callexceptionhandler(self, context)\n|\n|  calllater(self, delay, callback, *args, context=None)\n|\n|  callsoon(self, callback, *args, context=None)\n|\n|  callsoonthreadsafe(self, callback, *args, context=None)\n|\n|  close(self)\n|      Close the loop.\n|\n|      The loop should not be running.\n|\n|      This is idempotent and irreversible.\n|\n|      No other methods should be called after this one.\n|\n|  async connectacceptedsocket(self, protocolfactory, sock, *, ssl=None, sslhandshaketimeout=None)\n|      Handle an accepted connection.\n|\n|      This is used by servers that accept connections outside of\n|      asyncio, but use asyncio to handle connections.\n|\n|      This method is a coroutine.  When completed, the coroutine\n|      returns a (transport, protocol) pair.\n|\n|  async connectreadpipe(self, protocolfactory, pipe)\n|      Register read pipe in event loop. Set the pipe to non-blocking mode.\n|\n|      protocolfactory should instantiate object with Protocol interface.\n|      pipe is a file-like object.\n|      Return pair (transport, protocol), where transport supports the\n|      ReadTransport interface.\n|\n|  async connectwritepipe(self, protocolfactory, pipe)\n|      Register write pipe in event loop.\n|\n|      protocolfactory should instantiate object with BaseProtocol interface.\n|      Pipe is file-like object already switched to nonblocking.\n|      Return pair (transport, protocol), where transport support\n|      WriteTransport interface.\n|\n|  async createconnection(self, protocolfactory, host=None, port=None, *, ssl=None, family=0, proto=0, flags=0, sock=None, localaddr=None, serverhostname=None, sslhandshaketimeout=None, happyeyeballsdelay=None, interleave=None)\n|\n|  async createdatagramendpoint(self, protocolfactory, localaddr=None, remoteaddr=None, *, family=0, proto=0, flags=0, reuseaddress=None, reuseport=None, allowbroadcast=None, sock=None)\n|      A coroutine which creates a datagram endpoint.\n|\n|      This method will try to establish the endpoint in the background.\n|      When successful, the coroutine returns a (transport, protocol) pair.\n|\n|      protocolfactory must be a callable returning a protocol instance.\n|\n|      socket family AFINET, socket.AFINET6 or socket.AFUNIX depending on\n|      host (or family if specified), socket type SOCKDGRAM.\n|\n|      reuseaddress tells the kernel to reuse a local socket in\n|      TIMEWAIT state, without waiting for its natural timeout to\n|      expire. If not specified it will automatically be set to True on\n|      UNIX.\n|\n|      reuseport tells the kernel to allow this endpoint to be bound to\n|      the same port as other existing endpoints are bound to, so long as\n|      they all set this flag when being created. This option is not\n|      supported on Windows and some UNIX's. If the\n|      :py:data:`~socket.SOREUSEPORT` constant is not defined then this\n|      capability is unsupported.\n|\n|      allowbroadcast tells the kernel to allow this endpoint to send\n|      messages to the broadcast address.\n|\n|      sock can optionally be specified in order to use a preexisting\n|      socket object.\n|\n|  createfuture(self)\n|\n|  async createserver(self, protocolfactory, host=None, port=None, *, family=<AddressFamily.AFUNSPEC: 0>, flags=<AddressInfo.AIPASSIVE: 1>, sock=None, backlog=100, ssl=None, reuseaddress=None, reuseport=None, sslhandshaketimeout=None, startserving=True)\n|      A coroutine which creates a TCP server bound to host and port.\n|\n|      The return value is a Server object which can be used to stop\n|      the service.\n|\n|      If host is an empty string or None all interfaces are assumed\n|      and a list of multiple sockets will be returned (most likely\n|      one for IPv4 and another one for IPv6). The host parameter can also be\n|      a sequence (e.g. list) of hosts to bind to.\n|\n|      family can be set to either AFINET or AFINET6 to force the\n|      socket to use IPv4 or IPv6. If not set it will be determined\n|      from host (defaults to AFUNSPEC).\n|\n|      flags is a bitmask for getaddrinfo().\n|\n|      sock can optionally be specified in order to use a preexisting\n|      socket object.\n|\n|      backlog is the maximum number of queued connections passed to\n|      listen() (defaults to 100).\n|\n|      ssl can be set to an SSLContext to enable SSL over the\n|      accepted connections.\n|\n|      reuseaddress tells the kernel to reuse a local socket in\n|      TIMEWAIT state, without waiting for its natural timeout to\n|      expire. If not specified will automatically be set to True on\n|      UNIX.\n|\n|      reuseport tells the kernel to allow this endpoint to be bound to\n|      the same port as other existing endpoints are bound to, so long as\n|      they all set this flag when being created. This option is not\n|      supported on Windows.\n|\n|      sslhandshaketimeout is the time in seconds that an SSL server\n|      will wait for completion of the SSL handshake before aborting the\n|      connection. Default is 60s.\n|\n|      startserving set to True (default) causes the created server\n|      to start accepting connections immediately.  When set to False,\n|      the user should await Server.startserving() or Server.serveforever()\n|      to make the server to start accepting connections.\n|\n|  createtask(self, coro, *, name=None)\n|\n|  async createunixconnection(self, protocolfactory, path=None, *, ssl=None, sock=None, serverhostname=None, sslhandshaketimeout=None)\n|\n|  async createunixserver(self, protocolfactory, path=None, *, sock=None, backlog=100, ssl=None, sslhandshaketimeout=None, startserving=True)\n|      A coroutine which creates a UNIX Domain Socket server.\n|\n|      The return value is a Server object, which can be used to stop\n|      the service.\n|\n|      path is a str, representing a file system path to bind the\n|      server socket to.\n|\n|      sock can optionally be specified in order to use a preexisting\n|      socket object.\n|\n|      backlog is the maximum number of queued connections passed to\n|      listen() (defaults to 100).\n|\n|      ssl can be set to an SSLContext to enable SSL over the\n|      accepted connections.\n|\n|      sslhandshaketimeout is the time in seconds that an SSL server\n|      will wait for the SSL handshake to complete (defaults to 60s).\n|\n|      startserving set to True (default) causes the created server\n|      to start accepting connections immediately.  When set to False,\n|      the user should await Server.startserving() or Server.serveforever()\n|      to make the server to start accepting connections.\n|\n|  defaultexceptionhandler(self, context)\n|\n|  getdebug(self)\n|\n|  getexceptionhandler(self)\n|\n|  gettaskfactory(self)\n|\n|  async getaddrinfo(self, host, port, *, family=0, type=0, proto=0, flags=0)\n|\n|  async getnameinfo(self, sockaddr, flags=0)\n|\n|  isclosed(self)\n|      Returns True if the event loop was closed.\n|\n|  isrunning(self)\n|      Return whether the event loop is currently running.\n|\n|  removereader(self, fd)\n|\n|  removesignalhandler(self, sig)\n|\n|  removewriter(self, fd)\n|\n|  runforever(self)\n|      Run the event loop until stop() is called.\n|\n|  runinexecutor(self, executor, func, *args)\n|\n|  rununtilcomplete(self, future)\n|      Run the event loop until a Future is done.\n|\n|      Return the Future's result, or raise its exception.\n|\n|  async sendfile(self, transport, file, offset=0, count=None, *, fallback=True)\n|      Send a file through a transport.\n|\n|      Return an amount of sent bytes.\n|\n|  setdebug(self, enabled)\n|\n|  setdefaultexecutor(self, executor)\n|\n|  setexceptionhandler(self, handler)\n|\n|  settaskfactory(self, factory)\n|\n|  async shutdownasyncgens(self)\n|      Shutdown all active asynchronous generators.\n|\n|  async shutdowndefaultexecutor(self)\n|      Schedule the shutdown of the default executor.\n|\n|  async sockaccept(self, sock)\n|\n|  async sockconnect(self, sock, address)\n|\n|  async sockrecv(self, sock, nbytes)\n|\n|  async sockrecvinto(self, sock, buf)\n|\n|  async socksendall(self, sock, data)\n|\n|  async socksendfile(self, sock, file, offset=0, count=None, *, fallback=None)\n|\n|  async starttls(self, transport, protocol, sslcontext, *, serverside=False, serverhostname=None, sslhandshaketimeout=None)\n|      Upgrade a transport to TLS.\n|\n|      Return a new transport that *protocol* should start using\n|      immediately.\n|\n|  stop(self)\n|      Stop the event loop as soon as reasonable.\n|\n|      Exactly how soon that is may depend on the implementation, but\n|      no more I/O callbacks should be scheduled.\n|\n|  async subprocessexec(self, protocolfactory, *args, stdin=-1, stdout=-1, stderr=-1, kwargs)\n|\n|  async subprocessshell(self, protocolfactory, cmd, *, stdin=-1, stdout=-1, stderr=-1, kwargs)\n|\n|  time(self)\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors defined here:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class AbstractEventLoopPolicy\n\n|  Abstract policy for accessing the event loop.\n|\n|  Methods defined here:\n|\n|  getchildwatcher(self)\n|      Get the watcher for child processes.\n|\n|  geteventloop(self)\n|      Get the event loop for the current context.\n|\n|      Returns an event loop object implementing the BaseEventLoop interface,\n|      or raises an exception in case no event loop has been set for the\n|      current context and the current policy does not specify to create one.\n|\n|      It should never return None.\n|\n|  neweventloop(self)\n|      Create and return a new event loop object according to this\n|      policy's rules. If there's need to set this loop as the event loop for\n|      the current context, seteventloop must be called explicitly.\n|\n|  setchildwatcher(self, watcher)\n|      Set the watcher for child processes.\n|\n|  seteventloop(self, loop)\n|      Set the event loop for the current context to loop.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors defined here:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class AbstractServer\n\n|  Abstract server returned by createserver().\n|\n|  Methods defined here:\n|\n|  async aenter(self)\n|\n|  async aexit(self, *exc)\n|\n|  close(self)\n|      Stop serving.  This leaves existing connections open.\n|\n|  getloop(self)\n|      Get the event loop the Server object is attached to.\n|\n|  isserving(self)\n|      Return True if the server is accepting connections.\n|\n|  async serveforever(self)\n|      Start accepting connections until the coroutine is cancelled.\n|\n|      The server is closed when the coroutine is cancelled.\n|\n|  async startserving(self)\n|      Start accepting connections.\n|\n|      This method is idempotent, so it can be called when\n|      the server is already being serving.\n|\n|  async waitclosed(self)\n|      Coroutine to wait until service is closed.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors defined here:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class BaseEventLoop\n\n|  Method resolution order:\n|      BaseEventLoop\n|      asyncio.events.AbstractEventLoop\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  del(self, warn=<built-in function warn>)\n|\n|  init(self)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  callat(self, when, callback, *args, context=None)\n|      Like calllater(), but uses an absolute time.\n|\n|      Absolute time corresponds to the event loop's time() method.\n|\n|  callexceptionhandler(self, context)\n|      Call the current event loop's exception handler.\n|\n|      The context argument is a dict containing the following keys:\n|\n|      - 'message': Error message;\n|      - 'exception' (optional): Exception object;\n|      - 'future' (optional): Future instance;\n|      - 'task' (optional): Task instance;\n|      - 'handle' (optional): Handle instance;\n|      - 'protocol' (optional): Protocol instance;\n|      - 'transport' (optional): Transport instance;\n|      - 'socket' (optional): Socket instance;\n|      - 'asyncgen' (optional): Asynchronous generator that caused\n|                               the exception.\n|\n|      New keys maybe introduced in the future.\n|\n|      Note: do not overload this method in an event loop subclass.\n|      For custom exception handling, use the\n|      `setexceptionhandler()` method.\n|\n|  calllater(self, delay, callback, *args, context=None)\n|      Arrange for a callback to be called at a given time.\n|\n|      Return a Handle: an opaque object with a cancel() method that\n|      can be used to cancel the call.\n|\n|      The delay can be an int or float, expressed in seconds.  It is\n|      always relative to the current time.\n|\n|      Each callback will be called exactly once.  If two callbacks\n|      are scheduled for exactly the same time, it undefined which\n|      will be called first.\n|\n|      Any positional arguments after the callback will be passed to\n|      the callback when it is called.\n|\n|  callsoon(self, callback, *args, context=None)\n|      Arrange for a callback to be called as soon as possible.\n|\n|      This operates as a FIFO queue: callbacks are called in the\n|      order in which they are registered.  Each callback will be\n|      called exactly once.\n|\n|      Any positional arguments after the callback will be passed to\n|      the callback when it is called.\n|\n|  callsoonthreadsafe(self, callback, *args, context=None)\n|      Like callsoon(), but thread-safe.\n|\n|  close(self)\n|      Close the event loop.\n|\n|      This clears the queues and shuts down the executor,\n|      but does not wait for the executor to finish.\n|\n|      The event loop must not be running.\n|\n|  async connectacceptedsocket(self, protocolfactory, sock, *, ssl=None, sslhandshaketimeout=None)\n|      Handle an accepted connection.\n|\n|      This is used by servers that accept connections outside of\n|      asyncio, but use asyncio to handle connections.\n|\n|      This method is a coroutine.  When completed, the coroutine\n|      returns a (transport, protocol) pair.\n|\n|  async connectreadpipe(self, protocolfactory, pipe)\n|      Register read pipe in event loop. Set the pipe to non-blocking mode.\n|\n|      protocolfactory should instantiate object with Protocol interface.\n|      pipe is a file-like object.\n|      Return pair (transport, protocol), where transport supports the\n|      ReadTransport interface.\n|\n|  async connectwritepipe(self, protocolfactory, pipe)\n|      Register write pipe in event loop.\n|\n|      protocolfactory should instantiate object with BaseProtocol interface.\n|      Pipe is file-like object already switched to nonblocking.\n|      Return pair (transport, protocol), where transport support\n|      WriteTransport interface.\n|\n|  async createconnection(self, protocolfactory, host=None, port=None, *, ssl=None, family=0, proto=0, flags=0, sock=None, localaddr=None, serverhostname=None, sslhandshaketimeout=None, happyeyeballsdelay=None, interleave=None)\n|      Connect to a TCP server.\n|\n|      Create a streaming transport connection to a given internet host and\n|      port: socket family AFINET or socket.AFINET6 depending on host (or\n|      family if specified), socket type SOCKSTREAM. protocolfactory must be\n|      a callable returning a protocol instance.\n|\n|      This method is a coroutine which will try to establish the connection\n|      in the background.  When successful, the coroutine returns a\n|      (transport, protocol) pair.\n|\n|  async createdatagramendpoint(self, protocolfactory, localaddr=None, remoteaddr=None, *, family=0, proto=0, flags=0, reuseaddress=<object object at 0x7fcfe4facca0>, reuseport=None, allowbroadcast=None, sock=None)\n|      Create datagram connection.\n|\n|  createfuture(self)\n|      Create a Future object attached to the loop.\n|\n|  async createserver(self, protocolfactory, host=None, port=None, *, family=<AddressFamily.AFUNSPEC: 0>, flags=<AddressInfo.AIPASSIVE: 1>, sock=None, backlog=100, ssl=None, reuseaddress=None, reuseport=None, sslhandshaketimeout=None, startserving=True)\n|      Create a TCP server.\n|\n|      The host parameter can be a string, in that case the TCP server is\n|      bound to host and port.\n|\n|      The host parameter can also be a sequence of strings and in that case\n|      the TCP server is bound to all hosts of the sequence. If a host\n|      appears multiple times (possibly indirectly e.g. when hostnames\n|      resolve to the same IP address), the server is only bound once to that\n|      host.\n|\n|      Return a Server object which can be used to stop the service.\n|\n|      This method is a coroutine.\n|\n|  createtask(self, coro, *, name=None)\n|      Schedule a coroutine object.\n|\n|      Return a task object.\n|\n|  defaultexceptionhandler(self, context)\n|      Default exception handler.\n|\n|      This is called when an exception occurs and no exception\n|      handler is set, and can be called by a custom exception\n|      handler that wants to defer to the default behavior.\n|\n|      This default handler logs the error message and other\n|      context-dependent information.  In debug mode, a truncated\n|      stack trace is also appended showing where the given object\n|      (e.g. a handle or future or task) was created, if any.\n|\n|      The context parameter has the same meaning as in\n|      `callexceptionhandler()`.\n|\n|  getdebug(self)\n|\n|  getexceptionhandler(self)\n|      Return an exception handler, or None if the default one is in use.\n|\n|  gettaskfactory(self)\n|      Return a task factory, or None if the default one is in use.\n|\n|  async getaddrinfo(self, host, port, *, family=0, type=0, proto=0, flags=0)\n|\n|  async getnameinfo(self, sockaddr, flags=0)\n|\n|  isclosed(self)\n|      Returns True if the event loop was closed.\n|\n|  isrunning(self)\n|      Returns True if the event loop is running.\n|\n|  runforever(self)\n|      Run until stop() is called.\n|\n|  runinexecutor(self, executor, func, *args)\n|\n|  rununtilcomplete(self, future)\n|      Run until the Future is done.\n|\n|      If the argument is a coroutine, it is wrapped in a Task.\n|\n|      WARNING: It would be disastrous to call rununtilcomplete()\n|      with the same coroutine twice -- it would wrap it in two\n|      different Tasks and that can't be good.\n|\n|      Return the Future's result, or raise its exception.\n|\n|  async sendfile(self, transport, file, offset=0, count=None, *, fallback=True)\n|      Send a file to transport.\n|\n|      Return the total number of bytes which were sent.\n|\n|      The method uses high-performance os.sendfile if available.\n|\n|      file must be a regular file object opened in binary mode.\n|\n|      offset tells from where to start reading the file. If specified,\n|      count is the total number of bytes to transmit as opposed to\n|      sending the file until EOF is reached. File position is updated on\n|      return or also in case of error in which case file.tell()\n|      can be used to figure out the number of bytes\n|      which were sent.\n|\n|      fallback set to True makes asyncio to manually read and send\n|      the file when the platform does not support the sendfile syscall\n|      (e.g. Windows or SSL socket on Unix).\n|\n|      Raise SendfileNotAvailableError if the system does not support\n|      sendfile syscall and fallback is False.\n|\n|  setdebug(self, enabled)\n|\n|  setdefaultexecutor(self, executor)\n|\n|  setexceptionhandler(self, handler)\n|      Set handler as the new event loop exception handler.\n|\n|      If handler is None, the default exception handler will\n|      be set.\n|\n|      If handler is a callable object, it should have a\n|      signature matching '(loop, context)', where 'loop'\n|      will be a reference to the active event loop, 'context'\n|      will be a dict object (see `callexceptionhandler()`\n|      documentation for details about context).\n|\n|  settaskfactory(self, factory)\n|      Set a task factory that will be used by loop.createtask().\n|\n|      If factory is None the default task factory will be set.\n|\n|      If factory is a callable, it should have a signature matching\n|      '(loop, coro)', where 'loop' will be a reference to the active\n|      event loop, 'coro' will be a coroutine object.  The callable\n|      must return a Future.\n|\n|  async shutdownasyncgens(self)\n|      Shutdown all active asynchronous generators.\n|\n|  async shutdowndefaultexecutor(self)\n|      Schedule the shutdown of the default executor.\n|\n|  async socksendfile(self, sock, file, offset=0, count=None, *, fallback=True)\n|\n|  async starttls(self, transport, protocol, sslcontext, *, serverside=False, serverhostname=None, sslhandshaketimeout=None)\n|      Upgrade transport to TLS.\n|\n|      Return a new transport that *protocol* should start using\n|      immediately.\n|\n|  stop(self)\n|      Stop running the event loop.\n|\n|      Every callback already scheduled will still run.  This simply informs\n|      runforever to stop looping after a complete iteration.\n|\n|  async subprocessexec(self, protocolfactory, program, *args, stdin=-1, stdout=-1, stderr=-1, universalnewlines=False, shell=False, bufsize=0, encoding=None, errors=None, text=None, kwargs)\n|\n|  async subprocessshell(self, protocolfactory, cmd, *, stdin=-1, stdout=-1, stderr=-1, universalnewlines=False, shell=True, bufsize=0, encoding=None, errors=None, text=None, kwargs)\n|\n|  time(self)\n|      Return the time according to the event loop's clock.\n|\n|      This is a float expressed in seconds since an epoch, but the\n|      epoch, precision, accuracy and drift are unspecified and may\n|      differ per event loop.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from asyncio.events.AbstractEventLoop:\n|\n|  addreader(self, fd, callback, *args)\n|\n|  addsignalhandler(self, sig, callback, *args)\n|\n|  addwriter(self, fd, callback, *args)\n|\n|  async createunixconnection(self, protocolfactory, path=None, *, ssl=None, sock=None, serverhostname=None, sslhandshaketimeout=None)\n|\n|  async createunixserver(self, protocolfactory, path=None, *, sock=None, backlog=100, ssl=None, sslhandshaketimeout=None, startserving=True)\n|      A coroutine which creates a UNIX Domain Socket server.\n|\n|      The return value is a Server object, which can be used to stop\n|      the service.\n|\n|      path is a str, representing a file system path to bind the\n|      server socket to.\n|\n|      sock can optionally be specified in order to use a preexisting\n|      socket object.\n|\n|      backlog is the maximum number of queued connections passed to\n|      listen() (defaults to 100).\n|\n|      ssl can be set to an SSLContext to enable SSL over the\n|      accepted connections.\n|\n|      sslhandshaketimeout is the time in seconds that an SSL server\n|      will wait for the SSL handshake to complete (defaults to 60s).\n|\n|      startserving set to True (default) causes the created server\n|      to start accepting connections immediately.  When set to False,\n|      the user should await Server.startserving() or Server.serveforever()\n|      to make the server to start accepting connections.\n|\n|  removereader(self, fd)\n|\n|  removesignalhandler(self, sig)\n|\n|  removewriter(self, fd)\n|\n|  async sockaccept(self, sock)\n|\n|  async sockconnect(self, sock, address)\n|\n|  async sockrecv(self, sock, nbytes)\n|\n|  async sockrecvinto(self, sock, buf)\n|\n|  async socksendall(self, sock, data)\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from asyncio.events.AbstractEventLoop:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class BaseProtocol\n\n|  Common base class for protocol interfaces.\n|\n|  Usually user implements protocols that derived from BaseProtocol\n|  like Protocol or ProcessProtocol.\n|\n|  The only case when BaseProtocol should be implemented directly is\n|  write-only transport like write pipe\n|\n|  Methods defined here:\n|\n|  connectionlost(self, exc)\n|      Called when the connection is lost or closed.\n|\n|      The argument is an exception object or None (the latter\n|      meaning a regular EOF is received or the connection was\n|      aborted or closed).\n|\n|  connectionmade(self, transport)\n|      Called when a connection is made.\n|\n|      The argument is the transport representing the pipe connection.\n|      To receive data, wait for datareceived() calls.\n|      When the connection is closed, connectionlost() is called.\n|\n|  pausewriting(self)\n|      Called when the transport's buffer goes over the high-water mark.\n|\n|      Pause and resume calls are paired -- pausewriting() is called\n|      once when the buffer goes strictly over the high-water mark\n|      (even if subsequent writes increases the buffer size even\n|      more), and eventually resumewriting() is called once when the\n|      buffer size reaches the low-water mark.\n|\n|      Note that if the buffer size equals the high-water mark,\n|      pausewriting() is not called -- it must go strictly over.\n|      Conversely, resumewriting() is called when the buffer size is\n|      equal or lower than the low-water mark.  These end conditions\n|      are important to ensure that things go as expected when either\n|      mark is zero.\n|\n|      NOTE: This is the only Protocol callback that is not called\n|      through EventLoop.callsoon() -- if it were, it would have no\n|      effect when it's most needed (when the app keeps writing\n|      without yielding until pausewriting() is called).\n|\n|  resumewriting(self)\n|      Called when the transport's buffer drains below the low-water mark.\n|\n|      See pausewriting() for details.\n\n#### class BaseTransport\n\n|  BaseTransport(extra=None)\n|\n|  Base class for transports.\n|\n|  Methods defined here:\n|\n|  init(self, extra=None)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  close(self)\n|      Close the transport.\n|\n|      Buffered data will be flushed asynchronously.  No more data\n|      will be received.  After all buffered data is flushed, the\n|      protocol's connectionlost() method will (eventually) be\n|      called with None as its argument.\n|\n|  getextrainfo(self, name, default=None)\n|      Get optional transport information.\n|\n|  getprotocol(self)\n|      Return the current protocol.\n|\n|  isclosing(self)\n|      Return True if the transport is closing or closed.\n|\n|  setprotocol(self, protocol)\n|      Set a new protocol.\n\n#### class BoundedSemaphore\n\n|  BoundedSemaphore(value=1, *, loop=<object object at 0x7fcfe4facc70>)\n|\n|  A bounded semaphore implementation.\n|\n|  This raises ValueError in release() if it would increase the value\n|  above the initial value.\n|\n|  Method resolution order:\n|      BoundedSemaphore\n|      Semaphore\n|      ContextManagerMixin\n|      asyncio.mixins.LoopBoundMixin\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  init(self, value=1, *, loop=<object object at 0x7fcfe4facc70>)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  release(self)\n|      Release a semaphore, incrementing the internal counter by one.\n|\n|      When it was zero on entry and another coroutine is waiting for it to\n|      become larger than zero again, wake up that coroutine.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Semaphore:\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  async acquire(self)\n|      Acquire a semaphore.\n|\n|      If the internal counter is larger than zero on entry,\n|      decrement it by one and return True immediately.  If it is\n|      zero on entry, block, waiting until some other coroutine has\n|      called release() to make it larger than 0, and then return\n|      True.\n|\n|  locked(self)\n|      Returns True if semaphore cannot be acquired immediately.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from ContextManagerMixin:\n|\n|  async aenter(self)\n|\n|  async aexit(self, exctype, exc, tb)\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from ContextManagerMixin:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class BufferedProtocol\n\n|  Interface for stream protocol with manual buffer control.\n|\n|  Event methods, such as `createserver` and `createconnection`,\n|  accept factories that return protocols that implement this interface.\n|\n|  The idea of BufferedProtocol is that it allows to manually allocate\n|  and control the receive buffer.  Event loops can then use the buffer\n|  provided by the protocol to avoid unnecessary data copies.  This\n|  can result in noticeable performance improvement for protocols that\n|  receive big amounts of data.  Sophisticated protocols can allocate\n|  the buffer only once at creation time.\n|\n|  State machine of calls:\n|\n|    start -> CM [-> GB [-> BU?]]* [-> ER?] -> CL -> end\n|\n|  * CM: connectionmade()\n|  * GB: getbuffer()\n|  * BU: bufferupdated()\n|  * ER: eofreceived()\n|  * CL: connectionlost()\n|\n|  Method resolution order:\n|      BufferedProtocol\n|      BaseProtocol\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  bufferupdated(self, nbytes)\n|      Called when the buffer was updated with the received data.\n|\n|      *nbytes* is the total number of bytes that were written to\n|      the buffer.\n|\n|  eofreceived(self)\n|      Called when the other end calls writeeof() or equivalent.\n|\n|      If this returns a false value (including None), the transport\n|      will close itself.  If it returns a true value, closing the\n|      transport is up to the protocol.\n|\n|  getbuffer(self, sizehint)\n|      Called to allocate a new receive buffer.\n|\n|      *sizehint* is a recommended minimal size for the returned\n|      buffer.  When set to -1, the buffer size can be arbitrary.\n|\n|      Must return an object that implements the\n|      :ref:`buffer protocol <bufferobjects>`.\n|      It is an error to return a zero-sized buffer.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from BaseProtocol:\n|\n|  connectionlost(self, exc)\n|      Called when the connection is lost or closed.\n|\n|      The argument is an exception object or None (the latter\n|      meaning a regular EOF is received or the connection was\n|      aborted or closed).\n|\n|  connectionmade(self, transport)\n|      Called when a connection is made.\n|\n|      The argument is the transport representing the pipe connection.\n|      To receive data, wait for datareceived() calls.\n|      When the connection is closed, connectionlost() is called.\n|\n|  pausewriting(self)\n|      Called when the transport's buffer goes over the high-water mark.\n|\n|      Pause and resume calls are paired -- pausewriting() is called\n|      once when the buffer goes strictly over the high-water mark\n|      (even if subsequent writes increases the buffer size even\n|      more), and eventually resumewriting() is called once when the\n|      buffer size reaches the low-water mark.\n|\n|      Note that if the buffer size equals the high-water mark,\n|      pausewriting() is not called -- it must go strictly over.\n|      Conversely, resumewriting() is called when the buffer size is\n|      equal or lower than the low-water mark.  These end conditions\n|      are important to ensure that things go as expected when either\n|      mark is zero.\n|\n|      NOTE: This is the only Protocol callback that is not called\n|      through EventLoop.callsoon() -- if it were, it would have no\n|      effect when it's most needed (when the app keeps writing\n|      without yielding until pausewriting() is called).\n|\n|  resumewriting(self)\n|      Called when the transport's buffer drains below the low-water mark.\n|\n|      See pausewriting() for details.\n\n#### class CancelledError\n\n|  The Future or Task was cancelled.\n|\n|  Method resolution order:\n|      CancelledError\n|      builtins.BaseException\n|      builtins.object\n|\n|  Data descriptors defined here:\n|\n|  weakref\n|      list of weak references to the object (if defined)\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from builtins.BaseException:\n|\n|  delattr(self, name, /)\n|      Implement delattr(self, name).\n|\n|  getattribute(self, name, /)\n|      Return getattr(self, name).\n|\n|  init(self, /, *args, kwargs)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  reduce(...)\n|      Helper for pickle.\n|\n|  repr(self, /)\n|      Return repr(self).\n|\n|  setattr(self, name, value, /)\n|      Implement setattr(self, name, value).\n|\n|  setstate(...)\n|\n|  str(self, /)\n|      Return str(self).\n|\n|  withtraceback(...)\n|      Exception.withtraceback(tb) --\n|      set self.traceback to tb and return self.\n|\n|  ----------------------------------------------------------------------\n|  Static methods inherited from builtins.BaseException:\n|\n|  new(*args, kwargs) from builtins.type\n|      Create and return a new object.  See help(type) for accurate signature.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from builtins.BaseException:\n|\n|  cause\n|      exception cause\n|\n|  context\n|      exception context\n|\n|  dict\n|\n|  suppresscontext\n|\n|  traceback\n|\n|  args\n\n#### class Condition\n\n|  Condition(lock=None, *, loop=<object object at 0x7fcfe4facc70>)\n|\n|  Asynchronous equivalent to threading.Condition.\n|\n|  This class implements condition variable objects. A condition variable\n|  allows one or more coroutines to wait until they are notified by another\n|  coroutine.\n|\n|  A new Lock object is created and used as the underlying lock.\n|\n|  Method resolution order:\n|      Condition\n|      ContextManagerMixin\n|      asyncio.mixins.LoopBoundMixin\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  init(self, lock=None, *, loop=<object object at 0x7fcfe4facc70>)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  notify(self, n=1)\n|      By default, wake up one coroutine waiting on this condition, if any.\n|      If the calling coroutine has not acquired the lock when this method\n|      is called, a RuntimeError is raised.\n|\n|      This method wakes up at most n of the coroutines waiting for the\n|      condition variable; it is a no-op if no coroutines are waiting.\n|\n|      Note: an awakened coroutine does not actually return from its\n|      wait() call until it can reacquire the lock. Since notify() does\n|      not release the lock, its caller should.\n|\n|  notifyall(self)\n|      Wake up all threads waiting on this condition. This method acts\n|      like notify(), but wakes up all waiting threads instead of one. If the\n|      calling thread has not acquired the lock when this method is called,\n|      a RuntimeError is raised.\n|\n|  async wait(self)\n|      Wait until notified.\n|\n|      If the calling coroutine has not acquired the lock when this\n|      method is called, a RuntimeError is raised.\n|\n|      This method releases the underlying lock, and then blocks\n|      until it is awakened by a notify() or notifyall() call for\n|      the same condition variable in another coroutine.  Once\n|      awakened, it re-acquires the lock and returns True.\n|\n|  async waitfor(self, predicate)\n|      Wait until a predicate becomes true.\n|\n|      The predicate should be a callable which result will be\n|      interpreted as a boolean value.  The final predicate value is\n|      the return value.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from ContextManagerMixin:\n|\n|  async aenter(self)\n|\n|  async aexit(self, exctype, exc, tb)\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from ContextManagerMixin:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class DatagramProtocol\n\n|  Interface for datagram protocol.\n|\n|  Method resolution order:\n|      DatagramProtocol\n|      BaseProtocol\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  datagramreceived(self, data, addr)\n|      Called when some datagram is received.\n|\n|  errorreceived(self, exc)\n|      Called when a send or receive operation raises an OSError.\n|\n|      (Other than BlockingIOError or InterruptedError.)\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from BaseProtocol:\n|\n|  connectionlost(self, exc)\n|      Called when the connection is lost or closed.\n|\n|      The argument is an exception object or None (the latter\n|      meaning a regular EOF is received or the connection was\n|      aborted or closed).\n|\n|  connectionmade(self, transport)\n|      Called when a connection is made.\n|\n|      The argument is the transport representing the pipe connection.\n|      To receive data, wait for datareceived() calls.\n|      When the connection is closed, connectionlost() is called.\n|\n|  pausewriting(self)\n|      Called when the transport's buffer goes over the high-water mark.\n|\n|      Pause and resume calls are paired -- pausewriting() is called\n|      once when the buffer goes strictly over the high-water mark\n|      (even if subsequent writes increases the buffer size even\n|      more), and eventually resumewriting() is called once when the\n|      buffer size reaches the low-water mark.\n|\n|      Note that if the buffer size equals the high-water mark,\n|      pausewriting() is not called -- it must go strictly over.\n|      Conversely, resumewriting() is called when the buffer size is\n|      equal or lower than the low-water mark.  These end conditions\n|      are important to ensure that things go as expected when either\n|      mark is zero.\n|\n|      NOTE: This is the only Protocol callback that is not called\n|      through EventLoop.callsoon() -- if it were, it would have no\n|      effect when it's most needed (when the app keeps writing\n|      without yielding until pausewriting() is called).\n|\n|  resumewriting(self)\n|      Called when the transport's buffer drains below the low-water mark.\n|\n|      See pausewriting() for details.\n\n#### class DatagramTransport\n\n|  DatagramTransport(extra=None)\n|\n|  Interface for datagram (UDP) transports.\n|\n|  Method resolution order:\n|      DatagramTransport\n|      BaseTransport\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  abort(self)\n|      Close the transport immediately.\n|\n|      Buffered data will be lost.  No more data will be received.\n|      The protocol's connectionlost() method will (eventually) be\n|      called with None as its argument.\n|\n|  sendto(self, data, addr=None)\n|      Send data to the transport.\n|\n|      This does not block; it buffers the data and arranges for it\n|      to be sent out asynchronously.\n|      addr is target socket address.\n|      If addr is None use target address pointed on transport creation.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from BaseTransport:\n|\n|  init(self, extra=None)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  close(self)\n|      Close the transport.\n|\n|      Buffered data will be flushed asynchronously.  No more data\n|      will be received.  After all buffered data is flushed, the\n|      protocol's connectionlost() method will (eventually) be\n|      called with None as its argument.\n|\n|  getextrainfo(self, name, default=None)\n|      Get optional transport information.\n|\n|  getprotocol(self)\n|      Return the current protocol.\n|\n|  isclosing(self)\n|      Return True if the transport is closing or closed.\n|\n|  setprotocol(self, protocol)\n|      Set a new protocol.\n\nDefaultEventLoopPolicy = class UnixDefaultEventLoopPolicy(asyncio.events.BaseDefaultEventLoopPolicy)\n|  UNIX event loop policy with a watcher for child processes.\n|\n|  Method resolution order:\n|      UnixDefaultEventLoopPolicy\n|      asyncio.events.BaseDefaultEventLoopPolicy\n|      asyncio.events.AbstractEventLoopPolicy\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  init(self)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  getchildwatcher(self)\n|      Get the watcher for child processes.\n|\n|      If not yet set, a ThreadedChildWatcher object is automatically created.\n|\n|  setchildwatcher(self, watcher)\n|      Set the watcher for child processes.\n|\n|  seteventloop(self, loop)\n|      Set the event loop.\n|\n|      As a side effect, if a child watcher was set before, then calling\n|      .seteventloop() from the main thread will call .attachloop(loop) on\n|      the child watcher.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from asyncio.events.BaseDefaultEventLoopPolicy:\n|\n|  geteventloop(self)\n|      Get the event loop for the current context.\n|\n|      Returns an instance of EventLoop or raises an exception.\n|\n|  neweventloop(self)\n|      Create a new event loop.\n|\n|      You must call seteventloop() to make this the current event\n|      loop.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from asyncio.events.AbstractEventLoopPolicy:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class Event\n\n|  Event(*, loop=<object object at 0x7fcfe4facc70>)\n|\n|  Asynchronous equivalent to threading.Event.\n|\n|  Class implementing event objects. An event manages a flag that can be set\n|  to true with the set() method and reset to false with the clear() method.\n|  The wait() method blocks until the flag is true. The flag is initially\n|  false.\n|\n|  Method resolution order:\n|      Event\n|      asyncio.mixins.LoopBoundMixin\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  init(self, *, loop=<object object at 0x7fcfe4facc70>)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  clear(self)\n|      Reset the internal flag to false. Subsequently, coroutines calling\n|      wait() will block until set() is called to set the internal flag\n|      to true again.\n|\n|  isset(self)\n|      Return True if and only if the internal flag is true.\n|\n|  set(self)\n|      Set the internal flag to true. All coroutines waiting for it to\n|      become true are awakened. Coroutine that call wait() once the flag is\n|      true will not block at all.\n|\n|  async wait(self)\n|      Block until the internal flag is true.\n|\n|      If the internal flag is true on entry, return True\n|      immediately.  Otherwise, block until another coroutine calls\n|      set() to set the flag to true, then return True.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from asyncio.mixins.LoopBoundMixin:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class FastChildWatcher\n\n|  'Fast' child watcher implementation.\n|\n|  This implementation reaps every terminated processes by calling\n|  os.waitpid(-1) directly, possibly breaking other code spawning processes\n|  and waiting for their termination.\n|\n|  There is no noticeable overhead when handling a big number of children\n|  (O(1) each time a child terminates).\n|\n|  Method resolution order:\n|      FastChildWatcher\n|      BaseChildWatcher\n|      AbstractChildWatcher\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  enter(self)\n|      Enter the watcher's context and allow starting new processes\n|\n|      This function must return self\n|\n|  exit(self, a, b, c)\n|      Exit the watcher's context\n|\n|  init(self)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  addchildhandler(self, pid, callback, *args)\n|      Register a new child handler.\n|\n|      Arrange for callback(pid, returncode, *args) to be called when\n|      process 'pid' terminates. Specifying another callback for the same\n|      process replaces the previous handler.\n|\n|      Note: callback() must be thread-safe.\n|\n|  close(self)\n|      Close the watcher.\n|\n|      This must be called to make sure that any underlying resource is freed.\n|\n|  removechildhandler(self, pid)\n|      Removes the handler for process 'pid'.\n|\n|      The function returns True if the handler was successfully removed,\n|      False if there was nothing to remove.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from BaseChildWatcher:\n|\n|  attachloop(self, loop)\n|      Attach the watcher to an event loop.\n|\n|      If the watcher was previously attached to an event loop, then it is\n|      first detached before attaching to the new loop.\n|\n|      Note: loop may be None.\n|\n|  isactive(self)\n|      Return ``True`` if the watcher is active and is used by the event loop.\n|\n|      Return True if the watcher is installed and ready to handle process exit\n|      notifications.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from AbstractChildWatcher:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class Future\n\n|  Future(*, loop=None)\n|\n|  This class is *almost* compatible with concurrent.futures.Future.\n|\n|  Differences:\n|\n|  - result() and exception() do not take a timeout argument and\n|    raise an exception when the future isn't done yet.\n|\n|  - Callbacks registered with adddonecallback() are always called\n|    via the event loop's callsoonthreadsafe().\n|\n|  - This class is not compatible with the wait() and ascompleted()\n|    methods in the concurrent.futures package.\n|\n|  Methods defined here:\n|\n|  await(self, /)\n|      Return an iterator to be used in await expression.\n|\n|  del(...)\n|\n|  init(self, /, *args, kwargs)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  iter(self, /)\n|      Implement iter(self).\n|\n|  repr(self, /)\n|      Return repr(self).\n|\n|  adddonecallback(...)\n|      Add a callback to be run when the future becomes done.\n|\n|      The callback is called with a single argument - the future object. If\n|      the future is already done when this is called, the callback is\n|      scheduled with callsoon.\n|\n|  cancel(self, /, msg=None)\n|      Cancel the future and schedule callbacks.\n|\n|      If the future is already done or cancelled, return False.  Otherwise,\n|      change the future's state to cancelled, schedule the callbacks and\n|      return True.\n|\n|  cancelled(self, /)\n|      Return True if the future was cancelled.\n|\n|  done(self, /)\n|      Return True if the future is done.\n|\n|      Done means either that a result / exception are available, or that the\n|      future was cancelled.\n|\n|  exception(self, /)\n|      Return the exception that was set on this future.\n|\n|      The exception (or None if no exception was set) is returned only if\n|      the future is done.  If the future has been cancelled, raises\n|      CancelledError.  If the future isn't done yet, raises\n|      InvalidStateError.\n|\n|  getloop(self, /)\n|      Return the event loop the Future is bound to.\n|\n|  removedonecallback(self, fn, /)\n|      Remove all instances of a callback from the \"call when done\" list.\n|\n|      Returns the number of callbacks removed.\n|\n|  result(self, /)\n|      Return the result this future represents.\n|\n|      If the future has been cancelled, raises CancelledError.  If the\n|      future's result isn't yet available, raises InvalidStateError.  If\n|      the future is done and has an exception set, this exception is raised.\n|\n|  setexception(self, exception, /)\n|      Mark the future done and set an exception.\n|\n|      If the future is already done when this method is called, raises\n|      InvalidStateError.\n|\n|  setresult(self, result, /)\n|      Mark the future done and set its result.\n|\n|      If the future is already done when this method is called, raises\n|      InvalidStateError.\n|\n|  ----------------------------------------------------------------------\n|  Class methods defined here:\n|\n|  classgetitem(...) from builtins.type\n|      See PEP 585\n|\n|  ----------------------------------------------------------------------\n|  Static methods defined here:\n|\n|  new(*args, kwargs) from builtins.type\n|      Create and return a new object.  See help(type) for accurate signature.\n\n#### class Handle\n\n|  Handle(callback, args, loop, context=None)\n|\n|  Object returned by callback registration methods.\n|\n|  Methods defined here:\n|\n|  init(self, callback, args, loop, context=None)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  cancel(self)\n|\n|  cancelled(self)\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors defined here:\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class IncompleteReadError\n\n|  IncompleteReadError(partial, expected)\n|\n|  Incomplete read error. Attributes:\n|\n|  - partial: read bytes string before the end of stream was reached\n|  - expected: total number of expected bytes (or None if unknown)\n|\n|  Method resolution order:\n|      IncompleteReadError\n|      builtins.EOFError\n|      builtins.Exception\n|      builtins.BaseException\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  init(self, partial, expected)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  reduce(self)\n|      Helper for pickle.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors defined here:\n|\n|  weakref\n|      list of weak references to the object (if defined)\n|\n|  ----------------------------------------------------------------------\n|  Static methods inherited from builtins.EOFError:\n|\n|  new(*args, kwargs) from builtins.type\n|      Create and return a new object.  See help(type) for accurate signature.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from builtins.BaseException:\n|\n|  delattr(self, name, /)\n|      Implement delattr(self, name).\n|\n|  getattribute(self, name, /)\n|      Return getattr(self, name).\n|\n|  repr(self, /)\n|      Return repr(self).\n|\n|  setattr(self, name, value, /)\n|      Implement setattr(self, name, value).\n|\n|  setstate(...)\n|\n|  str(self, /)\n|      Return str(self).\n|\n|  withtraceback(...)\n|      Exception.withtraceback(tb) --\n|      set self.traceback to tb and return self.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from builtins.BaseException:\n|\n|  cause\n|      exception cause\n|\n|  context\n|      exception context\n|\n|  dict\n|\n|  suppresscontext\n|\n|  traceback\n|\n|  args\n\n#### class InvalidStateError\n\n|  The operation is not allowed in this state.\n|\n|  Method resolution order:\n|      InvalidStateError\n|      builtins.Exception\n|      builtins.BaseException\n|      builtins.object\n|\n|  Data descriptors defined here:\n|\n|  weakref\n|      list of weak references to the object (if defined)\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from builtins.Exception:\n|\n|  init(self, /, *args, kwargs)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  ----------------------------------------------------------------------\n|  Static methods inherited from builtins.Exception:\n|\n|  new(*args, kwargs) from builtins.type\n|      Create and return a new object.  See help(type) for accurate signature.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from builtins.BaseException:\n|\n|  delattr(self, name, /)\n|      Implement delattr(self, name).\n|\n|  getattribute(self, name, /)\n|      Return getattr(self, name).\n|\n|  reduce(...)\n|      Helper for pickle.\n|\n|  repr(self, /)\n|      Return repr(self).\n|\n|  setattr(self, name, value, /)\n|      Implement setattr(self, name, value).\n|\n|  setstate(...)\n|\n|  str(self, /)\n|      Return str(self).\n|\n|  withtraceback(...)\n|      Exception.withtraceback(tb) --\n|      set self.traceback to tb and return self.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from builtins.BaseException:\n|\n|  cause\n|      exception cause\n|\n|  context\n|      exception context\n|\n|  dict\n|\n|  suppresscontext\n|\n|  traceback\n|\n|  args\n\n#### class LifoQueue\n\n|  LifoQueue(maxsize=0, *, loop=<object object at 0x7fcfe4facc70>)\n|\n|  A subclass of Queue that retrieves most recently added entries first.\n|\n|  Method resolution order:\n|      LifoQueue\n|      Queue\n|      asyncio.mixins.LoopBoundMixin\n|      builtins.object\n|\n|  Methods inherited from Queue:\n|\n|  init(self, maxsize=0, *, loop=<object object at 0x7fcfe4facc70>)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  str(self)\n|      Return str(self).\n|\n|  empty(self)\n|      Return True if the queue is empty, False otherwise.\n|\n|  full(self)\n|      Return True if there are maxsize items in the queue.\n|\n|      Note: if the Queue was initialized with maxsize=0 (the default),\n|      then full() is never True.\n|\n|  async get(self)\n|      Remove and return an item from the queue.\n|\n|      If queue is empty, wait until an item is available.\n|\n|  getnowait(self)\n|      Remove and return an item from the queue.\n|\n|      Return an item if one is immediately available, else raise QueueEmpty.\n|\n|  async join(self)\n|      Block until all items in the queue have been gotten and processed.\n|\n|      The count of unfinished tasks goes up whenever an item is added to the\n|      queue. The count goes down whenever a consumer calls taskdone() to\n|      indicate that the item was retrieved and all work on it is complete.\n|      When the count of unfinished tasks drops to zero, join() unblocks.\n|\n|  async put(self, item)\n|      Put an item into the queue.\n|\n|      Put an item into the queue. If the queue is full, wait until a free\n|      slot is available before adding item.\n|\n|  putnowait(self, item)\n|      Put an item into the queue without blocking.\n|\n|      If no free slot is immediately available, raise QueueFull.\n|\n|  qsize(self)\n|      Number of items in the queue.\n|\n|  taskdone(self)\n|      Indicate that a formerly enqueued task is complete.\n|\n|      Used by queue consumers. For each get() used to fetch a task,\n|      a subsequent call to taskdone() tells the queue that the processing\n|      on the task is complete.\n|\n|      If a join() is currently blocking, it will resume when all items have\n|      been processed (meaning that a taskdone() call was received for every\n|      item that had been put() into the queue).\n|\n|      Raises ValueError if called more times than there were items placed in\n|      the queue.\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Queue:\n|\n|  classgetitem = GenericAlias(...) from builtins.type\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n|\n|  ----------------------------------------------------------------------\n|  Readonly properties inherited from Queue:\n|\n|  maxsize\n|      Number of items allowed in the queue.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from asyncio.mixins.LoopBoundMixin:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class LimitOverrunError\n\n|  LimitOverrunError(message, consumed)\n|\n|  Reached the buffer limit while looking for a separator.\n|\n|  Attributes:\n|  - consumed: total number of to be consumed bytes.\n|\n|  Method resolution order:\n|      LimitOverrunError\n|      builtins.Exception\n|      builtins.BaseException\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  init(self, message, consumed)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  reduce(self)\n|      Helper for pickle.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors defined here:\n|\n|  weakref\n|      list of weak references to the object (if defined)\n|\n|  ----------------------------------------------------------------------\n|  Static methods inherited from builtins.Exception:\n|\n|  new(*args, kwargs) from builtins.type\n|      Create and return a new object.  See help(type) for accurate signature.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from builtins.BaseException:\n|\n|  delattr(self, name, /)\n|      Implement delattr(self, name).\n|\n|  getattribute(self, name, /)\n|      Return getattr(self, name).\n|\n|  repr(self, /)\n|      Return repr(self).\n|\n|  setattr(self, name, value, /)\n|      Implement setattr(self, name, value).\n|\n|  setstate(...)\n|\n|  str(self, /)\n|      Return str(self).\n|\n|  withtraceback(...)\n|      Exception.withtraceback(tb) --\n|      set self.traceback to tb and return self.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from builtins.BaseException:\n|\n|  cause\n|      exception cause\n|\n|  context\n|      exception context\n|\n|  dict\n|\n|  suppresscontext\n|\n|  traceback\n|\n|  args\n\n#### class Lock\n\n|  Lock(*, loop=<object object at 0x7fcfe4facc70>)\n|\n|  Primitive lock objects.\n|\n|  A primitive lock is a synchronization primitive that is not owned\n|  by a particular coroutine when locked.  A primitive lock is in one\n|  of two states, 'locked' or 'unlocked'.\n|\n|  It is created in the unlocked state.  It has two basic methods,\n|  acquire() and release().  When the state is unlocked, acquire()\n|  changes the state to locked and returns immediately.  When the\n|  state is locked, acquire() blocks until a call to release() in\n|  another coroutine changes it to unlocked, then the acquire() call\n|  resets it to locked and returns.  The release() method should only\n|  be called in the locked state; it changes the state to unlocked\n|  and returns immediately.  If an attempt is made to release an\n|  unlocked lock, a RuntimeError will be raised.\n|\n|  When more than one coroutine is blocked in acquire() waiting for\n|  the state to turn to unlocked, only one coroutine proceeds when a\n|  release() call resets the state to unlocked; first coroutine which\n|  is blocked in acquire() is being processed.\n|\n|  acquire() is a coroutine and should be called with 'await'.\n|\n|  Locks also support the asynchronous context management protocol.\n|  'async with lock' statement should be used.\n|\n|  Usage:\n|\n|      lock = Lock()\n|      ...\n|      await lock.acquire()\n|      try:\n|          ...\n|      finally:\n|          lock.release()\n|\n|  Context manager usage:\n|\n|      lock = Lock()\n|      ...\n|      async with lock:\n|           ...\n|\n|  Lock objects can be tested for locking state:\n|\n|      if not lock.locked():\n|         await lock.acquire()\n|      else:\n|         # lock is acquired\n|         ...\n|\n|  Method resolution order:\n|      Lock\n|      ContextManagerMixin\n|      asyncio.mixins.LoopBoundMixin\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  init(self, *, loop=<object object at 0x7fcfe4facc70>)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  async acquire(self)\n|      Acquire a lock.\n|\n|      This method blocks until the lock is unlocked, then sets it to\n|      locked and returns True.\n|\n|  locked(self)\n|      Return True if lock is acquired.\n|\n|  release(self)\n|      Release a lock.\n|\n|      When the lock is locked, reset it to unlocked, and return.\n|      If any other coroutines are blocked waiting for the lock to become\n|      unlocked, allow exactly one of them to proceed.\n|\n|      When invoked on an unlocked lock, a RuntimeError is raised.\n|\n|      There is no return value.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from ContextManagerMixin:\n|\n|  async aenter(self)\n|\n|  async aexit(self, exctype, exc, tb)\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from ContextManagerMixin:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class MultiLoopChildWatcher\n\n|  A watcher that doesn't require running loop in the main thread.\n|\n|  This implementation registers a SIGCHLD signal handler on\n|  instantiation (which may conflict with other code that\n|  install own handler for this signal).\n|\n|  The solution is safe but it has a significant overhead when\n|  handling a big number of processes (*O(n)* each time a\n|  SIGCHLD is received).\n|\n|  Method resolution order:\n|      MultiLoopChildWatcher\n|      AbstractChildWatcher\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  enter(self)\n|      Enter the watcher's context and allow starting new processes\n|\n|      This function must return self\n|\n|  exit(self, exctype, excval, exctb)\n|      Exit the watcher's context\n|\n|  init(self)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  addchildhandler(self, pid, callback, *args)\n|      Register a new child handler.\n|\n|      Arrange for callback(pid, returncode, *args) to be called when\n|      process 'pid' terminates. Specifying another callback for the same\n|      process replaces the previous handler.\n|\n|      Note: callback() must be thread-safe.\n|\n|  attachloop(self, loop)\n|      Attach the watcher to an event loop.\n|\n|      If the watcher was previously attached to an event loop, then it is\n|      first detached before attaching to the new loop.\n|\n|      Note: loop may be None.\n|\n|  close(self)\n|      Close the watcher.\n|\n|      This must be called to make sure that any underlying resource is freed.\n|\n|  isactive(self)\n|      Return ``True`` if the watcher is active and is used by the event loop.\n|\n|      Return True if the watcher is installed and ready to handle process exit\n|      notifications.\n|\n|  removechildhandler(self, pid)\n|      Removes the handler for process 'pid'.\n|\n|      The function returns True if the handler was successfully removed,\n|      False if there was nothing to remove.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from AbstractChildWatcher:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class PidfdChildWatcher\n\n|  Child watcher implementation using Linux's pid file descriptors.\n|\n|  This child watcher polls process file descriptors (pidfds) to await child\n|  process termination. In some respects, PidfdChildWatcher is a \"Goldilocks\"\n|  child watcher implementation. It doesn't require signals or threads, doesn't\n|  interfere with any processes launched outside the event loop, and scales\n|  linearly with the number of subprocesses launched by the event loop. The\n|  main disadvantage is that pidfds are specific to Linux, and only work on\n|  recent (5.3+) kernels.\n|\n|  Method resolution order:\n|      PidfdChildWatcher\n|      AbstractChildWatcher\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  enter(self)\n|      Enter the watcher's context and allow starting new processes\n|\n|      This function must return self\n|\n|  exit(self, exctype, excvalue, exctraceback)\n|      Exit the watcher's context\n|\n|  init(self)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  addchildhandler(self, pid, callback, *args)\n|      Register a new child handler.\n|\n|      Arrange for callback(pid, returncode, *args) to be called when\n|      process 'pid' terminates. Specifying another callback for the same\n|      process replaces the previous handler.\n|\n|      Note: callback() must be thread-safe.\n|\n|  attachloop(self, loop)\n|      Attach the watcher to an event loop.\n|\n|      If the watcher was previously attached to an event loop, then it is\n|      first detached before attaching to the new loop.\n|\n|      Note: loop may be None.\n|\n|  close(self)\n|      Close the watcher.\n|\n|      This must be called to make sure that any underlying resource is freed.\n|\n|  isactive(self)\n|      Return ``True`` if the watcher is active and is used by the event loop.\n|\n|      Return True if the watcher is installed and ready to handle process exit\n|      notifications.\n|\n|  removechildhandler(self, pid)\n|      Removes the handler for process 'pid'.\n|\n|      The function returns True if the handler was successfully removed,\n|      False if there was nothing to remove.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from AbstractChildWatcher:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class PriorityQueue\n\n|  PriorityQueue(maxsize=0, *, loop=<object object at 0x7fcfe4facc70>)\n|\n|  A subclass of Queue; retrieves entries in priority order (lowest first).\n|\n|  Entries are typically tuples of the form: (priority number, data).\n|\n|  Method resolution order:\n|      PriorityQueue\n|      Queue\n|      asyncio.mixins.LoopBoundMixin\n|      builtins.object\n|\n|  Methods inherited from Queue:\n|\n|  init(self, maxsize=0, *, loop=<object object at 0x7fcfe4facc70>)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  str(self)\n|      Return str(self).\n|\n|  empty(self)\n|      Return True if the queue is empty, False otherwise.\n|\n|  full(self)\n|      Return True if there are maxsize items in the queue.\n|\n|      Note: if the Queue was initialized with maxsize=0 (the default),\n|      then full() is never True.\n|\n|  async get(self)\n|      Remove and return an item from the queue.\n|\n|      If queue is empty, wait until an item is available.\n|\n|  getnowait(self)\n|      Remove and return an item from the queue.\n|\n|      Return an item if one is immediately available, else raise QueueEmpty.\n|\n|  async join(self)\n|      Block until all items in the queue have been gotten and processed.\n|\n|      The count of unfinished tasks goes up whenever an item is added to the\n|      queue. The count goes down whenever a consumer calls taskdone() to\n|      indicate that the item was retrieved and all work on it is complete.\n|      When the count of unfinished tasks drops to zero, join() unblocks.\n|\n|  async put(self, item)\n|      Put an item into the queue.\n|\n|      Put an item into the queue. If the queue is full, wait until a free\n|      slot is available before adding item.\n|\n|  putnowait(self, item)\n|      Put an item into the queue without blocking.\n|\n|      If no free slot is immediately available, raise QueueFull.\n|\n|  qsize(self)\n|      Number of items in the queue.\n|\n|  taskdone(self)\n|      Indicate that a formerly enqueued task is complete.\n|\n|      Used by queue consumers. For each get() used to fetch a task,\n|      a subsequent call to taskdone() tells the queue that the processing\n|      on the task is complete.\n|\n|      If a join() is currently blocking, it will resume when all items have\n|      been processed (meaning that a taskdone() call was received for every\n|      item that had been put() into the queue).\n|\n|      Raises ValueError if called more times than there were items placed in\n|      the queue.\n|\n|  ----------------------------------------------------------------------\n|  Class methods inherited from Queue:\n|\n|  classgetitem = GenericAlias(...) from builtins.type\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n|\n|  ----------------------------------------------------------------------\n|  Readonly properties inherited from Queue:\n|\n|  maxsize\n|      Number of items allowed in the queue.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from asyncio.mixins.LoopBoundMixin:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class Protocol\n\n|  Interface for stream protocol.\n|\n|  The user should implement this interface.  They can inherit from\n|  this class but don't need to.  The implementations here do\n|  nothing (they don't raise exceptions).\n|\n|  When the user wants to requests a transport, they pass a protocol\n|  factory to a utility function (e.g., EventLoop.createconnection()).\n|\n|  When the connection is made successfully, connectionmade() is\n|  called with a suitable transport object.  Then datareceived()\n|  will be called 0 or more times with data (bytes) received from the\n|  transport; finally, connectionlost() will be called exactly once\n|  with either an exception object or None as an argument.\n|\n|  State machine of calls:\n|\n|    start -> CM [-> DR*] [-> ER?] -> CL -> end\n|\n|  * CM: connectionmade()\n|  * DR: datareceived()\n|  * ER: eofreceived()\n|  * CL: connectionlost()\n|\n|  Method resolution order:\n|      Protocol\n|      BaseProtocol\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  datareceived(self, data)\n|      Called when some data is received.\n|\n|      The argument is a bytes object.\n|\n|  eofreceived(self)\n|      Called when the other end calls writeeof() or equivalent.\n|\n|      If this returns a false value (including None), the transport\n|      will close itself.  If it returns a true value, closing the\n|      transport is up to the protocol.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from BaseProtocol:\n|\n|  connectionlost(self, exc)\n|      Called when the connection is lost or closed.\n|\n|      The argument is an exception object or None (the latter\n|      meaning a regular EOF is received or the connection was\n|      aborted or closed).\n|\n|  connectionmade(self, transport)\n|      Called when a connection is made.\n|\n|      The argument is the transport representing the pipe connection.\n|      To receive data, wait for datareceived() calls.\n|      When the connection is closed, connectionlost() is called.\n|\n|  pausewriting(self)\n|      Called when the transport's buffer goes over the high-water mark.\n|\n|      Pause and resume calls are paired -- pausewriting() is called\n|      once when the buffer goes strictly over the high-water mark\n|      (even if subsequent writes increases the buffer size even\n|      more), and eventually resumewriting() is called once when the\n|      buffer size reaches the low-water mark.\n|\n|      Note that if the buffer size equals the high-water mark,\n|      pausewriting() is not called -- it must go strictly over.\n|      Conversely, resumewriting() is called when the buffer size is\n|      equal or lower than the low-water mark.  These end conditions\n|      are important to ensure that things go as expected when either\n|      mark is zero.\n|\n|      NOTE: This is the only Protocol callback that is not called\n|      through EventLoop.callsoon() -- if it were, it would have no\n|      effect when it's most needed (when the app keeps writing\n|      without yielding until pausewriting() is called).\n|\n|  resumewriting(self)\n|      Called when the transport's buffer drains below the low-water mark.\n|\n|      See pausewriting() for details.\n\n#### class Queue\n\n|  Queue(maxsize=0, *, loop=<object object at 0x7fcfe4facc70>)\n|\n|  A queue, useful for coordinating producer and consumer coroutines.\n|\n|  If maxsize is less than or equal to zero, the queue size is infinite. If it\n|  is an integer greater than 0, then \"await put()\" will block when the\n|  queue reaches maxsize, until an item is removed by get().\n|\n|  Unlike the standard library Queue, you can reliably know this Queue's size\n|  with qsize(), since your single-threaded asyncio application won't be\n|  interrupted between calling qsize() and doing an operation on the Queue.\n|\n|  Method resolution order:\n|      Queue\n|      asyncio.mixins.LoopBoundMixin\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  init(self, maxsize=0, *, loop=<object object at 0x7fcfe4facc70>)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  str(self)\n|      Return str(self).\n|\n|  empty(self)\n|      Return True if the queue is empty, False otherwise.\n|\n|  full(self)\n|      Return True if there are maxsize items in the queue.\n|\n|      Note: if the Queue was initialized with maxsize=0 (the default),\n|      then full() is never True.\n|\n|  async get(self)\n|      Remove and return an item from the queue.\n|\n|      If queue is empty, wait until an item is available.\n|\n|  getnowait(self)\n|      Remove and return an item from the queue.\n|\n|      Return an item if one is immediately available, else raise QueueEmpty.\n|\n|  async join(self)\n|      Block until all items in the queue have been gotten and processed.\n|\n|      The count of unfinished tasks goes up whenever an item is added to the\n|      queue. The count goes down whenever a consumer calls taskdone() to\n|      indicate that the item was retrieved and all work on it is complete.\n|      When the count of unfinished tasks drops to zero, join() unblocks.\n|\n|  async put(self, item)\n|      Put an item into the queue.\n|\n|      Put an item into the queue. If the queue is full, wait until a free\n|      slot is available before adding item.\n|\n|  putnowait(self, item)\n|      Put an item into the queue without blocking.\n|\n|      If no free slot is immediately available, raise QueueFull.\n|\n|  qsize(self)\n|      Number of items in the queue.\n|\n|  taskdone(self)\n|      Indicate that a formerly enqueued task is complete.\n|\n|      Used by queue consumers. For each get() used to fetch a task,\n|      a subsequent call to taskdone() tells the queue that the processing\n|      on the task is complete.\n|\n|      If a join() is currently blocking, it will resume when all items have\n|      been processed (meaning that a taskdone() call was received for every\n|      item that had been put() into the queue).\n|\n|      Raises ValueError if called more times than there were items placed in\n|      the queue.\n|\n|  ----------------------------------------------------------------------\n|  Class methods defined here:\n|\n|  classgetitem = GenericAlias(...) from builtins.type\n|      Represent a PEP 585 generic type\n|\n|      E.g. for t = list[int], t.origin is list and t.args is (int,).\n|\n|  ----------------------------------------------------------------------\n|  Readonly properties defined here:\n|\n|  maxsize\n|      Number of items allowed in the queue.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from asyncio.mixins.LoopBoundMixin:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class QueueEmpty\n\n|  Raised when Queue.getnowait() is called on an empty Queue.\n|\n|  Method resolution order:\n|      QueueEmpty\n|      builtins.Exception\n|      builtins.BaseException\n|      builtins.object\n|\n|  Data descriptors defined here:\n|\n|  weakref\n|      list of weak references to the object (if defined)\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from builtins.Exception:\n|\n|  init(self, /, *args, kwargs)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  ----------------------------------------------------------------------\n|  Static methods inherited from builtins.Exception:\n|\n|  new(*args, kwargs) from builtins.type\n|      Create and return a new object.  See help(type) for accurate signature.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from builtins.BaseException:\n|\n|  delattr(self, name, /)\n|      Implement delattr(self, name).\n|\n|  getattribute(self, name, /)\n|      Return getattr(self, name).\n|\n|  reduce(...)\n|      Helper for pickle.\n|\n|  repr(self, /)\n|      Return repr(self).\n|\n|  setattr(self, name, value, /)\n|      Implement setattr(self, name, value).\n|\n|  setstate(...)\n|\n|  str(self, /)\n|      Return str(self).\n|\n|  withtraceback(...)\n|      Exception.withtraceback(tb) --\n|      set self.traceback to tb and return self.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from builtins.BaseException:\n|\n|  cause\n|      exception cause\n|\n|  context\n|      exception context\n|\n|  dict\n|\n|  suppresscontext\n|\n|  traceback\n|\n|  args\n\n#### class QueueFull\n\n|  Raised when the Queue.putnowait() method is called on a full Queue.\n|\n|  Method resolution order:\n|      QueueFull\n|      builtins.Exception\n|      builtins.BaseException\n|      builtins.object\n|\n|  Data descriptors defined here:\n|\n|  weakref\n|      list of weak references to the object (if defined)\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from builtins.Exception:\n|\n|  init(self, /, *args, kwargs)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  ----------------------------------------------------------------------\n|  Static methods inherited from builtins.Exception:\n|\n|  new(*args, kwargs) from builtins.type\n|      Create and return a new object.  See help(type) for accurate signature.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from builtins.BaseException:\n|\n|  delattr(self, name, /)\n|      Implement delattr(self, name).\n|\n|  getattribute(self, name, /)\n|      Return getattr(self, name).\n|\n|  reduce(...)\n|      Helper for pickle.\n|\n|  repr(self, /)\n|      Return repr(self).\n|\n|  setattr(self, name, value, /)\n|      Implement setattr(self, name, value).\n|\n|  setstate(...)\n|\n|  str(self, /)\n|      Return str(self).\n|\n|  withtraceback(...)\n|      Exception.withtraceback(tb) --\n|      set self.traceback to tb and return self.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from builtins.BaseException:\n|\n|  cause\n|      exception cause\n|\n|  context\n|      exception context\n|\n|  dict\n|\n|  suppresscontext\n|\n|  traceback\n|\n|  args\n\n#### class ReadTransport\n\n|  ReadTransport(extra=None)\n|\n|  Interface for read-only transports.\n|\n|  Method resolution order:\n|      ReadTransport\n|      BaseTransport\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  isreading(self)\n|      Return True if the transport is receiving.\n|\n|  pausereading(self)\n|      Pause the receiving end.\n|\n|      No data will be passed to the protocol's datareceived()\n|      method until resumereading() is called.\n|\n|  resumereading(self)\n|      Resume the receiving end.\n|\n|      Data received will once again be passed to the protocol's\n|      datareceived() method.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from BaseTransport:\n|\n|  init(self, extra=None)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  close(self)\n|      Close the transport.\n|\n|      Buffered data will be flushed asynchronously.  No more data\n|      will be received.  After all buffered data is flushed, the\n|      protocol's connectionlost() method will (eventually) be\n|      called with None as its argument.\n|\n|  getextrainfo(self, name, default=None)\n|      Get optional transport information.\n|\n|  getprotocol(self)\n|      Return the current protocol.\n|\n|  isclosing(self)\n|      Return True if the transport is closing or closed.\n|\n|  setprotocol(self, protocol)\n|      Set a new protocol.\n\n#### class SafeChildWatcher\n\n|  'Safe' child watcher implementation.\n|\n|  This implementation avoids disrupting other code spawning processes by\n|  polling explicitly each process in the SIGCHLD handler instead of calling\n|  os.waitpid(-1).\n|\n|  This is a safe solution but it has a significant overhead when handling a\n|  big number of children (O(n) each time SIGCHLD is raised)\n|\n|  Method resolution order:\n|      SafeChildWatcher\n|      BaseChildWatcher\n|      AbstractChildWatcher\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  enter(self)\n|      Enter the watcher's context and allow starting new processes\n|\n|      This function must return self\n|\n|  exit(self, a, b, c)\n|      Exit the watcher's context\n|\n|  addchildhandler(self, pid, callback, *args)\n|      Register a new child handler.\n|\n|      Arrange for callback(pid, returncode, *args) to be called when\n|      process 'pid' terminates. Specifying another callback for the same\n|      process replaces the previous handler.\n|\n|      Note: callback() must be thread-safe.\n|\n|  close(self)\n|      Close the watcher.\n|\n|      This must be called to make sure that any underlying resource is freed.\n|\n|  removechildhandler(self, pid)\n|      Removes the handler for process 'pid'.\n|\n|      The function returns True if the handler was successfully removed,\n|      False if there was nothing to remove.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from BaseChildWatcher:\n|\n|  init(self)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  attachloop(self, loop)\n|      Attach the watcher to an event loop.\n|\n|      If the watcher was previously attached to an event loop, then it is\n|      first detached before attaching to the new loop.\n|\n|      Note: loop may be None.\n|\n|  isactive(self)\n|      Return ``True`` if the watcher is active and is used by the event loop.\n|\n|      Return True if the watcher is installed and ready to handle process exit\n|      notifications.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from AbstractChildWatcher:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\nSelectorEventLoop = class UnixSelectorEventLoop(asyncio.selectorevents.BaseSelectorEventLoop)\n|  SelectorEventLoop(selector=None)\n|\n|  Unix event loop.\n|\n|  Adds signal handling and UNIX Domain Socket support to SelectorEventLoop.\n|\n|  Method resolution order:\n|      UnixSelectorEventLoop\n|      asyncio.selectorevents.BaseSelectorEventLoop\n|      asyncio.baseevents.BaseEventLoop\n|      asyncio.events.AbstractEventLoop\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  init(self, selector=None)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  addsignalhandler(self, sig, callback, *args)\n|      Add a handler for a signal.  UNIX only.\n|\n|      Raise ValueError if the signal number is invalid or uncatchable.\n|      Raise RuntimeError if there is a problem setting up the handler.\n|\n|  close(self)\n|      Close the event loop.\n|\n|      This clears the queues and shuts down the executor,\n|      but does not wait for the executor to finish.\n|\n|      The event loop must not be running.\n|\n|  async createunixconnection(self, protocolfactory, path=None, *, ssl=None, sock=None, serverhostname=None, sslhandshaketimeout=None)\n|\n|  async createunixserver(self, protocolfactory, path=None, *, sock=None, backlog=100, ssl=None, sslhandshaketimeout=None, startserving=True)\n|      A coroutine which creates a UNIX Domain Socket server.\n|\n|      The return value is a Server object, which can be used to stop\n|      the service.\n|\n|      path is a str, representing a file system path to bind the\n|      server socket to.\n|\n|      sock can optionally be specified in order to use a preexisting\n|      socket object.\n|\n|      backlog is the maximum number of queued connections passed to\n|      listen() (defaults to 100).\n|\n|      ssl can be set to an SSLContext to enable SSL over the\n|      accepted connections.\n|\n|      sslhandshaketimeout is the time in seconds that an SSL server\n|      will wait for the SSL handshake to complete (defaults to 60s).\n|\n|      startserving set to True (default) causes the created server\n|      to start accepting connections immediately.  When set to False,\n|      the user should await Server.startserving() or Server.serveforever()\n|      to make the server to start accepting connections.\n|\n|  removesignalhandler(self, sig)\n|      Remove a handler for a signal.  UNIX only.\n|\n|      Return True if a signal handler was removed, False if not.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from asyncio.selectorevents.BaseSelectorEventLoop:\n|\n|  addreader(self, fd, callback, *args)\n|      Add a reader callback.\n|\n|  addwriter(self, fd, callback, *args)\n|      Add a writer callback..\n|\n|  removereader(self, fd)\n|      Remove a reader callback.\n|\n|  removewriter(self, fd)\n|      Remove a writer callback.\n|\n|  async sockaccept(self, sock)\n|      Accept a connection.\n|\n|      The socket must be bound to an address and listening for connections.\n|      The return value is a pair (conn, address) where conn is a new socket\n|      object usable to send and receive data on the connection, and address\n|      is the address bound to the socket on the other end of the connection.\n|\n|  async sockconnect(self, sock, address)\n|      Connect to a remote socket at address.\n|\n|      This method is a coroutine.\n|\n|  async sockrecv(self, sock, n)\n|      Receive data from the socket.\n|\n|      The return value is a bytes object representing the data received.\n|      The maximum amount of data to be received at once is specified by\n|      nbytes.\n|\n|  async sockrecvinto(self, sock, buf)\n|      Receive data from the socket.\n|\n|      The received data is written into *buf* (a writable buffer).\n|      The return value is the number of bytes written.\n|\n|  async socksendall(self, sock, data)\n|      Send data to the socket.\n|\n|      The socket must be connected to a remote socket. This method continues\n|      to send data from data until either all data has been sent or an\n|      error occurs. None is returned on success. On error, an exception is\n|      raised, and there is no way to determine how much data, if any, was\n|      successfully processed by the receiving end of the connection.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from asyncio.baseevents.BaseEventLoop:\n|\n|  del(self, warn=<built-in function warn>)\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  callat(self, when, callback, *args, context=None)\n|      Like calllater(), but uses an absolute time.\n|\n|      Absolute time corresponds to the event loop's time() method.\n|\n|  callexceptionhandler(self, context)\n|      Call the current event loop's exception handler.\n|\n|      The context argument is a dict containing the following keys:\n|\n|      - 'message': Error message;\n|      - 'exception' (optional): Exception object;\n|      - 'future' (optional): Future instance;\n|      - 'task' (optional): Task instance;\n|      - 'handle' (optional): Handle instance;\n|      - 'protocol' (optional): Protocol instance;\n|      - 'transport' (optional): Transport instance;\n|      - 'socket' (optional): Socket instance;\n|      - 'asyncgen' (optional): Asynchronous generator that caused\n|                               the exception.\n|\n|      New keys maybe introduced in the future.\n|\n|      Note: do not overload this method in an event loop subclass.\n|      For custom exception handling, use the\n|      `setexceptionhandler()` method.\n|\n|  calllater(self, delay, callback, *args, context=None)\n|      Arrange for a callback to be called at a given time.\n|\n|      Return a Handle: an opaque object with a cancel() method that\n|      can be used to cancel the call.\n|\n|      The delay can be an int or float, expressed in seconds.  It is\n|      always relative to the current time.\n|\n|      Each callback will be called exactly once.  If two callbacks\n|      are scheduled for exactly the same time, it undefined which\n|      will be called first.\n|\n|      Any positional arguments after the callback will be passed to\n|      the callback when it is called.\n|\n|  callsoon(self, callback, *args, context=None)\n|      Arrange for a callback to be called as soon as possible.\n|\n|      This operates as a FIFO queue: callbacks are called in the\n|      order in which they are registered.  Each callback will be\n|      called exactly once.\n|\n|      Any positional arguments after the callback will be passed to\n|      the callback when it is called.\n|\n|  callsoonthreadsafe(self, callback, *args, context=None)\n|      Like callsoon(), but thread-safe.\n|\n|  async connectacceptedsocket(self, protocolfactory, sock, *, ssl=None, sslhandshaketimeout=None)\n|      Handle an accepted connection.\n|\n|      This is used by servers that accept connections outside of\n|      asyncio, but use asyncio to handle connections.\n|\n|      This method is a coroutine.  When completed, the coroutine\n|      returns a (transport, protocol) pair.\n|\n|  async connectreadpipe(self, protocolfactory, pipe)\n|      Register read pipe in event loop. Set the pipe to non-blocking mode.\n|\n|      protocolfactory should instantiate object with Protocol interface.\n|      pipe is a file-like object.\n|      Return pair (transport, protocol), where transport supports the\n|      ReadTransport interface.\n|\n|  async connectwritepipe(self, protocolfactory, pipe)\n|      Register write pipe in event loop.\n|\n|      protocolfactory should instantiate object with BaseProtocol interface.\n|      Pipe is file-like object already switched to nonblocking.\n|      Return pair (transport, protocol), where transport support\n|      WriteTransport interface.\n|\n|  async createconnection(self, protocolfactory, host=None, port=None, *, ssl=None, family=0, proto=0, flags=0, sock=None, localaddr=None, serverhostname=None, sslhandshaketimeout=None, happyeyeballsdelay=None, interleave=None)\n|      Connect to a TCP server.\n|\n|      Create a streaming transport connection to a given internet host and\n|      port: socket family AFINET or socket.AFINET6 depending on host (or\n|      family if specified), socket type SOCKSTREAM. protocolfactory must be\n|      a callable returning a protocol instance.\n|\n|      This method is a coroutine which will try to establish the connection\n|      in the background.  When successful, the coroutine returns a\n|      (transport, protocol) pair.\n|\n|  async createdatagramendpoint(self, protocolfactory, localaddr=None, remoteaddr=None, *, family=0, proto=0, flags=0, reuseaddress=<object object at 0x7fcfe4facca0>, reuseport=None, allowbroadcast=None, sock=None)\n|      Create datagram connection.\n|\n|  createfuture(self)\n|      Create a Future object attached to the loop.\n|\n|  async createserver(self, protocolfactory, host=None, port=None, *, family=<AddressFamily.AFUNSPEC: 0>, flags=<AddressInfo.AIPASSIVE: 1>, sock=None, backlog=100, ssl=None, reuseaddress=None, reuseport=None, sslhandshaketimeout=None, startserving=True)\n|      Create a TCP server.\n|\n|      The host parameter can be a string, in that case the TCP server is\n|      bound to host and port.\n|\n|      The host parameter can also be a sequence of strings and in that case\n|      the TCP server is bound to all hosts of the sequence. If a host\n|      appears multiple times (possibly indirectly e.g. when hostnames\n|      resolve to the same IP address), the server is only bound once to that\n|      host.\n|\n|      Return a Server object which can be used to stop the service.\n|\n|      This method is a coroutine.\n|\n|  createtask(self, coro, *, name=None)\n|      Schedule a coroutine object.\n|\n|      Return a task object.\n|\n|  defaultexceptionhandler(self, context)\n|      Default exception handler.\n|\n|      This is called when an exception occurs and no exception\n|      handler is set, and can be called by a custom exception\n|      handler that wants to defer to the default behavior.\n|\n|      This default handler logs the error message and other\n|      context-dependent information.  In debug mode, a truncated\n|      stack trace is also appended showing where the given object\n|      (e.g. a handle or future or task) was created, if any.\n|\n|      The context parameter has the same meaning as in\n|      `callexceptionhandler()`.\n|\n|  getdebug(self)\n|\n|  getexceptionhandler(self)\n|      Return an exception handler, or None if the default one is in use.\n|\n|  gettaskfactory(self)\n|      Return a task factory, or None if the default one is in use.\n|\n|  async getaddrinfo(self, host, port, *, family=0, type=0, proto=0, flags=0)\n|\n|  async getnameinfo(self, sockaddr, flags=0)\n|\n|  isclosed(self)\n|      Returns True if the event loop was closed.\n|\n|  isrunning(self)\n|      Returns True if the event loop is running.\n|\n|  runforever(self)\n|      Run until stop() is called.\n|\n|  runinexecutor(self, executor, func, *args)\n|\n|  rununtilcomplete(self, future)\n|      Run until the Future is done.\n|\n|      If the argument is a coroutine, it is wrapped in a Task.\n|\n|      WARNING: It would be disastrous to call rununtilcomplete()\n|      with the same coroutine twice -- it would wrap it in two\n|      different Tasks and that can't be good.\n|\n|      Return the Future's result, or raise its exception.\n|\n|  async sendfile(self, transport, file, offset=0, count=None, *, fallback=True)\n|      Send a file to transport.\n|\n|      Return the total number of bytes which were sent.\n|\n|      The method uses high-performance os.sendfile if available.\n|\n|      file must be a regular file object opened in binary mode.\n|\n|      offset tells from where to start reading the file. If specified,\n|      count is the total number of bytes to transmit as opposed to\n|      sending the file until EOF is reached. File position is updated on\n|      return or also in case of error in which case file.tell()\n|      can be used to figure out the number of bytes\n|      which were sent.\n|\n|      fallback set to True makes asyncio to manually read and send\n|      the file when the platform does not support the sendfile syscall\n|      (e.g. Windows or SSL socket on Unix).\n|\n|      Raise SendfileNotAvailableError if the system does not support\n|      sendfile syscall and fallback is False.\n|\n|  setdebug(self, enabled)\n|\n|  setdefaultexecutor(self, executor)\n|\n|  setexceptionhandler(self, handler)\n|      Set handler as the new event loop exception handler.\n|\n|      If handler is None, the default exception handler will\n|      be set.\n|\n|      If handler is a callable object, it should have a\n|      signature matching '(loop, context)', where 'loop'\n|      will be a reference to the active event loop, 'context'\n|      will be a dict object (see `callexceptionhandler()`\n|      documentation for details about context).\n|\n|  settaskfactory(self, factory)\n|      Set a task factory that will be used by loop.createtask().\n|\n|      If factory is None the default task factory will be set.\n|\n|      If factory is a callable, it should have a signature matching\n|      '(loop, coro)', where 'loop' will be a reference to the active\n|      event loop, 'coro' will be a coroutine object.  The callable\n|      must return a Future.\n|\n|  async shutdownasyncgens(self)\n|      Shutdown all active asynchronous generators.\n|\n|  async shutdowndefaultexecutor(self)\n|      Schedule the shutdown of the default executor.\n|\n|  async socksendfile(self, sock, file, offset=0, count=None, *, fallback=True)\n|\n|  async starttls(self, transport, protocol, sslcontext, *, serverside=False, serverhostname=None, sslhandshaketimeout=None)\n|      Upgrade transport to TLS.\n|\n|      Return a new transport that *protocol* should start using\n|      immediately.\n|\n|  stop(self)\n|      Stop running the event loop.\n|\n|      Every callback already scheduled will still run.  This simply informs\n|      runforever to stop looping after a complete iteration.\n|\n|  async subprocessexec(self, protocolfactory, program, *args, stdin=-1, stdout=-1, stderr=-1, universalnewlines=False, shell=False, bufsize=0, encoding=None, errors=None, text=None, kwargs)\n|\n|  async subprocessshell(self, protocolfactory, cmd, *, stdin=-1, stdout=-1, stderr=-1, universalnewlines=False, shell=True, bufsize=0, encoding=None, errors=None, text=None, kwargs)\n|\n|  time(self)\n|      Return the time according to the event loop's clock.\n|\n|      This is a float expressed in seconds since an epoch, but the\n|      epoch, precision, accuracy and drift are unspecified and may\n|      differ per event loop.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from asyncio.events.AbstractEventLoop:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class Semaphore\n\n|  Semaphore(value=1, *, loop=<object object at 0x7fcfe4facc70>)\n|\n|  A Semaphore implementation.\n|\n|  A semaphore manages an internal counter which is decremented by each\n|  acquire() call and incremented by each release() call. The counter\n|  can never go below zero; when acquire() finds that it is zero, it blocks,\n|  waiting until some other thread calls release().\n|\n|  Semaphores also support the context management protocol.\n|\n|  The optional argument gives the initial value for the internal\n|  counter; it defaults to 1. If the value given is less than 0,\n|  ValueError is raised.\n|\n|  Method resolution order:\n|      Semaphore\n|      ContextManagerMixin\n|      asyncio.mixins.LoopBoundMixin\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  init(self, value=1, *, loop=<object object at 0x7fcfe4facc70>)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  async acquire(self)\n|      Acquire a semaphore.\n|\n|      If the internal counter is larger than zero on entry,\n|      decrement it by one and return True immediately.  If it is\n|      zero on entry, block, waiting until some other coroutine has\n|      called release() to make it larger than 0, and then return\n|      True.\n|\n|  locked(self)\n|      Returns True if semaphore cannot be acquired immediately.\n|\n|  release(self)\n|      Release a semaphore, incrementing the internal counter by one.\n|\n|      When it was zero on entry and another coroutine is waiting for it to\n|      become larger than zero again, wake up that coroutine.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from ContextManagerMixin:\n|\n|  async aenter(self)\n|\n|  async aexit(self, exctype, exc, tb)\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from ContextManagerMixin:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class SendfileNotAvailableError\n\n|  Sendfile syscall is not available.\n|\n|  Raised if OS does not support sendfile syscall for given socket or\n|  file type.\n|\n|  Method resolution order:\n|      SendfileNotAvailableError\n|      builtins.RuntimeError\n|      builtins.Exception\n|      builtins.BaseException\n|      builtins.object\n|\n|  Data descriptors defined here:\n|\n|  weakref\n|      list of weak references to the object (if defined)\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from builtins.RuntimeError:\n|\n|  init(self, /, *args, kwargs)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  ----------------------------------------------------------------------\n|  Static methods inherited from builtins.RuntimeError:\n|\n|  new(*args, kwargs) from builtins.type\n|      Create and return a new object.  See help(type) for accurate signature.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from builtins.BaseException:\n|\n|  delattr(self, name, /)\n|      Implement delattr(self, name).\n|\n|  getattribute(self, name, /)\n|      Return getattr(self, name).\n|\n|  reduce(...)\n|      Helper for pickle.\n|\n|  repr(self, /)\n|      Return repr(self).\n|\n|  setattr(self, name, value, /)\n|      Implement setattr(self, name, value).\n|\n|  setstate(...)\n|\n|  str(self, /)\n|      Return str(self).\n|\n|  withtraceback(...)\n|      Exception.withtraceback(tb) --\n|      set self.traceback to tb and return self.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from builtins.BaseException:\n|\n|  cause\n|      exception cause\n|\n|  context\n|      exception context\n|\n|  dict\n|\n|  suppresscontext\n|\n|  traceback\n|\n|  args\n\n#### class Server\n\n|  Server(loop, sockets, protocolfactory, sslcontext, backlog, sslhandshaketimeout)\n|\n|  Method resolution order:\n|      Server\n|      asyncio.events.AbstractServer\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  init(self, loop, sockets, protocolfactory, sslcontext, backlog, sslhandshaketimeout)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  close(self)\n|      Stop serving.  This leaves existing connections open.\n|\n|  getloop(self)\n|      Get the event loop the Server object is attached to.\n|\n|  isserving(self)\n|      Return True if the server is accepting connections.\n|\n|  async serveforever(self)\n|      Start accepting connections until the coroutine is cancelled.\n|\n|      The server is closed when the coroutine is cancelled.\n|\n|  async startserving(self)\n|      Start accepting connections.\n|\n|      This method is idempotent, so it can be called when\n|      the server is already being serving.\n|\n|  async waitclosed(self)\n|      Coroutine to wait until service is closed.\n|\n|  ----------------------------------------------------------------------\n|  Readonly properties defined here:\n|\n|  sockets\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from asyncio.events.AbstractServer:\n|\n|  async aenter(self)\n|\n|  async aexit(self, *exc)\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from asyncio.events.AbstractServer:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class StreamReader\n\n|  StreamReader(limit=65536, loop=None)\n|\n|  Methods defined here:\n|\n|  aiter(self)\n|\n|  async anext(self)\n|\n|  init(self, limit=65536, loop=None)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  ateof(self)\n|      Return True if the buffer is empty and 'feedeof' was called.\n|\n|  exception(self)\n|\n|  feeddata(self, data)\n|\n|  feedeof(self)\n|\n|  async read(self, n=-1)\n|      Read up to `n` bytes from the stream.\n|\n|      If `n` is not provided or set to -1,\n|      read until EOF, then return all read bytes.\n|      If EOF was received and the internal buffer is empty,\n|      return an empty bytes object.\n|\n|      If `n` is 0, return an empty bytes object immediately.\n|\n|      If `n` is positive, return at most `n` available bytes\n|      as soon as at least 1 byte is available in the internal buffer.\n|      If EOF is received before any byte is read, return an empty\n|      bytes object.\n|\n|      Returned value is not limited with limit, configured at stream\n|      creation.\n|\n|      If stream was paused, this function will automatically resume it if\n|      needed.\n|\n|  async readexactly(self, n)\n|      Read exactly `n` bytes.\n|\n|      Raise an IncompleteReadError if EOF is reached before `n` bytes can be\n|      read. The IncompleteReadError.partial attribute of the exception will\n|      contain the partial read bytes.\n|\n|      if n is zero, return empty bytes object.\n|\n|      Returned value is not limited with limit, configured at stream\n|      creation.\n|\n|      If stream was paused, this function will automatically resume it if\n|      needed.\n|\n|  async readline(self)\n|      Read chunk of data from the stream until newline (b'\n|      ') is found.\n|\n|              On success, return chunk that ends with newline. If only partial\n|              line can be read due to EOF, return incomplete line without\n|              terminating newline. When EOF was reached while no bytes read, empty\n|              bytes object is returned.\n|\n|              If limit is reached, ValueError will be raised. In that case, if\n|              newline was found, complete line including newline will be removed\n|              from internal buffer. Else, internal buffer will be cleared. Limit is\n|              compared against part of the line without newline.\n|\n|              If stream was paused, this function will automatically resume it if\n|              needed.\n|\n|  async readuntil(self, separator=b'\\n')\n|      Read data from the stream until ``separator`` is found.\n|\n|      On success, the data and separator will be removed from the\n|      internal buffer (consumed). Returned data will include the\n|      separator at the end.\n|\n|      Configured stream limit is used to check result. Limit sets the\n|      maximal length of data that can be returned, not counting the\n|      separator.\n|\n|      If an EOF occurs and the complete separator is still not found,\n|      an IncompleteReadError exception will be raised, and the internal\n|      buffer will be reset.  The IncompleteReadError.partial attribute\n|      may contain the separator partially.\n|\n|      If the data cannot be read because of over limit, a\n|      LimitOverrunError exception  will be raised, and the data\n|      will be left in the internal buffer, so it can be read again.\n|\n|  setexception(self, exc)\n|\n|  settransport(self, transport)\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors defined here:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class StreamReaderProtocol\n\n|  StreamReaderProtocol(streamreader, clientconnectedcb=None, loop=None)\n|\n|  Helper class to adapt between Protocol and StreamReader.\n|\n|  (This is a helper class instead of making StreamReader itself a\n|  Protocol subclass, because the StreamReader has other potential\n|  uses, and to prevent the user of the StreamReader to accidentally\n|  call inappropriate methods of the protocol.)\n|\n|  Method resolution order:\n|      StreamReaderProtocol\n|      FlowControlMixin\n|      asyncio.protocols.Protocol\n|      asyncio.protocols.BaseProtocol\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  del(self)\n|\n|  init(self, streamreader, clientconnectedcb=None, loop=None)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  connectionlost(self, exc)\n|      Called when the connection is lost or closed.\n|\n|      The argument is an exception object or None (the latter\n|      meaning a regular EOF is received or the connection was\n|      aborted or closed).\n|\n|  connectionmade(self, transport)\n|      Called when a connection is made.\n|\n|      The argument is the transport representing the pipe connection.\n|      To receive data, wait for datareceived() calls.\n|      When the connection is closed, connectionlost() is called.\n|\n|  datareceived(self, data)\n|      Called when some data is received.\n|\n|      The argument is a bytes object.\n|\n|  eofreceived(self)\n|      Called when the other end calls writeeof() or equivalent.\n|\n|      If this returns a false value (including None), the transport\n|      will close itself.  If it returns a true value, closing the\n|      transport is up to the protocol.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from FlowControlMixin:\n|\n|  pausewriting(self)\n|      Called when the transport's buffer goes over the high-water mark.\n|\n|      Pause and resume calls are paired -- pausewriting() is called\n|      once when the buffer goes strictly over the high-water mark\n|      (even if subsequent writes increases the buffer size even\n|      more), and eventually resumewriting() is called once when the\n|      buffer size reaches the low-water mark.\n|\n|      Note that if the buffer size equals the high-water mark,\n|      pausewriting() is not called -- it must go strictly over.\n|      Conversely, resumewriting() is called when the buffer size is\n|      equal or lower than the low-water mark.  These end conditions\n|      are important to ensure that things go as expected when either\n|      mark is zero.\n|\n|      NOTE: This is the only Protocol callback that is not called\n|      through EventLoop.callsoon() -- if it were, it would have no\n|      effect when it's most needed (when the app keeps writing\n|      without yielding until pausewriting() is called).\n|\n|  resumewriting(self)\n|      Called when the transport's buffer drains below the low-water mark.\n|\n|      See pausewriting() for details.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from FlowControlMixin:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class StreamWriter\n\n|  StreamWriter(transport, protocol, reader, loop)\n|\n|  Wraps a Transport.\n|\n|  This exposes write(), writelines(), [can]writeeof(),\n|  getextrainfo() and close().  It adds drain() which returns an\n|  optional Future on which you can wait for flow control.  It also\n|  adds a transport property which references the Transport\n|  directly.\n|\n|  Methods defined here:\n|\n|  init(self, transport, protocol, reader, loop)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  canwriteeof(self)\n|\n|  close(self)\n|\n|  async drain(self)\n|      Flush the write buffer.\n|\n|      The intended use is to write\n|\n|        w.write(data)\n|        await w.drain()\n|\n|  getextrainfo(self, name, default=None)\n|\n|  isclosing(self)\n|\n|  async waitclosed(self)\n|\n|  write(self, data)\n|\n|  writeeof(self)\n|\n|  writelines(self, data)\n|\n|  ----------------------------------------------------------------------\n|  Readonly properties defined here:\n|\n|  transport\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors defined here:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class SubprocessProtocol\n\n|  Interface for protocol for subprocess calls.\n|\n|  Method resolution order:\n|      SubprocessProtocol\n|      BaseProtocol\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  pipeconnectionlost(self, fd, exc)\n|      Called when a file descriptor associated with the child process is\n|      closed.\n|\n|      fd is the int file descriptor that was closed.\n|\n|  pipedatareceived(self, fd, data)\n|      Called when the subprocess writes data into stdout/stderr pipe.\n|\n|      fd is int file descriptor.\n|      data is bytes object.\n|\n|  processexited(self)\n|      Called when subprocess has exited.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from BaseProtocol:\n|\n|  connectionlost(self, exc)\n|      Called when the connection is lost or closed.\n|\n|      The argument is an exception object or None (the latter\n|      meaning a regular EOF is received or the connection was\n|      aborted or closed).\n|\n|  connectionmade(self, transport)\n|      Called when a connection is made.\n|\n|      The argument is the transport representing the pipe connection.\n|      To receive data, wait for datareceived() calls.\n|      When the connection is closed, connectionlost() is called.\n|\n|  pausewriting(self)\n|      Called when the transport's buffer goes over the high-water mark.\n|\n|      Pause and resume calls are paired -- pausewriting() is called\n|      once when the buffer goes strictly over the high-water mark\n|      (even if subsequent writes increases the buffer size even\n|      more), and eventually resumewriting() is called once when the\n|      buffer size reaches the low-water mark.\n|\n|      Note that if the buffer size equals the high-water mark,\n|      pausewriting() is not called -- it must go strictly over.\n|      Conversely, resumewriting() is called when the buffer size is\n|      equal or lower than the low-water mark.  These end conditions\n|      are important to ensure that things go as expected when either\n|      mark is zero.\n|\n|      NOTE: This is the only Protocol callback that is not called\n|      through EventLoop.callsoon() -- if it were, it would have no\n|      effect when it's most needed (when the app keeps writing\n|      without yielding until pausewriting() is called).\n|\n|  resumewriting(self)\n|      Called when the transport's buffer drains below the low-water mark.\n|\n|      See pausewriting() for details.\n\n#### class SubprocessTransport\n\n|  SubprocessTransport(extra=None)\n|\n|  Method resolution order:\n|      SubprocessTransport\n|      BaseTransport\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  getpid(self)\n|      Get subprocess id.\n|\n|  getpipetransport(self, fd)\n|      Get transport for pipe with number fd.\n|\n|  getreturncode(self)\n|      Get subprocess returncode.\n|\n|      See also\n|      http://docs.python.org/3/library/subprocess#subprocess.Popen.returncode\n|\n|  kill(self)\n|      Kill the subprocess.\n|\n|      On Posix OSs the function sends SIGKILL to the subprocess.\n|      On Windows kill() is an alias for terminate().\n|\n|      See also:\n|      http://docs.python.org/3/library/subprocess#subprocess.Popen.kill\n|\n|  sendsignal(self, signal)\n|      Send signal to subprocess.\n|\n|      See also:\n|      docs.python.org/3/library/subprocess#subprocess.Popen.sendsignal\n|\n|  terminate(self)\n|      Stop the subprocess.\n|\n|      Alias for close() method.\n|\n|      On Posix OSs the method sends SIGTERM to the subprocess.\n|      On Windows the Win32 API function TerminateProcess()\n|       is called to stop the subprocess.\n|\n|      See also:\n|      http://docs.python.org/3/library/subprocess#subprocess.Popen.terminate\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from BaseTransport:\n|\n|  init(self, extra=None)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  close(self)\n|      Close the transport.\n|\n|      Buffered data will be flushed asynchronously.  No more data\n|      will be received.  After all buffered data is flushed, the\n|      protocol's connectionlost() method will (eventually) be\n|      called with None as its argument.\n|\n|  getextrainfo(self, name, default=None)\n|      Get optional transport information.\n|\n|  getprotocol(self)\n|      Return the current protocol.\n|\n|  isclosing(self)\n|      Return True if the transport is closing or closed.\n|\n|  setprotocol(self, protocol)\n|      Set a new protocol.\n\n#### class Task\n\n|  Task(coro, *, loop=None, name=None)\n|\n|  A coroutine wrapped in a Future.\n|\n|  Method resolution order:\n|      Task\n|      Future\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  await(self, /)\n|      Return an iterator to be used in await expression.\n|\n|  del(...)\n|\n|  init(self, /, *args, kwargs)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  iter(self, /)\n|      Implement iter(self).\n|\n|  repr(self, /)\n|      Return repr(self).\n|\n|  adddonecallback(...)\n|      Add a callback to be run when the future becomes done.\n|\n|      The callback is called with a single argument - the future object. If\n|      the future is already done when this is called, the callback is\n|      scheduled with callsoon.\n|\n|  cancel(self, /, msg=None)\n|      Request that this task cancel itself.\n|\n|      This arranges for a CancelledError to be thrown into the\n|      wrapped coroutine on the next cycle through the event loop.\n|      The coroutine then has a chance to clean up or even deny\n|      the request using try/except/finally.\n|\n|      Unlike Future.cancel, this does not guarantee that the\n|      task will be cancelled: the exception might be caught and\n|      acted upon, delaying cancellation of the task or preventing\n|      cancellation completely.  The task may also return a value or\n|      raise a different exception.\n|\n|      Immediately after this method is called, Task.cancelled() will\n|      not return True (unless the task was already cancelled).  A\n|      task will be marked as cancelled when the wrapped coroutine\n|      terminates with a CancelledError exception (even if cancel()\n|      was not called).\n|\n|  cancelled(self, /)\n|      Return True if the future was cancelled.\n|\n|  done(self, /)\n|      Return True if the future is done.\n|\n|      Done means either that a result / exception are available, or that the\n|      future was cancelled.\n|\n|  exception(self, /)\n|      Return the exception that was set on this future.\n|\n|      The exception (or None if no exception was set) is returned only if\n|      the future is done.  If the future has been cancelled, raises\n|      CancelledError.  If the future isn't done yet, raises\n|      InvalidStateError.\n|\n|  getcoro(self, /)\n|\n|  getname(self, /)\n|\n|  getstack(self, /, *, limit=None)\n|      Return the list of stack frames for this task's coroutine.\n|\n|      If the coroutine is not done, this returns the stack where it is\n|      suspended.  If the coroutine has completed successfully or was\n|      cancelled, this returns an empty list.  If the coroutine was\n|      terminated by an exception, this returns the list of traceback\n|      frames.\n|\n|      The frames are always ordered from oldest to newest.\n|\n|      The optional limit gives the maximum number of frames to\n|      return; by default all available frames are returned.  Its\n|      meaning differs depending on whether a stack or a traceback is\n|      returned: the newest frames of a stack are returned, but the\n|      oldest frames of a traceback are returned.  (This matches the\n|      behavior of the traceback module.)\n|\n|      For reasons beyond our control, only one stack frame is\n|      returned for a suspended coroutine.\n|\n|  printstack(self, /, *, limit=None, file=None)\n|      Print the stack or traceback for this task's coroutine.\n|\n|      This produces output similar to that of the traceback module,\n|      for the frames retrieved by getstack().  The limit argument\n|      is passed to getstack().  The file argument is an I/O stream\n|      to which the output is written; by default output is written\n|      to sys.stderr.\n|\n|  removedonecallback(self, fn, /)\n|      Remove all instances of a callback from the \"call when done\" list.\n|\n|      Returns the number of callbacks removed.\n|\n|  result(self, /)\n|      Return the result this future represents.\n|\n|      If the future has been cancelled, raises CancelledError.  If the\n|      future's result isn't yet available, raises InvalidStateError.  If\n|      the future is done and has an exception set, this exception is raised.\n|\n|  setexception(self, exception, /)\n|      Mark the future done and set an exception.\n|\n|      If the future is already done when this method is called, raises\n|      InvalidStateError.\n|\n|  setname(self, value, /)\n|\n|  setresult(self, result, /)\n|      Mark the future done and set its result.\n|\n|      If the future is already done when this method is called, raises\n|      InvalidStateError.\n|\n|  ----------------------------------------------------------------------\n|  Class methods defined here:\n|\n|  classgetitem(...) from builtins.type\n|      See PEP 585\n|\n|  ----------------------------------------------------------------------\n|  Static methods defined here:\n|\n|  new(*args, kwargs) from builtins.type\n|      Create and return a new object.  See help(type) for accurate signature.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Future:\n|\n|  getloop(self, /)\n|      Return the event loop the Future is bound to.\n\n#### class ThreadedChildWatcher\n\n|  Threaded child watcher implementation.\n|\n|  The watcher uses a thread per process\n|  for waiting for the process finish.\n|\n|  It doesn't require subscription on POSIX signal\n|  but a thread creation is not free.\n|\n|  The watcher has O(1) complexity, its performance doesn't depend\n|  on amount of spawn processes.\n|\n|  Method resolution order:\n|      ThreadedChildWatcher\n|      AbstractChildWatcher\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  del(self, warn=<built-in function warn>)\n|\n|  enter(self)\n|      Enter the watcher's context and allow starting new processes\n|\n|      This function must return self\n|\n|  exit(self, exctype, excval, exctb)\n|      Exit the watcher's context\n|\n|  init(self)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  addchildhandler(self, pid, callback, *args)\n|      Register a new child handler.\n|\n|      Arrange for callback(pid, returncode, *args) to be called when\n|      process 'pid' terminates. Specifying another callback for the same\n|      process replaces the previous handler.\n|\n|      Note: callback() must be thread-safe.\n|\n|  attachloop(self, loop)\n|      Attach the watcher to an event loop.\n|\n|      If the watcher was previously attached to an event loop, then it is\n|      first detached before attaching to the new loop.\n|\n|      Note: loop may be None.\n|\n|  close(self)\n|      Close the watcher.\n|\n|      This must be called to make sure that any underlying resource is freed.\n|\n|  isactive(self)\n|      Return ``True`` if the watcher is active and is used by the event loop.\n|\n|      Return True if the watcher is installed and ready to handle process exit\n|      notifications.\n|\n|  removechildhandler(self, pid)\n|      Removes the handler for process 'pid'.\n|\n|      The function returns True if the handler was successfully removed,\n|      False if there was nothing to remove.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from AbstractChildWatcher:\n|\n|  dict\n|      dictionary for instance variables (if defined)\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class TimeoutError\n\n|  The operation exceeded the given deadline.\n|\n|  Method resolution order:\n|      TimeoutError\n|      builtins.Exception\n|      builtins.BaseException\n|      builtins.object\n|\n|  Data descriptors defined here:\n|\n|  weakref\n|      list of weak references to the object (if defined)\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from builtins.Exception:\n|\n|  init(self, /, *args, kwargs)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  ----------------------------------------------------------------------\n|  Static methods inherited from builtins.Exception:\n|\n|  new(*args, kwargs) from builtins.type\n|      Create and return a new object.  See help(type) for accurate signature.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from builtins.BaseException:\n|\n|  delattr(self, name, /)\n|      Implement delattr(self, name).\n|\n|  getattribute(self, name, /)\n|      Return getattr(self, name).\n|\n|  reduce(...)\n|      Helper for pickle.\n|\n|  repr(self, /)\n|      Return repr(self).\n|\n|  setattr(self, name, value, /)\n|      Implement setattr(self, name, value).\n|\n|  setstate(...)\n|\n|  str(self, /)\n|      Return str(self).\n|\n|  withtraceback(...)\n|      Exception.withtraceback(tb) --\n|      set self.traceback to tb and return self.\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from builtins.BaseException:\n|\n|  cause\n|      exception cause\n|\n|  context\n|      exception context\n|\n|  dict\n|\n|  suppresscontext\n|\n|  traceback\n|\n|  args\n\n#### class TimerHandle\n\n|  TimerHandle(when, callback, args, loop, context=None)\n|\n|  Object returned by timed callback registration methods.\n|\n|  Method resolution order:\n|      TimerHandle\n|      Handle\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  eq(self, other)\n|      Return self==value.\n|\n|  ge(self, other)\n|      Return self>=value.\n|\n|  gt(self, other)\n|      Return self>value.\n|\n|  hash(self)\n|      Return hash(self).\n|\n|  init(self, when, callback, args, loop, context=None)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  le(self, other)\n|      Return self<=value.\n|\n|  lt(self, other)\n|      Return self<value.\n|\n|  cancel(self)\n|\n|  when(self)\n|      Return a scheduled callback time.\n|\n|      The time is an absolute timestamp, using the same time\n|      reference as loop.time().\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from Handle:\n|\n|  repr(self)\n|      Return repr(self).\n|\n|  cancelled(self)\n|\n|  ----------------------------------------------------------------------\n|  Data descriptors inherited from Handle:\n|\n|  weakref\n|      list of weak references to the object (if defined)\n\n#### class Transport\n\n|  Transport(extra=None)\n|\n|  Interface representing a bidirectional transport.\n|\n|  There may be several implementations, but typically, the user does\n|  not implement new transports; rather, the platform provides some\n|  useful transports that are implemented using the platform's best\n|  practices.\n|\n|  The user never instantiates a transport directly; they call a\n|  utility function, passing it a protocol factory and other\n|  information necessary to create the transport and protocol.  (E.g.\n|  EventLoop.createconnection() or EventLoop.createserver().)\n|\n|  The utility function will asynchronously create a transport and a\n|  protocol and hook them up by calling the protocol's\n|  connectionmade() method, passing it the transport.\n|\n|  The implementation here raises NotImplemented for every method\n|  except writelines(), which calls write() in a loop.\n|\n|  Method resolution order:\n|      Transport\n|      ReadTransport\n|      WriteTransport\n|      BaseTransport\n|      builtins.object\n|\n|  Methods inherited from ReadTransport:\n|\n|  isreading(self)\n|      Return True if the transport is receiving.\n|\n|  pausereading(self)\n|      Pause the receiving end.\n|\n|      No data will be passed to the protocol's datareceived()\n|      method until resumereading() is called.\n|\n|  resumereading(self)\n|      Resume the receiving end.\n|\n|      Data received will once again be passed to the protocol's\n|      datareceived() method.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from WriteTransport:\n|\n|  abort(self)\n|      Close the transport immediately.\n|\n|      Buffered data will be lost.  No more data will be received.\n|      The protocol's connectionlost() method will (eventually) be\n|      called with None as its argument.\n|\n|  canwriteeof(self)\n|      Return True if this transport supports writeeof(), False if not.\n|\n|  getwritebufferlimits(self)\n|      Get the high and low watermarks for write flow control.\n|      Return a tuple (low, high) where low and high are\n|      positive number of bytes.\n|\n|  getwritebuffersize(self)\n|      Return the current size of the write buffer.\n|\n|  setwritebufferlimits(self, high=None, low=None)\n|      Set the high- and low-water limits for write flow control.\n|\n|      These two values control when to call the protocol's\n|      pausewriting() and resumewriting() methods.  If specified,\n|      the low-water limit must be less than or equal to the\n|      high-water limit.  Neither value can be negative.\n|\n|      The defaults are implementation-specific.  If only the\n|      high-water limit is given, the low-water limit defaults to an\n|      implementation-specific value less than or equal to the\n|      high-water limit.  Setting high to zero forces low to zero as\n|      well, and causes pausewriting() to be called whenever the\n|      buffer becomes non-empty.  Setting low to zero causes\n|      resumewriting() to be called only once the buffer is empty.\n|      Use of zero for either limit is generally sub-optimal as it\n|      reduces opportunities for doing I/O and computation\n|      concurrently.\n|\n|  write(self, data)\n|      Write some data bytes to the transport.\n|\n|      This does not block; it buffers the data and arranges for it\n|      to be sent out asynchronously.\n|\n|  writeeof(self)\n|      Close the write end after flushing buffered data.\n|\n|      (This is like typing ^D into a UNIX program reading from stdin.)\n|\n|      Data may still be received.\n|\n|  writelines(self, listofdata)\n|      Write a list (or any iterable) of data bytes to the transport.\n|\n|      The default implementation concatenates the arguments and\n|      calls write() on the result.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from BaseTransport:\n|\n|  init(self, extra=None)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  close(self)\n|      Close the transport.\n|\n|      Buffered data will be flushed asynchronously.  No more data\n|      will be received.  After all buffered data is flushed, the\n|      protocol's connectionlost() method will (eventually) be\n|      called with None as its argument.\n|\n|  getextrainfo(self, name, default=None)\n|      Get optional transport information.\n|\n|  getprotocol(self)\n|      Return the current protocol.\n|\n|  isclosing(self)\n|      Return True if the transport is closing or closed.\n|\n|  setprotocol(self, protocol)\n|      Set a new protocol.\n\n#### class WriteTransport\n\n|  WriteTransport(extra=None)\n|\n|  Interface for write-only transports.\n|\n|  Method resolution order:\n|      WriteTransport\n|      BaseTransport\n|      builtins.object\n|\n|  Methods defined here:\n|\n|  abort(self)\n|      Close the transport immediately.\n|\n|      Buffered data will be lost.  No more data will be received.\n|      The protocol's connectionlost() method will (eventually) be\n|      called with None as its argument.\n|\n|  canwriteeof(self)\n|      Return True if this transport supports writeeof(), False if not.\n|\n|  getwritebufferlimits(self)\n|      Get the high and low watermarks for write flow control.\n|      Return a tuple (low, high) where low and high are\n|      positive number of bytes.\n|\n|  getwritebuffersize(self)\n|      Return the current size of the write buffer.\n|\n|  setwritebufferlimits(self, high=None, low=None)\n|      Set the high- and low-water limits for write flow control.\n|\n|      These two values control when to call the protocol's\n|      pausewriting() and resumewriting() methods.  If specified,\n|      the low-water limit must be less than or equal to the\n|      high-water limit.  Neither value can be negative.\n|\n|      The defaults are implementation-specific.  If only the\n|      high-water limit is given, the low-water limit defaults to an\n|      implementation-specific value less than or equal to the\n|      high-water limit.  Setting high to zero forces low to zero as\n|      well, and causes pausewriting() to be called whenever the\n|      buffer becomes non-empty.  Setting low to zero causes\n|      resumewriting() to be called only once the buffer is empty.\n|      Use of zero for either limit is generally sub-optimal as it\n|      reduces opportunities for doing I/O and computation\n|      concurrently.\n|\n|  write(self, data)\n|      Write some data bytes to the transport.\n|\n|      This does not block; it buffers the data and arranges for it\n|      to be sent out asynchronously.\n|\n|  writeeof(self)\n|      Close the write end after flushing buffered data.\n|\n|      (This is like typing ^D into a UNIX program reading from stdin.)\n|\n|      Data may still be received.\n|\n|  writelines(self, listofdata)\n|      Write a list (or any iterable) of data bytes to the transport.\n|\n|      The default implementation concatenates the arguments and\n|      calls write() on the result.\n|\n|  ----------------------------------------------------------------------\n|  Methods inherited from BaseTransport:\n|\n|  init(self, extra=None)\n|      Initialize self.  See help(type(self)) for accurate signature.\n|\n|  close(self)\n|      Close the transport.\n|\n|      Buffered data will be flushed asynchronously.  No more data\n|      will be received.  After all buffered data is flushed, the\n|      protocol's connectionlost() method will (eventually) be\n|      called with None as its argument.\n|\n|  getextrainfo(self, name, default=None)\n|      Get optional transport information.\n|\n|  getprotocol(self)\n|      Return the current protocol.\n|\n|  isclosing(self)\n|      Return True if the transport is closing or closed.\n|\n|  setprotocol(self, protocol)\n|      Set a new protocol.\n\n### FUNCTIONS\n\nentertask(loop, task)\nEnter into task execution or resume suspended task.\n\nTask belongs to loop.\n\nReturns None.\n\ngetrunningloop()\nReturn the running event loop or None.\n\nThis is a low-level function intended to be used by event loops.\nThis function is thread-specific.\n\nleavetask(loop, task)\nLeave task execution or suspend a task.\n\nTask belongs to loop.\n\nReturns None.\n\nregistertask(task)\nRegister a new task in asyncio as executed by loop.\n\nReturns None.\n\nsetrunningloop(loop, /)\nSet the running event loop.\n\nThis is a low-level function intended to be used by event loops.\nThis function is thread-specific.\n\nunregistertask(task)\nUnregister a task.\n\nReturns None.\n\n#### all_tasks\n\nReturn a set of all tasks for the loop.\n\n#### as_completed\n\nReturn an iterator whose values are coroutines.\n\nWhen waiting for the yielded coroutines you'll get the results (or\nexceptions!) of the original Futures (or coroutines), in the order\nin which and as soon as they complete.\n\nThis differs from PEP 3148; the proper way to use this is:\n\nfor f in ascompleted(fs):\nresult = await f  # The 'await' may raise.\n# Use result.\n\nIf a timeout is specified, the 'await' will raise\nTimeoutError when the timeout occurs before all Futures are done.\n\nNote: The futures 'f' are not necessarily members of fs.\n\n#### coroutine\n\nDecorator to mark coroutines.\n\nIf the coroutine is not yielded from before it is destroyed,\nan error message is logged.\n\nasync createsubprocessexec(program, *args, stdin=None, stdout=None, stderr=None, limit=65536, kwds)\n\nasync createsubprocessshell(cmd, stdin=None, stdout=None, stderr=None, limit=65536, kwds)\n\n#### create_task\n\nSchedule the execution of a coroutine object in a spawn task.\n\nReturn a Task object.\n\n#### current_task\n\nReturn a currently executed task.\n\n#### ensure_future\n\nWrap a coroutine or an awaitable in a future.\n\nIf the argument is a Future, it is returned directly.\n\n#### gather\n\nReturn a future aggregating results from the given coroutines/futures.\n\nCoroutines will be wrapped in a future and scheduled in the event\nloop. They will not necessarily be scheduled in the same order as\npassed in.\n\nAll futures must share the same event loop.  If all the tasks are\ndone successfully, the returned future's result is the list of\nresults (in the order of the original sequence, not necessarily\nthe order of results arrival).  If *returnexceptions* is True,\nexceptions in the tasks are treated the same as successful\nresults, and gathered in the result list; otherwise, the first\nraised exception will be immediately propagated to the returned\nfuture.\n\nCancellation: if the outer Future is cancelled, all children (that\nhave not completed yet) are also cancelled.  If any child is\ncancelled, this is treated as if it raised CancelledError --\nthe outer Future is *not* cancelled in this case.  (This is to\nprevent the cancellation of one child to cause other children to\nbe cancelled.)\n\nIf *returnexceptions* is False, cancelling gather() after it\nhas been marked done won't cancel any submitted awaitables.\nFor instance, gather can be marked done after propagating an\nexception to the caller, therefore, calling ``gather.cancel()``\nafter catching an exception (raised by one of the awaitables) from\ngather won't cancel any other awaitables.\n\n#### get_child_watcher\n\nEquivalent to calling geteventlooppolicy().getchildwatcher().\n\n#### get_event_loop\n\nReturn an asyncio event loop.\n\nWhen called from a coroutine or a callback (e.g. scheduled with\ncallsoon or similar API), this function will always return the\nrunning event loop.\n\nIf there is no running event loop set, the function will return\nthe result of `geteventlooppolicy().geteventloop()` call.\n\n#### get_event_loop_policy\n\nGet the current event loop policy.\n\n#### get_running_loop\n\nReturn the running event loop.  Raise a RuntimeError if there is none.\n\nThis function is thread-specific.\n\n#### iscoroutine\n\nReturn True if obj is a coroutine object.\n\n#### iscoroutinefunction\n\nReturn True if func is a decorated coroutine function.\n\n#### isfuture\n\nCheck for a Future.\n\nThis returns True when obj is a Future instance or is advertising\nitself as duck-type compatible by setting asynciofutureblocking.\nSee comment in Future for more details.\n\n#### new_event_loop\n\nEquivalent to calling geteventlooppolicy().neweventloop().\n\nasync openconnection(host=None, port=None, *, limit=65536, kwds)\nA wrapper for createconnection() returning a (reader, writer) pair.\n\nThe reader returned is a StreamReader instance; the writer is a\nStreamWriter instance.\n\nThe arguments are all the usual arguments to createconnection()\nexcept protocolfactory; most common are positional host and port,\nwith various optional keyword arguments following.\n\nAdditional optional keyword arguments are loop (to set the event loop\ninstance to use) and limit (to set the buffer limit passed to the\nStreamReader).\n\n(If you want to customize the StreamReader and/or\nStreamReaderProtocol classes, just copy the code -- there's\nreally nothing special here except some convenience.)\n\nasync openunixconnection(path=None, *, limit=65536, kwds)\nSimilar to `openconnection` but works with UNIX Domain Sockets.\n\n#### run\n\nExecute the coroutine and return the result.\n\nThis function runs the passed coroutine, taking care of\nmanaging the asyncio event loop and finalizing asynchronous\ngenerators.\n\nThis function cannot be called when another asyncio event loop is\nrunning in the same thread.\n\nIf debug is True, the event loop will be run in debug mode.\n\nThis function always creates a new event loop and closes it at the end.\nIt should be used as a main entry point for asyncio programs, and should\nideally only be called once.\n\nExample:\n\nasync def main():\nawait asyncio.sleep(1)\nprint('hello')\n\nasyncio.run(main())\n\n#### run_coroutine_threadsafe\n\nSubmit a coroutine object to a given event loop.\n\nReturn a concurrent.futures.Future to access the result.\n\n#### set_child_watcher\n\nEquivalent to calling\ngeteventlooppolicy().setchildwatcher(watcher).\n\n#### set_event_loop\n\nEquivalent to calling geteventlooppolicy().seteventloop(loop).\n\n#### set_event_loop_policy\n\nSet the current event loop policy.\n\nIf policy is None, the default policy is restored.\n\n#### shield\n\nWait for a future, shielding it from cancellation.\n\nThe statement\n\ntask = asyncio.createtask(something())\nres = await shield(task)\n\nis exactly equivalent to the statement\n\nres = await something()\n\n*except* that if the coroutine containing it is cancelled, the\ntask running in something() is not cancelled.  From the POV of\nsomething(), the cancellation did not happen.  But its caller is\nstill cancelled, so the yield-from expression still raises\nCancelledError.  Note: If something() is cancelled by other means\nthis will still cancel shield().\n\nIf you want to completely ignore cancellation (not recommended)\nyou can combine shield() with a try/except clause, as follows:\n\ntask = asyncio.createtask(something())\ntry:\nres = await shield(task)\nexcept CancelledError:\nres = None\n\nSave a reference to tasks passed to this function, to avoid\na task disappearing mid-execution. The event loop only keeps\nweak references to tasks. A task that isn't referenced elsewhere\nmay get garbage collected at any time, even before it's done.\n\nasync sleep(delay, result=None)\nCoroutine that completes after a given time (in seconds).\n\nasync startserver(clientconnectedcb, host=None, port=None, *, limit=65536, kwds)\nStart a socket server, call back for each client connected.\n\nThe first parameter, `clientconnectedcb`, takes two parameters:\nclientreader, clientwriter.  clientreader is a StreamReader\nobject, while clientwriter is a StreamWriter object.  This\nparameter can either be a plain callback function or a coroutine;\nif it is a coroutine, it will be automatically converted into a\nTask.\n\nThe rest of the arguments are all the usual arguments to\nloop.createserver() except protocolfactory; most common are\npositional host and port, with various optional keyword arguments\nfollowing.  The return value is the same as loop.createserver().\n\nAdditional optional keyword arguments are loop (to set the event loop\ninstance to use) and limit (to set the buffer limit passed to the\nStreamReader).\n\nThe return value is the same as loop.createserver(), i.e. a\nServer object which can be used to stop the service.\n\nasync startunixserver(clientconnectedcb, path=None, *, limit=65536, kwds)\nSimilar to `startserver` but works with UNIX Domain Sockets.\n\nasync tothread(func, /, *args, kwargs)\nAsynchronously run function *func* in a separate thread.\n\nAny *args and kwargs supplied for this function are directly passed\nto *func*. Also, the current :class:`contextvars.Context` is propagated,\nallowing context variables from the main thread to be accessed in the\nseparate thread.\n\nReturn a coroutine that can be awaited to get the eventual result of *func*.\n\nasync wait(fs, *, timeout=None, returnwhen='ALLCOMPLETED')\nWait for the Futures and coroutines given by fs to complete.\n\nThe fs iterable must not be empty.\n\nCoroutines will be wrapped in Tasks.\n\nReturns two sets of Future: (done, pending).\n\nUsage:\n\ndone, pending = await asyncio.wait(fs)\n\nNote: This does not raise TimeoutError! Futures that aren't done\nwhen the timeout occurs are returned in the second set.\n\nasync waitfor(fut, timeout)\nWait for the single Future or coroutine to complete, with timeout.\n\nCoroutine will be wrapped in Task.\n\nReturns result of the Future or coroutine.  When a timeout occurs,\nit cancels the task and raises TimeoutError.  To avoid the task\ncancellation, wrap it in shield().\n\nIf the wait is cancelled, the task is also cancelled.\n\nThis function is a coroutine.\n\n#### wrap_future\n\nWrap concurrent.futures.Future object.\n\n### DATA\n\nALLCOMPLETED = 'ALLCOMPLETED'\nFIRSTCOMPLETED = 'FIRSTCOMPLETED'\nFIRSTEXCEPTION = 'FIRSTEXCEPTION'\nall = ('BaseEventLoop', 'Server', 'coroutine', 'iscoroutinefunctio...\n\n### FILE\n\n/usr/lib/python3.10/asyncio/init.py\n\n"
        }
    ],
    "structuredContent": {
        "command": "asyncio",
        "section": "",
        "mode": "pydoc",
        "summary": "asyncio - The asyncio package, tracking PEP 3156.",
        "synopsis": null,
        "tldr_summary": null,
        "tldr_examples": [],
        "tldr_source": null,
        "flags": [],
        "examples": [],
        "see_also": [],
        "section_outline": [
            {
                "name": "NAME",
                "lines": 2,
                "subsections": []
            },
            {
                "name": "MODULE REFERENCE",
                "lines": 8,
                "subsections": []
            },
            {
                "name": "PACKAGE CONTENTS",
                "lines": 31,
                "subsections": []
            },
            {
                "name": "CLASSES",
                "lines": 64,
                "subsections": [
                    {
                        "name": "class AbstractChildWatcher",
                        "lines": 74
                    },
                    {
                        "name": "class AbstractEventLoop",
                        "lines": 254
                    },
                    {
                        "name": "class AbstractEventLoopPolicy",
                        "lines": 36
                    },
                    {
                        "name": "class AbstractServer",
                        "lines": 40
                    },
                    {
                        "name": "class BaseEventLoop",
                        "lines": 334
                    },
                    {
                        "name": "class BaseProtocol",
                        "lines": 50
                    },
                    {
                        "name": "class BaseTransport",
                        "lines": 29
                    },
                    {
                        "name": "class BoundedSemaphore",
                        "lines": 59
                    },
                    {
                        "name": "class BufferedProtocol",
                        "lines": 95
                    },
                    {
                        "name": "class CancelledError",
                        "lines": 65
                    },
                    {
                        "name": "class Condition",
                        "lines": 76
                    },
                    {
                        "name": "class DatagramProtocol",
                        "lines": 60
                    },
                    {
                        "name": "class DatagramTransport",
                        "lines": 104
                    },
                    {
                        "name": "class Event",
                        "lines": 51
                    },
                    {
                        "name": "class FastChildWatcher",
                        "lines": 74
                    },
                    {
                        "name": "class Future",
                        "lines": 101
                    },
                    {
                        "name": "class Handle",
                        "lines": 22
                    },
                    {
                        "name": "class IncompleteReadError",
                        "lines": 75
                    },
                    {
                        "name": "class InvalidStateError",
                        "lines": 69
                    },
                    {
                        "name": "class LifoQueue",
                        "lines": 99
                    },
                    {
                        "name": "class LimitOverrunError",
                        "lines": 74
                    },
                    {
                        "name": "class Lock",
                        "lines": 103
                    },
                    {
                        "name": "class MultiLoopChildWatcher",
                        "lines": 71
                    },
                    {
                        "name": "class PidfdChildWatcher",
                        "lines": 71
                    },
                    {
                        "name": "class PriorityQueue",
                        "lines": 101
                    },
                    {
                        "name": "class Protocol",
                        "lines": 86
                    },
                    {
                        "name": "class Queue",
                        "lines": 106
                    },
                    {
                        "name": "class QueueEmpty",
                        "lines": 69
                    },
                    {
                        "name": "class QueueFull",
                        "lines": 69
                    },
                    {
                        "name": "class ReadTransport",
                        "lines": 52
                    },
                    {
                        "name": "class SafeChildWatcher",
                        "lines": 456
                    },
                    {
                        "name": "class Semaphore",
                        "lines": 63
                    },
                    {
                        "name": "class SendfileNotAvailableError",
                        "lines": 73
                    },
                    {
                        "name": "class Server",
                        "lines": 59
                    },
                    {
                        "name": "class StreamReader",
                        "lines": 109
                    },
                    {
                        "name": "class StreamReaderProtocol",
                        "lines": 87
                    },
                    {
                        "name": "class StreamWriter",
                        "lines": 56
                    },
                    {
                        "name": "class SubprocessProtocol",
                        "lines": 67
                    },
                    {
                        "name": "class SubprocessTransport",
                        "lines": 74
                    },
                    {
                        "name": "class Task",
                        "lines": 147
                    },
                    {
                        "name": "class ThreadedChildWatcher",
                        "lines": 74
                    },
                    {
                        "name": "class TimeoutError",
                        "lines": 69
                    },
                    {
                        "name": "class TimerHandle",
                        "lines": 54
                    },
                    {
                        "name": "class Transport",
                        "lines": 130
                    },
                    {
                        "name": "class WriteTransport",
                        "lines": 93
                    }
                ]
            },
            {
                "name": "FUNCTIONS",
                "lines": 36,
                "subsections": [
                    {
                        "name": "all_tasks",
                        "lines": 2
                    },
                    {
                        "name": "as_completed",
                        "lines": 17
                    },
                    {
                        "name": "coroutine",
                        "lines": 9
                    },
                    {
                        "name": "create_task",
                        "lines": 4
                    },
                    {
                        "name": "current_task",
                        "lines": 2
                    },
                    {
                        "name": "ensure_future",
                        "lines": 4
                    },
                    {
                        "name": "gather",
                        "lines": 29
                    },
                    {
                        "name": "get_child_watcher",
                        "lines": 2
                    },
                    {
                        "name": "get_event_loop",
                        "lines": 9
                    },
                    {
                        "name": "get_event_loop_policy",
                        "lines": 2
                    },
                    {
                        "name": "get_running_loop",
                        "lines": 4
                    },
                    {
                        "name": "iscoroutine",
                        "lines": 2
                    },
                    {
                        "name": "iscoroutinefunction",
                        "lines": 2
                    },
                    {
                        "name": "isfuture",
                        "lines": 6
                    },
                    {
                        "name": "new_event_loop",
                        "lines": 23
                    },
                    {
                        "name": "run",
                        "lines": 23
                    },
                    {
                        "name": "run_coroutine_threadsafe",
                        "lines": 4
                    },
                    {
                        "name": "set_child_watcher",
                        "lines": 3
                    },
                    {
                        "name": "set_event_loop",
                        "lines": 2
                    },
                    {
                        "name": "set_event_loop_policy",
                        "lines": 4
                    },
                    {
                        "name": "shield",
                        "lines": 99
                    },
                    {
                        "name": "wrap_future",
                        "lines": 2
                    }
                ]
            },
            {
                "name": "DATA",
                "lines": 5,
                "subsections": []
            },
            {
                "name": "FILE",
                "lines": 3,
                "subsections": []
            }
        ]
    }
}