venv

62 files changed, 12785 insertions, 0 deletions

diff --git a/venv/lib/python3.11/site-packages/uvloop/__init__.py b/venv/lib/python3.11/site-packages/uvloop/__init__.py
new file mode 100644
index 0000000..9bb6592
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/__init__.py
@@ -0,0 +1,168 @@
+import asyncio as __asyncio
+import typing as _typing
+import sys as _sys
+import warnings as _warnings
+
+from asyncio.events import BaseDefaultEventLoopPolicy as __BasePolicy
+
+from . import includes as __includes  # NOQA
+from .loop import Loop as __BaseLoop  # NOQA
+from ._version import __version__  # NOQA
+
+
+__all__ = ('new_event_loop', 'install', 'EventLoopPolicy')
+
+
+_T = _typing.TypeVar("_T")
+
+
+class Loop(__BaseLoop, __asyncio.AbstractEventLoop):  # type: ignore[misc]
+    pass
+
+
+def new_event_loop() -> Loop:
+    """Return a new event loop."""
+    return Loop()
+
+
+def install() -> None:
+    """A helper function to install uvloop policy."""
+    if _sys.version_info[:2] >= (3, 12):
+        _warnings.warn(
+            'uvloop.install() is deprecated in favor of uvloop.run() '
+            'starting with Python 3.12.',
+            DeprecationWarning,
+            stacklevel=1,
+        )
+    __asyncio.set_event_loop_policy(EventLoopPolicy())
+
+
+if _typing.TYPE_CHECKING:
+    def run(
+        main: _typing.Coroutine[_typing.Any, _typing.Any, _T],
+        *,
+        loop_factory: _typing.Optional[
+            _typing.Callable[[], Loop]
+        ] = new_event_loop,
+        debug: _typing.Optional[bool]=None,
+    ) -> _T:
+        """The preferred way of running a coroutine with uvloop."""
+else:
+    def run(main, *, loop_factory=new_event_loop, debug=None, **run_kwargs):
+        """The preferred way of running a coroutine with uvloop."""
+
+        async def wrapper():
+            # If `loop_factory` is provided we want it to return
+            # either uvloop.Loop or a subtype of it, assuming the user
+            # is using `uvloop.run()` intentionally.
+            loop = __asyncio._get_running_loop()
+            if not isinstance(loop, Loop):
+                raise TypeError('uvloop.run() uses a non-uvloop event loop')
+            return await main
+
+        vi = _sys.version_info[:2]
+
+        if vi <= (3, 10):
+            # Copied from python/cpython
+
+            if __asyncio._get_running_loop() is not None:
+                raise RuntimeError(
+                    "asyncio.run() cannot be called from a running event loop")
+
+            if not __asyncio.iscoroutine(main):
+                raise ValueError(
+                    "a coroutine was expected, got {!r}".format(main)
+                )
+
+            loop = loop_factory()
+            try:
+                __asyncio.set_event_loop(loop)
+                if debug is not None:
+                    loop.set_debug(debug)
+                return loop.run_until_complete(wrapper())
+            finally:
+                try:
+                    _cancel_all_tasks(loop)
+                    loop.run_until_complete(loop.shutdown_asyncgens())
+                    if hasattr(loop, 'shutdown_default_executor'):
+                        loop.run_until_complete(
+                            loop.shutdown_default_executor()
+                        )
+                finally:
+                    __asyncio.set_event_loop(None)
+                    loop.close()
+
+        elif vi == (3, 11):
+            if __asyncio._get_running_loop() is not None:
+                raise RuntimeError(
+                    "asyncio.run() cannot be called from a running event loop")
+
+            with __asyncio.Runner(
+                loop_factory=loop_factory,
+                debug=debug,
+                **run_kwargs
+            ) as runner:
+                return runner.run(wrapper())
+
+        else:
+            assert vi >= (3, 12)
+            return __asyncio.run(
+                wrapper(),
+                loop_factory=loop_factory,
+                debug=debug,
+                **run_kwargs
+            )
+
+
+def _cancel_all_tasks(loop: __asyncio.AbstractEventLoop) -> None:
+    # Copied from python/cpython
+
+    to_cancel = __asyncio.all_tasks(loop)
+    if not to_cancel:
+        return
+
+    for task in to_cancel:
+        task.cancel()
+
+    loop.run_until_complete(
+        __asyncio.gather(*to_cancel, return_exceptions=True)
+    )
+
+    for task in to_cancel:
+        if task.cancelled():
+            continue
+        if task.exception() is not None:
+            loop.call_exception_handler({
+                'message': 'unhandled exception during asyncio.run() shutdown',
+                'exception': task.exception(),
+                'task': task,
+            })
+
+
+class EventLoopPolicy(__BasePolicy):
+    """Event loop policy.
+
+    The preferred way to make your application use uvloop:
+
+    >>> import asyncio
+    >>> import uvloop
+    >>> asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+    >>> asyncio.get_event_loop()
+    <uvloop.Loop running=False closed=False debug=False>
+    """
+
+    def _loop_factory(self) -> Loop:
+        return new_event_loop()
+
+    if _typing.TYPE_CHECKING:
+        # EventLoopPolicy doesn't implement these, but since they are marked
+        # as abstract in typeshed, we have to put them in so mypy thinks
+        # the base methods are overridden. This is the same approach taken
+        # for the Windows event loop policy classes in typeshed.
+        def get_child_watcher(self) -> _typing.NoReturn:
+            ...
+
+        def set_child_watcher(
+            self, watcher: _typing.Any
+        ) -> _typing.NoReturn:
+            ...
diff --git a/venv/lib/python3.11/site-packages/uvloop/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvloop/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000..ebc913e
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/__pycache__/__init__.cpython-311.pyc
diff --git a/venv/lib/python3.11/site-packages/uvloop/__pycache__/_noop.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvloop/__pycache__/_noop.cpython-311.pyc
new file mode 100644
index 0000000..155eaae
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/__pycache__/_noop.cpython-311.pyc
diff --git a/venv/lib/python3.11/site-packages/uvloop/__pycache__/_testbase.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvloop/__pycache__/_testbase.cpython-311.pyc
new file mode 100644
index 0000000..ca115de
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/__pycache__/_testbase.cpython-311.pyc
diff --git a/venv/lib/python3.11/site-packages/uvloop/__pycache__/_version.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvloop/__pycache__/_version.cpython-311.pyc
new file mode 100644
index 0000000..e31e416
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/__pycache__/_version.cpython-311.pyc
diff --git a/venv/lib/python3.11/site-packages/uvloop/_noop.py b/venv/lib/python3.11/site-packages/uvloop/_noop.py
new file mode 100644
index 0000000..bfc14dc
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/_noop.py
@@ -0,0 +1,3 @@
+def noop() -> None:
+    """Empty function to invoke CPython ceval loop."""
+    return
diff --git a/venv/lib/python3.11/site-packages/uvloop/_testbase.py b/venv/lib/python3.11/site-packages/uvloop/_testbase.py
new file mode 100644
index 0000000..c4a7595
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/_testbase.py
@@ -0,0 +1,550 @@
+"""Test utilities. Don't use outside of the uvloop project."""
+
+
+import asyncio
+import asyncio.events
+import collections
+import contextlib
+import gc
+import logging
+import os
+import pprint
+import re
+import select
+import socket
+import ssl
+import sys
+import tempfile
+import threading
+import time
+import unittest
+import uvloop
+
+
+class MockPattern(str):
+    def __eq__(self, other):
+        return bool(re.search(str(self), other, re.S))
+
+
+class TestCaseDict(collections.UserDict):
+
+    def __init__(self, name):
+        super().__init__()
+        self.name = name
+
+    def __setitem__(self, key, value):
+        if key in self.data:
+            raise RuntimeError('duplicate test {}.{}'.format(
+                self.name, key))
+        super().__setitem__(key, value)
+
+
+class BaseTestCaseMeta(type):
+
+    @classmethod
+    def __prepare__(mcls, name, bases):
+        return TestCaseDict(name)
+
+    def __new__(mcls, name, bases, dct):
+        for test_name in dct:
+            if not test_name.startswith('test_'):
+                continue
+            for base in bases:
+                if hasattr(base, test_name):
+                    raise RuntimeError(
+                        'duplicate test {}.{} (also defined in {} '
+                        'parent class)'.format(
+                            name, test_name, base.__name__))
+
+        return super().__new__(mcls, name, bases, dict(dct))
+
+
+class BaseTestCase(unittest.TestCase, metaclass=BaseTestCaseMeta):
+
+    def new_loop(self):
+        raise NotImplementedError
+
+    def new_policy(self):
+        raise NotImplementedError
+
+    def mock_pattern(self, str):
+        return MockPattern(str)
+
+    async def wait_closed(self, obj):
+        if not isinstance(obj, asyncio.StreamWriter):
+            return
+        try:
+            await obj.wait_closed()
+        except (BrokenPipeError, ConnectionError):
+            pass
+
+    def is_asyncio_loop(self):
+        return type(self.loop).__module__.startswith('asyncio.')
+
+    def run_loop_briefly(self, *, delay=0.01):
+        self.loop.run_until_complete(asyncio.sleep(delay))
+
+    def loop_exception_handler(self, loop, context):
+        self.__unhandled_exceptions.append(context)
+        self.loop.default_exception_handler(context)
+
+    def setUp(self):
+        self.loop = self.new_loop()
+        asyncio.set_event_loop_policy(self.new_policy())
+        asyncio.set_event_loop(self.loop)
+        self._check_unclosed_resources_in_debug = True
+
+        self.loop.set_exception_handler(self.loop_exception_handler)
+        self.__unhandled_exceptions = []
+
+    def tearDown(self):
+        self.loop.close()
+
+        if self.__unhandled_exceptions:
+            print('Unexpected calls to loop.call_exception_handler():')
+            pprint.pprint(self.__unhandled_exceptions)
+            self.fail('unexpected calls to loop.call_exception_handler()')
+            return
+
+        if not self._check_unclosed_resources_in_debug:
+            return
+
+        # GC to show any resource warnings as the test completes
+        gc.collect()
+        gc.collect()
+        gc.collect()
+
+        if getattr(self.loop, '_debug_cc', False):
+            gc.collect()
+            gc.collect()
+            gc.collect()
+
+            self.assertEqual(
+                self.loop._debug_uv_handles_total,
+                self.loop._debug_uv_handles_freed,
+                'not all uv_handle_t handles were freed')
+
+            self.assertEqual(
+                self.loop._debug_cb_handles_count, 0,
+                'not all callbacks (call_soon) are GCed')
+
+            self.assertEqual(
+                self.loop._debug_cb_timer_handles_count, 0,
+                'not all timer callbacks (call_later) are GCed')
+
+            self.assertEqual(
+                self.loop._debug_stream_write_ctx_cnt, 0,
+                'not all stream write contexts are GCed')
+
+            for h_name, h_cnt in self.loop._debug_handles_current.items():
+                with self.subTest('Alive handle after test',
+                                  handle_name=h_name):
+                    self.assertEqual(
+                        h_cnt, 0,
+                        'alive {} after test'.format(h_name))
+
+            for h_name, h_cnt in self.loop._debug_handles_total.items():
+                with self.subTest('Total/closed handles',
+                                  handle_name=h_name):
+                    self.assertEqual(
+                        h_cnt, self.loop._debug_handles_closed[h_name],
+                        'total != closed for {}'.format(h_name))
+
+        asyncio.set_event_loop(None)
+        asyncio.set_event_loop_policy(None)
+        self.loop = None
+
+    def skip_unclosed_handles_check(self):
+        self._check_unclosed_resources_in_debug = False
+
+    def tcp_server(self, server_prog, *,
+                   family=socket.AF_INET,
+                   addr=None,
+                   timeout=5,
+                   backlog=1,
+                   max_clients=10):
+
+        if addr is None:
+            if family == socket.AF_UNIX:
+                with tempfile.NamedTemporaryFile() as tmp:
+                    addr = tmp.name
+            else:
+                addr = ('127.0.0.1', 0)
+
+        sock = socket.socket(family, socket.SOCK_STREAM)
+
+        if timeout is None:
+            raise RuntimeError('timeout is required')
+        if timeout <= 0:
+            raise RuntimeError('only blocking sockets are supported')
+        sock.settimeout(timeout)
+
+        try:
+            sock.bind(addr)
+            sock.listen(backlog)
+        except OSError as ex:
+            sock.close()
+            raise ex
+
+        return TestThreadedServer(
+            self, sock, server_prog, timeout, max_clients)
+
+    def tcp_client(self, client_prog,
+                   family=socket.AF_INET,
+                   timeout=10):
+
+        sock = socket.socket(family, socket.SOCK_STREAM)
+
+        if timeout is None:
+            raise RuntimeError('timeout is required')
+        if timeout <= 0:
+            raise RuntimeError('only blocking sockets are supported')
+        sock.settimeout(timeout)
+
+        return TestThreadedClient(
+            self, sock, client_prog, timeout)
+
+    def unix_server(self, *args, **kwargs):
+        return self.tcp_server(*args, family=socket.AF_UNIX, **kwargs)
+
+    def unix_client(self, *args, **kwargs):
+        return self.tcp_client(*args, family=socket.AF_UNIX, **kwargs)
+
+    @contextlib.contextmanager
+    def unix_sock_name(self):
+        with tempfile.TemporaryDirectory() as td:
+            fn = os.path.join(td, 'sock')
+            try:
+                yield fn
+            finally:
+                try:
+                    os.unlink(fn)
+                except OSError:
+                    pass
+
+    def _abort_socket_test(self, ex):
+        try:
+            self.loop.stop()
+        finally:
+            self.fail(ex)
+
+
+def _cert_fullname(test_file_name, cert_file_name):
+    fullname = os.path.abspath(os.path.join(
+        os.path.dirname(test_file_name), 'certs', cert_file_name))
+    assert os.path.isfile(fullname)
+    return fullname
+
+
+@contextlib.contextmanager
+def silence_long_exec_warning():
+
+    class Filter(logging.Filter):
+        def filter(self, record):
+            return not (record.msg.startswith('Executing') and
+                        record.msg.endswith('seconds'))
+
+    logger = logging.getLogger('asyncio')
+    filter = Filter()
+    logger.addFilter(filter)
+    try:
+        yield
+    finally:
+        logger.removeFilter(filter)
+
+
+def find_free_port(start_from=50000):
+    for port in range(start_from, start_from + 500):
+        sock = socket.socket()
+        with sock:
+            try:
+                sock.bind(('', port))
+            except socket.error:
+                continue
+            else:
+                return port
+    raise RuntimeError('could not find a free port')
+
+
+class SSLTestCase:
+
+    def _create_server_ssl_context(self, certfile, keyfile=None):
+        if hasattr(ssl, 'PROTOCOL_TLS'):
+            sslcontext = ssl.SSLContext(ssl.PROTOCOL_TLS)
+        else:
+            sslcontext = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
+        sslcontext.options |= ssl.OP_NO_SSLv2
+        sslcontext.load_cert_chain(certfile, keyfile)
+        return sslcontext
+
+    def _create_client_ssl_context(self, *, disable_verify=True):
+        sslcontext = ssl.create_default_context()
+        sslcontext.check_hostname = False
+        if disable_verify:
+            sslcontext.verify_mode = ssl.CERT_NONE
+        return sslcontext
+
+    @contextlib.contextmanager
+    def _silence_eof_received_warning(self):
+        # TODO This warning has to be fixed in asyncio.
+        logger = logging.getLogger('asyncio')
+        filter = logging.Filter('has no effect when using ssl')
+        logger.addFilter(filter)
+        try:
+            yield
+        finally:
+            logger.removeFilter(filter)
+
+
+class UVTestCase(BaseTestCase):
+
+    implementation = 'uvloop'
+
+    def new_loop(self):
+        return uvloop.new_event_loop()
+
+    def new_policy(self):
+        return uvloop.EventLoopPolicy()
+
+
+class AIOTestCase(BaseTestCase):
+
+    implementation = 'asyncio'
+
+    def setUp(self):
+        super().setUp()
+
+        if sys.version_info < (3, 12):
+            watcher = asyncio.SafeChildWatcher()
+            watcher.attach_loop(self.loop)
+            asyncio.set_child_watcher(watcher)
+
+    def tearDown(self):
+        if sys.version_info < (3, 12):
+            asyncio.set_child_watcher(None)
+        super().tearDown()
+
+    def new_loop(self):
+        return asyncio.new_event_loop()
+
+    def new_policy(self):
+        return asyncio.DefaultEventLoopPolicy()
+
+
+def has_IPv6():
+    server_sock = socket.socket(socket.AF_INET6)
+    with server_sock:
+        try:
+            server_sock.bind(('::1', 0))
+        except OSError:
+            return False
+        else:
+            return True
+
+
+has_IPv6 = has_IPv6()
+
+
+###############################################################################
+# Socket Testing Utilities
+###############################################################################
+
+
+class TestSocketWrapper:
+
+    def __init__(self, sock):
+        self.__sock = sock
+
+    def recv_all(self, n):
+        buf = b''
+        while len(buf) < n:
+            data = self.recv(n - len(buf))
+            if data == b'':
+                raise ConnectionAbortedError
+            buf += data
+        return buf
+
+    def starttls(self, ssl_context, *,
+                 server_side=False,
+                 server_hostname=None,
+                 do_handshake_on_connect=True):
+
+        assert isinstance(ssl_context, ssl.SSLContext)
+
+        ssl_sock = ssl_context.wrap_socket(
+            self.__sock, server_side=server_side,
+            server_hostname=server_hostname,
+            do_handshake_on_connect=do_handshake_on_connect)
+
+        if server_side:
+            ssl_sock.do_handshake()
+
+        self.__sock.close()
+        self.__sock = ssl_sock
+
+    def __getattr__(self, name):
+        return getattr(self.__sock, name)
+
+    def __repr__(self):
+        return '<{} {!r}>'.format(type(self).__name__, self.__sock)
+
+
+class SocketThread(threading.Thread):
+
+    def stop(self):
+        self._active = False
+        self.join()
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, *exc):
+        self.stop()
+
+
+class TestThreadedClient(SocketThread):
+
+    def __init__(self, test, sock, prog, timeout):
+        threading.Thread.__init__(self, None, None, 'test-client')
+        self.daemon = True
+
+        self._timeout = timeout
+        self._sock = sock
+        self._active = True
+        self._prog = prog
+        self._test = test
+
+    def run(self):
+        try:
+            self._prog(TestSocketWrapper(self._sock))
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as ex:
+            self._test._abort_socket_test(ex)
+
+
+class TestThreadedServer(SocketThread):
+
+    def __init__(self, test, sock, prog, timeout, max_clients):
+        threading.Thread.__init__(self, None, None, 'test-server')
+        self.daemon = True
+
+        self._clients = 0
+        self._finished_clients = 0
+        self._max_clients = max_clients
+        self._timeout = timeout
+        self._sock = sock
+        self._active = True
+
+        self._prog = prog
+
+        self._s1, self._s2 = socket.socketpair()
+        self._s1.setblocking(False)
+
+        self._test = test
+
+    def stop(self):
+        try:
+            if self._s2 and self._s2.fileno() != -1:
+                try:
+                    self._s2.send(b'stop')
+                except OSError:
+                    pass
+        finally:
+            super().stop()
+
+    def run(self):
+        try:
+            with self._sock:
+                self._sock.setblocking(0)
+                self._run()
+        finally:
+            self._s1.close()
+            self._s2.close()
+
+    def _run(self):
+        while self._active:
+            if self._clients >= self._max_clients:
+                return
+
+            r, w, x = select.select(
+                [self._sock, self._s1], [], [], self._timeout)
+
+            if self._s1 in r:
+                return
+
+            if self._sock in r:
+                try:
+                    conn, addr = self._sock.accept()
+                except BlockingIOError:
+                    continue
+                except socket.timeout:
+                    if not self._active:
+                        return
+                    else:
+                        raise
+                else:
+                    self._clients += 1
+                    conn.settimeout(self._timeout)
+                    try:
+                        with conn:
+                            self._handle_client(conn)
+                    except (KeyboardInterrupt, SystemExit):
+                        raise
+                    except BaseException as ex:
+                        self._active = False
+                        try:
+                            raise
+                        finally:
+                            self._test._abort_socket_test(ex)
+
+    def _handle_client(self, sock):
+        self._prog(TestSocketWrapper(sock))
+
+    @property
+    def addr(self):
+        return self._sock.getsockname()
+
+
+###############################################################################
+# A few helpers from asyncio/tests/testutils.py
+###############################################################################
+
+
+def run_briefly(loop):
+    async def once():
+        pass
+    gen = once()
+    t = loop.create_task(gen)
+    # Don't log a warning if the task is not done after run_until_complete().
+    # It occurs if the loop is stopped or if a task raises a BaseException.
+    t._log_destroy_pending = False
+    try:
+        loop.run_until_complete(t)
+    finally:
+        gen.close()
+
+
+def run_until(loop, pred, timeout=30):
+    deadline = time.time() + timeout
+    while not pred():
+        if timeout is not None:
+            timeout = deadline - time.time()
+            if timeout <= 0:
+                raise asyncio.futures.TimeoutError()
+        loop.run_until_complete(asyncio.tasks.sleep(0.001))
+
+
+@contextlib.contextmanager
+def disable_logger():
+    """Context manager to disable asyncio logger.
+
+    For example, it can be used to ignore warnings in debug mode.
+    """
+    old_level = asyncio.log.logger.level
+    try:
+        asyncio.log.logger.setLevel(logging.CRITICAL + 1)
+        yield
+    finally:
+        asyncio.log.logger.setLevel(old_level)
diff --git a/venv/lib/python3.11/site-packages/uvloop/_version.py b/venv/lib/python3.11/site-packages/uvloop/_version.py
new file mode 100644
index 0000000..0667c6a
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/_version.py
@@ -0,0 +1,13 @@
+# This file MUST NOT contain anything but the __version__ assignment.
+#
+# When making a release, change the value of __version__
+# to an appropriate value, and open a pull request against
+# the correct branch (master if making a new feature release).
+# The commit message MUST contain a properly formatted release
+# log, and the commit must be signed.
+#
+# The release automation will: build and test the packages for the
+# supported platforms, publish the packages on PyPI, merge the PR
+# to the target branch, create a Git tag pointing to the commit.
+
+__version__ = '0.19.0'
diff --git a/venv/lib/python3.11/site-packages/uvloop/cbhandles.pxd b/venv/lib/python3.11/site-packages/uvloop/cbhandles.pxd
new file mode 100644
index 0000000..e594b13
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/cbhandles.pxd
@@ -0,0 +1,39 @@
+cdef class Handle:
+    cdef:
+        Loop loop
+        object context
+        bint _cancelled
+
+        str meth_name
+        int cb_type
+        void *callback
+        object arg1, arg2, arg3, arg4
+
+        object __weakref__
+
+        readonly _source_traceback
+
+    cdef inline _set_loop(self, Loop loop)
+    cdef inline _set_context(self, object context)
+
+    cdef inline _run(self)
+    cdef _cancel(self)
+
+    cdef _format_handle(self)
+
+
+cdef class TimerHandle:
+    cdef:
+        object callback
+        tuple args
+        bint _cancelled
+        UVTimer timer
+        Loop loop
+        object context
+        tuple _debug_info
+        object __weakref__
+        object _when
+
+    cdef _run(self)
+    cdef _cancel(self)
+    cdef inline _clear(self)
diff --git a/venv/lib/python3.11/site-packages/uvloop/cbhandles.pyx b/venv/lib/python3.11/site-packages/uvloop/cbhandles.pyx
new file mode 100644
index 0000000..2914b42
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/cbhandles.pyx
@@ -0,0 +1,434 @@
+@cython.no_gc_clear
+@cython.freelist(DEFAULT_FREELIST_SIZE)
+cdef class Handle:
+    def __cinit__(self):
+        self._cancelled = 0
+        self.cb_type = 0
+        self._source_traceback = None
+
+    cdef inline _set_loop(self, Loop loop):
+        self.loop = loop
+        if UVLOOP_DEBUG:
+            loop._debug_cb_handles_total += 1
+            loop._debug_cb_handles_count += 1
+        if loop._debug:
+            self._source_traceback = extract_stack()
+
+    cdef inline _set_context(self, object context):
+        if context is None:
+            context = Context_CopyCurrent()
+        self.context = context
+
+    def __dealloc__(self):
+        if UVLOOP_DEBUG and self.loop is not None:
+            self.loop._debug_cb_handles_count -= 1
+        if self.loop is None:
+            raise RuntimeError('Handle.loop is None in Handle.__dealloc__')
+
+    def __init__(self):
+        raise TypeError(
+            '{} is not supposed to be instantiated from Python'.format(
+                self.__class__.__name__))
+
+    cdef inline _run(self):
+        cdef:
+            int cb_type
+            object callback
+
+        if self._cancelled:
+            return
+
+        cb_type = self.cb_type
+
+        # Since _run is a cdef and there's no BoundMethod,
+        # we guard 'self' manually (since the callback
+        # might cause GC of the handle.)
+        Py_INCREF(self)
+
+        try:
+            assert self.context is not None
+            Context_Enter(self.context)
+
+            if cb_type == 1:
+                callback = self.arg1
+                if callback is None:
+                    raise RuntimeError(
+                        'cannot run Handle; callback is not set')
+
+                args = self.arg2
+
+                if args is None:
+                    callback()
+                else:
+                    callback(*args)
+
+            elif cb_type == 2:
+                (<method_t>self.callback)(self.arg1)
+
+            elif cb_type == 3:
+                (<method1_t>self.callback)(self.arg1, self.arg2)
+
+            elif cb_type == 4:
+                (<method2_t>self.callback)(self.arg1, self.arg2, self.arg3)
+
+            elif cb_type == 5:
+                (<method3_t>self.callback)(
+                    self.arg1, self.arg2, self.arg3, self.arg4)
+
+            else:
+                raise RuntimeError('invalid Handle.cb_type: {}'.format(
+                    cb_type))
+
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as ex:
+            if cb_type == 1:
+                msg = 'Exception in callback {}'.format(callback)
+            else:
+                msg = 'Exception in callback {}'.format(self.meth_name)
+
+            context = {
+                'message': msg,
+                'exception': ex,
+                'handle': self,
+            }
+
+            if self._source_traceback is not None:
+                context['source_traceback'] = self._source_traceback
+
+            self.loop.call_exception_handler(context)
+
+        finally:
+            context = self.context
+            Py_DECREF(self)
+            Context_Exit(context)
+
+    cdef _cancel(self):
+        self._cancelled = 1
+        self.callback = NULL
+        self.arg1 = self.arg2 = self.arg3 = self.arg4 = None
+
+    cdef _format_handle(self):
+        # Mirrors `asyncio.base_events._format_handle`.
+        if self.cb_type == 1 and self.arg1 is not None:
+            cb = self.arg1
+            if isinstance(getattr(cb, '__self__', None), aio_Task):
+                try:
+                    return repr(cb.__self__)
+                except (AttributeError, TypeError, ValueError) as ex:
+                    # Cython generates empty __code__ objects for coroutines
+                    # that can crash asyncio.Task.__repr__ with an
+                    # AttributeError etc.  Guard against that.
+                    self.loop.call_exception_handler({
+                        'message': 'exception in Task.__repr__',
+                        'task': cb.__self__,
+                        'exception': ex,
+                        'handle': self,
+                    })
+        return repr(self)
+
+    # Public API
+
+    def __repr__(self):
+        info = [self.__class__.__name__]
+
+        if self._cancelled:
+            info.append('cancelled')
+
+        if self.cb_type == 1 and self.arg1 is not None:
+            func = self.arg1
+            # Cython can unset func.__qualname__/__name__, hence the checks.
+            if hasattr(func, '__qualname__') and func.__qualname__:
+                cb_name = func.__qualname__
+            elif hasattr(func, '__name__') and func.__name__:
+                cb_name = func.__name__
+            else:
+                cb_name = repr(func)
+
+            info.append(cb_name)
+        elif self.meth_name is not None:
+            info.append(self.meth_name)
+
+        if self._source_traceback is not None:
+            frame = self._source_traceback[-1]
+            info.append('created at {}:{}'.format(frame[0], frame[1]))
+
+        return '<' + ' '.join(info) + '>'
+
+    def cancel(self):
+        self._cancel()
+
+    def cancelled(self):
+        return self._cancelled
+
+
+@cython.no_gc_clear
+@cython.freelist(DEFAULT_FREELIST_SIZE)
+cdef class TimerHandle:
+    def __cinit__(self, Loop loop, object callback, object args,
+                  uint64_t delay, object context):
+
+        self.loop = loop
+        self.callback = callback
+        self.args = args
+        self._cancelled = 0
+
+        if UVLOOP_DEBUG:
+            self.loop._debug_cb_timer_handles_total += 1
+            self.loop._debug_cb_timer_handles_count += 1
+
+        if context is None:
+            context = Context_CopyCurrent()
+        self.context = context
+
+        if loop._debug:
+            self._debug_info = (
+                format_callback_name(callback),
+                extract_stack()
+            )
+        else:
+            self._debug_info = None
+
+        self.timer = UVTimer.new(
+            loop, <method_t>self._run, self, delay)
+
+        self.timer.start()
+        self._when = self.timer.get_when() * 1e-3
+
+        # Only add to loop._timers when `self.timer` is successfully created
+        loop._timers.add(self)
+
+    property _source_traceback:
+        def __get__(self):
+            if self._debug_info is not None:
+                return self._debug_info[1]
+
+    def __dealloc__(self):
+        if UVLOOP_DEBUG:
+            self.loop._debug_cb_timer_handles_count -= 1
+        if self.timer is not None:
+            raise RuntimeError('active TimerHandle is deallacating')
+
+    cdef _cancel(self):
+        if self._cancelled == 1:
+            return
+        self._cancelled = 1
+        self._clear()
+
+    cdef inline _clear(self):
+        if self.timer is None:
+            return
+
+        self.callback = None
+        self.args = None
+
+        try:
+            self.loop._timers.remove(self)
+        finally:
+            self.timer._close()
+            self.timer = None  # let the UVTimer handle GC
+
+    cdef _run(self):
+        if self._cancelled == 1:
+            return
+        if self.callback is None:
+            raise RuntimeError('cannot run TimerHandle; callback is not set')
+
+        callback = self.callback
+        args = self.args
+
+        # Since _run is a cdef and there's no BoundMethod,
+        # we guard 'self' manually.
+        Py_INCREF(self)
+
+        if self.loop._debug:
+            started = time_monotonic()
+        try:
+            assert self.context is not None
+            Context_Enter(self.context)
+
+            if args is not None:
+                callback(*args)
+            else:
+                callback()
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as ex:
+            context = {
+                'message': 'Exception in callback {}'.format(callback),
+                'exception': ex,
+                'handle': self,
+            }
+
+            if self._debug_info is not None:
+                context['source_traceback'] = self._debug_info[1]
+
+            self.loop.call_exception_handler(context)
+        else:
+            if self.loop._debug:
+                delta = time_monotonic() - started
+                if delta > self.loop.slow_callback_duration:
+                    aio_logger.warning(
+                        'Executing %r took %.3f seconds',
+                        self, delta)
+        finally:
+            context = self.context
+            Py_DECREF(self)
+            Context_Exit(context)
+            self._clear()
+
+    # Public API
+
+    def __repr__(self):
+        info = [self.__class__.__name__]
+
+        if self._cancelled:
+            info.append('cancelled')
+
+        if self._debug_info is not None:
+            callback_name = self._debug_info[0]
+            source_traceback = self._debug_info[1]
+        else:
+            callback_name = None
+            source_traceback = None
+
+        if callback_name is not None:
+            info.append(callback_name)
+        elif self.callback is not None:
+            info.append(format_callback_name(self.callback))
+
+        if source_traceback is not None:
+            frame = source_traceback[-1]
+            info.append('created at {}:{}'.format(frame[0], frame[1]))
+
+        return '<' + ' '.join(info) + '>'
+
+    def cancelled(self):
+        return self._cancelled
+
+    def cancel(self):
+        self._cancel()
+
+    def when(self):
+        return self._when
+
+
+cdef format_callback_name(func):
+    if hasattr(func, '__qualname__'):
+        cb_name = getattr(func, '__qualname__')
+    elif hasattr(func, '__name__'):
+        cb_name = getattr(func, '__name__')
+    else:
+        cb_name = repr(func)
+    return cb_name
+
+
+cdef new_Handle(Loop loop, object callback, object args, object context):
+    cdef Handle handle
+    handle = Handle.__new__(Handle)
+    handle._set_loop(loop)
+    handle._set_context(context)
+
+    handle.cb_type = 1
+
+    handle.arg1 = callback
+    handle.arg2 = args
+
+    return handle
+
+
+cdef new_MethodHandle(Loop loop, str name, method_t callback, object context,
+                      object bound_to):
+    cdef Handle handle
+    handle = Handle.__new__(Handle)
+    handle._set_loop(loop)
+    handle._set_context(context)
+
+    handle.cb_type = 2
+    handle.meth_name = name
+
+    handle.callback = <void*> callback
+    handle.arg1 = bound_to
+
+    return handle
+
+
+cdef new_MethodHandle1(Loop loop, str name, method1_t callback, object context,
+                       object bound_to, object arg):
+
+    cdef Handle handle
+    handle = Handle.__new__(Handle)
+    handle._set_loop(loop)
+    handle._set_context(context)
+
+    handle.cb_type = 3
+    handle.meth_name = name
+
+    handle.callback = <void*> callback
+    handle.arg1 = bound_to
+    handle.arg2 = arg
+
+    return handle
+
+
+cdef new_MethodHandle2(Loop loop, str name, method2_t callback, object context,
+                       object bound_to, object arg1, object arg2):
+
+    cdef Handle handle
+    handle = Handle.__new__(Handle)
+    handle._set_loop(loop)
+    handle._set_context(context)
+
+    handle.cb_type = 4
+    handle.meth_name = name
+
+    handle.callback = <void*> callback
+    handle.arg1 = bound_to
+    handle.arg2 = arg1
+    handle.arg3 = arg2
+
+    return handle
+
+
+cdef new_MethodHandle3(Loop loop, str name, method3_t callback, object context,
+                       object bound_to, object arg1, object arg2, object arg3):
+
+    cdef Handle handle
+    handle = Handle.__new__(Handle)
+    handle._set_loop(loop)
+    handle._set_context(context)
+
+    handle.cb_type = 5
+    handle.meth_name = name
+
+    handle.callback = <void*> callback
+    handle.arg1 = bound_to
+    handle.arg2 = arg1
+    handle.arg3 = arg2
+    handle.arg4 = arg3
+
+    return handle
+
+
+cdef extract_stack():
+    """Replacement for traceback.extract_stack() that only does the
+    necessary work for asyncio debug mode.
+    """
+    try:
+        f = sys_getframe()
+    # sys._getframe() might raise ValueError if being called without a frame, e.g.
+    # from Cython or similar C extensions.
+    except ValueError:
+        return None
+    if f is None:
+        return
+
+    try:
+        stack = tb_StackSummary.extract(tb_walk_stack(f),
+                                        limit=DEBUG_STACK_DEPTH,
+                                        lookup_lines=False)
+    finally:
+        f = None
+
+    stack.reverse()
+    return stack
diff --git a/venv/lib/python3.11/site-packages/uvloop/dns.pyx b/venv/lib/python3.11/site-packages/uvloop/dns.pyx
new file mode 100644
index 0000000..7aad631
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/dns.pyx
@@ -0,0 +1,471 @@
+cdef __port_to_int(port, proto):
+    if type(port) is int:
+        return port
+
+    if port is None or port == '' or port == b'':
+        return 0
+
+    try:
+        return int(port)
+    except (ValueError, TypeError):
+        pass
+
+    if isinstance(port, bytes):
+        port = port.decode()
+
+    if isinstance(port, str) and proto is not None:
+        if proto == uv.IPPROTO_TCP:
+            return socket_getservbyname(port, 'tcp')
+        elif proto == uv.IPPROTO_UDP:
+            return socket_getservbyname(port, 'udp')
+
+    raise OSError('service/proto not found')
+
+
+cdef __convert_sockaddr_to_pyaddr(const system.sockaddr* addr):
+    # Converts sockaddr structs into what Python socket
+    # module can understand:
+    #   - for IPv4 a tuple of (host, port)
+    #   - for IPv6 a tuple of (host, port, flowinfo, scope_id)
+
+    cdef:
+        char buf[128]  # INET6_ADDRSTRLEN is usually 46
+        int err
+        system.sockaddr_in *addr4
+        system.sockaddr_in6 *addr6
+        system.sockaddr_un *addr_un
+
+    if addr.sa_family == uv.AF_INET:
+        addr4 = <system.sockaddr_in*>addr
+
+        err = uv.uv_ip4_name(addr4, buf, sizeof(buf))
+        if err < 0:
+            raise convert_error(err)
+
+        return (
+            PyUnicode_FromString(buf),
+            system.ntohs(addr4.sin_port)
+        )
+
+    elif addr.sa_family == uv.AF_INET6:
+        addr6 = <system.sockaddr_in6*>addr
+
+        err = uv.uv_ip6_name(addr6, buf, sizeof(buf))
+        if err < 0:
+            raise convert_error(err)
+
+        return (
+            PyUnicode_FromString(buf),
+            system.ntohs(addr6.sin6_port),
+            system.ntohl(addr6.sin6_flowinfo),
+            addr6.sin6_scope_id
+        )
+
+    elif addr.sa_family == uv.AF_UNIX:
+        addr_un = <system.sockaddr_un*>addr
+        return system.MakeUnixSockPyAddr(addr_un)
+
+    raise RuntimeError("cannot convert sockaddr into Python object")
+
+
+@cython.freelist(DEFAULT_FREELIST_SIZE)
+cdef class SockAddrHolder:
+    cdef:
+        int family
+        system.sockaddr_storage addr
+        Py_ssize_t addr_size
+
+
+cdef LruCache sockaddrs = LruCache(maxsize=DNS_PYADDR_TO_SOCKADDR_CACHE_SIZE)
+
+
+cdef __convert_pyaddr_to_sockaddr(int family, object addr,
+                                  system.sockaddr* res):
+    cdef:
+        int err
+        int addr_len
+        int scope_id = 0
+        int flowinfo = 0
+        char *buf
+        Py_ssize_t buflen
+        SockAddrHolder ret
+
+    ret = sockaddrs.get(addr, None)
+    if ret is not None and ret.family == family:
+        memcpy(res, &ret.addr, ret.addr_size)
+        return
+
+    ret = SockAddrHolder.__new__(SockAddrHolder)
+    if family == uv.AF_INET:
+        if not isinstance(addr, tuple):
+            raise TypeError('AF_INET address must be tuple')
+        if len(addr) != 2:
+            raise ValueError('AF_INET address must be tuple of (host, port)')
+        host, port = addr
+        if isinstance(host, str):
+            try:
+                # idna codec is rather slow, so we try ascii first.
+                host = host.encode('ascii')
+            except UnicodeEncodeError:
+                host = host.encode('idna')
+        if not isinstance(host, (bytes, bytearray)):
+            raise TypeError('host must be a string or bytes object')
+
+        port = __port_to_int(port, None)
+
+        ret.addr_size = sizeof(system.sockaddr_in)
+        err = uv.uv_ip4_addr(host, <int>port, <system.sockaddr_in*>&ret.addr)
+        if err < 0:
+            raise convert_error(err)
+
+    elif family == uv.AF_INET6:
+        if not isinstance(addr, tuple):
+            raise TypeError('AF_INET6 address must be tuple')
+
+        addr_len = len(addr)
+        if addr_len < 2 or addr_len > 4:
+            raise ValueError(
+                'AF_INET6 must be a tuple of 2-4 parameters: '
+                '(host, port, flowinfo?, scope_id?)')
+
+        host = addr[0]
+        if isinstance(host, str):
+            try:
+                # idna codec is rather slow, so we try ascii first.
+                host = host.encode('ascii')
+            except UnicodeEncodeError:
+                host = host.encode('idna')
+        if not isinstance(host, (bytes, bytearray)):
+            raise TypeError('host must be a string or bytes object')
+
+        port = __port_to_int(addr[1], None)
+
+        if addr_len > 2:
+            flowinfo = addr[2]
+        if addr_len > 3:
+            scope_id = addr[3]
+
+        ret.addr_size = sizeof(system.sockaddr_in6)
+
+        err = uv.uv_ip6_addr(host, port, <system.sockaddr_in6*>&ret.addr)
+        if err < 0:
+            raise convert_error(err)
+
+        (<system.sockaddr_in6*>&ret.addr).sin6_flowinfo = flowinfo
+        (<system.sockaddr_in6*>&ret.addr).sin6_scope_id = scope_id
+
+    elif family == uv.AF_UNIX:
+        if isinstance(addr, str):
+            addr = addr.encode(sys_getfilesystemencoding())
+        elif not isinstance(addr, bytes):
+            raise TypeError('AF_UNIX address must be a str or a bytes object')
+
+        PyBytes_AsStringAndSize(addr, &buf, &buflen)
+        if buflen > 107:
+            raise ValueError(
+                f'unix socket path {addr!r} is longer than 107 characters')
+
+        ret.addr_size = sizeof(system.sockaddr_un)
+        memset(&ret.addr, 0, sizeof(system.sockaddr_un))
+        (<system.sockaddr_un*>&ret.addr).sun_family = uv.AF_UNIX
+        memcpy((<system.sockaddr_un*>&ret.addr).sun_path, buf, buflen)
+
+    else:
+        raise ValueError(
+            f'expected AF_INET, AF_INET6, or AF_UNIX family, got {family}')
+
+    ret.family = family
+    sockaddrs[addr] = ret
+    memcpy(res, &ret.addr, ret.addr_size)
+
+
+cdef __static_getaddrinfo(object host, object port,
+                          int family, int type,
+                          int proto,
+                          system.sockaddr *addr):
+
+    if proto not in {0, uv.IPPROTO_TCP, uv.IPPROTO_UDP}:
+        return
+
+    if _is_sock_stream(type):
+        proto = uv.IPPROTO_TCP
+    elif _is_sock_dgram(type):
+        proto = uv.IPPROTO_UDP
+    else:
+        return
+
+    try:
+        port = __port_to_int(port, proto)
+    except Exception:
+        return
+
+    hp = (host, port)
+    if family == uv.AF_UNSPEC:
+        try:
+            __convert_pyaddr_to_sockaddr(uv.AF_INET, hp, addr)
+        except Exception:
+            pass
+        else:
+            return (uv.AF_INET, type, proto)
+
+        try:
+            __convert_pyaddr_to_sockaddr(uv.AF_INET6, hp, addr)
+        except Exception:
+            pass
+        else:
+            return (uv.AF_INET6, type, proto)
+
+    else:
+        try:
+            __convert_pyaddr_to_sockaddr(family, hp, addr)
+        except Exception:
+            pass
+        else:
+            return (family, type, proto)
+
+
+cdef __static_getaddrinfo_pyaddr(object host, object port,
+                                 int family, int type,
+                                 int proto, int flags):
+
+    cdef:
+        system.sockaddr_storage addr
+        object triplet
+
+    triplet = __static_getaddrinfo(
+        host, port, family, type,
+        proto, <system.sockaddr*>&addr)
+    if triplet is None:
+        return
+
+    af, type, proto = triplet
+
+    try:
+        pyaddr = __convert_sockaddr_to_pyaddr(<system.sockaddr*>&addr)
+    except Exception:
+        return
+
+    # When the host is an IP while type is one of TCP or UDP, different libc
+    # implementations of getaddrinfo() behave differently:
+    # 1. When AI_CANONNAME is set:
+    #    * glibc: returns ai_canonname
+    #    * musl: returns ai_canonname
+    #    * macOS: returns an empty string for ai_canonname
+    # 2. When AI_CANONNAME is NOT set:
+    #    * glibc: returns an empty string for ai_canonname
+    #    * musl: returns ai_canonname
+    #    * macOS: returns an empty string for ai_canonname
+    # At the same time, libuv and CPython both uses libc directly, even though
+    # this different behavior is violating what is in the documentation.
+    #
+    # uvloop potentially should be a 100% drop-in replacement for asyncio,
+    # doing whatever asyncio does, especially when the libc implementations are
+    # also different in the same way. However, making our implementation to be
+    # consistent with libc/CPython would be complex and hard to maintain
+    # (including caching libc behaviors when flag is/not set), therefore we
+    # decided to simply normalize the behavior in uvloop for this very marginal
+    # case following the documentation, even though uvloop would behave
+    # differently to asyncio on macOS and musl platforms, when again the host
+    # is an IP and type is one of TCP or UDP.
+    # All other cases are still asyncio-compatible.
+    if flags & socket_AI_CANONNAME:
+        if isinstance(host, str):
+            canon_name = host
+        else:
+            canon_name = host.decode('ascii')
+    else:
+        canon_name = ''
+
+    return (
+        _intenum_converter(af, socket_AddressFamily),
+        _intenum_converter(type, socket_SocketKind),
+        proto,
+        canon_name,
+        pyaddr,
+    )
+
+
+@cython.freelist(DEFAULT_FREELIST_SIZE)
+cdef class AddrInfo:
+    cdef:
+        system.addrinfo *data
+
+    def __cinit__(self):
+        self.data = NULL
+
+    def __dealloc__(self):
+        if self.data is not NULL:
+            uv.uv_freeaddrinfo(self.data)  # returns void
+            self.data = NULL
+
+    cdef void set_data(self, system.addrinfo *data):
+        self.data = data
+
+    cdef unpack(self):
+        cdef:
+            list result = []
+            system.addrinfo *ptr
+
+        if self.data is NULL:
+            raise RuntimeError('AddrInfo.data is NULL')
+
+        ptr = self.data
+        while ptr != NULL:
+            if ptr.ai_addr.sa_family in (uv.AF_INET, uv.AF_INET6):
+                result.append((
+                    _intenum_converter(ptr.ai_family, socket_AddressFamily),
+                    _intenum_converter(ptr.ai_socktype, socket_SocketKind),
+                    ptr.ai_protocol,
+                    ('' if ptr.ai_canonname is NULL else
+                        (<bytes>ptr.ai_canonname).decode()),
+                    __convert_sockaddr_to_pyaddr(ptr.ai_addr)
+                ))
+
+            ptr = ptr.ai_next
+
+        return result
+
+    @staticmethod
+    cdef int isinstance(object other):
+        return type(other) is AddrInfo
+
+
+cdef class AddrInfoRequest(UVRequest):
+    cdef:
+        system.addrinfo hints
+        object callback
+        uv.uv_getaddrinfo_t _req_data
+
+    def __cinit__(self, Loop loop,
+                  bytes host, bytes port,
+                  int family, int type, int proto, int flags,
+                  object callback):
+
+        cdef:
+            int err
+            char *chost
+            char *cport
+
+        if host is None:
+            chost = NULL
+        else:
+            chost = <char*>host
+
+        if port is None:
+            cport = NULL
+        else:
+            cport = <char*>port
+
+        if cport is NULL and chost is NULL:
+            self.on_done()
+            msg = system.gai_strerror(socket_EAI_NONAME).decode('utf-8')
+            ex = socket_gaierror(socket_EAI_NONAME, msg)
+            callback(ex)
+            return
+
+        memset(&self.hints, 0, sizeof(system.addrinfo))
+        self.hints.ai_flags = flags
+        self.hints.ai_family = family
+        self.hints.ai_socktype = type
+        self.hints.ai_protocol = proto
+
+        self.request = <uv.uv_req_t*> &self._req_data
+        self.callback = callback
+        self.request.data = <void*>self
+
+        err = uv.uv_getaddrinfo(loop.uvloop,
+                                <uv.uv_getaddrinfo_t*>self.request,
+                                __on_addrinfo_resolved,
+                                chost,
+                                cport,
+                                &self.hints)
+
+        if err < 0:
+            self.on_done()
+            callback(convert_error(err))
+
+
+cdef class NameInfoRequest(UVRequest):
+    cdef:
+        object callback
+        uv.uv_getnameinfo_t _req_data
+
+    def __cinit__(self, Loop loop, callback):
+        self.request = <uv.uv_req_t*> &self._req_data
+        self.callback = callback
+        self.request.data = <void*>self
+
+    cdef query(self, system.sockaddr *addr, int flags):
+        cdef int err
+        err = uv.uv_getnameinfo(self.loop.uvloop,
+                                <uv.uv_getnameinfo_t*>self.request,
+                                __on_nameinfo_resolved,
+                                addr,
+                                flags)
+        if err < 0:
+            self.on_done()
+            self.callback(convert_error(err))
+
+
+cdef _intenum_converter(value, enum_klass):
+    try:
+        return enum_klass(value)
+    except ValueError:
+        return value
+
+
+cdef void __on_addrinfo_resolved(
+    uv.uv_getaddrinfo_t *resolver,
+    int status,
+    system.addrinfo *res,
+) noexcept with gil:
+
+    if resolver.data is NULL:
+        aio_logger.error(
+            'AddrInfoRequest callback called with NULL resolver.data')
+        return
+
+    cdef:
+        AddrInfoRequest request = <AddrInfoRequest> resolver.data
+        Loop loop = request.loop
+        object callback = request.callback
+        AddrInfo ai
+
+    try:
+        if status < 0:
+            callback(convert_error(status))
+        else:
+            ai = AddrInfo()
+            ai.set_data(res)
+            callback(ai)
+    except (KeyboardInterrupt, SystemExit):
+        raise
+    except BaseException as ex:
+        loop._handle_exception(ex)
+    finally:
+        request.on_done()
+
+
+cdef void __on_nameinfo_resolved(
+    uv.uv_getnameinfo_t* req,
+    int status,
+    const char* hostname,
+    const char* service,
+) noexcept with gil:
+    cdef:
+        NameInfoRequest request = <NameInfoRequest> req.data
+        Loop loop = request.loop
+        object callback = request.callback
+
+    try:
+        if status < 0:
+            callback(convert_error(status))
+        else:
+            callback(((<bytes>hostname).decode(),
+                      (<bytes>service).decode()))
+    except (KeyboardInterrupt, SystemExit):
+        raise
+    except BaseException as ex:
+        loop._handle_exception(ex)
+    finally:
+        request.on_done()
diff --git a/venv/lib/python3.11/site-packages/uvloop/errors.pyx b/venv/lib/python3.11/site-packages/uvloop/errors.pyx
new file mode 100644
index 0000000..d810d65
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/errors.pyx
@@ -0,0 +1,113 @@
+cdef str __strerr(int errno):
+    return strerror(errno).decode()
+
+
+cdef __convert_python_error(int uverr):
+    # XXX Won't work for Windows:
+    # From libuv docs:
+    #      Implementation detail: on Unix error codes are the
+    #      negated errno (or -errno), while on Windows they
+    #      are defined by libuv to arbitrary negative numbers.
+    cdef int oserr = -uverr
+
+    exc = OSError
+
+    if uverr in (uv.UV_EACCES, uv.UV_EPERM):
+        exc = PermissionError
+
+    elif uverr in (uv.UV_EAGAIN, uv.UV_EALREADY):
+        exc = BlockingIOError
+
+    elif uverr in (uv.UV_EPIPE, uv.UV_ESHUTDOWN):
+        exc = BrokenPipeError
+
+    elif uverr == uv.UV_ECONNABORTED:
+        exc = ConnectionAbortedError
+
+    elif uverr == uv.UV_ECONNREFUSED:
+        exc = ConnectionRefusedError
+
+    elif uverr == uv.UV_ECONNRESET:
+        exc = ConnectionResetError
+
+    elif uverr == uv.UV_EEXIST:
+        exc = FileExistsError
+
+    elif uverr == uv.UV_ENOENT:
+        exc = FileNotFoundError
+
+    elif uverr == uv.UV_EINTR:
+        exc = InterruptedError
+
+    elif uverr == uv.UV_EISDIR:
+        exc = IsADirectoryError
+
+    elif uverr == uv.UV_ESRCH:
+        exc = ProcessLookupError
+
+    elif uverr == uv.UV_ETIMEDOUT:
+        exc = TimeoutError
+
+    return exc(oserr, __strerr(oserr))
+
+
+cdef int __convert_socket_error(int uverr):
+    cdef int sock_err = 0
+
+    if uverr == uv.UV_EAI_ADDRFAMILY:
+        sock_err = socket_EAI_ADDRFAMILY
+
+    elif uverr == uv.UV_EAI_AGAIN:
+        sock_err = socket_EAI_AGAIN
+
+    elif uverr == uv.UV_EAI_BADFLAGS:
+        sock_err = socket_EAI_BADFLAGS
+
+    elif uverr == uv.UV_EAI_BADHINTS:
+        sock_err = socket_EAI_BADHINTS
+
+    elif uverr == uv.UV_EAI_CANCELED:
+        sock_err = socket_EAI_CANCELED
+
+    elif uverr == uv.UV_EAI_FAIL:
+        sock_err = socket_EAI_FAIL
+
+    elif uverr == uv.UV_EAI_FAMILY:
+        sock_err = socket_EAI_FAMILY
+
+    elif uverr == uv.UV_EAI_MEMORY:
+        sock_err = socket_EAI_MEMORY
+
+    elif uverr == uv.UV_EAI_NODATA:
+        sock_err = socket_EAI_NODATA
+
+    elif uverr == uv.UV_EAI_NONAME:
+        sock_err = socket_EAI_NONAME
+
+    elif uverr == uv.UV_EAI_OVERFLOW:
+        sock_err = socket_EAI_OVERFLOW
+
+    elif uverr == uv.UV_EAI_PROTOCOL:
+        sock_err = socket_EAI_PROTOCOL
+
+    elif uverr == uv.UV_EAI_SERVICE:
+        sock_err = socket_EAI_SERVICE
+
+    elif uverr == uv.UV_EAI_SOCKTYPE:
+        sock_err = socket_EAI_SOCKTYPE
+
+    return sock_err
+
+
+cdef convert_error(int uverr):
+    cdef int sock_err
+
+    if uverr == uv.UV_ECANCELED:
+        return aio_CancelledError()
+
+    sock_err = __convert_socket_error(uverr)
+    if sock_err:
+        msg = system.gai_strerror(sock_err).decode('utf-8')
+        return socket_gaierror(sock_err, msg)
+
+    return __convert_python_error(uverr)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/async_.pxd b/venv/lib/python3.11/site-packages/uvloop/handles/async_.pxd
new file mode 100644
index 0000000..5f0d820
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/async_.pxd
@@ -0,0 +1,11 @@
+cdef class UVAsync(UVHandle):
+    cdef:
+        method_t callback
+        object ctx
+
+    cdef _init(self, Loop loop, method_t callback, object ctx)
+
+    cdef send(self)
+
+    @staticmethod
+    cdef UVAsync new(Loop loop, method_t callback, object ctx)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/async_.pyx b/venv/lib/python3.11/site-packages/uvloop/handles/async_.pyx
new file mode 100644
index 0000000..5c740cf
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/async_.pyx
@@ -0,0 +1,56 @@
+@cython.no_gc_clear
+cdef class UVAsync(UVHandle):
+    cdef _init(self, Loop loop, method_t callback, object ctx):
+        cdef int err
+
+        self._start_init(loop)
+
+        self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_async_t))
+        if self._handle is NULL:
+            self._abort_init()
+            raise MemoryError()
+
+        err = uv.uv_async_init(self._loop.uvloop,
+                               <uv.uv_async_t*>self._handle,
+                               __uvasync_callback)
+        if err < 0:
+            self._abort_init()
+            raise convert_error(err)
+
+        self._finish_init()
+
+        self.callback = callback
+        self.ctx = ctx
+
+    cdef send(self):
+        cdef int err
+
+        self._ensure_alive()
+
+        err = uv.uv_async_send(<uv.uv_async_t*>self._handle)
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+
+    @staticmethod
+    cdef UVAsync new(Loop loop, method_t callback, object ctx):
+        cdef UVAsync handle
+        handle = UVAsync.__new__(UVAsync)
+        handle._init(loop, callback, ctx)
+        return handle
+
+
+cdef void __uvasync_callback(
+    uv.uv_async_t* handle,
+) noexcept with gil:
+    if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVAsync callback") == 0:
+        return
+
+    cdef:
+        UVAsync async_ = <UVAsync> handle.data
+        method_t cb = async_.callback
+    try:
+        cb(async_.ctx)
+    except BaseException as ex:
+        async_._error(ex, False)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/basetransport.pxd b/venv/lib/python3.11/site-packages/uvloop/handles/basetransport.pxd
new file mode 100644
index 0000000..ba356a7
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/basetransport.pxd
@@ -0,0 +1,54 @@
+cdef class UVBaseTransport(UVSocketHandle):
+
+    cdef:
+        readonly bint _closing
+
+        bint _protocol_connected
+        bint _protocol_paused
+        object _protocol_data_received
+        size_t _high_water
+        size_t _low_water
+
+        object _protocol
+        Server _server
+        object _waiter
+
+        dict _extra_info
+
+        uint32_t _conn_lost
+
+        object __weakref__
+
+    # All "inline" methods are final
+
+    cdef inline _maybe_pause_protocol(self)
+    cdef inline _maybe_resume_protocol(self)
+
+    cdef inline _schedule_call_connection_made(self)
+    cdef inline _schedule_call_connection_lost(self, exc)
+
+    cdef _wakeup_waiter(self)
+    cdef _call_connection_made(self)
+    cdef _call_connection_lost(self, exc)
+
+    # Overloads of UVHandle methods:
+    cdef _fatal_error(self, exc, throw, reason=?)
+    cdef _close(self)
+
+    cdef inline _set_server(self, Server server)
+    cdef inline _set_waiter(self, object waiter)
+
+    cdef _set_protocol(self, object protocol)
+    cdef _clear_protocol(self)
+
+    cdef inline _init_protocol(self)
+    cdef inline _add_extra_info(self, str name, object obj)
+
+    # === overloads ===
+
+    cdef _new_socket(self)
+    cdef size_t _get_write_buffer_size(self)
+
+    cdef bint _is_reading(self)
+    cdef _start_reading(self)
+    cdef _stop_reading(self)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/basetransport.pyx b/venv/lib/python3.11/site-packages/uvloop/handles/basetransport.pyx
new file mode 100644
index 0000000..28b3079
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/basetransport.pyx
@@ -0,0 +1,293 @@
+cdef class UVBaseTransport(UVSocketHandle):
+
+    def __cinit__(self):
+        # Flow control
+        self._high_water = FLOW_CONTROL_HIGH_WATER * 1024
+        self._low_water = FLOW_CONTROL_HIGH_WATER // 4
+
+        self._protocol = None
+        self._protocol_connected = 0
+        self._protocol_paused = 0
+        self._protocol_data_received = None
+
+        self._server = None
+        self._waiter = None
+        self._extra_info = None
+
+        self._conn_lost = 0
+
+        self._closing = 0
+
+    cdef size_t _get_write_buffer_size(self):
+        return 0
+
+    cdef inline _schedule_call_connection_made(self):
+        self._loop._call_soon_handle(
+            new_MethodHandle(self._loop,
+                             "UVTransport._call_connection_made",
+                             <method_t>self._call_connection_made,
+                             self.context,
+                             self))
+
+    cdef inline _schedule_call_connection_lost(self, exc):
+        self._loop._call_soon_handle(
+            new_MethodHandle1(self._loop,
+                              "UVTransport._call_connection_lost",
+                              <method1_t>self._call_connection_lost,
+                              self.context,
+                              self, exc))
+
+    cdef _fatal_error(self, exc, throw, reason=None):
+        # Overload UVHandle._fatal_error
+
+        self._force_close(exc)
+
+        if not isinstance(exc, OSError):
+
+            if throw or self._loop is None:
+                raise exc
+
+            msg = f'Fatal error on transport {self.__class__.__name__}'
+            if reason is not None:
+                msg = f'{msg} ({reason})'
+
+            self._loop.call_exception_handler({
+                'message': msg,
+                'exception': exc,
+                'transport': self,
+                'protocol': self._protocol,
+            })
+
+    cdef inline _maybe_pause_protocol(self):
+        cdef:
+            size_t size = self._get_write_buffer_size()
+
+        if size <= self._high_water:
+            return
+
+        if not self._protocol_paused:
+            self._protocol_paused = 1
+            try:
+                # _maybe_pause_protocol() is always triggered from user-calls,
+                # so we must copy the context to avoid entering context twice
+                run_in_context(
+                    self.context.copy(), self._protocol.pause_writing,
+                )
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException as exc:
+                self._loop.call_exception_handler({
+                    'message': 'protocol.pause_writing() failed',
+                    'exception': exc,
+                    'transport': self,
+                    'protocol': self._protocol,
+                })
+
+    cdef inline _maybe_resume_protocol(self):
+        cdef:
+            size_t size = self._get_write_buffer_size()
+
+        if self._protocol_paused and size <= self._low_water:
+            self._protocol_paused = 0
+            try:
+                # We're copying the context to avoid entering context twice,
+                # even though it's not always necessary to copy - it's easier
+                # to copy here than passing down a copied context.
+                run_in_context(
+                    self.context.copy(), self._protocol.resume_writing,
+                )
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException as exc:
+                self._loop.call_exception_handler({
+                    'message': 'protocol.resume_writing() failed',
+                    'exception': exc,
+                    'transport': self,
+                    'protocol': self._protocol,
+                })
+
+    cdef _wakeup_waiter(self):
+        if self._waiter is not None:
+            if not self._waiter.cancelled():
+                if not self._is_alive():
+                    self._waiter.set_exception(
+                        RuntimeError(
+                            'closed Transport handle and unset waiter'))
+                else:
+                    self._waiter.set_result(True)
+            self._waiter = None
+
+    cdef _call_connection_made(self):
+        if self._protocol is None:
+            raise RuntimeError(
+                'protocol is not set, cannot call connection_made()')
+
+        # We use `_is_alive()` and not `_closing`, because we call
+        # `transport._close()` in `loop.create_connection()` if an
+        # exception happens during `await waiter`.
+        if not self._is_alive():
+            # A connection waiter can be cancelled between
+            # 'await loop.create_connection()' and
+            # `_schedule_call_connection_made` and
+            # the actual `_call_connection_made`.
+            self._wakeup_waiter()
+            return
+
+        # Set _protocol_connected to 1 before calling "connection_made":
+        # if transport is aborted or closed, "connection_lost" will
+        # still be scheduled.
+        self._protocol_connected = 1
+
+        try:
+            self._protocol.connection_made(self)
+        except BaseException:
+            self._wakeup_waiter()
+            raise
+
+        if not self._is_alive():
+            # This might happen when "transport.abort()" is called
+            # from "Protocol.connection_made".
+            self._wakeup_waiter()
+            return
+
+        self._start_reading()
+        self._wakeup_waiter()
+
+    cdef _call_connection_lost(self, exc):
+        if self._waiter is not None:
+            if not self._waiter.done():
+                self._waiter.set_exception(exc)
+            self._waiter = None
+
+        if self._closed:
+            # The handle is closed -- likely, _call_connection_lost
+            # was already called before.
+            return
+
+        try:
+            if self._protocol_connected:
+                self._protocol.connection_lost(exc)
+        finally:
+            self._clear_protocol()
+
+            self._close()
+
+            server = self._server
+            if server is not None:
+                (<Server>server)._detach()
+                self._server = None
+
+    cdef inline _set_server(self, Server server):
+        self._server = server
+        (<Server>server)._attach()
+
+    cdef inline _set_waiter(self, object waiter):
+        if waiter is not None and not isfuture(waiter):
+            raise TypeError(
+                f'invalid waiter object {waiter!r}, expected asyncio.Future')
+
+        self._waiter = waiter
+
+    cdef _set_protocol(self, object protocol):
+        self._protocol = protocol
+        # Store a reference to the bound method directly
+        try:
+            self._protocol_data_received = protocol.data_received
+        except AttributeError:
+            pass
+
+    cdef _clear_protocol(self):
+        self._protocol = None
+        self._protocol_data_received = None
+
+    cdef inline _init_protocol(self):
+        self._loop._track_transport(self)
+        if self._protocol is None:
+            raise RuntimeError('invalid _init_protocol call')
+        self._schedule_call_connection_made()
+
+    cdef inline _add_extra_info(self, str name, object obj):
+        if self._extra_info is None:
+            self._extra_info = {}
+        self._extra_info[name] = obj
+
+    cdef bint _is_reading(self):
+        raise NotImplementedError
+
+    cdef _start_reading(self):
+        raise NotImplementedError
+
+    cdef _stop_reading(self):
+        raise NotImplementedError
+
+    # === Public API ===
+
+    property _paused:
+        # Used by SSLProto.  Might be removed in the future.
+        def __get__(self):
+            return bool(not self._is_reading())
+
+    def get_protocol(self):
+        return self._protocol
+
+    def set_protocol(self, protocol):
+        self._set_protocol(protocol)
+        if self._is_reading():
+            self._stop_reading()
+            self._start_reading()
+
+    def _force_close(self, exc):
+        # Used by SSLProto.  Might be removed in the future.
+        if self._conn_lost or self._closed:
+            return
+        if not self._closing:
+            self._closing = 1
+            self._stop_reading()
+        self._conn_lost += 1
+        self._schedule_call_connection_lost(exc)
+
+    def abort(self):
+        self._force_close(None)
+
+    def close(self):
+        if self._closing or self._closed:
+            return
+
+        self._closing = 1
+        self._stop_reading()
+
+        if not self._get_write_buffer_size():
+            # The write buffer is empty
+            self._conn_lost += 1
+            self._schedule_call_connection_lost(None)
+
+    def is_closing(self):
+        return self._closing
+
+    def get_write_buffer_size(self):
+        return self._get_write_buffer_size()
+
+    def set_write_buffer_limits(self, high=None, low=None):
+        self._ensure_alive()
+
+        self._high_water, self._low_water = add_flowcontrol_defaults(
+            high, low, FLOW_CONTROL_HIGH_WATER)
+
+        self._maybe_pause_protocol()
+
+    def get_write_buffer_limits(self):
+        return (self._low_water, self._high_water)
+
+    def get_extra_info(self, name, default=None):
+        if self._extra_info is not None and name in self._extra_info:
+            return self._extra_info[name]
+        if name == 'socket':
+            return self._get_socket()
+        if name == 'sockname':
+            return self._get_socket().getsockname()
+        if name == 'peername':
+            try:
+                return self._get_socket().getpeername()
+            except socket_error:
+                return default
+        return default
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/check.pxd b/venv/lib/python3.11/site-packages/uvloop/handles/check.pxd
new file mode 100644
index 0000000..86cfd8f
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/check.pxd
@@ -0,0 +1,14 @@
+cdef class UVCheck(UVHandle):
+    cdef:
+        Handle h
+        bint running
+
+    # All "inline" methods are final
+
+    cdef _init(self, Loop loop, Handle h)
+
+    cdef inline stop(self)
+    cdef inline start(self)
+
+    @staticmethod
+    cdef UVCheck new(Loop loop, Handle h)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/check.pyx b/venv/lib/python3.11/site-packages/uvloop/handles/check.pyx
new file mode 100644
index 0000000..1a61c4e
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/check.pyx
@@ -0,0 +1,72 @@
+@cython.no_gc_clear
+cdef class UVCheck(UVHandle):
+    cdef _init(self, Loop loop, Handle h):
+        cdef int err
+
+        self._start_init(loop)
+
+        self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_check_t))
+        if self._handle is NULL:
+            self._abort_init()
+            raise MemoryError()
+
+        err = uv.uv_check_init(self._loop.uvloop, <uv.uv_check_t*>self._handle)
+        if err < 0:
+            self._abort_init()
+            raise convert_error(err)
+
+        self._finish_init()
+
+        self.h = h
+        self.running = 0
+
+    cdef inline stop(self):
+        cdef int err
+
+        if not self._is_alive():
+            self.running = 0
+            return
+
+        if self.running == 1:
+            err = uv.uv_check_stop(<uv.uv_check_t*>self._handle)
+            self.running = 0
+            if err < 0:
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+                return
+
+    cdef inline start(self):
+        cdef int err
+
+        self._ensure_alive()
+
+        if self.running == 0:
+            err = uv.uv_check_start(<uv.uv_check_t*>self._handle,
+                                    cb_check_callback)
+            if err < 0:
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+                return
+            self.running = 1
+
+    @staticmethod
+    cdef UVCheck new(Loop loop, Handle h):
+        cdef UVCheck handle
+        handle = UVCheck.__new__(UVCheck)
+        handle._init(loop, h)
+        return handle
+
+
+cdef void cb_check_callback(
+    uv.uv_check_t* handle,
+) noexcept with gil:
+    if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVCheck callback") == 0:
+        return
+
+    cdef:
+        UVCheck check = <UVCheck> handle.data
+        Handle h = check.h
+    try:
+        h._run()
+    except BaseException as ex:
+        check._error(ex, False)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/fsevent.pxd b/venv/lib/python3.11/site-packages/uvloop/handles/fsevent.pxd
new file mode 100644
index 0000000..3a32428
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/fsevent.pxd
@@ -0,0 +1,12 @@
+cdef class UVFSEvent(UVHandle):
+    cdef:
+        object callback
+        bint running
+
+    cdef _init(self, Loop loop, object callback, object context)
+    cdef _close(self)
+    cdef start(self, char* path, int flags)
+    cdef stop(self)
+
+    @staticmethod
+    cdef UVFSEvent new(Loop loop, object callback, object context)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/fsevent.pyx b/venv/lib/python3.11/site-packages/uvloop/handles/fsevent.pyx
new file mode 100644
index 0000000..6ed6433
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/fsevent.pyx
@@ -0,0 +1,116 @@
+import enum
+
+
+class FileSystemEvent(enum.IntEnum):
+    RENAME = uv.UV_RENAME
+    CHANGE = uv.UV_CHANGE
+    RENAME_CHANGE = RENAME | CHANGE
+
+
+@cython.no_gc_clear
+cdef class UVFSEvent(UVHandle):
+    cdef _init(self, Loop loop, object callback, object context):
+        cdef int err
+
+        self._start_init(loop)
+
+        self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(
+            sizeof(uv.uv_fs_event_t)
+        )
+        if self._handle is NULL:
+            self._abort_init()
+            raise MemoryError()
+
+        err = uv.uv_fs_event_init(
+            self._loop.uvloop, <uv.uv_fs_event_t*>self._handle
+        )
+        if err < 0:
+            self._abort_init()
+            raise convert_error(err)
+
+        self._finish_init()
+
+        self.running = 0
+        self.callback = callback
+        if context is None:
+            context = Context_CopyCurrent()
+        self.context = context
+
+    cdef start(self, char* path, int flags):
+        cdef int err
+
+        self._ensure_alive()
+
+        if self.running == 0:
+            err = uv.uv_fs_event_start(
+                <uv.uv_fs_event_t*>self._handle,
+                __uvfsevent_callback,
+                path,
+                flags,
+            )
+            if err < 0:
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+                return
+            self.running = 1
+
+    cdef stop(self):
+        cdef int err
+
+        if not self._is_alive():
+            self.running = 0
+            return
+
+        if self.running == 1:
+            err = uv.uv_fs_event_stop(<uv.uv_fs_event_t*>self._handle)
+            self.running = 0
+            if err < 0:
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+                return
+
+    cdef _close(self):
+        try:
+            self.stop()
+        finally:
+            UVHandle._close(<UVHandle>self)
+
+    def cancel(self):
+        self._close()
+
+    def cancelled(self):
+        return self.running == 0
+
+    @staticmethod
+    cdef UVFSEvent new(Loop loop, object callback, object context):
+        cdef UVFSEvent handle
+        handle = UVFSEvent.__new__(UVFSEvent)
+        handle._init(loop, callback, context)
+        return handle
+
+
+cdef void __uvfsevent_callback(
+    uv.uv_fs_event_t* handle,
+    const char *filename,
+    int events,
+    int status,
+) noexcept with gil:
+    if __ensure_handle_data(
+        <uv.uv_handle_t*>handle, "UVFSEvent callback"
+    ) == 0:
+        return
+
+    cdef:
+        UVFSEvent fs_event = <UVFSEvent> handle.data
+        Handle h
+
+    try:
+        h = new_Handle(
+            fs_event._loop,
+            fs_event.callback,
+            (filename, FileSystemEvent(events)),
+            fs_event.context,
+        )
+        h._run()
+    except BaseException as ex:
+        fs_event._error(ex, False)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/handle.pxd b/venv/lib/python3.11/site-packages/uvloop/handles/handle.pxd
new file mode 100644
index 0000000..5af1c14
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/handle.pxd
@@ -0,0 +1,48 @@
+cdef class UVHandle:
+    cdef:
+        uv.uv_handle_t *_handle
+        Loop _loop
+        readonly _source_traceback
+        bint _closed
+        bint _inited
+        object context
+
+        # Added to enable current UDPTransport implementation,
+        # which doesn't use libuv handles.
+        bint _has_handle
+
+    # All "inline" methods are final
+
+    cdef inline _start_init(self, Loop loop)
+    cdef inline _abort_init(self)
+    cdef inline _finish_init(self)
+
+    cdef inline bint _is_alive(self)
+    cdef inline _ensure_alive(self)
+
+    cdef _error(self, exc, throw)
+    cdef _fatal_error(self, exc, throw, reason=?)
+
+    cdef _warn_unclosed(self)
+
+    cdef _free(self)
+    cdef _close(self)
+
+
+cdef class UVSocketHandle(UVHandle):
+    cdef:
+        # Points to a Python file-object that should be closed
+        # when the transport is closing.  Used by pipes.  This
+        # should probably be refactored somehow.
+        object _fileobj
+        object __cached_socket
+
+    # All "inline" methods are final
+
+    cdef _fileno(self)
+
+    cdef _new_socket(self)
+    cdef inline _get_socket(self)
+    cdef inline _attach_fileobj(self, object file)
+
+    cdef _open(self, int sockfd)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/handle.pyx b/venv/lib/python3.11/site-packages/uvloop/handles/handle.pyx
new file mode 100644
index 0000000..6efe375
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/handle.pyx
@@ -0,0 +1,395 @@
+cdef class UVHandle:
+    """A base class for all libuv handles.
+
+    Automatically manages memory deallocation and closing.
+
+    Important:
+
+       1. call "_ensure_alive()" before calling any libuv functions on
+          your handles.
+
+       2. call "__ensure_handle_data" in *all* libuv handle callbacks.
+    """
+
+    def __cinit__(self):
+        self._closed = 0
+        self._inited = 0
+        self._has_handle = 1
+        self._handle = NULL
+        self._loop = None
+        self._source_traceback = None
+
+    def __init__(self):
+        raise TypeError(
+            '{} is not supposed to be instantiated from Python'.format(
+                self.__class__.__name__))
+
+    def __dealloc__(self):
+        if UVLOOP_DEBUG:
+            if self._loop is not None:
+                if self._inited:
+                    self._loop._debug_handles_current.subtract([
+                        self.__class__.__name__])
+            else:
+                # No "@cython.no_gc_clear" decorator on this UVHandle
+                raise RuntimeError(
+                    '{} without @no_gc_clear; loop was set to None by GC'
+                    .format(self.__class__.__name__))
+
+        if self._handle is NULL:
+            return
+
+        # -> When we're at this point, something is wrong <-
+
+        if self._handle.loop is NULL:
+            # The handle wasn't initialized with "uv_{handle}_init"
+            self._closed = 1
+            self._free()
+            raise RuntimeError(
+                '{} is open in __dealloc__ with loop set to NULL'
+                .format(self.__class__.__name__))
+
+        if self._closed:
+            # So _handle is not NULL and self._closed == 1?
+            raise RuntimeError(
+                '{}.__dealloc__: _handle is NULL, _closed == 1'.format(
+                    self.__class__.__name__))
+
+        # The handle is dealloced while open.  Let's try to close it.
+        # Situations when this is possible include unhandled exceptions,
+        # errors during Handle.__cinit__/__init__ etc.
+        if self._inited:
+            self._handle.data = NULL
+            uv.uv_close(self._handle, __uv_close_handle_cb)  # void; no errors
+            self._handle = NULL
+            self._warn_unclosed()
+        else:
+            # The handle was allocated, but not initialized
+            self._closed = 1
+            self._free()
+
+    cdef _free(self):
+        if self._handle == NULL:
+            return
+
+        if UVLOOP_DEBUG and self._inited:
+            self._loop._debug_uv_handles_freed += 1
+
+        PyMem_RawFree(self._handle)
+        self._handle = NULL
+
+    cdef _warn_unclosed(self):
+        if self._source_traceback is not None:
+            try:
+                tb = ''.join(tb_format_list(self._source_traceback))
+                tb = 'object created at (most recent call last):\n{}'.format(
+                    tb.rstrip())
+            except Exception as ex:
+                msg = (
+                    'unclosed resource {!r}; could not serialize '
+                    'debug traceback: {}: {}'
+                ).format(self, type(ex).__name__, ex)
+            else:
+                msg = 'unclosed resource {!r}; {}'.format(self, tb)
+        else:
+            msg = 'unclosed resource {!r}'.format(self)
+        warnings_warn(msg, ResourceWarning)
+
+    cdef inline _abort_init(self):
+        if self._handle is not NULL:
+            self._free()
+
+        try:
+            if UVLOOP_DEBUG:
+                name = self.__class__.__name__
+                if self._inited:
+                    raise RuntimeError(
+                        '_abort_init: {}._inited is set'.format(name))
+                if self._closed:
+                    raise RuntimeError(
+                        '_abort_init: {}._closed is set'.format(name))
+        finally:
+            self._closed = 1
+
+    cdef inline _finish_init(self):
+        self._inited = 1
+        if self._has_handle == 1:
+            self._handle.data = <void*>self
+        if self._loop._debug:
+            self._source_traceback = extract_stack()
+        if UVLOOP_DEBUG:
+            cls_name = self.__class__.__name__
+            self._loop._debug_uv_handles_total += 1
+            self._loop._debug_handles_total.update([cls_name])
+            self._loop._debug_handles_current.update([cls_name])
+
+    cdef inline _start_init(self, Loop loop):
+        if UVLOOP_DEBUG:
+            if self._loop is not None:
+                raise RuntimeError(
+                    '{}._start_init can only be called once'.format(
+                        self.__class__.__name__))
+
+        self._loop = loop
+
+    cdef inline bint _is_alive(self):
+        cdef bint res
+        res = self._closed != 1 and self._inited == 1
+        if UVLOOP_DEBUG:
+            if res and self._has_handle == 1:
+                name = self.__class__.__name__
+                if self._handle is NULL:
+                    raise RuntimeError(
+                        '{} is alive, but _handle is NULL'.format(name))
+                if self._loop is None:
+                    raise RuntimeError(
+                        '{} is alive, but _loop is None'.format(name))
+                if self._handle.loop is not self._loop.uvloop:
+                    raise RuntimeError(
+                        '{} is alive, but _handle.loop is not '
+                        'initialized'.format(name))
+                if self._handle.data is not <void*>self:
+                    raise RuntimeError(
+                        '{} is alive, but _handle.data is not '
+                        'initialized'.format(name))
+        return res
+
+    cdef inline _ensure_alive(self):
+        if not self._is_alive():
+            raise RuntimeError(
+                'unable to perform operation on {!r}; '
+                'the handler is closed'.format(self))
+
+    cdef _fatal_error(self, exc, throw, reason=None):
+        # Fatal error means an error that was returned by the
+        # underlying libuv handle function.  We usually can't
+        # recover from that, hence we just close the handle.
+        self._close()
+
+        if throw or self._loop is None:
+            raise exc
+        else:
+            self._loop._handle_exception(exc)
+
+    cdef _error(self, exc, throw):
+        # A non-fatal error is usually an error that was caught
+        # by the handler, but was originated in the client code
+        # (not in libuv).  In this case we either want to simply
+        # raise or log it.
+        if throw or self._loop is None:
+            raise exc
+        else:
+            self._loop._handle_exception(exc)
+
+    cdef _close(self):
+        if self._closed == 1:
+            return
+
+        self._closed = 1
+
+        if self._handle is NULL:
+            return
+
+        if UVLOOP_DEBUG:
+            if self._handle.data is NULL:
+                raise RuntimeError(
+                    '{}._close: _handle.data is NULL'.format(
+                        self.__class__.__name__))
+
+            if <object>self._handle.data is not self:
+                raise RuntimeError(
+                    '{}._close: _handle.data is not UVHandle/self'.format(
+                        self.__class__.__name__))
+
+            if uv.uv_is_closing(self._handle):
+                raise RuntimeError(
+                    '{}._close: uv_is_closing() is true'.format(
+                        self.__class__.__name__))
+
+        # We want the handle wrapper (UVHandle) to stay alive until
+        # the closing callback fires.
+        Py_INCREF(self)
+        uv.uv_close(self._handle, __uv_close_handle_cb)  # void; no errors
+
+    def __repr__(self):
+        return '<{} closed={} {:#x}>'.format(
+            self.__class__.__name__,
+            self._closed,
+            id(self))
+
+
+cdef class UVSocketHandle(UVHandle):
+
+    def __cinit__(self):
+        self._fileobj = None
+        self.__cached_socket = None
+
+    cdef _fileno(self):
+        cdef:
+            int fd
+            int err
+
+        self._ensure_alive()
+        err = uv.uv_fileno(self._handle, <uv.uv_os_fd_t*>&fd)
+        if err < 0:
+            raise convert_error(err)
+
+        return fd
+
+    cdef _new_socket(self):
+        raise NotImplementedError
+
+    cdef inline _get_socket(self):
+        if self.__cached_socket is not None:
+            return self.__cached_socket
+
+        if not self._is_alive():
+            return None
+
+        self.__cached_socket = self._new_socket()
+        if UVLOOP_DEBUG:
+            # We don't "dup" for the "__cached_socket".
+            assert self.__cached_socket.fileno() == self._fileno()
+        return self.__cached_socket
+
+    cdef inline _attach_fileobj(self, object file):
+        # When we create a TCP/PIPE/etc connection/server based on
+        # a Python file object, we need to close the file object when
+        # the uv handle is closed.
+        socket_inc_io_ref(file)
+        self._fileobj = file
+
+    cdef _close(self):
+        if self.__cached_socket is not None:
+            (<PseudoSocket>self.__cached_socket)._fd = -1
+
+        UVHandle._close(self)
+
+        try:
+            # This code will only run for transports created from
+            # Python sockets, i.e. with `loop.create_server(sock=sock)` etc.
+            if self._fileobj is not None:
+                if isinstance(self._fileobj, socket_socket):
+                    # Detaching the socket object is the ideal solution:
+                    # * libuv will actually close the FD;
+                    # * detach() call will reset FD for the Python socket
+                    #   object, which means that it won't be closed 2nd time
+                    #   when the socket object is GCed.
+                    #
+                    # No need to call `socket_dec_io_ref()`, as
+                    # `socket.detach()` ignores `socket._io_refs`.
+                    self._fileobj.detach()
+                else:
+                    try:
+                        # `socket.close()` will raise an EBADF because libuv
+                        # has already closed the underlying FD.
+                        self._fileobj.close()
+                    except OSError as ex:
+                        if ex.errno != errno_EBADF:
+                            raise
+        except Exception as ex:
+            self._loop.call_exception_handler({
+                'exception': ex,
+                'transport': self,
+                'message': f'could not close attached file object '
+                           f'{self._fileobj!r}',
+            })
+        finally:
+            self._fileobj = None
+
+    cdef _open(self, int sockfd):
+        raise NotImplementedError
+
+
+cdef inline bint __ensure_handle_data(uv.uv_handle_t* handle,
+                                      const char* handle_ctx):
+
+    cdef Loop loop
+
+    if UVLOOP_DEBUG:
+        if handle.loop is NULL:
+            raise RuntimeError(
+                'handle.loop is NULL in __ensure_handle_data')
+
+        if handle.loop.data is NULL:
+            raise RuntimeError(
+                'handle.loop.data is NULL in __ensure_handle_data')
+
+    if handle.data is NULL:
+        loop = <Loop>handle.loop.data
+        loop.call_exception_handler({
+            'message': '{} called with handle.data == NULL'.format(
+                handle_ctx.decode('latin-1'))
+        })
+        return 0
+
+    if handle.data is NULL:
+        # The underlying UVHandle object was GCed with an open uv_handle_t.
+        loop = <Loop>handle.loop.data
+        loop.call_exception_handler({
+            'message': '{} called after destroying the UVHandle'.format(
+                handle_ctx.decode('latin-1'))
+        })
+        return 0
+
+    return 1
+
+
+cdef void __uv_close_handle_cb(uv.uv_handle_t* handle) noexcept with gil:
+    cdef UVHandle h
+
+    if handle.data is NULL:
+        # The original UVHandle is long dead. Just free the mem of
+        # the uv_handle_t* handler.
+
+        if UVLOOP_DEBUG:
+            if handle.loop == NULL or handle.loop.data == NULL:
+                raise RuntimeError(
+                    '__uv_close_handle_cb: handle.loop is invalid')
+            (<Loop>handle.loop.data)._debug_uv_handles_freed += 1
+
+        PyMem_RawFree(handle)
+    else:
+        h = <UVHandle>handle.data
+        try:
+            if UVLOOP_DEBUG:
+                if not h._has_handle:
+                    raise RuntimeError(
+                        'has_handle=0 in __uv_close_handle_cb')
+                h._loop._debug_handles_closed.update([
+                    h.__class__.__name__])
+            h._free()
+        finally:
+            Py_DECREF(h)  # Was INCREFed in UVHandle._close
+
+
+cdef void __close_all_handles(Loop loop):
+    uv.uv_walk(loop.uvloop,
+               __uv_walk_close_all_handles_cb,
+               <void*>loop)  # void
+
+
+cdef void __uv_walk_close_all_handles_cb(
+    uv.uv_handle_t* handle,
+    void* arg,
+) noexcept with gil:
+
+    cdef:
+        Loop loop = <Loop>arg
+        UVHandle h
+
+    if uv.uv_is_closing(handle):
+        # The handle is closed or is closing.
+        return
+
+    if handle.data is NULL:
+        # This shouldn't happen. Ever.
+        loop.call_exception_handler({
+            'message': 'handle.data is NULL in __close_all_handles_cb'
+        })
+        return
+
+    h = <UVHandle>handle.data
+    if not h._closed:
+        h._warn_unclosed()
+        h._close()
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/idle.pxd b/venv/lib/python3.11/site-packages/uvloop/handles/idle.pxd
new file mode 100644
index 0000000..cf7b19f
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/idle.pxd
@@ -0,0 +1,14 @@
+cdef class UVIdle(UVHandle):
+    cdef:
+        Handle h
+        bint running
+
+    # All "inline" methods are final
+
+    cdef _init(self, Loop loop, Handle h)
+
+    cdef inline stop(self)
+    cdef inline start(self)
+
+    @staticmethod
+    cdef UVIdle new(Loop loop, Handle h)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/idle.pyx b/venv/lib/python3.11/site-packages/uvloop/handles/idle.pyx
new file mode 100644
index 0000000..91c641f
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/idle.pyx
@@ -0,0 +1,72 @@
+@cython.no_gc_clear
+cdef class UVIdle(UVHandle):
+    cdef _init(self, Loop loop, Handle h):
+        cdef int err
+
+        self._start_init(loop)
+
+        self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_idle_t))
+        if self._handle is NULL:
+            self._abort_init()
+            raise MemoryError()
+
+        err = uv.uv_idle_init(self._loop.uvloop, <uv.uv_idle_t*>self._handle)
+        if err < 0:
+            self._abort_init()
+            raise convert_error(err)
+
+        self._finish_init()
+
+        self.h = h
+        self.running = 0
+
+    cdef inline stop(self):
+        cdef int err
+
+        if not self._is_alive():
+            self.running = 0
+            return
+
+        if self.running == 1:
+            err = uv.uv_idle_stop(<uv.uv_idle_t*>self._handle)
+            self.running = 0
+            if err < 0:
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+                return
+
+    cdef inline start(self):
+        cdef int err
+
+        self._ensure_alive()
+
+        if self.running == 0:
+            err = uv.uv_idle_start(<uv.uv_idle_t*>self._handle,
+                                   cb_idle_callback)
+            if err < 0:
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+                return
+            self.running = 1
+
+    @staticmethod
+    cdef UVIdle new(Loop loop, Handle h):
+        cdef UVIdle handle
+        handle = UVIdle.__new__(UVIdle)
+        handle._init(loop, h)
+        return handle
+
+
+cdef void cb_idle_callback(
+    uv.uv_idle_t* handle,
+) noexcept with gil:
+    if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVIdle callback") == 0:
+        return
+
+    cdef:
+        UVIdle idle = <UVIdle> handle.data
+        Handle h = idle.h
+    try:
+        h._run()
+    except BaseException as ex:
+        idle._error(ex, False)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/pipe.pxd b/venv/lib/python3.11/site-packages/uvloop/handles/pipe.pxd
new file mode 100644
index 0000000..56fc265
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/pipe.pxd
@@ -0,0 +1,33 @@
+cdef class UnixServer(UVStreamServer):
+
+    cdef bind(self, str path)
+
+    @staticmethod
+    cdef UnixServer new(Loop loop, object protocol_factory, Server server,
+                        object backlog,
+                        object ssl,
+                        object ssl_handshake_timeout,
+                        object ssl_shutdown_timeout)
+
+
+cdef class UnixTransport(UVStream):
+
+    @staticmethod
+    cdef UnixTransport new(Loop loop, object protocol, Server server,
+                           object waiter, object context)
+
+    cdef connect(self, char* addr)
+
+
+cdef class ReadUnixTransport(UVStream):
+
+    @staticmethod
+    cdef ReadUnixTransport new(Loop loop, object protocol, Server server,
+                               object waiter)
+
+
+cdef class WriteUnixTransport(UVStream):
+
+    @staticmethod
+    cdef WriteUnixTransport new(Loop loop, object protocol, Server server,
+                                object waiter)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/pipe.pyx b/venv/lib/python3.11/site-packages/uvloop/handles/pipe.pyx
new file mode 100644
index 0000000..195576c
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/pipe.pyx
@@ -0,0 +1,226 @@
+cdef __pipe_init_uv_handle(UVStream handle, Loop loop):
+    cdef int err
+
+    handle._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_pipe_t))
+    if handle._handle is NULL:
+        handle._abort_init()
+        raise MemoryError()
+
+    # Initialize pipe handle with ipc=0.
+    # ipc=1 means that libuv will use recvmsg/sendmsg
+    # instead of recv/send.
+    err = uv.uv_pipe_init(handle._loop.uvloop,
+                          <uv.uv_pipe_t*>handle._handle,
+                          0)
+    # UV_HANDLE_READABLE allows calling uv_read_start() on this pipe
+    # even if it is O_WRONLY, see also #317, libuv/libuv#2058
+    handle._handle.flags |= uv.UV_INTERNAL_HANDLE_READABLE
+    if err < 0:
+        handle._abort_init()
+        raise convert_error(err)
+
+    handle._finish_init()
+
+
+cdef __pipe_open(UVStream handle, int fd):
+    cdef int err
+    err = uv.uv_pipe_open(<uv.uv_pipe_t *>handle._handle,
+                          <uv.uv_file>fd)
+    if err < 0:
+        exc = convert_error(err)
+        raise exc
+
+
+cdef __pipe_get_socket(UVSocketHandle handle):
+    fileno = handle._fileno()
+    return PseudoSocket(uv.AF_UNIX, uv.SOCK_STREAM, 0, fileno)
+
+
+@cython.no_gc_clear
+cdef class UnixServer(UVStreamServer):
+
+    @staticmethod
+    cdef UnixServer new(Loop loop, object protocol_factory, Server server,
+                        object backlog,
+                        object ssl,
+                        object ssl_handshake_timeout,
+                        object ssl_shutdown_timeout):
+
+        cdef UnixServer handle
+        handle = UnixServer.__new__(UnixServer)
+        handle._init(loop, protocol_factory, server, backlog,
+                     ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
+        __pipe_init_uv_handle(<UVStream>handle, loop)
+        return handle
+
+    cdef _new_socket(self):
+        return __pipe_get_socket(<UVSocketHandle>self)
+
+    cdef _open(self, int sockfd):
+        self._ensure_alive()
+        __pipe_open(<UVStream>self, sockfd)
+        self._mark_as_open()
+
+    cdef bind(self, str path):
+        cdef int err
+        self._ensure_alive()
+        err = uv.uv_pipe_bind(<uv.uv_pipe_t *>self._handle,
+                              path.encode())
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+
+        self._mark_as_open()
+
+    cdef UVStream _make_new_transport(self, object protocol, object waiter,
+                                      object context):
+        cdef UnixTransport tr
+        tr = UnixTransport.new(self._loop, protocol, self._server, waiter,
+                               context)
+        return <UVStream>tr
+
+
+@cython.no_gc_clear
+cdef class UnixTransport(UVStream):
+
+    @staticmethod
+    cdef UnixTransport new(Loop loop, object protocol, Server server,
+                           object waiter, object context):
+
+        cdef UnixTransport handle
+        handle = UnixTransport.__new__(UnixTransport)
+        handle._init(loop, protocol, server, waiter, context)
+        __pipe_init_uv_handle(<UVStream>handle, loop)
+        return handle
+
+    cdef _new_socket(self):
+        return __pipe_get_socket(<UVSocketHandle>self)
+
+    cdef _open(self, int sockfd):
+        __pipe_open(<UVStream>self, sockfd)
+
+    cdef connect(self, char* addr):
+        cdef _PipeConnectRequest req
+        req = _PipeConnectRequest(self._loop, self)
+        req.connect(addr)
+
+
+@cython.no_gc_clear
+cdef class ReadUnixTransport(UVStream):
+
+    @staticmethod
+    cdef ReadUnixTransport new(Loop loop, object protocol, Server server,
+                               object waiter):
+        cdef ReadUnixTransport handle
+        handle = ReadUnixTransport.__new__(ReadUnixTransport)
+        # This is only used in connect_read_pipe() and subprocess_shell/exec()
+        # directly, we could simply copy the current context.
+        handle._init(loop, protocol, server, waiter, Context_CopyCurrent())
+        __pipe_init_uv_handle(<UVStream>handle, loop)
+        return handle
+
+    cdef _new_socket(self):
+        return __pipe_get_socket(<UVSocketHandle>self)
+
+    cdef _open(self, int sockfd):
+        __pipe_open(<UVStream>self, sockfd)
+
+    def get_write_buffer_limits(self):
+        raise NotImplementedError
+
+    def set_write_buffer_limits(self, high=None, low=None):
+        raise NotImplementedError
+
+    def get_write_buffer_size(self):
+        raise NotImplementedError
+
+    def write(self, data):
+        raise NotImplementedError
+
+    def writelines(self, list_of_data):
+        raise NotImplementedError
+
+    def write_eof(self):
+        raise NotImplementedError
+
+    def can_write_eof(self):
+        raise NotImplementedError
+
+    def abort(self):
+        raise NotImplementedError
+
+
+@cython.no_gc_clear
+cdef class WriteUnixTransport(UVStream):
+
+    @staticmethod
+    cdef WriteUnixTransport new(Loop loop, object protocol, Server server,
+                                object waiter):
+        cdef WriteUnixTransport handle
+        handle = WriteUnixTransport.__new__(WriteUnixTransport)
+
+        # We listen for read events on write-end of the pipe. When
+        # the read-end is close, the uv_stream_t.read callback will
+        # receive an error -- we want to silence that error, and just
+        # close the transport.
+        handle._close_on_read_error()
+
+        # This is only used in connect_write_pipe() and subprocess_shell/exec()
+        # directly, we could simply copy the current context.
+        handle._init(loop, protocol, server, waiter, Context_CopyCurrent())
+        __pipe_init_uv_handle(<UVStream>handle, loop)
+        return handle
+
+    cdef _new_socket(self):
+        return __pipe_get_socket(<UVSocketHandle>self)
+
+    cdef _open(self, int sockfd):
+        __pipe_open(<UVStream>self, sockfd)
+
+    def pause_reading(self):
+        raise NotImplementedError
+
+    def resume_reading(self):
+        raise NotImplementedError
+
+
+cdef class _PipeConnectRequest(UVRequest):
+    cdef:
+        UnixTransport transport
+        uv.uv_connect_t _req_data
+
+    def __cinit__(self, loop, transport):
+        self.request = <uv.uv_req_t*> &self._req_data
+        self.request.data = <void*>self
+        self.transport = transport
+
+    cdef connect(self, char* addr):
+        # uv_pipe_connect returns void
+        uv.uv_pipe_connect(<uv.uv_connect_t*>self.request,
+                           <uv.uv_pipe_t*>self.transport._handle,
+                           addr,
+                           __pipe_connect_callback)
+
+cdef void __pipe_connect_callback(
+    uv.uv_connect_t* req,
+    int status,
+) noexcept with gil:
+    cdef:
+        _PipeConnectRequest wrapper
+        UnixTransport transport
+
+    wrapper = <_PipeConnectRequest> req.data
+    transport = wrapper.transport
+
+    if status < 0:
+        exc = convert_error(status)
+    else:
+        exc = None
+
+    try:
+        transport._on_connect(exc)
+    except BaseException as ex:
+        wrapper.transport._fatal_error(ex, False)
+    finally:
+        wrapper.on_done()
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/poll.pxd b/venv/lib/python3.11/site-packages/uvloop/handles/poll.pxd
new file mode 100644
index 0000000..d07030b
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/poll.pxd
@@ -0,0 +1,25 @@
+cdef class UVPoll(UVHandle):
+    cdef:
+        int fd
+        Handle reading_handle
+        Handle writing_handle
+
+    cdef _init(self, Loop loop, int fd)
+    cdef _close(self)
+
+    cdef inline _poll_start(self, int flags)
+    cdef inline _poll_stop(self)
+
+    cdef int is_active(self)
+
+    cdef is_reading(self)
+    cdef is_writing(self)
+
+    cdef start_reading(self, Handle callback)
+    cdef start_writing(self, Handle callback)
+    cdef stop_reading(self)
+    cdef stop_writing(self)
+    cdef stop(self)
+
+    @staticmethod
+    cdef UVPoll new(Loop loop, int fd)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/poll.pyx b/venv/lib/python3.11/site-packages/uvloop/handles/poll.pyx
new file mode 100644
index 0000000..fca5981
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/poll.pyx
@@ -0,0 +1,233 @@
+@cython.no_gc_clear
+cdef class UVPoll(UVHandle):
+    cdef _init(self, Loop loop, int fd):
+        cdef int err
+
+        self._start_init(loop)
+
+        self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_poll_t))
+        if self._handle is NULL:
+            self._abort_init()
+            raise MemoryError()
+
+        err = uv.uv_poll_init(self._loop.uvloop,
+                              <uv.uv_poll_t *>self._handle, fd)
+        if err < 0:
+            self._abort_init()
+            raise convert_error(err)
+
+        self._finish_init()
+
+        self.fd = fd
+        self.reading_handle = None
+        self.writing_handle = None
+
+    @staticmethod
+    cdef UVPoll new(Loop loop, int fd):
+        cdef UVPoll handle
+        handle = UVPoll.__new__(UVPoll)
+        handle._init(loop, fd)
+        return handle
+
+    cdef int is_active(self):
+        return (self.reading_handle is not None or
+                self.writing_handle is not None)
+
+    cdef inline _poll_start(self, int flags):
+        cdef int err
+
+        self._ensure_alive()
+
+        err = uv.uv_poll_start(
+            <uv.uv_poll_t*>self._handle,
+            flags,
+            __on_uvpoll_event)
+
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+
+    cdef inline _poll_stop(self):
+        cdef int err
+
+        if not self._is_alive():
+            return
+
+        err = uv.uv_poll_stop(<uv.uv_poll_t*>self._handle)
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+
+        cdef:
+            int backend_id
+            system.epoll_event dummy_event
+
+        if system.PLATFORM_IS_LINUX:
+            # libuv doesn't remove the FD from epoll immediately
+            # after uv_poll_stop or uv_poll_close, causing hard
+            # to debug issue with dup-ed file descriptors causing
+            # CPU burn in epoll/epoll_ctl:
+            #    https://github.com/MagicStack/uvloop/issues/61
+            #
+            # It's safe though to manually call epoll_ctl here,
+            # after calling uv_poll_stop.
+
+            backend_id = uv.uv_backend_fd(self._loop.uvloop)
+            if backend_id != -1:
+                memset(&dummy_event, 0, sizeof(dummy_event))
+                system.epoll_ctl(
+                    backend_id,
+                    system.EPOLL_CTL_DEL,
+                    self.fd,
+                    &dummy_event)  # ignore errors
+
+    cdef is_reading(self):
+        return self._is_alive() and self.reading_handle is not None
+
+    cdef is_writing(self):
+        return self._is_alive() and self.writing_handle is not None
+
+    cdef start_reading(self, Handle callback):
+        cdef:
+            int mask = 0
+
+        if self.reading_handle is None:
+            # not reading right now, setup the handle
+
+            mask = uv.UV_READABLE
+            if self.writing_handle is not None:
+                # are we writing right now?
+                mask |= uv.UV_WRITABLE
+
+            self._poll_start(mask)
+        else:
+            self.reading_handle._cancel()
+
+        self.reading_handle = callback
+
+    cdef start_writing(self, Handle callback):
+        cdef:
+            int mask = 0
+
+        if self.writing_handle is None:
+            # not writing right now, setup the handle
+
+            mask = uv.UV_WRITABLE
+            if self.reading_handle is not None:
+                # are we reading right now?
+                mask |= uv.UV_READABLE
+
+            self._poll_start(mask)
+        else:
+            self.writing_handle._cancel()
+
+        self.writing_handle = callback
+
+    cdef stop_reading(self):
+        if self.reading_handle is None:
+            return False
+
+        self.reading_handle._cancel()
+        self.reading_handle = None
+
+        if self.writing_handle is None:
+            self.stop()
+        else:
+            self._poll_start(uv.UV_WRITABLE)
+
+        return True
+
+    cdef stop_writing(self):
+        if self.writing_handle is None:
+            return False
+
+        self.writing_handle._cancel()
+        self.writing_handle = None
+
+        if self.reading_handle is None:
+            self.stop()
+        else:
+            self._poll_start(uv.UV_READABLE)
+
+        return True
+
+    cdef stop(self):
+        if self.reading_handle is not None:
+            self.reading_handle._cancel()
+            self.reading_handle = None
+
+        if self.writing_handle is not None:
+            self.writing_handle._cancel()
+            self.writing_handle = None
+
+        self._poll_stop()
+
+    cdef _close(self):
+        if self.is_active():
+            self.stop()
+
+        UVHandle._close(<UVHandle>self)
+
+    cdef _fatal_error(self, exc, throw, reason=None):
+        try:
+            if self.reading_handle is not None:
+                try:
+                    self.reading_handle._run()
+                except BaseException as ex:
+                    self._loop._handle_exception(ex)
+                self.reading_handle = None
+
+            if self.writing_handle is not None:
+                try:
+                    self.writing_handle._run()
+                except BaseException as ex:
+                    self._loop._handle_exception(ex)
+                self.writing_handle = None
+
+        finally:
+            self._close()
+
+
+cdef void __on_uvpoll_event(
+    uv.uv_poll_t* handle,
+    int status,
+    int events,
+) noexcept with gil:
+
+    if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVPoll callback") == 0:
+        return
+
+    cdef:
+        UVPoll poll = <UVPoll> handle.data
+
+    if status < 0:
+        exc = convert_error(status)
+        poll._fatal_error(exc, False)
+        return
+
+    if ((events & (uv.UV_READABLE | uv.UV_DISCONNECT)) and
+            poll.reading_handle is not None):
+
+        try:
+            if UVLOOP_DEBUG:
+                poll._loop._poll_read_events_total += 1
+            poll.reading_handle._run()
+        except BaseException as ex:
+            if UVLOOP_DEBUG:
+                poll._loop._poll_read_cb_errors_total += 1
+            poll._error(ex, False)
+            # continue code execution
+
+    if ((events & (uv.UV_WRITABLE | uv.UV_DISCONNECT)) and
+            poll.writing_handle is not None):
+
+        try:
+            if UVLOOP_DEBUG:
+                poll._loop._poll_write_events_total += 1
+            poll.writing_handle._run()
+        except BaseException as ex:
+            if UVLOOP_DEBUG:
+                poll._loop._poll_write_cb_errors_total += 1
+            poll._error(ex, False)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/process.pxd b/venv/lib/python3.11/site-packages/uvloop/handles/process.pxd
new file mode 100644
index 0000000..970abcf
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/process.pxd
@@ -0,0 +1,80 @@
+cdef class UVProcess(UVHandle):
+    cdef:
+        object _returncode
+        object _pid
+
+        object _errpipe_read
+        object _errpipe_write
+        object _preexec_fn
+        bint _restore_signals
+
+        list _fds_to_close
+
+        # Attributes used to compose uv_process_options_t:
+        uv.uv_process_options_t options
+        uv.uv_stdio_container_t[3] iocnt
+        list __env
+        char **uv_opt_env
+        list __args
+        char **uv_opt_args
+        char *uv_opt_file
+        bytes __cwd
+
+    cdef _close_process_handle(self)
+
+    cdef _init(self, Loop loop, list args, dict env, cwd,
+               start_new_session,
+               _stdin, _stdout, _stderr, pass_fds,
+               debug_flags, preexec_fn, restore_signals)
+
+    cdef _after_fork(self)
+
+    cdef char** __to_cstring_array(self, list arr)
+    cdef _init_args(self, list args)
+    cdef _init_env(self, dict env)
+    cdef _init_files(self, _stdin, _stdout, _stderr)
+    cdef _init_options(self, list args, dict env, cwd, start_new_session,
+                       _stdin, _stdout, _stderr, bint force_fork)
+
+    cdef _close_after_spawn(self, int fd)
+
+    cdef _on_exit(self, int64_t exit_status, int term_signal)
+    cdef _kill(self, int signum)
+
+
+cdef class UVProcessTransport(UVProcess):
+    cdef:
+        list _exit_waiters
+        list _init_futs
+        bint _stdio_ready
+        list _pending_calls
+        object _protocol
+        bint _finished
+
+        WriteUnixTransport _stdin
+        ReadUnixTransport _stdout
+        ReadUnixTransport _stderr
+
+        object stdin_proto
+        object stdout_proto
+        object stderr_proto
+
+    cdef _file_redirect_stdio(self, int fd)
+    cdef _file_devnull(self)
+    cdef _file_inpipe(self)
+    cdef _file_outpipe(self)
+
+    cdef _check_proc(self)
+    cdef _pipe_connection_lost(self, int fd, exc)
+    cdef _pipe_data_received(self, int fd, data)
+
+    cdef _call_connection_made(self, waiter)
+    cdef _try_finish(self)
+
+    @staticmethod
+    cdef UVProcessTransport new(Loop loop, protocol, args, env, cwd,
+                                start_new_session,
+                                _stdin, _stdout, _stderr, pass_fds,
+                                waiter,
+                                debug_flags,
+                                preexec_fn, restore_signals)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/process.pyx b/venv/lib/python3.11/site-packages/uvloop/handles/process.pyx
new file mode 100644
index 0000000..63b982a
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/process.pyx
@@ -0,0 +1,792 @@
+@cython.no_gc_clear
+cdef class UVProcess(UVHandle):
+    """Abstract class; wrapper over uv_process_t handle."""
+
+    def __cinit__(self):
+        self.uv_opt_env = NULL
+        self.uv_opt_args = NULL
+        self._returncode = None
+        self._pid = None
+        self._fds_to_close = list()
+        self._preexec_fn = None
+        self._restore_signals = True
+        self.context = Context_CopyCurrent()
+
+    cdef _close_process_handle(self):
+        # XXX: This is a workaround for a libuv bug:
+        # - https://github.com/libuv/libuv/issues/1933
+        # - https://github.com/libuv/libuv/pull/551
+        if self._handle is NULL:
+            return
+        self._handle.data = NULL
+        uv.uv_close(self._handle, __uv_close_process_handle_cb)
+        self._handle = NULL  # close callback will free() the memory
+
+    cdef _init(self, Loop loop, list args, dict env,
+               cwd, start_new_session,
+               _stdin, _stdout, _stderr,  # std* can be defined as macros in C
+               pass_fds, debug_flags, preexec_fn, restore_signals):
+
+        global __forking
+        global __forking_loop
+        global __forkHandler
+
+        cdef int err
+
+        self._start_init(loop)
+
+        self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(
+            sizeof(uv.uv_process_t))
+        if self._handle is NULL:
+            self._abort_init()
+            raise MemoryError()
+
+        # Too early to call _finish_init, but still a lot of work to do.
+        # Let's set handle.data to NULL, so in case something goes wrong,
+        # callbacks have a chance to avoid casting *something* into UVHandle.
+        self._handle.data = NULL
+
+        force_fork = False
+        if system.PLATFORM_IS_APPLE and not (
+            preexec_fn is None
+            and not pass_fds
+        ):
+            # see _execute_child() in CPython/subprocess.py
+            force_fork = True
+
+        try:
+            self._init_options(args, env, cwd, start_new_session,
+                               _stdin, _stdout, _stderr, force_fork)
+
+            restore_inheritable = set()
+            if pass_fds:
+                for fd in pass_fds:
+                    if not os_get_inheritable(fd):
+                        restore_inheritable.add(fd)
+                        os_set_inheritable(fd, True)
+        except Exception:
+            self._abort_init()
+            raise
+
+        if __forking or loop.active_process_handler is not None:
+            # Our pthread_atfork handlers won't work correctly when
+            # another loop is forking in another thread (even though
+            # GIL should help us to avoid that.)
+            self._abort_init()
+            raise RuntimeError(
+                'Racing with another loop to spawn a process.')
+
+        self._errpipe_read, self._errpipe_write = os_pipe()
+        fds_to_close = self._fds_to_close
+        self._fds_to_close = None
+        fds_to_close.append(self._errpipe_read)
+        # add the write pipe last so we can close it early
+        fds_to_close.append(self._errpipe_write)
+        try:
+            os_set_inheritable(self._errpipe_write, True)
+
+            self._preexec_fn = preexec_fn
+            self._restore_signals = restore_signals
+
+            loop.active_process_handler = self
+            __forking = 1
+            __forking_loop = loop
+            system.setForkHandler(<system.OnForkHandler>&__get_fork_handler)
+
+            PyOS_BeforeFork()
+
+            err = uv.uv_spawn(loop.uvloop,
+                              <uv.uv_process_t*>self._handle,
+                              &self.options)
+
+            __forking = 0
+            __forking_loop = None
+            system.resetForkHandler()
+            loop.active_process_handler = None
+
+            PyOS_AfterFork_Parent()
+
+            if err < 0:
+                self._close_process_handle()
+                self._abort_init()
+                raise convert_error(err)
+
+            self._finish_init()
+
+            # close the write pipe early
+            os_close(fds_to_close.pop())
+
+            if preexec_fn is not None:
+                errpipe_data = bytearray()
+                while True:
+                    # XXX: This is a blocking code that has to be
+                    # rewritten (using loop.connect_read_pipe() or
+                    # otherwise.)
+                    part = os_read(self._errpipe_read, 50000)
+                    errpipe_data += part
+                    if not part or len(errpipe_data) > 50000:
+                        break
+
+        finally:
+            while fds_to_close:
+                os_close(fds_to_close.pop())
+
+            for fd in restore_inheritable:
+                os_set_inheritable(fd, False)
+
+        # asyncio caches the PID in BaseSubprocessTransport,
+        # so that the transport knows what the PID was even
+        # after the process is finished.
+        self._pid = (<uv.uv_process_t*>self._handle).pid
+
+        # Track the process handle (create a strong ref to it)
+        # to guarantee that __dealloc__ doesn't happen in an
+        # uncontrolled fashion.  We want to wait until the process
+        # exits and libuv calls __uvprocess_on_exit_callback,
+        # which will call `UVProcess._close()`, which will, in turn,
+        # untrack this handle.
+        self._loop._track_process(self)
+
+        if debug_flags & __PROCESS_DEBUG_SLEEP_AFTER_FORK:
+            time_sleep(1)
+
+        if preexec_fn is not None and errpipe_data:
+            # preexec_fn has raised an exception.  The child
+            # process must be dead now.
+            try:
+                exc_name, exc_msg = errpipe_data.split(b':', 1)
+                exc_name = exc_name.decode()
+                exc_msg = exc_msg.decode()
+            except Exception:
+                self._close()
+                raise subprocess_SubprocessError(
+                    'Bad exception data from child: {!r}'.format(
+                        errpipe_data))
+            exc_cls = getattr(__builtins__, exc_name,
+                              subprocess_SubprocessError)
+
+            exc = subprocess_SubprocessError(
+                'Exception occurred in preexec_fn.')
+            exc.__cause__ = exc_cls(exc_msg)
+            self._close()
+            raise exc
+
+    cdef _after_fork(self):
+        # See CPython/_posixsubprocess.c for details
+        cdef int err
+
+        if self._restore_signals:
+            _Py_RestoreSignals()
+
+        PyOS_AfterFork_Child()
+
+        err = uv.uv_loop_fork(self._loop.uvloop)
+        if err < 0:
+            raise convert_error(err)
+
+        if self._preexec_fn is not None:
+            try:
+                gc_disable()
+                self._preexec_fn()
+            except BaseException as ex:
+                try:
+                    with open(self._errpipe_write, 'wb') as f:
+                        f.write(str(ex.__class__.__name__).encode())
+                        f.write(b':')
+                        f.write(str(ex.args[0]).encode())
+                finally:
+                    system._exit(255)
+                    return
+            else:
+                os_close(self._errpipe_write)
+        else:
+            os_close(self._errpipe_write)
+
+    cdef _close_after_spawn(self, int fd):
+        if self._fds_to_close is None:
+            raise RuntimeError(
+                'UVProcess._close_after_spawn called after uv_spawn')
+        self._fds_to_close.append(fd)
+
+    def __dealloc__(self):
+        if self.uv_opt_env is not NULL:
+            PyMem_RawFree(self.uv_opt_env)
+            self.uv_opt_env = NULL
+
+        if self.uv_opt_args is not NULL:
+            PyMem_RawFree(self.uv_opt_args)
+            self.uv_opt_args = NULL
+
+    cdef char** __to_cstring_array(self, list arr):
+        cdef:
+            int i
+            ssize_t arr_len = len(arr)
+            bytes el
+
+            char **ret
+
+        ret = <char **>PyMem_RawMalloc((arr_len + 1) * sizeof(char *))
+        if ret is NULL:
+            raise MemoryError()
+
+        for i in range(arr_len):
+            el = arr[i]
+            # NB: PyBytes_AsString doesn't copy the data;
+            # we have to be careful when the "arr" is GCed,
+            # and it shouldn't be ever mutated.
+            ret[i] = PyBytes_AsString(el)
+
+        ret[arr_len] = NULL
+        return ret
+
+    cdef _init_options(self, list args, dict env, cwd, start_new_session,
+                       _stdin, _stdout, _stderr, bint force_fork):
+
+        memset(&self.options, 0, sizeof(uv.uv_process_options_t))
+
+        self._init_env(env)
+        self.options.env = self.uv_opt_env
+
+        self._init_args(args)
+        self.options.file = self.uv_opt_file
+        self.options.args = self.uv_opt_args
+
+        if start_new_session:
+            self.options.flags |= uv.UV_PROCESS_DETACHED
+
+        if force_fork:
+            # This is a hack to work around the change in libuv 1.44:
+            #    > macos: use posix_spawn instead of fork
+            # where Python subprocess options like preexec_fn are
+            # crippled. CPython only uses posix_spawn under a pretty
+            # strict list of conditions (see subprocess.py), and falls
+            # back to using fork() otherwise. We'd like to simulate such
+            # behavior with libuv, but unfortunately libuv doesn't
+            # provide explicit API to choose such implementation detail.
+            # Based on current (libuv 1.46) behavior, setting
+            # UV_PROCESS_SETUID or UV_PROCESS_SETGID would reliably make
+            # libuv fallback to use fork, so let's just use it for now.
+            self.options.flags |= uv.UV_PROCESS_SETUID
+            self.options.uid = uv.getuid()
+
+        if cwd is not None:
+            cwd = os_fspath(cwd)
+
+            if isinstance(cwd, str):
+                cwd = PyUnicode_EncodeFSDefault(cwd)
+            if not isinstance(cwd, bytes):
+                raise ValueError('cwd must be a str or bytes object')
+
+            self.__cwd = cwd
+            self.options.cwd = PyBytes_AsString(self.__cwd)
+
+        self.options.exit_cb = &__uvprocess_on_exit_callback
+
+        self._init_files(_stdin, _stdout, _stderr)
+
+    cdef _init_args(self, list args):
+        cdef:
+            bytes path
+            int an = len(args)
+
+        if an < 1:
+            raise ValueError('cannot spawn a process: args are empty')
+
+        self.__args = args.copy()
+        for i in range(an):
+            arg = os_fspath(args[i])
+            if isinstance(arg, str):
+                self.__args[i] = PyUnicode_EncodeFSDefault(arg)
+            elif not isinstance(arg, bytes):
+                raise TypeError('all args must be str or bytes')
+
+        path = self.__args[0]
+        self.uv_opt_file = PyBytes_AsString(path)
+        self.uv_opt_args = self.__to_cstring_array(self.__args)
+
+    cdef _init_env(self, dict env):
+        if env is not None:
+            self.__env = list()
+            for key in env:
+                val = env[key]
+
+                if isinstance(key, str):
+                    key = PyUnicode_EncodeFSDefault(key)
+                elif not isinstance(key, bytes):
+                    raise TypeError(
+                        'all environment vars must be bytes or str')
+
+                if isinstance(val, str):
+                    val = PyUnicode_EncodeFSDefault(val)
+                elif not isinstance(val, bytes):
+                    raise TypeError(
+                        'all environment values must be bytes or str')
+
+                self.__env.append(key + b'=' + val)
+
+            self.uv_opt_env = self.__to_cstring_array(self.__env)
+        else:
+            self.__env = None
+
+    cdef _init_files(self, _stdin, _stdout, _stderr):
+        self.options.stdio_count = 0
+
+    cdef _kill(self, int signum):
+        cdef int err
+        self._ensure_alive()
+        err = uv.uv_process_kill(<uv.uv_process_t*>self._handle, signum)
+        if err < 0:
+            raise convert_error(err)
+
+    cdef _on_exit(self, int64_t exit_status, int term_signal):
+        if term_signal:
+            # From Python docs:
+            #    A negative value -N indicates that the child was
+            #    terminated by signal N (POSIX only).
+            self._returncode = -term_signal
+        else:
+            self._returncode = exit_status
+
+        self._close()
+
+    cdef _close(self):
+        try:
+            if self._loop is not None:
+                self._loop._untrack_process(self)
+        finally:
+            UVHandle._close(self)
+
+
+DEF _CALL_PIPE_DATA_RECEIVED = 0
+DEF _CALL_PIPE_CONNECTION_LOST = 1
+DEF _CALL_PROCESS_EXITED = 2
+DEF _CALL_CONNECTION_LOST = 3
+
+
+@cython.no_gc_clear
+cdef class UVProcessTransport(UVProcess):
+    def __cinit__(self):
+        self._exit_waiters = []
+        self._protocol = None
+
+        self._init_futs = []
+        self._pending_calls = []
+        self._stdio_ready = 0
+
+        self._stdin = self._stdout = self._stderr = None
+        self.stdin_proto = self.stdout_proto = self.stderr_proto = None
+
+        self._finished = 0
+
+    cdef _on_exit(self, int64_t exit_status, int term_signal):
+        UVProcess._on_exit(self, exit_status, term_signal)
+
+        if self._stdio_ready:
+            self._loop.call_soon(self._protocol.process_exited,
+                                 context=self.context)
+        else:
+            self._pending_calls.append((_CALL_PROCESS_EXITED, None, None))
+
+        self._try_finish()
+
+        for waiter in self._exit_waiters:
+            if not waiter.cancelled():
+                waiter.set_result(self._returncode)
+        self._exit_waiters.clear()
+
+        self._close()
+
+    cdef _check_proc(self):
+        if not self._is_alive() or self._returncode is not None:
+            raise ProcessLookupError()
+
+    cdef _pipe_connection_lost(self, int fd, exc):
+        if self._stdio_ready:
+            self._loop.call_soon(self._protocol.pipe_connection_lost, fd, exc,
+                                 context=self.context)
+            self._try_finish()
+        else:
+            self._pending_calls.append((_CALL_PIPE_CONNECTION_LOST, fd, exc))
+
+    cdef _pipe_data_received(self, int fd, data):
+        if self._stdio_ready:
+            self._loop.call_soon(self._protocol.pipe_data_received, fd, data,
+                                 context=self.context)
+        else:
+            self._pending_calls.append((_CALL_PIPE_DATA_RECEIVED, fd, data))
+
+    cdef _file_redirect_stdio(self, int fd):
+        fd = os_dup(fd)
+        os_set_inheritable(fd, True)
+        self._close_after_spawn(fd)
+        return fd
+
+    cdef _file_devnull(self):
+        dn = os_open(os_devnull, os_O_RDWR)
+        os_set_inheritable(dn, True)
+        self._close_after_spawn(dn)
+        return dn
+
+    cdef _file_outpipe(self):
+        r, w = __socketpair()
+        os_set_inheritable(w, True)
+        self._close_after_spawn(w)
+        return r, w
+
+    cdef _file_inpipe(self):
+        r, w = __socketpair()
+        os_set_inheritable(r, True)
+        self._close_after_spawn(r)
+        return r, w
+
+    cdef _init_files(self, _stdin, _stdout, _stderr):
+        cdef uv.uv_stdio_container_t *iocnt
+
+        UVProcess._init_files(self, _stdin, _stdout, _stderr)
+
+        io = [None, None, None]
+
+        self.options.stdio_count = 3
+        self.options.stdio = self.iocnt
+
+        if _stdin is not None:
+            if _stdin == subprocess_PIPE:
+                r, w = self._file_inpipe()
+                io[0] = r
+
+                self.stdin_proto = WriteSubprocessPipeProto(self, 0)
+                waiter = self._loop._new_future()
+                self._stdin = WriteUnixTransport.new(
+                    self._loop, self.stdin_proto, None, waiter)
+                self._init_futs.append(waiter)
+                self._stdin._open(w)
+                self._stdin._init_protocol()
+            elif _stdin == subprocess_DEVNULL:
+                io[0] = self._file_devnull()
+            elif _stdout == subprocess_STDOUT:
+                raise ValueError(
+                    'subprocess.STDOUT is supported only by stderr parameter')
+            else:
+                io[0] = self._file_redirect_stdio(_stdin)
+        else:
+            io[0] = self._file_redirect_stdio(0)
+
+        if _stdout is not None:
+            if _stdout == subprocess_PIPE:
+                # We can't use UV_CREATE_PIPE here, since 'stderr' might be
+                # set to 'subprocess.STDOUT', and there is no way to
+                # emulate that functionality with libuv high-level
+                # streams API. Therefore, we create pipes for stdout and
+                # stderr manually.
+
+                r, w = self._file_outpipe()
+                io[1] = w
+
+                self.stdout_proto = ReadSubprocessPipeProto(self, 1)
+                waiter = self._loop._new_future()
+                self._stdout = ReadUnixTransport.new(
+                    self._loop, self.stdout_proto, None, waiter)
+                self._init_futs.append(waiter)
+                self._stdout._open(r)
+                self._stdout._init_protocol()
+            elif _stdout == subprocess_DEVNULL:
+                io[1] = self._file_devnull()
+            elif _stdout == subprocess_STDOUT:
+                raise ValueError(
+                    'subprocess.STDOUT is supported only by stderr parameter')
+            else:
+                io[1] = self._file_redirect_stdio(_stdout)
+        else:
+            io[1] = self._file_redirect_stdio(1)
+
+        if _stderr is not None:
+            if _stderr == subprocess_PIPE:
+                r, w = self._file_outpipe()
+                io[2] = w
+
+                self.stderr_proto = ReadSubprocessPipeProto(self, 2)
+                waiter = self._loop._new_future()
+                self._stderr = ReadUnixTransport.new(
+                    self._loop, self.stderr_proto, None, waiter)
+                self._init_futs.append(waiter)
+                self._stderr._open(r)
+                self._stderr._init_protocol()
+            elif _stderr == subprocess_STDOUT:
+                if io[1] is None:
+                    # shouldn't ever happen
+                    raise RuntimeError('cannot apply subprocess.STDOUT')
+
+                io[2] = self._file_redirect_stdio(io[1])
+            elif _stderr == subprocess_DEVNULL:
+                io[2] = self._file_devnull()
+            else:
+                io[2] = self._file_redirect_stdio(_stderr)
+        else:
+            io[2] = self._file_redirect_stdio(2)
+
+        assert len(io) == 3
+        for idx in range(3):
+            iocnt = &self.iocnt[idx]
+            if io[idx] is not None:
+                iocnt.flags = uv.UV_INHERIT_FD
+                iocnt.data.fd = io[idx]
+            else:
+                iocnt.flags = uv.UV_IGNORE
+
+    cdef _call_connection_made(self, waiter):
+        try:
+            # we're always called in the right context, so just call the user's
+            self._protocol.connection_made(self)
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as ex:
+            if waiter is not None and not waiter.cancelled():
+                waiter.set_exception(ex)
+            else:
+                raise
+        else:
+            if waiter is not None and not waiter.cancelled():
+                waiter.set_result(True)
+
+        self._stdio_ready = 1
+        if self._pending_calls:
+            pending_calls = self._pending_calls.copy()
+            self._pending_calls.clear()
+            for (type, fd, arg) in pending_calls:
+                if type == _CALL_PIPE_CONNECTION_LOST:
+                    self._pipe_connection_lost(fd, arg)
+                elif type == _CALL_PIPE_DATA_RECEIVED:
+                    self._pipe_data_received(fd, arg)
+                elif type == _CALL_PROCESS_EXITED:
+                    self._loop.call_soon(self._protocol.process_exited)
+                elif type == _CALL_CONNECTION_LOST:
+                    self._loop.call_soon(self._protocol.connection_lost, None)
+
+    cdef _try_finish(self):
+        if self._returncode is None or self._finished:
+            return
+
+        if ((self.stdin_proto is None or self.stdin_proto.disconnected) and
+                (self.stdout_proto is None or
+                    self.stdout_proto.disconnected) and
+                (self.stderr_proto is None or
+                    self.stderr_proto.disconnected)):
+
+            self._finished = 1
+
+            if self._stdio_ready:
+                # copy self.context for simplicity
+                self._loop.call_soon(self._protocol.connection_lost, None,
+                                     context=self.context)
+            else:
+                self._pending_calls.append((_CALL_CONNECTION_LOST, None, None))
+
+    def __stdio_inited(self, waiter, stdio_fut):
+        exc = stdio_fut.exception()
+        if exc is not None:
+            if waiter is None:
+                raise exc
+            else:
+                waiter.set_exception(exc)
+        else:
+            self._loop._call_soon_handle(
+                new_MethodHandle1(self._loop,
+                                  "UVProcessTransport._call_connection_made",
+                                  <method1_t>self._call_connection_made,
+                                  None,  # means to copy the current context
+                                  self, waiter))
+
+    @staticmethod
+    cdef UVProcessTransport new(Loop loop, protocol, args, env,
+                                cwd, start_new_session,
+                                _stdin, _stdout, _stderr, pass_fds,
+                                waiter,
+                                debug_flags,
+                                preexec_fn,
+                                restore_signals):
+
+        cdef UVProcessTransport handle
+        handle = UVProcessTransport.__new__(UVProcessTransport)
+        handle._protocol = protocol
+        handle._init(loop, args, env, cwd, start_new_session,
+                     __process_convert_fileno(_stdin),
+                     __process_convert_fileno(_stdout),
+                     __process_convert_fileno(_stderr),
+                     pass_fds,
+                     debug_flags,
+                     preexec_fn,
+                     restore_signals)
+
+        if handle._init_futs:
+            handle._stdio_ready = 0
+            init_fut = aio_gather(*handle._init_futs)
+            # add_done_callback will copy the current context and run the
+            # callback within the context
+            init_fut.add_done_callback(
+                ft_partial(handle.__stdio_inited, waiter))
+        else:
+            handle._stdio_ready = 1
+            loop._call_soon_handle(
+                new_MethodHandle1(loop,
+                                  "UVProcessTransport._call_connection_made",
+                                  <method1_t>handle._call_connection_made,
+                                  None,  # means to copy the current context
+                                  handle, waiter))
+
+        return handle
+
+    def get_protocol(self):
+        return self._protocol
+
+    def set_protocol(self, protocol):
+        self._protocol = protocol
+
+    def get_pid(self):
+        return self._pid
+
+    def get_returncode(self):
+        return self._returncode
+
+    def get_pipe_transport(self, fd):
+        if fd == 0:
+            return self._stdin
+        elif fd == 1:
+            return self._stdout
+        elif fd == 2:
+            return self._stderr
+
+    def terminate(self):
+        self._check_proc()
+        self._kill(uv.SIGTERM)
+
+    def kill(self):
+        self._check_proc()
+        self._kill(uv.SIGKILL)
+
+    def send_signal(self, int signal):
+        self._check_proc()
+        self._kill(signal)
+
+    def is_closing(self):
+        return self._closed
+
+    def close(self):
+        if self._returncode is None:
+            self._kill(uv.SIGKILL)
+
+        if self._stdin is not None:
+            self._stdin.close()
+        if self._stdout is not None:
+            self._stdout.close()
+        if self._stderr is not None:
+            self._stderr.close()
+
+        if self._returncode is not None:
+            # The process is dead, just close the UV handle.
+            #
+            # (If "self._returncode is None", the process should have been
+            # killed already and we're just waiting for a SIGCHLD; after
+            # which the transport will be GC'ed and the uvhandle will be
+            # closed in UVHandle.__dealloc__.)
+            self._close()
+
+    def get_extra_info(self, name, default=None):
+        return default
+
+    def _wait(self):
+        fut = self._loop._new_future()
+        if self._returncode is not None:
+            fut.set_result(self._returncode)
+            return fut
+
+        self._exit_waiters.append(fut)
+        return fut
+
+
+class WriteSubprocessPipeProto(aio_BaseProtocol):
+
+    def __init__(self, proc, fd):
+        if UVLOOP_DEBUG:
+            if type(proc) is not UVProcessTransport:
+                raise TypeError
+            if not isinstance(fd, int):
+                raise TypeError
+        self.proc = proc
+        self.fd = fd
+        self.pipe = None
+        self.disconnected = False
+
+    def connection_made(self, transport):
+        self.pipe = transport
+
+    def __repr__(self):
+        return ('<%s fd=%s pipe=%r>'
+                % (self.__class__.__name__, self.fd, self.pipe))
+
+    def connection_lost(self, exc):
+        self.disconnected = True
+        (<UVProcessTransport>self.proc)._pipe_connection_lost(self.fd, exc)
+        self.proc = None
+
+    def pause_writing(self):
+        (<UVProcessTransport>self.proc)._protocol.pause_writing()
+
+    def resume_writing(self):
+        (<UVProcessTransport>self.proc)._protocol.resume_writing()
+
+
+class ReadSubprocessPipeProto(WriteSubprocessPipeProto,
+                              aio_Protocol):
+
+    def data_received(self, data):
+        (<UVProcessTransport>self.proc)._pipe_data_received(self.fd, data)
+
+
+cdef __process_convert_fileno(object obj):
+    if obj is None or isinstance(obj, int):
+        return obj
+
+    fileno = obj.fileno()
+    if not isinstance(fileno, int):
+        raise TypeError(
+            '{!r}.fileno() returned non-integer'.format(obj))
+    return fileno
+
+
+cdef void __uvprocess_on_exit_callback(
+    uv.uv_process_t *handle,
+    int64_t exit_status,
+    int term_signal,
+) noexcept with gil:
+
+    if __ensure_handle_data(<uv.uv_handle_t*>handle,
+                            "UVProcess exit callback") == 0:
+        return
+
+    cdef UVProcess proc = <UVProcess> handle.data
+    try:
+        proc._on_exit(exit_status, term_signal)
+    except BaseException as ex:
+        proc._error(ex, False)
+
+
+cdef __socketpair():
+    cdef:
+        int fds[2]
+        int err
+
+    err = system.socketpair(uv.AF_UNIX, uv.SOCK_STREAM, 0, fds)
+    if err:
+        exc = convert_error(-err)
+        raise exc
+
+    os_set_inheritable(fds[0], False)
+    os_set_inheritable(fds[1], False)
+
+    return fds[0], fds[1]
+
+
+cdef void __uv_close_process_handle_cb(
+    uv.uv_handle_t* handle
+) noexcept with gil:
+    PyMem_RawFree(handle)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/stream.pxd b/venv/lib/python3.11/site-packages/uvloop/handles/stream.pxd
new file mode 100644
index 0000000..8ca8743
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/stream.pxd
@@ -0,0 +1,50 @@
+cdef class UVStream(UVBaseTransport):
+    cdef:
+        uv.uv_shutdown_t _shutdown_req
+        bint __shutting_down
+        bint __reading
+        bint __read_error_close
+
+        bint __buffered
+        object _protocol_get_buffer
+        object _protocol_buffer_updated
+
+        bint _eof
+        list _buffer
+        size_t _buffer_size
+
+        Py_buffer _read_pybuf
+        bint _read_pybuf_acquired
+
+    # All "inline" methods are final
+
+    cdef inline _init(self, Loop loop, object protocol, Server server,
+                      object waiter, object context)
+
+
+    cdef inline _shutdown(self)
+    cdef inline _accept(self, UVStream server)
+
+    cdef inline _close_on_read_error(self)
+
+    cdef inline __reading_started(self)
+    cdef inline __reading_stopped(self)
+
+    # The user API write() and writelines() firstly call _buffer_write() to
+    # buffer up user data chunks, potentially multiple times in writelines(),
+    # and then call _initiate_write() to start writing either immediately or in
+    # the next iteration (loop._queue_write()).
+    cdef inline _buffer_write(self, object data)
+    cdef inline _initiate_write(self)
+
+    # _exec_write() is the method that does the actual send, and _try_write()
+    # is a fast-path used in _exec_write() to send a single chunk.
+    cdef inline _exec_write(self)
+    cdef inline _try_write(self, object data)
+
+    cdef _close(self)
+
+    cdef inline _on_accept(self)
+    cdef inline _on_eof(self)
+    cdef inline _on_write(self)
+    cdef inline _on_connect(self, object exc)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/stream.pyx b/venv/lib/python3.11/site-packages/uvloop/handles/stream.pyx
new file mode 100644
index 0000000..d4e02e3
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/stream.pyx
@@ -0,0 +1,1015 @@
+DEF __PREALLOCED_BUFS = 4
+
+
+@cython.no_gc_clear
+@cython.freelist(DEFAULT_FREELIST_SIZE)
+cdef class _StreamWriteContext:
+    # used to hold additional write request information for uv_write
+
+    cdef:
+        uv.uv_write_t   req
+
+        list            buffers
+
+        uv.uv_buf_t     uv_bufs_sml[__PREALLOCED_BUFS]
+        Py_buffer       py_bufs_sml[__PREALLOCED_BUFS]
+        bint            py_bufs_sml_inuse
+
+        uv.uv_buf_t*    uv_bufs
+        Py_buffer*      py_bufs
+        size_t          py_bufs_len
+
+        uv.uv_buf_t*    uv_bufs_start
+        size_t          uv_bufs_len
+
+        UVStream        stream
+
+        bint            closed
+
+    cdef free_bufs(self):
+        cdef size_t i
+
+        if self.uv_bufs is not NULL:
+            PyMem_RawFree(self.uv_bufs)
+            self.uv_bufs = NULL
+            if UVLOOP_DEBUG:
+                if self.py_bufs_sml_inuse:
+                    raise RuntimeError(
+                        '_StreamWriteContext.close: uv_bufs != NULL and '
+                        'py_bufs_sml_inuse is True')
+
+        if self.py_bufs is not NULL:
+            for i from 0 <= i < self.py_bufs_len:
+                PyBuffer_Release(&self.py_bufs[i])
+            PyMem_RawFree(self.py_bufs)
+            self.py_bufs = NULL
+            if UVLOOP_DEBUG:
+                if self.py_bufs_sml_inuse:
+                    raise RuntimeError(
+                        '_StreamWriteContext.close: py_bufs != NULL and '
+                        'py_bufs_sml_inuse is True')
+
+        if self.py_bufs_sml_inuse:
+            for i from 0 <= i < self.py_bufs_len:
+                PyBuffer_Release(&self.py_bufs_sml[i])
+            self.py_bufs_sml_inuse = 0
+
+        self.py_bufs_len = 0
+        self.buffers = None
+
+    cdef close(self):
+        if self.closed:
+            return
+        self.closed = 1
+        self.free_bufs()
+        Py_DECREF(self)
+
+    cdef advance_uv_buf(self, size_t sent):
+        # Advance the pointer to first uv_buf and the
+        # pointer to first byte in that buffer.
+        #
+        # We do this after a "uv_try_write" call, which
+        # sometimes sends only a portion of data.
+        # We then call "advance_uv_buf" on the write
+        # context, and reuse it in a "uv_write" call.
+
+        cdef:
+            uv.uv_buf_t* buf
+            size_t idx
+
+        for idx from 0 <= idx < self.uv_bufs_len:
+            buf = &self.uv_bufs_start[idx]
+            if buf.len > sent:
+                buf.len -= sent
+                buf.base = buf.base + sent
+                self.uv_bufs_start = buf
+                self.uv_bufs_len -= idx
+                return
+            else:
+                sent -= self.uv_bufs_start[idx].len
+
+            if UVLOOP_DEBUG:
+                if sent < 0:
+                    raise RuntimeError('fatal: sent < 0 in advance_uv_buf')
+
+        raise RuntimeError('fatal: Could not advance _StreamWriteContext')
+
+    @staticmethod
+    cdef _StreamWriteContext new(UVStream stream, list buffers):
+        cdef:
+            _StreamWriteContext ctx
+            int uv_bufs_idx = 0
+            size_t py_bufs_len = 0
+            int i
+
+            Py_buffer* p_pybufs
+            uv.uv_buf_t* p_uvbufs
+
+        ctx = _StreamWriteContext.__new__(_StreamWriteContext)
+        ctx.stream = None
+        ctx.closed = 1
+        ctx.py_bufs_len = 0
+        ctx.py_bufs_sml_inuse = 0
+        ctx.uv_bufs = NULL
+        ctx.py_bufs = NULL
+        ctx.buffers = buffers
+        ctx.stream = stream
+
+        if len(buffers) <= __PREALLOCED_BUFS:
+            # We've got a small number of buffers to write, don't
+            # need to use malloc.
+            ctx.py_bufs_sml_inuse = 1
+            p_pybufs = <Py_buffer*>&ctx.py_bufs_sml
+            p_uvbufs = <uv.uv_buf_t*>&ctx.uv_bufs_sml
+
+        else:
+            for buf in buffers:
+                if UVLOOP_DEBUG:
+                    if not isinstance(buf, (bytes, bytearray, memoryview)):
+                        raise RuntimeError(
+                            'invalid data in writebuf: an instance of '
+                            'bytes, bytearray or memoryview was expected, '
+                            'got {}'.format(type(buf)))
+
+                if not PyBytes_CheckExact(buf):
+                    py_bufs_len += 1
+
+            if py_bufs_len > 0:
+                ctx.py_bufs = <Py_buffer*>PyMem_RawMalloc(
+                    py_bufs_len * sizeof(Py_buffer))
+                if ctx.py_bufs is NULL:
+                    raise MemoryError()
+
+            ctx.uv_bufs = <uv.uv_buf_t*>PyMem_RawMalloc(
+                len(buffers) * sizeof(uv.uv_buf_t))
+            if ctx.uv_bufs is NULL:
+                raise MemoryError()
+
+            p_pybufs = ctx.py_bufs
+            p_uvbufs = ctx.uv_bufs
+
+        py_bufs_len = 0
+        for buf in buffers:
+            if PyBytes_CheckExact(buf):
+                # We can only use this hack for bytes since it's
+                # immutable.  For everything else it is only safe to
+                # use buffer protocol.
+                p_uvbufs[uv_bufs_idx].base = PyBytes_AS_STRING(buf)
+                p_uvbufs[uv_bufs_idx].len = Py_SIZE(buf)
+
+            else:
+                try:
+                    PyObject_GetBuffer(
+                        buf, &p_pybufs[py_bufs_len], PyBUF_SIMPLE)
+                except Exception:
+                    # This shouldn't ever happen, as `UVStream._buffer_write`
+                    # casts non-bytes objects to `memoryviews`.
+                    ctx.py_bufs_len = py_bufs_len
+                    ctx.free_bufs()
+                    raise
+
+                p_uvbufs[uv_bufs_idx].base = <char*>p_pybufs[py_bufs_len].buf
+                p_uvbufs[uv_bufs_idx].len = p_pybufs[py_bufs_len].len
+
+                py_bufs_len += 1
+
+            uv_bufs_idx += 1
+
+        ctx.uv_bufs_start = p_uvbufs
+        ctx.uv_bufs_len = uv_bufs_idx
+
+        ctx.py_bufs_len = py_bufs_len
+        ctx.req.data = <void*> ctx
+
+        if UVLOOP_DEBUG:
+            stream._loop._debug_stream_write_ctx_total += 1
+            stream._loop._debug_stream_write_ctx_cnt += 1
+
+        # Do incref after everything else is done.
+        # Under no circumstances we want `ctx` to be GCed while
+        # libuv is still working with `ctx.uv_bufs`.
+        Py_INCREF(ctx)
+        ctx.closed = 0
+        return ctx
+
+    def __dealloc__(self):
+        if not self.closed:
+            # Because we do an INCREF in _StreamWriteContext.new,
+            # __dealloc__ shouldn't ever happen with `self.closed == 1`
+            raise RuntimeError(
+                'open _StreamWriteContext is being deallocated')
+
+        if UVLOOP_DEBUG:
+            if self.stream is not None:
+                self.stream._loop._debug_stream_write_ctx_cnt -= 1
+                self.stream = None
+
+
+@cython.no_gc_clear
+cdef class UVStream(UVBaseTransport):
+
+    def __cinit__(self):
+        self.__shutting_down = 0
+        self.__reading = 0
+        self.__read_error_close = 0
+        self.__buffered = 0
+        self._eof = 0
+        self._buffer = []
+        self._buffer_size = 0
+
+        self._protocol_get_buffer = None
+        self._protocol_buffer_updated = None
+
+        self._read_pybuf_acquired = False
+
+    cdef _set_protocol(self, object protocol):
+        if protocol is None:
+            raise TypeError('protocol is required')
+
+        UVBaseTransport._set_protocol(self, protocol)
+
+        if (hasattr(protocol, 'get_buffer') and
+                not isinstance(protocol, aio_Protocol)):
+            try:
+                self._protocol_get_buffer = protocol.get_buffer
+                self._protocol_buffer_updated = protocol.buffer_updated
+                self.__buffered = 1
+            except AttributeError:
+                pass
+        else:
+            self.__buffered = 0
+
+    cdef _clear_protocol(self):
+        UVBaseTransport._clear_protocol(self)
+        self._protocol_get_buffer = None
+        self._protocol_buffer_updated = None
+        self.__buffered = 0
+
+    cdef inline _shutdown(self):
+        cdef int err
+
+        if self.__shutting_down:
+            return
+        self.__shutting_down = 1
+
+        self._ensure_alive()
+
+        self._shutdown_req.data = <void*> self
+        err = uv.uv_shutdown(&self._shutdown_req,
+                             <uv.uv_stream_t*> self._handle,
+                             __uv_stream_on_shutdown)
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+
+    cdef inline _accept(self, UVStream server):
+        cdef int err
+        self._ensure_alive()
+
+        err = uv.uv_accept(<uv.uv_stream_t*>server._handle,
+                           <uv.uv_stream_t*>self._handle)
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+
+        self._on_accept()
+
+    cdef inline _close_on_read_error(self):
+        self.__read_error_close = 1
+
+    cdef bint _is_reading(self):
+        return self.__reading
+
+    cdef _start_reading(self):
+        cdef int err
+
+        if self._closing:
+            return
+
+        self._ensure_alive()
+
+        if self.__reading:
+            return
+
+        if self.__buffered:
+            err = uv.uv_read_start(<uv.uv_stream_t*>self._handle,
+                                   __uv_stream_buffered_alloc,
+                                   __uv_stream_buffered_on_read)
+        else:
+            err = uv.uv_read_start(<uv.uv_stream_t*>self._handle,
+                                   __loop_alloc_buffer,
+                                   __uv_stream_on_read)
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+        else:
+            # UVStream must live until the read callback is called
+            self.__reading_started()
+
+    cdef inline __reading_started(self):
+        if self.__reading:
+            return
+        self.__reading = 1
+        Py_INCREF(self)
+
+    cdef inline __reading_stopped(self):
+        if not self.__reading:
+            return
+        self.__reading = 0
+        Py_DECREF(self)
+
+    cdef _stop_reading(self):
+        cdef int err
+
+        if not self.__reading:
+            return
+
+        self._ensure_alive()
+
+        # From libuv docs:
+        #    This function is idempotent and may be safely
+        #    called on a stopped stream.
+        err = uv.uv_read_stop(<uv.uv_stream_t*>self._handle)
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+        else:
+            self.__reading_stopped()
+
+    cdef inline _try_write(self, object data):
+        cdef:
+            ssize_t written
+            bint used_buf = 0
+            Py_buffer py_buf
+            void* buf
+            size_t blen
+            int saved_errno
+            int fd
+
+        if (<uv.uv_stream_t*>self._handle).write_queue_size != 0:
+            raise RuntimeError(
+                'UVStream._try_write called with data in uv buffers')
+
+        if PyBytes_CheckExact(data):
+            # We can only use this hack for bytes since it's
+            # immutable.  For everything else it is only safe to
+            # use buffer protocol.
+            buf = <void*>PyBytes_AS_STRING(data)
+            blen = Py_SIZE(data)
+        else:
+            PyObject_GetBuffer(data, &py_buf, PyBUF_SIMPLE)
+            used_buf = 1
+            buf = py_buf.buf
+            blen = py_buf.len
+
+        if blen == 0:
+            # Empty data, do nothing.
+            return 0
+
+        fd = self._fileno()
+        # Use `unistd.h/write` directly, it's faster than
+        # uv_try_write -- less layers of code.  The error
+        # checking logic is copied from libuv.
+        written = system.write(fd, buf, blen)
+        while written == -1 and (
+                errno.errno == errno.EINTR or
+                (system.PLATFORM_IS_APPLE and
+                    errno.errno == errno.EPROTOTYPE)):
+            # From libuv code (unix/stream.c):
+            #   Due to a possible kernel bug at least in OS X 10.10 "Yosemite",
+            #   EPROTOTYPE can be returned while trying to write to a socket
+            #   that is shutting down. If we retry the write, we should get
+            #   the expected EPIPE instead.
+            written = system.write(fd, buf, blen)
+        saved_errno = errno.errno
+
+        if used_buf:
+            PyBuffer_Release(&py_buf)
+
+        if written < 0:
+            if saved_errno == errno.EAGAIN or \
+                    saved_errno == system.EWOULDBLOCK:
+                return -1
+            else:
+                exc = convert_error(-saved_errno)
+                self._fatal_error(exc, True)
+                return
+
+        if UVLOOP_DEBUG:
+            self._loop._debug_stream_write_tries += 1
+
+        if <size_t>written == blen:
+            return 0
+
+        return written
+
+    cdef inline _buffer_write(self, object data):
+        cdef int dlen
+
+        if not PyBytes_CheckExact(data):
+            data = memoryview(data).cast('b')
+
+        dlen = len(data)
+        if not dlen:
+            return
+
+        self._buffer_size += dlen
+        self._buffer.append(data)
+
+    cdef inline _initiate_write(self):
+        if (not self._protocol_paused and
+                (<uv.uv_stream_t*>self._handle).write_queue_size == 0 and
+                self._buffer_size > self._high_water):
+            # Fast-path.  If:
+            #   - the protocol isn't yet paused,
+            #   - there is no data in libuv buffers for this stream,
+            #   - the protocol will be paused if we continue to buffer data
+            #
+            # Then:
+            #   - Try to write all buffered data right now.
+            all_sent = self._exec_write()
+            if UVLOOP_DEBUG:
+                if self._buffer_size != 0 or self._buffer != []:
+                    raise RuntimeError(
+                        '_buffer_size is not 0 after a successful _exec_write')
+
+            # There is no need to call `_queue_write` anymore,
+            # as `uv_write` should be called already.
+
+            if not all_sent:
+                # If not all of the data was sent successfully,
+                # we might need to pause the protocol.
+                self._maybe_pause_protocol()
+
+        elif self._buffer_size > 0:
+            self._maybe_pause_protocol()
+            self._loop._queue_write(self)
+
+    cdef inline _exec_write(self):
+        cdef:
+            int err
+            int buf_len
+            _StreamWriteContext ctx = None
+
+        if self._closed:
+            # If the handle is closed, just return, it's too
+            # late to do anything.
+            return
+
+        buf_len = len(self._buffer)
+        if not buf_len:
+            return
+
+        if (<uv.uv_stream_t*>self._handle).write_queue_size == 0:
+            # libuv internal write buffers for this stream are empty.
+            if buf_len == 1:
+                # If we only have one piece of data to send, let's
+                # use our fast implementation of try_write.
+                data = self._buffer[0]
+                sent = self._try_write(data)
+
+                if sent is None:
+                    # A `self._fatal_error` was called.
+                    # It might not raise an exception under some
+                    # conditions.
+                    self._buffer_size = 0
+                    self._buffer.clear()
+                    if not self._closing:
+                        # This should never happen.
+                        raise RuntimeError(
+                            'stream is open after UVStream._try_write '
+                            'returned None')
+                    return
+
+                if sent == 0:
+                    # All data was successfully written.
+                    self._buffer_size = 0
+                    self._buffer.clear()
+                    # on_write will call "maybe_resume_protocol".
+                    self._on_write()
+                    return True
+
+                if sent > 0:
+                    if UVLOOP_DEBUG:
+                        if sent == len(data):
+                            raise RuntimeError(
+                                '_try_write sent all data and returned '
+                                'non-zero')
+
+                    if PyBytes_CheckExact(data):
+                        # Cast bytes to memoryview to avoid copying
+                        # data that wasn't sent.
+                        data = memoryview(data)
+                    data = data[sent:]
+
+                    self._buffer_size -= sent
+                    self._buffer[0] = data
+
+                # At this point it's either data was sent partially,
+                # or an EAGAIN has happened.
+
+            else:
+                ctx = _StreamWriteContext.new(self, self._buffer)
+
+                err = uv.uv_try_write(<uv.uv_stream_t*>self._handle,
+                                      ctx.uv_bufs_start,
+                                      ctx.uv_bufs_len)
+
+                if err > 0:
+                    # Some data was successfully sent.
+
+                    if <size_t>err == self._buffer_size:
+                        # Everything was sent.
+                        ctx.close()
+                        self._buffer.clear()
+                        self._buffer_size = 0
+                        # on_write will call "maybe_resume_protocol".
+                        self._on_write()
+                        return True
+
+                    try:
+                        # Advance pointers to uv_bufs in `ctx`,
+                        # we will reuse it soon for a uv_write
+                        # call.
+                        ctx.advance_uv_buf(<ssize_t>err)
+                    except Exception as ex:  # This should never happen.
+                        # Let's try to close the `ctx` anyways.
+                        ctx.close()
+                        self._fatal_error(ex, True)
+                        self._buffer.clear()
+                        self._buffer_size = 0
+                        return
+
+                elif err != uv.UV_EAGAIN:
+                    ctx.close()
+                    exc = convert_error(err)
+                    self._fatal_error(exc, True)
+                    self._buffer.clear()
+                    self._buffer_size = 0
+                    return
+
+                # fall through
+
+        if ctx is None:
+            ctx = _StreamWriteContext.new(self, self._buffer)
+
+        err = uv.uv_write(&ctx.req,
+                          <uv.uv_stream_t*>self._handle,
+                          ctx.uv_bufs_start,
+                          ctx.uv_bufs_len,
+                          __uv_stream_on_write)
+
+        self._buffer_size = 0
+        # Can't use `_buffer.clear()` here: `ctx` holds a reference to
+        # the `_buffer`.
+        self._buffer = []
+
+        if err < 0:
+            # close write context
+            ctx.close()
+
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+
+        self._maybe_resume_protocol()
+
+    cdef size_t _get_write_buffer_size(self):
+        if self._handle is NULL:
+            return 0
+        return ((<uv.uv_stream_t*>self._handle).write_queue_size +
+                self._buffer_size)
+
+    cdef _close(self):
+        try:
+            if self._read_pybuf_acquired:
+                # Should never happen. libuv always calls uv_alloc/uv_read
+                # in pairs.
+                self._loop.call_exception_handler({
+                    'transport': self,
+                    'message': 'XXX: an allocated buffer in transport._close()'
+                })
+                self._read_pybuf_acquired = 0
+                PyBuffer_Release(&self._read_pybuf)
+
+            self._stop_reading()
+        finally:
+            UVSocketHandle._close(<UVHandle>self)
+
+    cdef inline _on_accept(self):
+        # Ultimately called by __uv_stream_on_listen.
+        self._init_protocol()
+
+    cdef inline _on_eof(self):
+        # Any exception raised here will be caught in
+        # __uv_stream_on_read.
+
+        try:
+            meth = self._protocol.eof_received
+        except AttributeError:
+            keep_open = False
+        else:
+            keep_open = run_in_context(self.context, meth)
+
+        if keep_open:
+            # We're keeping the connection open so the
+            # protocol can write more, but we still can't
+            # receive more, so remove the reader callback.
+            self._stop_reading()
+        else:
+            self.close()
+
+    cdef inline _on_write(self):
+        self._maybe_resume_protocol()
+        if not self._get_write_buffer_size():
+            if self._closing:
+                self._schedule_call_connection_lost(None)
+            elif self._eof:
+                self._shutdown()
+
+    cdef inline _init(self, Loop loop, object protocol, Server server,
+                      object waiter, object context):
+        self.context = context
+        self._set_protocol(protocol)
+        self._start_init(loop)
+
+        if server is not None:
+            self._set_server(server)
+
+        if waiter is not None:
+            self._set_waiter(waiter)
+
+    cdef inline _on_connect(self, object exc):
+        # Called from __tcp_connect_callback (tcp.pyx) and
+        # __pipe_connect_callback (pipe.pyx).
+        if exc is None:
+            self._init_protocol()
+        else:
+            if self._waiter is None:
+                self._fatal_error(exc, False, "connect failed")
+            elif self._waiter.cancelled():
+                # Connect call was cancelled; just close the transport
+                # silently.
+                self._close()
+            elif self._waiter.done():
+                self._fatal_error(exc, False, "connect failed")
+            else:
+                self._waiter.set_exception(exc)
+                self._close()
+
+    # === Public API ===
+
+    def __repr__(self):
+        return '<{} closed={} reading={} {:#x}>'.format(
+            self.__class__.__name__,
+            self._closed,
+            self.__reading,
+            id(self))
+
+    def write(self, object buf):
+        self._ensure_alive()
+
+        if self._eof:
+            raise RuntimeError('Cannot call write() after write_eof()')
+        if not buf:
+            return
+        if self._conn_lost:
+            self._conn_lost += 1
+            return
+        self._buffer_write(buf)
+        self._initiate_write()
+
+    def writelines(self, bufs):
+        self._ensure_alive()
+
+        if self._eof:
+            raise RuntimeError('Cannot call writelines() after write_eof()')
+        if self._conn_lost:
+            self._conn_lost += 1
+            return
+        for buf in bufs:
+            self._buffer_write(buf)
+        self._initiate_write()
+
+    def write_eof(self):
+        self._ensure_alive()
+
+        if self._eof:
+            return
+
+        self._eof = 1
+        if not self._get_write_buffer_size():
+            self._shutdown()
+
+    def can_write_eof(self):
+        return True
+
+    def is_reading(self):
+        return self._is_reading()
+
+    def pause_reading(self):
+        if self._closing or not self._is_reading():
+            return
+        self._stop_reading()
+
+    def resume_reading(self):
+        if self._is_reading() or self._closing:
+            return
+        self._start_reading()
+
+
+cdef void __uv_stream_on_shutdown(uv.uv_shutdown_t* req,
+                                  int status) noexcept with gil:
+
+    # callback for uv_shutdown
+
+    if req.data is NULL:
+        aio_logger.error(
+            'UVStream.shutdown callback called with NULL req.data, status=%r',
+            status)
+        return
+
+    cdef UVStream stream = <UVStream> req.data
+
+    if status < 0 and status != uv.UV_ECANCELED:
+        # From libuv source code:
+        #     The ECANCELED error code is a lie, the shutdown(2) syscall is a
+        #     fait accompli at this point. Maybe we should revisit this in
+        #     v0.11.  A possible reason for leaving it unchanged is that it
+        #     informs the callee that the handle has been destroyed.
+
+        if UVLOOP_DEBUG:
+            stream._loop._debug_stream_shutdown_errors_total += 1
+
+        exc = convert_error(status)
+        stream._fatal_error(
+            exc, False, "error status in uv_stream_t.shutdown callback")
+        return
+
+
+cdef inline bint __uv_stream_on_read_common(
+    UVStream sc,
+    Loop loop,
+    ssize_t nread,
+):
+    if sc._closed:
+        # The stream was closed, there is no reason to
+        # do any work now.
+        sc.__reading_stopped()  # Just in case.
+        return True
+
+    if nread == uv.UV_EOF:
+        # From libuv docs:
+        #     The callee is responsible for stopping closing the stream
+        #     when an error happens by calling uv_read_stop() or uv_close().
+        #     Trying to read from the stream again is undefined.
+        try:
+            if UVLOOP_DEBUG:
+                loop._debug_stream_read_eof_total += 1
+
+            sc._stop_reading()
+            sc._on_eof()
+        except BaseException as ex:
+            if UVLOOP_DEBUG:
+                loop._debug_stream_read_eof_cb_errors_total += 1
+
+            sc._fatal_error(ex, False)
+        finally:
+            return True
+
+    if nread == 0:
+        # From libuv docs:
+        #     nread might be 0, which does not indicate an error or EOF.
+        #     This is equivalent to EAGAIN or EWOULDBLOCK under read(2).
+        return True
+
+    if nread < 0:
+        # From libuv docs:
+        #     The callee is responsible for stopping closing the stream
+        #     when an error happens by calling uv_read_stop() or uv_close().
+        #     Trying to read from the stream again is undefined.
+        #
+        # Therefore, we're closing the stream.  Since "UVHandle._close()"
+        # doesn't raise exceptions unless uvloop is built with DEBUG=1,
+        # we don't need try...finally here.
+
+        if UVLOOP_DEBUG:
+            loop._debug_stream_read_errors_total += 1
+
+        if sc.__read_error_close:
+            # Used for getting notified when a pipe is closed.
+            # See WriteUnixTransport for the explanation.
+            sc._on_eof()
+            return True
+
+        exc = convert_error(nread)
+        sc._fatal_error(
+            exc, False, "error status in uv_stream_t.read callback")
+        return True
+
+    return False
+
+
+cdef inline void __uv_stream_on_read_impl(
+    uv.uv_stream_t* stream,
+    ssize_t nread,
+    const uv.uv_buf_t* buf,
+):
+    cdef:
+        UVStream sc = <UVStream>stream.data
+        Loop loop = sc._loop
+
+    # It's OK to free the buffer early, since nothing will
+    # be able to touch it until this method is done.
+    __loop_free_buffer(loop)
+
+    if __uv_stream_on_read_common(sc, loop, nread):
+        return
+
+    try:
+        if UVLOOP_DEBUG:
+            loop._debug_stream_read_cb_total += 1
+
+        run_in_context1(
+            sc.context,
+            sc._protocol_data_received,
+            loop._recv_buffer[:nread],
+        )
+    except BaseException as exc:
+        if UVLOOP_DEBUG:
+            loop._debug_stream_read_cb_errors_total += 1
+
+        sc._fatal_error(exc, False)
+
+
+cdef inline void __uv_stream_on_write_impl(
+    uv.uv_write_t* req,
+    int status,
+):
+    cdef:
+        _StreamWriteContext ctx = <_StreamWriteContext> req.data
+        UVStream stream = <UVStream>ctx.stream
+
+    ctx.close()
+
+    if stream._closed:
+        # The stream was closed, there is nothing to do.
+        # Even if there is an error, like EPIPE, there
+        # is no reason to report it.
+        return
+
+    if status < 0:
+        if UVLOOP_DEBUG:
+            stream._loop._debug_stream_write_errors_total += 1
+
+        exc = convert_error(status)
+        stream._fatal_error(
+            exc, False, "error status in uv_stream_t.write callback")
+        return
+
+    try:
+        stream._on_write()
+    except BaseException as exc:
+        if UVLOOP_DEBUG:
+            stream._loop._debug_stream_write_cb_errors_total += 1
+
+        stream._fatal_error(exc, False)
+
+
+cdef void __uv_stream_on_read(
+    uv.uv_stream_t* stream,
+    ssize_t nread,
+    const uv.uv_buf_t* buf,
+) noexcept with gil:
+
+    if __ensure_handle_data(<uv.uv_handle_t*>stream,
+                            "UVStream read callback") == 0:
+        return
+
+    # Don't need try-finally, __uv_stream_on_read_impl is void
+    __uv_stream_on_read_impl(stream, nread, buf)
+
+
+cdef void __uv_stream_on_write(
+    uv.uv_write_t* req,
+    int status,
+) noexcept with gil:
+
+    if UVLOOP_DEBUG:
+        if req.data is NULL:
+            aio_logger.error(
+                'UVStream.write callback called with NULL req.data, status=%r',
+                status)
+            return
+
+    # Don't need try-finally, __uv_stream_on_write_impl is void
+    __uv_stream_on_write_impl(req, status)
+
+
+cdef void __uv_stream_buffered_alloc(
+    uv.uv_handle_t* stream,
+    size_t suggested_size,
+    uv.uv_buf_t* uvbuf,
+) noexcept with gil:
+
+    if __ensure_handle_data(<uv.uv_handle_t*>stream,
+                            "UVStream alloc buffer callback") == 0:
+        return
+
+    cdef:
+        UVStream sc = <UVStream>stream.data
+        Loop loop = sc._loop
+        Py_buffer* pybuf = &sc._read_pybuf
+        int got_buf = 0
+
+    if sc._read_pybuf_acquired:
+        uvbuf.len = 0
+        uvbuf.base = NULL
+        return
+
+    sc._read_pybuf_acquired = 0
+    try:
+        buf = run_in_context1(
+            sc.context,
+            sc._protocol_get_buffer,
+            suggested_size,
+        )
+        PyObject_GetBuffer(buf, pybuf, PyBUF_WRITABLE)
+        got_buf = 1
+    except BaseException as exc:
+        # Can't call 'sc._fatal_error' or 'sc._close', libuv will SF.
+        # We'll do it later in __uv_stream_buffered_on_read when we
+        # receive UV_ENOBUFS.
+        uvbuf.len = 0
+        uvbuf.base = NULL
+        return
+
+    if not pybuf.len:
+        uvbuf.len = 0
+        uvbuf.base = NULL
+        if got_buf:
+            PyBuffer_Release(pybuf)
+        return
+
+    sc._read_pybuf_acquired = 1
+    uvbuf.base = <char*>pybuf.buf
+    uvbuf.len = pybuf.len
+
+
+cdef void __uv_stream_buffered_on_read(
+    uv.uv_stream_t* stream,
+    ssize_t nread,
+    const uv.uv_buf_t* buf,
+) noexcept with gil:
+
+    if __ensure_handle_data(<uv.uv_handle_t*>stream,
+                            "UVStream buffered read callback") == 0:
+        return
+
+    cdef:
+        UVStream sc = <UVStream>stream.data
+        Loop loop = sc._loop
+        Py_buffer* pybuf = &sc._read_pybuf
+
+    if nread == uv.UV_ENOBUFS:
+        sc._fatal_error(
+            RuntimeError(
+                'unhandled error (or an empty buffer) in get_buffer()'),
+            False)
+        return
+
+    try:
+        if nread > 0 and not sc._read_pybuf_acquired:
+            # From libuv docs:
+            #     nread is > 0 if there is data available or < 0 on error. When
+            #     we’ve reached EOF, nread will be set to UV_EOF. When
+            #     nread < 0, the buf parameter might not point to a valid
+            #     buffer; in that case buf.len and buf.base are both set to 0.
+            raise RuntimeError(
+                f'no python buffer is allocated in on_read; nread={nread}')
+
+        if nread == 0:
+            # From libuv docs:
+            #     nread might be 0, which does not indicate an error or EOF.
+            #     This is equivalent to EAGAIN or EWOULDBLOCK under read(2).
+            return
+
+        if __uv_stream_on_read_common(sc, loop, nread):
+            return
+
+        if UVLOOP_DEBUG:
+            loop._debug_stream_read_cb_total += 1
+
+        run_in_context1(sc.context, sc._protocol_buffer_updated, nread)
+    except BaseException as exc:
+        if UVLOOP_DEBUG:
+            loop._debug_stream_read_cb_errors_total += 1
+
+        sc._fatal_error(exc, False)
+    finally:
+        sc._read_pybuf_acquired = 0
+        PyBuffer_Release(pybuf)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/streamserver.pxd b/venv/lib/python3.11/site-packages/uvloop/handles/streamserver.pxd
new file mode 100644
index 0000000..a004efd
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/streamserver.pxd
@@ -0,0 +1,26 @@
+cdef class UVStreamServer(UVSocketHandle):
+    cdef:
+        int backlog
+        object ssl
+        object ssl_handshake_timeout
+        object ssl_shutdown_timeout
+        object protocol_factory
+        bint opened
+        Server _server
+
+    # All "inline" methods are final
+
+    cdef inline _init(self, Loop loop, object protocol_factory,
+                      Server server,
+                      object backlog,
+                      object ssl,
+                      object ssl_handshake_timeout,
+                      object ssl_shutdown_timeout)
+
+    cdef inline _mark_as_open(self)
+
+    cdef inline listen(self)
+    cdef inline _on_listen(self)
+
+    cdef UVStream _make_new_transport(self, object protocol, object waiter,
+                                      object context)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/streamserver.pyx b/venv/lib/python3.11/site-packages/uvloop/handles/streamserver.pyx
new file mode 100644
index 0000000..9993317
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/streamserver.pyx
@@ -0,0 +1,150 @@
+@cython.no_gc_clear
+cdef class UVStreamServer(UVSocketHandle):
+
+    def __cinit__(self):
+        self.opened = 0
+        self._server = None
+        self.ssl = None
+        self.ssl_handshake_timeout = None
+        self.ssl_shutdown_timeout = None
+        self.protocol_factory = None
+
+    cdef inline _init(self, Loop loop, object protocol_factory,
+                      Server server,
+                      object backlog,
+                      object ssl,
+                      object ssl_handshake_timeout,
+                      object ssl_shutdown_timeout):
+
+        if not isinstance(backlog, int):
+            # Don't allow floats
+            raise TypeError('integer argument expected, got {}'.format(
+                type(backlog).__name__))
+
+        if ssl is not None:
+            if not isinstance(ssl, ssl_SSLContext):
+                raise TypeError(
+                    'ssl is expected to be None or an instance of '
+                    'ssl.SSLContext, got {!r}'.format(ssl))
+        else:
+            if ssl_handshake_timeout is not None:
+                raise ValueError(
+                    'ssl_handshake_timeout is only meaningful with ssl')
+            if ssl_shutdown_timeout is not None:
+                raise ValueError(
+                    'ssl_shutdown_timeout is only meaningful with ssl')
+
+        self.backlog = backlog
+        self.ssl = ssl
+        self.ssl_handshake_timeout = ssl_handshake_timeout
+        self.ssl_shutdown_timeout = ssl_shutdown_timeout
+
+        self._start_init(loop)
+        self.protocol_factory = protocol_factory
+        self._server = server
+
+    cdef inline listen(self):
+        cdef int err
+        self._ensure_alive()
+
+        if self.protocol_factory is None:
+            raise RuntimeError('unable to listen(); no protocol_factory')
+
+        if self.opened != 1:
+            raise RuntimeError('unopened TCPServer')
+
+        self.context = Context_CopyCurrent()
+
+        err = uv.uv_listen(<uv.uv_stream_t*> self._handle,
+                           self.backlog,
+                           __uv_streamserver_on_listen)
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+
+    cdef inline _on_listen(self):
+        cdef UVStream client
+
+        protocol = run_in_context(self.context, self.protocol_factory)
+
+        if self.ssl is None:
+            client = self._make_new_transport(protocol, None, self.context)
+
+        else:
+            waiter = self._loop._new_future()
+
+            ssl_protocol = SSLProtocol(
+                self._loop, protocol, self.ssl,
+                waiter,
+                server_side=True,
+                server_hostname=None,
+                ssl_handshake_timeout=self.ssl_handshake_timeout,
+                ssl_shutdown_timeout=self.ssl_shutdown_timeout)
+
+            client = self._make_new_transport(ssl_protocol, None, self.context)
+
+            waiter.add_done_callback(
+                ft_partial(self.__on_ssl_connected, client))
+
+        client._accept(<UVStream>self)
+
+    cdef _fatal_error(self, exc, throw, reason=None):
+        # Overload UVHandle._fatal_error
+
+        self._close()
+
+        if not isinstance(exc, OSError):
+
+            if throw or self._loop is None:
+                raise exc
+
+            msg = f'Fatal error on server {self.__class__.__name__}'
+            if reason is not None:
+                msg = f'{msg} ({reason})'
+
+            self._loop.call_exception_handler({
+                'message': msg,
+                'exception': exc,
+            })
+
+    cdef inline _mark_as_open(self):
+        self.opened = 1
+
+    cdef UVStream _make_new_transport(self, object protocol, object waiter,
+                                      object context):
+        raise NotImplementedError
+
+    def __on_ssl_connected(self, transport, fut):
+        exc = fut.exception()
+        if exc is not None:
+            transport._force_close(exc)
+
+
+cdef void __uv_streamserver_on_listen(
+    uv.uv_stream_t* handle,
+    int status,
+) noexcept with gil:
+
+    # callback for uv_listen
+
+    if __ensure_handle_data(<uv.uv_handle_t*>handle,
+                            "UVStream listen callback") == 0:
+        return
+
+    cdef:
+        UVStreamServer stream = <UVStreamServer> handle.data
+
+    if status < 0:
+        if UVLOOP_DEBUG:
+            stream._loop._debug_stream_listen_errors_total += 1
+
+        exc = convert_error(status)
+        stream._fatal_error(
+            exc, False, "error status in uv_stream_t.listen callback")
+        return
+
+    try:
+        stream._on_listen()
+    except BaseException as exc:
+        stream._error(exc, False)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/tcp.pxd b/venv/lib/python3.11/site-packages/uvloop/handles/tcp.pxd
new file mode 100644
index 0000000..8d388ef
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/tcp.pxd
@@ -0,0 +1,26 @@
+cdef class TCPServer(UVStreamServer):
+    cdef bind(self, system.sockaddr* addr, unsigned int flags=*)
+
+    @staticmethod
+    cdef TCPServer new(Loop loop, object protocol_factory, Server server,
+                       unsigned int flags,
+                       object backlog,
+                       object ssl,
+                       object ssl_handshake_timeout,
+                       object ssl_shutdown_timeout)
+
+
+cdef class TCPTransport(UVStream):
+    cdef:
+        bint __peername_set
+        bint __sockname_set
+        system.sockaddr_storage __peername
+        system.sockaddr_storage __sockname
+
+    cdef bind(self, system.sockaddr* addr, unsigned int flags=*)
+    cdef connect(self, system.sockaddr* addr)
+    cdef _set_nodelay(self)
+
+    @staticmethod
+    cdef TCPTransport new(Loop loop, object protocol, Server server,
+                          object waiter, object context)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/tcp.pyx b/venv/lib/python3.11/site-packages/uvloop/handles/tcp.pyx
new file mode 100644
index 0000000..d5fe827
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/tcp.pyx
@@ -0,0 +1,228 @@
+cdef __tcp_init_uv_handle(UVStream handle, Loop loop, unsigned int flags):
+    cdef int err
+
+    handle._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_tcp_t))
+    if handle._handle is NULL:
+        handle._abort_init()
+        raise MemoryError()
+
+    err = uv.uv_tcp_init_ex(handle._loop.uvloop,
+                            <uv.uv_tcp_t*>handle._handle,
+                            flags)
+    if err < 0:
+        handle._abort_init()
+        raise convert_error(err)
+
+    handle._finish_init()
+
+
+cdef __tcp_bind(UVStream handle, system.sockaddr* addr, unsigned int flags):
+    cdef int err
+    err = uv.uv_tcp_bind(<uv.uv_tcp_t *>handle._handle,
+                         addr, flags)
+    if err < 0:
+        exc = convert_error(err)
+        raise exc
+
+
+cdef __tcp_open(UVStream handle, int sockfd):
+    cdef int err
+    err = uv.uv_tcp_open(<uv.uv_tcp_t *>handle._handle,
+                         <uv.uv_os_sock_t>sockfd)
+    if err < 0:
+        exc = convert_error(err)
+        raise exc
+
+
+cdef __tcp_get_socket(UVSocketHandle handle):
+    cdef:
+        int buf_len = sizeof(system.sockaddr_storage)
+        int fileno
+        int err
+        system.sockaddr_storage buf
+
+    fileno = handle._fileno()
+
+    err = uv.uv_tcp_getsockname(<uv.uv_tcp_t*>handle._handle,
+                                <system.sockaddr*>&buf,
+                                &buf_len)
+    if err < 0:
+        raise convert_error(err)
+
+    return PseudoSocket(buf.ss_family, uv.SOCK_STREAM, 0, fileno)
+
+
+@cython.no_gc_clear
+cdef class TCPServer(UVStreamServer):
+
+    @staticmethod
+    cdef TCPServer new(Loop loop, object protocol_factory, Server server,
+                       unsigned int flags,
+                       object backlog,
+                       object ssl,
+                       object ssl_handshake_timeout,
+                       object ssl_shutdown_timeout):
+
+        cdef TCPServer handle
+        handle = TCPServer.__new__(TCPServer)
+        handle._init(loop, protocol_factory, server, backlog,
+                     ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
+        __tcp_init_uv_handle(<UVStream>handle, loop, flags)
+        return handle
+
+    cdef _new_socket(self):
+        return __tcp_get_socket(<UVSocketHandle>self)
+
+    cdef _open(self, int sockfd):
+        self._ensure_alive()
+        try:
+            __tcp_open(<UVStream>self, sockfd)
+        except Exception as exc:
+            self._fatal_error(exc, True)
+        else:
+            self._mark_as_open()
+
+    cdef bind(self, system.sockaddr* addr, unsigned int flags=0):
+        self._ensure_alive()
+        try:
+            __tcp_bind(<UVStream>self, addr, flags)
+        except Exception as exc:
+            self._fatal_error(exc, True)
+        else:
+            self._mark_as_open()
+
+    cdef UVStream _make_new_transport(self, object protocol, object waiter,
+                                      object context):
+        cdef TCPTransport tr
+        tr = TCPTransport.new(self._loop, protocol, self._server, waiter,
+                              context)
+        return <UVStream>tr
+
+
+@cython.no_gc_clear
+cdef class TCPTransport(UVStream):
+
+    @staticmethod
+    cdef TCPTransport new(Loop loop, object protocol, Server server,
+                          object waiter, object context):
+
+        cdef TCPTransport handle
+        handle = TCPTransport.__new__(TCPTransport)
+        handle._init(loop, protocol, server, waiter, context)
+        __tcp_init_uv_handle(<UVStream>handle, loop, uv.AF_UNSPEC)
+        handle.__peername_set = 0
+        handle.__sockname_set = 0
+        handle._set_nodelay()
+        return handle
+
+    cdef _set_nodelay(self):
+        cdef int err
+        self._ensure_alive()
+        err = uv.uv_tcp_nodelay(<uv.uv_tcp_t*>self._handle, 1)
+        if err < 0:
+            raise convert_error(err)
+
+    cdef _call_connection_made(self):
+        # asyncio saves peername & sockname when transports are instantiated,
+        # so that they're accessible even after the transport is closed.
+        # We are doing the same thing here, except that we create Python
+        # objects lazily, on request in get_extra_info()
+
+        cdef:
+            int err
+            int buf_len
+
+        buf_len = sizeof(system.sockaddr_storage)
+        err = uv.uv_tcp_getsockname(<uv.uv_tcp_t*>self._handle,
+                                    <system.sockaddr*>&self.__sockname,
+                                    &buf_len)
+        if err >= 0:
+            # Ignore errors, this is an optional thing.
+            # If something serious is going on, the transport
+            # will crash later (in roughly the same way how
+            # an asyncio transport would.)
+            self.__sockname_set = 1
+
+        buf_len = sizeof(system.sockaddr_storage)
+        err = uv.uv_tcp_getpeername(<uv.uv_tcp_t*>self._handle,
+                                    <system.sockaddr*>&self.__peername,
+                                    &buf_len)
+        if err >= 0:
+            # Same as few lines above -- we don't really care
+            # about error case here.
+            self.__peername_set = 1
+
+        UVBaseTransport._call_connection_made(self)
+
+    def get_extra_info(self, name, default=None):
+        if name == 'sockname':
+            if self.__sockname_set:
+                return __convert_sockaddr_to_pyaddr(
+                    <system.sockaddr*>&self.__sockname)
+        elif name == 'peername':
+            if self.__peername_set:
+                return __convert_sockaddr_to_pyaddr(
+                    <system.sockaddr*>&self.__peername)
+        return super().get_extra_info(name, default)
+
+    cdef _new_socket(self):
+        return __tcp_get_socket(<UVSocketHandle>self)
+
+    cdef bind(self, system.sockaddr* addr, unsigned int flags=0):
+        self._ensure_alive()
+        __tcp_bind(<UVStream>self, addr, flags)
+
+    cdef _open(self, int sockfd):
+        self._ensure_alive()
+        __tcp_open(<UVStream>self, sockfd)
+
+    cdef connect(self, system.sockaddr* addr):
+        cdef _TCPConnectRequest req
+        req = _TCPConnectRequest(self._loop, self)
+        req.connect(addr)
+
+
+cdef class _TCPConnectRequest(UVRequest):
+    cdef:
+        TCPTransport transport
+        uv.uv_connect_t _req_data
+
+    def __cinit__(self, loop, transport):
+        self.request = <uv.uv_req_t*>&self._req_data
+        self.request.data = <void*>self
+        self.transport = transport
+
+    cdef connect(self, system.sockaddr* addr):
+        cdef int err
+        err = uv.uv_tcp_connect(<uv.uv_connect_t*>self.request,
+                                <uv.uv_tcp_t*>self.transport._handle,
+                                addr,
+                                __tcp_connect_callback)
+        if err < 0:
+            exc = convert_error(err)
+            self.on_done()
+            raise exc
+
+
+cdef void __tcp_connect_callback(
+    uv.uv_connect_t* req,
+    int status,
+) noexcept with gil:
+    cdef:
+        _TCPConnectRequest wrapper
+        TCPTransport transport
+
+    wrapper = <_TCPConnectRequest> req.data
+    transport = wrapper.transport
+
+    if status < 0:
+        exc = convert_error(status)
+    else:
+        exc = None
+
+    try:
+        transport._on_connect(exc)
+    except BaseException as ex:
+        wrapper.transport._fatal_error(ex, False)
+    finally:
+        wrapper.on_done()
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/timer.pxd b/venv/lib/python3.11/site-packages/uvloop/handles/timer.pxd
new file mode 100644
index 0000000..fda23b6
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/timer.pxd
@@ -0,0 +1,18 @@
+cdef class UVTimer(UVHandle):
+    cdef:
+        method_t callback
+        object ctx
+        bint running
+        uint64_t timeout
+        uint64_t start_t
+
+    cdef _init(self, Loop loop, method_t callback, object ctx,
+               uint64_t timeout)
+
+    cdef stop(self)
+    cdef start(self)
+    cdef get_when(self)
+
+    @staticmethod
+    cdef UVTimer new(Loop loop, method_t callback, object ctx,
+                     uint64_t timeout)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/timer.pyx b/venv/lib/python3.11/site-packages/uvloop/handles/timer.pyx
new file mode 100644
index 0000000..86d46ef
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/timer.pyx
@@ -0,0 +1,89 @@
+@cython.no_gc_clear
+cdef class UVTimer(UVHandle):
+    cdef _init(self, Loop loop, method_t callback, object ctx,
+               uint64_t timeout):
+
+        cdef int err
+
+        self._start_init(loop)
+
+        self._handle = <uv.uv_handle_t*> PyMem_RawMalloc(sizeof(uv.uv_timer_t))
+        if self._handle is NULL:
+            self._abort_init()
+            raise MemoryError()
+
+        err = uv.uv_timer_init(self._loop.uvloop, <uv.uv_timer_t*>self._handle)
+        if err < 0:
+            self._abort_init()
+            raise convert_error(err)
+
+        self._finish_init()
+
+        self.callback = callback
+        self.ctx = ctx
+        self.running = 0
+        self.timeout = timeout
+        self.start_t = 0
+
+    cdef stop(self):
+        cdef int err
+
+        if not self._is_alive():
+            self.running = 0
+            return
+
+        if self.running == 1:
+            err = uv.uv_timer_stop(<uv.uv_timer_t*>self._handle)
+            self.running = 0
+            if err < 0:
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+                return
+
+    cdef start(self):
+        cdef int err
+
+        self._ensure_alive()
+
+        if self.running == 0:
+            # Update libuv internal time.
+            uv.uv_update_time(self._loop.uvloop)  # void
+            self.start_t = uv.uv_now(self._loop.uvloop)
+
+            err = uv.uv_timer_start(<uv.uv_timer_t*>self._handle,
+                                    __uvtimer_callback,
+                                    self.timeout, 0)
+            if err < 0:
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+                return
+            self.running = 1
+
+    cdef get_when(self):
+        return self.start_t + self.timeout
+
+    @staticmethod
+    cdef UVTimer new(Loop loop, method_t callback, object ctx,
+                     uint64_t timeout):
+
+        cdef UVTimer handle
+        handle = UVTimer.__new__(UVTimer)
+        handle._init(loop, callback, ctx, timeout)
+        return handle
+
+
+cdef void __uvtimer_callback(
+    uv.uv_timer_t* handle,
+) noexcept with gil:
+    if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVTimer callback") == 0:
+        return
+
+    cdef:
+        UVTimer timer = <UVTimer> handle.data
+        method_t cb = timer.callback
+
+    timer.running = 0
+    try:
+        cb(timer.ctx)
+    except BaseException as ex:
+        timer._error(ex, False)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/udp.pxd b/venv/lib/python3.11/site-packages/uvloop/handles/udp.pxd
new file mode 100644
index 0000000..daa9a1b
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/udp.pxd
@@ -0,0 +1,22 @@
+cdef class UDPTransport(UVBaseTransport):
+    cdef:
+        bint __receiving
+        int _family
+        object _address
+
+    cdef _init(self, Loop loop, unsigned int family)
+    cdef _set_address(self, system.addrinfo *addr)
+
+    cdef _connect(self, system.sockaddr* addr, size_t addr_len)
+
+    cdef _bind(self, system.sockaddr* addr)
+    cdef open(self, int family, int sockfd)
+    cdef _set_broadcast(self, bint on)
+
+    cdef inline __receiving_started(self)
+    cdef inline __receiving_stopped(self)
+
+    cdef _send(self, object data, object addr)
+
+    cdef _on_receive(self, bytes data, object exc, object addr)
+    cdef _on_sent(self, object exc, object context=*)
diff --git a/venv/lib/python3.11/site-packages/uvloop/handles/udp.pyx b/venv/lib/python3.11/site-packages/uvloop/handles/udp.pyx
new file mode 100644
index 0000000..bbe60d5
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/handles/udp.pyx
@@ -0,0 +1,409 @@
+@cython.no_gc_clear
+@cython.freelist(DEFAULT_FREELIST_SIZE)
+cdef class _UDPSendContext:
+    # used to hold additional write request information for uv_write
+
+    cdef:
+        uv.uv_udp_send_t   req
+
+        uv.uv_buf_t     uv_buf
+        Py_buffer       py_buf
+
+        UDPTransport    udp
+
+        bint            closed
+
+    cdef close(self):
+        if self.closed:
+            return
+
+        self.closed = 1
+        PyBuffer_Release(&self.py_buf)  # void
+        self.req.data = NULL
+        self.uv_buf.base = NULL
+        Py_DECREF(self)
+        self.udp = None
+
+    @staticmethod
+    cdef _UDPSendContext new(UDPTransport udp, object data):
+        cdef _UDPSendContext ctx
+        ctx = _UDPSendContext.__new__(_UDPSendContext)
+        ctx.udp = None
+        ctx.closed = 1
+
+        ctx.req.data = <void*> ctx
+        Py_INCREF(ctx)
+
+        PyObject_GetBuffer(data, &ctx.py_buf, PyBUF_SIMPLE)
+        ctx.uv_buf.base = <char*>ctx.py_buf.buf
+        ctx.uv_buf.len = ctx.py_buf.len
+        ctx.udp = udp
+
+        ctx.closed = 0
+        return ctx
+
+    def __dealloc__(self):
+        if UVLOOP_DEBUG:
+            if not self.closed:
+                raise RuntimeError(
+                    'open _UDPSendContext is being deallocated')
+        self.udp = None
+
+
+@cython.no_gc_clear
+cdef class UDPTransport(UVBaseTransport):
+    def __cinit__(self):
+        self._family = uv.AF_UNSPEC
+        self.__receiving = 0
+        self._address = None
+        self.context = Context_CopyCurrent()
+
+    cdef _init(self, Loop loop, unsigned int family):
+        cdef int err
+
+        self._start_init(loop)
+
+        self._handle = <uv.uv_handle_t*>PyMem_RawMalloc(sizeof(uv.uv_udp_t))
+        if self._handle is NULL:
+            self._abort_init()
+            raise MemoryError()
+
+        err = uv.uv_udp_init_ex(loop.uvloop,
+                                <uv.uv_udp_t*>self._handle,
+                                family)
+        if err < 0:
+            self._abort_init()
+            raise convert_error(err)
+
+        if family in (uv.AF_INET, uv.AF_INET6):
+            self._family = family
+
+        self._finish_init()
+
+    cdef _set_address(self, system.addrinfo *addr):
+        self._address = __convert_sockaddr_to_pyaddr(addr.ai_addr)
+
+    cdef _connect(self, system.sockaddr* addr, size_t addr_len):
+        cdef int err
+        err = uv.uv_udp_connect(<uv.uv_udp_t*>self._handle, addr)
+        if err < 0:
+            exc = convert_error(err)
+            raise exc
+
+    cdef open(self, int family, int sockfd):
+        if family in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):
+            self._family = family
+        else:
+            raise ValueError(
+                'cannot open a UDP handle, invalid family {}'.format(family))
+
+        cdef int err
+        err = uv.uv_udp_open(<uv.uv_udp_t*>self._handle,
+                             <uv.uv_os_sock_t>sockfd)
+
+        if err < 0:
+            exc = convert_error(err)
+            raise exc
+
+    cdef _bind(self, system.sockaddr* addr):
+        cdef:
+            int err
+            int flags = 0
+
+        self._ensure_alive()
+
+        err = uv.uv_udp_bind(<uv.uv_udp_t*>self._handle, addr, flags)
+        if err < 0:
+            exc = convert_error(err)
+            raise exc
+
+    cdef _set_broadcast(self, bint on):
+        cdef int err
+
+        self._ensure_alive()
+
+        err = uv.uv_udp_set_broadcast(<uv.uv_udp_t*>self._handle, on)
+        if err < 0:
+            exc = convert_error(err)
+            raise exc
+
+    cdef size_t _get_write_buffer_size(self):
+        if self._handle is NULL:
+            return 0
+        return (<uv.uv_udp_t*>self._handle).send_queue_size
+
+    cdef bint _is_reading(self):
+        return self.__receiving
+
+    cdef _start_reading(self):
+        cdef int err
+
+        if self.__receiving:
+            return
+
+        self._ensure_alive()
+
+        err = uv.uv_udp_recv_start(<uv.uv_udp_t*>self._handle,
+                                   __loop_alloc_buffer,
+                                   __uv_udp_on_receive)
+
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+        else:
+            # UDPTransport must live until the read callback is called
+            self.__receiving_started()
+
+    cdef _stop_reading(self):
+        cdef int err
+
+        if not self.__receiving:
+            return
+
+        self._ensure_alive()
+
+        err = uv.uv_udp_recv_stop(<uv.uv_udp_t*>self._handle)
+        if err < 0:
+            exc = convert_error(err)
+            self._fatal_error(exc, True)
+            return
+        else:
+            self.__receiving_stopped()
+
+    cdef inline __receiving_started(self):
+        if self.__receiving:
+            return
+        self.__receiving = 1
+        Py_INCREF(self)
+
+    cdef inline __receiving_stopped(self):
+        if not self.__receiving:
+            return
+        self.__receiving = 0
+        Py_DECREF(self)
+
+    cdef _new_socket(self):
+        if self._family not in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):
+            raise RuntimeError(
+                'UDPTransport.family is undefined; '
+                'cannot create python socket')
+
+        fileno = self._fileno()
+        return PseudoSocket(self._family, uv.SOCK_DGRAM, 0, fileno)
+
+    cdef _send(self, object data, object addr):
+        cdef:
+            _UDPSendContext ctx
+            system.sockaddr_storage saddr_st
+            system.sockaddr *saddr
+            Py_buffer       try_pybuf
+            uv.uv_buf_t     try_uvbuf
+
+        self._ensure_alive()
+
+        if self._family not in (uv.AF_INET, uv.AF_INET6, uv.AF_UNIX):
+            raise RuntimeError('UDPTransport.family is undefined; cannot send')
+
+        if addr is None:
+            saddr = NULL
+        else:
+            try:
+                __convert_pyaddr_to_sockaddr(self._family, addr,
+                                             <system.sockaddr*>&saddr_st)
+            except (ValueError, TypeError):
+                raise
+            except Exception:
+                raise ValueError(
+                    f'{addr!r}: socket family mismatch or '
+                    f'a DNS lookup is required')
+            saddr = <system.sockaddr*>(&saddr_st)
+
+        if self._get_write_buffer_size() == 0:
+            PyObject_GetBuffer(data, &try_pybuf, PyBUF_SIMPLE)
+            try_uvbuf.base = <char*>try_pybuf.buf
+            try_uvbuf.len = try_pybuf.len
+            err = uv.uv_udp_try_send(<uv.uv_udp_t*>self._handle,
+                                     &try_uvbuf,
+                                     1,
+                                     saddr)
+            PyBuffer_Release(&try_pybuf)
+        else:
+            err = uv.UV_EAGAIN
+
+        if err == uv.UV_EAGAIN:
+            ctx = _UDPSendContext.new(self, data)
+            err = uv.uv_udp_send(&ctx.req,
+                                 <uv.uv_udp_t*>self._handle,
+                                 &ctx.uv_buf,
+                                 1,
+                                 saddr,
+                                 __uv_udp_on_send)
+
+            if err < 0:
+                ctx.close()
+
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+            else:
+                self._maybe_pause_protocol()
+
+        else:
+            if err < 0:
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+            else:
+                self._on_sent(None, self.context.copy())
+
+    cdef _on_receive(self, bytes data, object exc, object addr):
+        if exc is None:
+            run_in_context2(
+                self.context, self._protocol.datagram_received, data, addr,
+            )
+        else:
+            run_in_context1(self.context, self._protocol.error_received, exc)
+
+    cdef _on_sent(self, object exc, object context=None):
+        if exc is not None:
+            if isinstance(exc, OSError):
+                if context is None:
+                    context = self.context
+                run_in_context1(context, self._protocol.error_received, exc)
+            else:
+                self._fatal_error(
+                    exc, False, 'Fatal write error on datagram transport')
+
+        self._maybe_resume_protocol()
+        if not self._get_write_buffer_size():
+            if self._closing:
+                self._schedule_call_connection_lost(None)
+
+    # === Public API ===
+
+    def sendto(self, data, addr=None):
+        if not data:
+            # Replicating asyncio logic here.
+            return
+
+        if self._address:
+            if addr not in (None, self._address):
+                # Replicating asyncio logic here.
+                raise ValueError(
+                    'Invalid address: must be None or %s' % (self._address,))
+
+            # Instead of setting addr to self._address below like what asyncio
+            # does, we depend on previous uv_udp_connect() to set the address
+            addr = None
+
+        if self._conn_lost:
+            # Replicating asyncio logic here.
+            if self._conn_lost >= LOG_THRESHOLD_FOR_CONNLOST_WRITES:
+                aio_logger.warning('socket.send() raised exception.')
+            self._conn_lost += 1
+            return
+
+        self._send(data, addr)
+
+
+cdef void __uv_udp_on_receive(
+    uv.uv_udp_t* handle,
+    ssize_t nread,
+    const uv.uv_buf_t* buf,
+    const system.sockaddr* addr,
+    unsigned flags
+) noexcept with gil:
+
+    if __ensure_handle_data(<uv.uv_handle_t*>handle,
+                            "UDPTransport receive callback") == 0:
+        return
+
+    cdef:
+        UDPTransport udp = <UDPTransport>handle.data
+        Loop loop = udp._loop
+        bytes data
+        object pyaddr
+
+    # It's OK to free the buffer early, since nothing will
+    # be able to touch it until this method is done.
+    __loop_free_buffer(loop)
+
+    if udp._closed:
+        # The handle was closed, there is no reason to
+        # do any work now.
+        udp.__receiving_stopped()  # Just in case.
+        return
+
+    if addr is NULL and nread == 0:
+        # From libuv docs:
+        #      addr: struct sockaddr* containing the address
+        #      of the sender. Can be NULL. Valid for the duration
+        #      of the callback only.
+        #      [...]
+        #      The receive callback will be called with
+        #      nread == 0 and addr == NULL when there is
+        #      nothing to read, and with nread == 0 and
+        #      addr != NULL when an empty UDP packet is
+        #      received.
+        return
+
+    if addr is NULL:
+        pyaddr = None
+    elif addr.sa_family == uv.AF_UNSPEC:
+        # https://github.com/MagicStack/uvloop/issues/304
+        if system.PLATFORM_IS_LINUX:
+            pyaddr = None
+        else:
+            pyaddr = ''
+    else:
+        try:
+            pyaddr = __convert_sockaddr_to_pyaddr(addr)
+        except BaseException as exc:
+            udp._error(exc, False)
+            return
+
+    if nread < 0:
+        exc = convert_error(nread)
+        udp._on_receive(None, exc, pyaddr)
+        return
+
+    if nread == 0:
+        data = b''
+    else:
+        data = loop._recv_buffer[:nread]
+
+    try:
+        udp._on_receive(data, None, pyaddr)
+    except BaseException as exc:
+        udp._error(exc, False)
+
+
+cdef void __uv_udp_on_send(
+    uv.uv_udp_send_t* req,
+    int status,
+) noexcept with gil:
+
+    if req.data is NULL:
+        # Shouldn't happen as:
+        #    - _UDPSendContext does an extra INCREF in its 'init()'
+        #    - _UDPSendContext holds a ref to the relevant UDPTransport
+        aio_logger.error(
+            'UVStream.write callback called with NULL req.data, status=%r',
+            status)
+        return
+
+    cdef:
+        _UDPSendContext ctx = <_UDPSendContext> req.data
+        UDPTransport udp = <UDPTransport>ctx.udp
+
+    ctx.close()
+
+    if status < 0:
+        exc = convert_error(status)
+        print(exc)
+    else:
+        exc = None
+
+    try:
+        udp._on_sent(exc)
+    except BaseException as exc:
+        udp._error(exc, False)
diff --git a/venv/lib/python3.11/site-packages/uvloop/includes/__init__.py b/venv/lib/python3.11/site-packages/uvloop/includes/__init__.py
new file mode 100644
index 0000000..2ccf9ca
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/includes/__init__.py
@@ -0,0 +1,23 @@
+# flake8: noqa
+
+# These have to be synced with the stdlib.pxi
+import asyncio
+import collections
+import concurrent.futures
+import errno
+import functools
+import gc
+import inspect
+import itertools
+import os
+import signal
+import socket
+import subprocess
+import ssl
+import stat
+import sys
+import threading
+import traceback
+import time
+import warnings
+import weakref
diff --git a/venv/lib/python3.11/site-packages/uvloop/includes/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvloop/includes/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000..a4464aa
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/includes/__pycache__/__init__.cpython-311.pyc
diff --git a/venv/lib/python3.11/site-packages/uvloop/includes/consts.pxi b/venv/lib/python3.11/site-packages/uvloop/includes/consts.pxi
new file mode 100644
index 0000000..f765053
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/includes/consts.pxi
@@ -0,0 +1,25 @@
+DEF UV_STREAM_RECV_BUF_SIZE = 256000  # 250kb
+
+DEF FLOW_CONTROL_HIGH_WATER = 64  # KiB
+DEF FLOW_CONTROL_HIGH_WATER_SSL_READ = 256  # KiB
+DEF FLOW_CONTROL_HIGH_WATER_SSL_WRITE = 512  # KiB
+
+DEF DEFAULT_FREELIST_SIZE = 250
+DEF DNS_PYADDR_TO_SOCKADDR_CACHE_SIZE = 2048
+
+DEF DEBUG_STACK_DEPTH = 10
+
+
+DEF __PROCESS_DEBUG_SLEEP_AFTER_FORK = 1
+
+
+DEF LOG_THRESHOLD_FOR_CONNLOST_WRITES = 5
+
+
+# Number of seconds to wait for SSL handshake to complete
+# The default timeout matches that of Nginx.
+DEF SSL_HANDSHAKE_TIMEOUT = 60.0
+# Number of seconds to wait for SSL shutdown to complete
+# The default timeout mimics lingering_time
+DEF SSL_SHUTDOWN_TIMEOUT = 30.0
+DEF SSL_READ_MAX_SIZE = 256 * 1024
diff --git a/venv/lib/python3.11/site-packages/uvloop/includes/debug.pxd b/venv/lib/python3.11/site-packages/uvloop/includes/debug.pxd
new file mode 100644
index 0000000..a825def
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/includes/debug.pxd
@@ -0,0 +1,3 @@
+cdef extern from "includes/debug.h":
+
+    cdef int UVLOOP_DEBUG
diff --git a/venv/lib/python3.11/site-packages/uvloop/includes/flowcontrol.pxd b/venv/lib/python3.11/site-packages/uvloop/includes/flowcontrol.pxd
new file mode 100644
index 0000000..f22f1a7
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/includes/flowcontrol.pxd
@@ -0,0 +1,23 @@
+# flake8: noqa
+
+
+cdef inline add_flowcontrol_defaults(high, low, int kb):
+    cdef int h, l
+    if high is None:
+        if low is None:
+            h = kb * 1024
+        else:
+            l = low
+            h = 4 * l
+    else:
+        h = high
+    if low is None:
+        l = h // 4
+    else:
+        l = low
+
+    if not h >= l >= 0:
+        raise ValueError('high (%r) must be >= low (%r) must be >= 0' %
+                         (h, l))
+
+    return h, l
diff --git a/venv/lib/python3.11/site-packages/uvloop/includes/python.pxd b/venv/lib/python3.11/site-packages/uvloop/includes/python.pxd
new file mode 100644
index 0000000..454d5c7
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/includes/python.pxd
@@ -0,0 +1,31 @@
+cdef extern from "Python.h":
+    int PY_VERSION_HEX
+
+    unicode PyUnicode_FromString(const char *)
+
+    void* PyMem_RawMalloc(size_t n) nogil
+    void* PyMem_RawRealloc(void *p, size_t n) nogil
+    void* PyMem_RawCalloc(size_t nelem, size_t elsize) nogil
+    void PyMem_RawFree(void *p) nogil
+
+    object PyUnicode_EncodeFSDefault(object)
+    void PyErr_SetInterrupt() nogil
+
+    void _Py_RestoreSignals()
+
+    object PyMemoryView_FromMemory(char *mem, ssize_t size, int flags)
+    object PyMemoryView_FromObject(object obj)
+    int PyMemoryView_Check(object obj)
+
+    cdef enum:
+        PyBUF_WRITE
+
+
+cdef extern from "includes/compat.h":
+    object Context_CopyCurrent()
+    int Context_Enter(object) except -1
+    int Context_Exit(object) except -1
+
+    void PyOS_BeforeFork()
+    void PyOS_AfterFork_Parent()
+    void PyOS_AfterFork_Child()
diff --git a/venv/lib/python3.11/site-packages/uvloop/includes/stdlib.pxi b/venv/lib/python3.11/site-packages/uvloop/includes/stdlib.pxi
new file mode 100644
index 0000000..e7957fe
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/includes/stdlib.pxi
@@ -0,0 +1,175 @@
+# flake8: noqa
+
+
+import asyncio, asyncio.log, asyncio.base_events, \
+       asyncio.sslproto, asyncio.coroutines, \
+       asyncio.futures, asyncio.transports
+import collections.abc
+import concurrent.futures
+import errno
+import functools
+import gc
+import inspect
+import itertools
+import os
+import signal
+import socket
+import subprocess
+import ssl
+import stat
+import sys
+import threading
+import traceback
+import time
+import warnings
+import weakref
+
+
+cdef aio_get_event_loop = asyncio.get_event_loop
+cdef aio_CancelledError = asyncio.CancelledError
+cdef aio_InvalidStateError = asyncio.InvalidStateError
+cdef aio_TimeoutError = asyncio.TimeoutError
+cdef aio_Future = asyncio.Future
+cdef aio_Task = asyncio.Task
+cdef aio_ensure_future = asyncio.ensure_future
+cdef aio_gather = asyncio.gather
+cdef aio_wait = asyncio.wait
+cdef aio_wrap_future = asyncio.wrap_future
+cdef aio_logger = asyncio.log.logger
+cdef aio_iscoroutine = asyncio.iscoroutine
+cdef aio_iscoroutinefunction = asyncio.iscoroutinefunction
+cdef aio_BaseProtocol = asyncio.BaseProtocol
+cdef aio_Protocol = asyncio.Protocol
+cdef aio_isfuture = getattr(asyncio, 'isfuture', None)
+cdef aio_get_running_loop = getattr(asyncio, '_get_running_loop', None)
+cdef aio_set_running_loop = getattr(asyncio, '_set_running_loop', None)
+cdef aio_debug_wrapper = getattr(asyncio.coroutines, 'debug_wrapper', None)
+cdef aio_AbstractChildWatcher = asyncio.AbstractChildWatcher
+cdef aio_Transport = asyncio.Transport
+cdef aio_FlowControlMixin = asyncio.transports._FlowControlMixin
+
+cdef col_deque = collections.deque
+cdef col_Iterable = collections.abc.Iterable
+cdef col_Counter = collections.Counter
+cdef col_OrderedDict = collections.OrderedDict
+
+cdef cc_ThreadPoolExecutor = concurrent.futures.ThreadPoolExecutor
+cdef cc_Future = concurrent.futures.Future
+
+cdef errno_EBADF = errno.EBADF
+cdef errno_EINVAL = errno.EINVAL
+
+cdef ft_partial = functools.partial
+
+cdef gc_disable = gc.disable
+
+cdef iter_chain = itertools.chain
+cdef inspect_isgenerator = inspect.isgenerator
+
+cdef int has_IPV6_V6ONLY = hasattr(socket, 'IPV6_V6ONLY')
+cdef int IPV6_V6ONLY = getattr(socket, 'IPV6_V6ONLY', -1)
+cdef int has_SO_REUSEPORT = hasattr(socket, 'SO_REUSEPORT')
+cdef int SO_REUSEPORT = getattr(socket, 'SO_REUSEPORT', 0)
+cdef int SO_BROADCAST = getattr(socket, 'SO_BROADCAST')
+cdef int SOCK_NONBLOCK = getattr(socket, 'SOCK_NONBLOCK', -1)
+cdef int socket_AI_CANONNAME = getattr(socket, 'AI_CANONNAME')
+
+cdef socket_gaierror = socket.gaierror
+cdef socket_error = socket.error
+cdef socket_timeout = socket.timeout
+cdef socket_socket = socket.socket
+cdef socket_socketpair = socket.socketpair
+cdef socket_getservbyname = socket.getservbyname
+cdef socket_AddressFamily = socket.AddressFamily
+cdef socket_SocketKind = socket.SocketKind
+
+cdef int socket_EAI_ADDRFAMILY = getattr(socket, 'EAI_ADDRFAMILY', -1)
+cdef int socket_EAI_AGAIN      = getattr(socket, 'EAI_AGAIN', -1)
+cdef int socket_EAI_BADFLAGS   = getattr(socket, 'EAI_BADFLAGS', -1)
+cdef int socket_EAI_BADHINTS   = getattr(socket, 'EAI_BADHINTS', -1)
+cdef int socket_EAI_CANCELED   = getattr(socket, 'EAI_CANCELED', -1)
+cdef int socket_EAI_FAIL       = getattr(socket, 'EAI_FAIL', -1)
+cdef int socket_EAI_FAMILY     = getattr(socket, 'EAI_FAMILY', -1)
+cdef int socket_EAI_MEMORY     = getattr(socket, 'EAI_MEMORY', -1)
+cdef int socket_EAI_NODATA     = getattr(socket, 'EAI_NODATA', -1)
+cdef int socket_EAI_NONAME     = getattr(socket, 'EAI_NONAME', -1)
+cdef int socket_EAI_OVERFLOW   = getattr(socket, 'EAI_OVERFLOW', -1)
+cdef int socket_EAI_PROTOCOL   = getattr(socket, 'EAI_PROTOCOL', -1)
+cdef int socket_EAI_SERVICE    = getattr(socket, 'EAI_SERVICE', -1)
+cdef int socket_EAI_SOCKTYPE   = getattr(socket, 'EAI_SOCKTYPE', -1)
+
+
+cdef str os_name = os.name
+cdef os_environ = os.environ
+cdef os_dup = os.dup
+cdef os_set_inheritable = os.set_inheritable
+cdef os_get_inheritable = os.get_inheritable
+cdef os_close = os.close
+cdef os_open = os.open
+cdef os_devnull = os.devnull
+cdef os_O_RDWR = os.O_RDWR
+cdef os_pipe = os.pipe
+cdef os_read = os.read
+cdef os_remove = os.remove
+cdef os_stat = os.stat
+cdef os_fspath = os.fspath
+
+cdef stat_S_ISSOCK = stat.S_ISSOCK
+
+cdef sys_ignore_environment = sys.flags.ignore_environment
+cdef sys_dev_mode = sys.flags.dev_mode
+cdef sys_exc_info = sys.exc_info
+cdef sys_set_coroutine_wrapper = getattr(sys, 'set_coroutine_wrapper', None)
+cdef sys_get_coroutine_wrapper = getattr(sys, 'get_coroutine_wrapper', None)
+cdef sys_getframe = sys._getframe
+cdef sys_version_info = sys.version_info
+cdef sys_getfilesystemencoding = sys.getfilesystemencoding
+cdef str sys_platform = sys.platform
+
+cdef ssl_SSLContext = ssl.SSLContext
+cdef ssl_MemoryBIO = ssl.MemoryBIO
+cdef ssl_create_default_context = ssl.create_default_context
+cdef ssl_SSLError = ssl.SSLError
+cdef ssl_SSLAgainErrors = (ssl.SSLWantReadError, ssl.SSLSyscallError)
+cdef ssl_SSLZeroReturnError = ssl.SSLZeroReturnError
+cdef ssl_CertificateError = ssl.CertificateError
+cdef int ssl_SSL_ERROR_WANT_READ = ssl.SSL_ERROR_WANT_READ
+cdef int ssl_SSL_ERROR_WANT_WRITE = ssl.SSL_ERROR_WANT_WRITE
+cdef int ssl_SSL_ERROR_SYSCALL = ssl.SSL_ERROR_SYSCALL
+
+cdef threading_Thread = threading.Thread
+cdef threading_main_thread = threading.main_thread
+
+cdef int subprocess_PIPE = subprocess.PIPE
+cdef int subprocess_STDOUT = subprocess.STDOUT
+cdef int subprocess_DEVNULL = subprocess.DEVNULL
+cdef subprocess_SubprocessError = subprocess.SubprocessError
+
+cdef int signal_NSIG = signal.NSIG
+cdef signal_signal = signal.signal
+cdef signal_siginterrupt = signal.siginterrupt
+cdef signal_set_wakeup_fd = signal.set_wakeup_fd
+cdef signal_default_int_handler = signal.default_int_handler
+cdef signal_SIG_DFL = signal.SIG_DFL
+
+cdef time_sleep = time.sleep
+cdef time_monotonic = time.monotonic
+
+cdef tb_StackSummary = traceback.StackSummary
+cdef tb_walk_stack = traceback.walk_stack
+cdef tb_format_list = traceback.format_list
+
+cdef warnings_warn = warnings.warn
+
+cdef weakref_WeakValueDictionary = weakref.WeakValueDictionary
+cdef weakref_WeakSet = weakref.WeakSet
+
+cdef py_inf = float('inf')
+
+
+# Cython doesn't clean-up imported objects properly in Py3 mode,
+# so we delete refs to all modules manually (except sys)
+del asyncio, concurrent, collections, errno
+del functools, inspect, itertools, socket, os, threading
+del signal, subprocess, ssl
+del time, traceback, warnings, weakref
diff --git a/venv/lib/python3.11/site-packages/uvloop/includes/system.pxd b/venv/lib/python3.11/site-packages/uvloop/includes/system.pxd
new file mode 100644
index 0000000..367fedd
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/includes/system.pxd
@@ -0,0 +1,96 @@
+from libc.stdint cimport int8_t, uint64_t
+
+cdef extern from "arpa/inet.h" nogil:
+
+    int ntohl(int)
+    int htonl(int)
+    int ntohs(int)
+
+
+cdef extern from "sys/socket.h" nogil:
+
+    struct sockaddr:
+        unsigned short sa_family
+        char           sa_data[14]
+
+    struct addrinfo:
+        int            ai_flags
+        int            ai_family
+        int            ai_socktype
+        int            ai_protocol
+        size_t         ai_addrlen
+        sockaddr*      ai_addr
+        char*          ai_canonname
+        addrinfo*      ai_next
+
+    struct sockaddr_in:
+        unsigned short sin_family
+        unsigned short sin_port
+        # ...
+
+    struct sockaddr_in6:
+        unsigned short sin6_family
+        unsigned short sin6_port
+        unsigned long  sin6_flowinfo
+        # ...
+        unsigned long  sin6_scope_id
+
+    struct sockaddr_storage:
+        unsigned short ss_family
+        # ...
+
+    const char *gai_strerror(int errcode)
+
+    int socketpair(int domain, int type, int protocol, int socket_vector[2])
+
+    int setsockopt(int socket, int level, int option_name,
+                   const void *option_value, int option_len)
+
+
+cdef extern from "sys/un.h" nogil:
+
+    struct sockaddr_un:
+        unsigned short sun_family
+        char*          sun_path
+        # ...
+
+
+cdef extern from "unistd.h" nogil:
+
+    ssize_t write(int fd, const void *buf, size_t count)
+    void _exit(int status)
+
+
+cdef extern from "pthread.h":
+
+    int pthread_atfork(
+        void (*prepare)(),
+        void (*parent)(),
+        void (*child)())
+
+
+cdef extern from "includes/compat.h" nogil:
+
+    cdef int EWOULDBLOCK
+
+    cdef int PLATFORM_IS_APPLE
+    cdef int PLATFORM_IS_LINUX
+
+    struct epoll_event:
+        # We don't use the fields
+        pass
+
+    int EPOLL_CTL_DEL
+    int epoll_ctl(int epfd, int op, int fd, epoll_event *event)
+    object MakeUnixSockPyAddr(sockaddr_un *addr)
+
+
+cdef extern from "includes/fork_handler.h":
+
+    uint64_t MAIN_THREAD_ID
+    int8_t MAIN_THREAD_ID_SET
+    ctypedef void (*OnForkHandler)()
+    void handleAtFork()
+    void setForkHandler(OnForkHandler handler)
+    void resetForkHandler()
+    void setMainThreadID(uint64_t id)
diff --git a/venv/lib/python3.11/site-packages/uvloop/includes/uv.pxd b/venv/lib/python3.11/site-packages/uvloop/includes/uv.pxd
new file mode 100644
index 0000000..8765130
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/includes/uv.pxd
@@ -0,0 +1,506 @@
+from libc.stdint cimport uint16_t, uint32_t, uint64_t, int64_t
+from posix.types cimport gid_t, uid_t
+from posix.unistd cimport getuid
+
+from . cimport system
+
+# This is an internal enum UV_HANDLE_READABLE from uv-common.h, used only by
+# handles/pipe.pyx to temporarily workaround a libuv issue libuv/libuv#2058,
+# before there is a proper fix in libuv. In short, libuv disallowed feeding a
+# write-only pipe to uv_read_start(), which was needed by uvloop to detect a
+# broken pipe without having to send anything on the write-only end. We're
+# setting UV_HANDLE_READABLE on pipe_t to workaround this limitation
+# temporarily, please see also #317.
+cdef enum:
+    UV_INTERNAL_HANDLE_READABLE = 0x00004000
+
+cdef extern from "uv.h" nogil:
+    cdef int UV_TCP_IPV6ONLY
+
+    cdef int UV_EACCES
+    cdef int UV_EAGAIN
+    cdef int UV_EALREADY
+    cdef int UV_EBUSY
+    cdef int UV_ECONNABORTED
+    cdef int UV_ECONNREFUSED
+    cdef int UV_ECONNRESET
+    cdef int UV_ECANCELED
+    cdef int UV_EEXIST
+    cdef int UV_EINTR
+    cdef int UV_EINVAL
+    cdef int UV_EISDIR
+    cdef int UV_ENOENT
+    cdef int UV_EOF
+    cdef int UV_EPERM
+    cdef int UV_EPIPE
+    cdef int UV_ESHUTDOWN
+    cdef int UV_ESRCH
+    cdef int UV_ETIMEDOUT
+    cdef int UV_EBADF
+    cdef int UV_ENOBUFS
+
+    cdef int UV_EAI_ADDRFAMILY
+    cdef int UV_EAI_AGAIN
+    cdef int UV_EAI_BADFLAGS
+    cdef int UV_EAI_BADHINTS
+    cdef int UV_EAI_CANCELED
+    cdef int UV_EAI_FAIL
+    cdef int UV_EAI_FAMILY
+    cdef int UV_EAI_MEMORY
+    cdef int UV_EAI_NODATA
+    cdef int UV_EAI_NONAME
+    cdef int UV_EAI_OVERFLOW
+    cdef int UV_EAI_PROTOCOL
+    cdef int UV_EAI_SERVICE
+    cdef int UV_EAI_SOCKTYPE
+
+    cdef int SOL_SOCKET
+    cdef int SO_ERROR
+    cdef int SO_REUSEADDR
+    cdef int SO_REUSEPORT
+    cdef int AF_INET
+    cdef int AF_INET6
+    cdef int AF_UNIX
+    cdef int AF_UNSPEC
+    cdef int AI_PASSIVE
+    cdef int AI_NUMERICHOST
+    cdef int INET6_ADDRSTRLEN
+    cdef int IPPROTO_IPV6
+    cdef int SOCK_STREAM
+    cdef int SOCK_DGRAM
+    cdef int IPPROTO_TCP
+    cdef int IPPROTO_UDP
+
+    cdef int SIGINT
+    cdef int SIGHUP
+    cdef int SIGCHLD
+    cdef int SIGKILL
+    cdef int SIGTERM
+
+    ctypedef int uv_os_sock_t
+    ctypedef int uv_file
+    ctypedef int uv_os_fd_t
+
+    ctypedef struct uv_buf_t:
+        char* base
+        size_t len
+
+    ctypedef struct uv_loop_t:
+        void* data
+        # ...
+
+    ctypedef struct uv_handle_t:
+        void* data
+        uv_loop_t* loop
+        unsigned int flags
+        # ...
+
+    ctypedef struct uv_idle_t:
+        void* data
+        uv_loop_t* loop
+        # ...
+
+    ctypedef struct uv_check_t:
+        void* data
+        uv_loop_t* loop
+        # ...
+
+    ctypedef struct uv_signal_t:
+        void* data
+        uv_loop_t* loop
+        # ...
+
+    ctypedef struct uv_async_t:
+        void* data
+        uv_loop_t* loop
+        # ...
+
+    ctypedef struct uv_timer_t:
+        void* data
+        uv_loop_t* loop
+        # ...
+
+    ctypedef struct uv_stream_t:
+        void* data
+        size_t write_queue_size
+        uv_loop_t* loop
+        # ...
+
+    ctypedef struct uv_tcp_t:
+        void* data
+        uv_loop_t* loop
+        # ...
+
+    ctypedef struct uv_pipe_t:
+        void* data
+        uv_loop_t* loop
+        # ...
+
+    ctypedef struct uv_udp_t:
+        void* data
+        uv_loop_t* loop
+        size_t send_queue_size
+        size_t send_queue_count
+        # ...
+
+    ctypedef struct uv_udp_send_t:
+        void* data
+        uv_udp_t* handle
+
+    ctypedef struct uv_poll_t:
+        void* data
+        uv_loop_t* loop
+        # ...
+
+    ctypedef struct uv_req_t:
+        # Only cancellation of uv_fs_t, uv_getaddrinfo_t,
+        # uv_getnameinfo_t and uv_work_t requests is
+        # currently supported.
+        void* data
+        uv_req_type type
+        # ...
+
+    ctypedef struct uv_connect_t:
+        void* data
+
+    ctypedef struct uv_getaddrinfo_t:
+        void* data
+        # ...
+
+    ctypedef struct uv_getnameinfo_t:
+        void* data
+        # ...
+
+    ctypedef struct uv_write_t:
+        void* data
+        # ...
+
+    ctypedef struct uv_shutdown_t:
+        void* data
+        # ...
+
+    ctypedef struct uv_process_t:
+        void* data
+        int pid
+        # ...
+
+    ctypedef struct uv_fs_event_t:
+        void* data
+        # ...
+
+    ctypedef enum uv_req_type:
+        UV_UNKNOWN_REQ = 0,
+        UV_REQ,
+        UV_CONNECT,
+        UV_WRITE,
+        UV_SHUTDOWN,
+        UV_UDP_SEND,
+        UV_FS,
+        UV_WORK,
+        UV_GETADDRINFO,
+        UV_GETNAMEINFO,
+        UV_REQ_TYPE_PRIVATE,
+        UV_REQ_TYPE_MAX
+
+    ctypedef enum uv_run_mode:
+        UV_RUN_DEFAULT = 0,
+        UV_RUN_ONCE,
+        UV_RUN_NOWAIT
+
+    ctypedef enum uv_poll_event:
+        UV_READABLE = 1,
+        UV_WRITABLE = 2,
+        UV_DISCONNECT = 4
+
+    ctypedef enum uv_udp_flags:
+        UV_UDP_IPV6ONLY = 1,
+        UV_UDP_PARTIAL = 2
+
+    ctypedef enum uv_membership:
+        UV_LEAVE_GROUP = 0,
+        UV_JOIN_GROUP
+
+    cpdef enum uv_fs_event:
+        UV_RENAME = 1,
+        UV_CHANGE = 2
+
+    const char* uv_strerror(int err)
+    const char* uv_err_name(int err)
+
+    ctypedef void (*uv_walk_cb)(uv_handle_t* handle, void* arg) with gil
+
+    ctypedef void (*uv_close_cb)(uv_handle_t* handle) with gil
+    ctypedef void (*uv_idle_cb)(uv_idle_t* handle) with gil
+    ctypedef void (*uv_check_cb)(uv_check_t* handle) with gil
+    ctypedef void (*uv_signal_cb)(uv_signal_t* handle, int signum) with gil
+    ctypedef void (*uv_async_cb)(uv_async_t* handle) with gil
+    ctypedef void (*uv_timer_cb)(uv_timer_t* handle) with gil
+    ctypedef void (*uv_connection_cb)(uv_stream_t* server, int status) with gil
+    ctypedef void (*uv_alloc_cb)(uv_handle_t* handle,
+                                 size_t suggested_size,
+                                 uv_buf_t* buf) with gil
+    ctypedef void (*uv_read_cb)(uv_stream_t* stream,
+                                ssize_t nread,
+                                const uv_buf_t* buf) with gil
+    ctypedef void (*uv_write_cb)(uv_write_t* req, int status) with gil
+    ctypedef void (*uv_getaddrinfo_cb)(uv_getaddrinfo_t* req,
+                                       int status,
+                                       system.addrinfo* res) with gil
+    ctypedef void (*uv_getnameinfo_cb)(uv_getnameinfo_t* req,
+                                       int status,
+                                       const char* hostname,
+                                       const char* service) with gil
+    ctypedef void (*uv_shutdown_cb)(uv_shutdown_t* req, int status) with gil
+    ctypedef void (*uv_poll_cb)(uv_poll_t* handle,
+                                int status, int events) with gil
+
+    ctypedef void (*uv_connect_cb)(uv_connect_t* req, int status) with gil
+
+    ctypedef void (*uv_udp_send_cb)(uv_udp_send_t* req, int status) with gil
+    ctypedef void (*uv_udp_recv_cb)(uv_udp_t* handle,
+                                    ssize_t nread,
+                                    const uv_buf_t* buf,
+                                    const system.sockaddr* addr,
+                                    unsigned flags) with gil
+    ctypedef void (*uv_fs_event_cb)(uv_fs_event_t* handle,
+                                    const char *filename,
+                                    int events,
+                                    int status) with gil
+
+    # Generic request functions
+    int uv_cancel(uv_req_t* req)
+
+    # Generic handler functions
+    int uv_is_active(const uv_handle_t* handle)
+    void uv_close(uv_handle_t* handle, uv_close_cb close_cb)
+    int uv_is_closing(const uv_handle_t* handle)
+    int uv_fileno(const uv_handle_t* handle, uv_os_fd_t* fd)
+    void uv_walk(uv_loop_t* loop, uv_walk_cb walk_cb, void* arg)
+
+    # Loop functions
+    int uv_loop_init(uv_loop_t* loop)
+    int uv_loop_close(uv_loop_t* loop)
+    int uv_loop_alive(uv_loop_t* loop)
+    int uv_loop_fork(uv_loop_t* loop)
+    int uv_backend_fd(uv_loop_t* loop)
+
+    void uv_update_time(uv_loop_t* loop)
+    uint64_t uv_now(const uv_loop_t*)
+
+    int uv_run(uv_loop_t*, uv_run_mode mode) nogil
+    void uv_stop(uv_loop_t*)
+
+    # Idle handler
+    int uv_idle_init(uv_loop_t*, uv_idle_t* idle)
+    int uv_idle_start(uv_idle_t* idle, uv_idle_cb cb)
+    int uv_idle_stop(uv_idle_t* idle)
+
+    # Check handler
+    int uv_check_init(uv_loop_t*, uv_check_t* idle)
+    int uv_check_start(uv_check_t* check, uv_check_cb cb)
+    int uv_check_stop(uv_check_t* check)
+
+    # Signal handler
+    int uv_signal_init(uv_loop_t* loop, uv_signal_t* handle)
+    int uv_signal_start(uv_signal_t* handle,
+                        uv_signal_cb signal_cb,
+                        int signum)
+    int uv_signal_stop(uv_signal_t* handle)
+
+    # Async handler
+    int uv_async_init(uv_loop_t*,
+                      uv_async_t* async_,
+                      uv_async_cb async_cb)
+    int uv_async_send(uv_async_t* async_)
+
+    # Timer handler
+    int uv_timer_init(uv_loop_t*, uv_timer_t* handle)
+    int uv_timer_start(uv_timer_t* handle,
+                       uv_timer_cb cb,
+                       uint64_t timeout,
+                       uint64_t repeat)
+    int uv_timer_stop(uv_timer_t* handle)
+
+    # DNS
+    int uv_getaddrinfo(uv_loop_t* loop,
+                       uv_getaddrinfo_t* req,
+                       uv_getaddrinfo_cb getaddrinfo_cb,
+                       const char* node,
+                       const char* service,
+                       const system.addrinfo* hints)
+
+    void uv_freeaddrinfo(system.addrinfo* ai)
+
+    int uv_getnameinfo(uv_loop_t* loop,
+                       uv_getnameinfo_t* req,
+                       uv_getnameinfo_cb getnameinfo_cb,
+                       const system.sockaddr* addr,
+                       int flags)
+
+    int uv_ip4_name(const system.sockaddr_in* src, char* dst, size_t size)
+    int uv_ip6_name(const system.sockaddr_in6* src, char* dst, size_t size)
+
+    # Streams
+
+    int uv_listen(uv_stream_t* stream, int backlog, uv_connection_cb cb)
+    int uv_accept(uv_stream_t* server, uv_stream_t* client)
+    int uv_read_start(uv_stream_t* stream,
+                      uv_alloc_cb alloc_cb,
+                      uv_read_cb read_cb)
+    int uv_read_stop(uv_stream_t*)
+    int uv_write(uv_write_t* req, uv_stream_t* handle,
+                 uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb)
+
+    int uv_try_write(uv_stream_t* handle, uv_buf_t bufs[], unsigned int nbufs)
+
+    int uv_shutdown(uv_shutdown_t* req, uv_stream_t* handle, uv_shutdown_cb cb)
+
+    int uv_is_readable(const uv_stream_t* handle)
+    int uv_is_writable(const uv_stream_t* handle)
+
+    # TCP
+
+    int uv_tcp_init_ex(uv_loop_t*, uv_tcp_t* handle, unsigned int flags)
+    int uv_tcp_nodelay(uv_tcp_t* handle, int enable)
+    int uv_tcp_keepalive(uv_tcp_t* handle, int enable, unsigned int delay)
+    int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock)
+    int uv_tcp_bind(uv_tcp_t* handle, system.sockaddr* addr,
+                    unsigned int flags)
+
+    int uv_tcp_getsockname(const uv_tcp_t* handle, system.sockaddr* name,
+                           int* namelen)
+    int uv_tcp_getpeername(const uv_tcp_t* handle, system.sockaddr* name,
+                           int* namelen)
+
+    int uv_tcp_connect(uv_connect_t* req, uv_tcp_t* handle,
+                       const system.sockaddr* addr, uv_connect_cb cb)
+
+    # Pipes
+
+    int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc)
+    int uv_pipe_open(uv_pipe_t* handle, uv_file file)
+    int uv_pipe_bind(uv_pipe_t* handle, const char* name)
+
+    void uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle,
+                         const char* name, uv_connect_cb cb)
+
+    # UDP
+
+    int uv_udp_init_ex(uv_loop_t* loop, uv_udp_t* handle, unsigned int flags)
+    int uv_udp_connect(uv_udp_t* handle, const system.sockaddr* addr)
+    int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock)
+    int uv_udp_bind(uv_udp_t* handle, const system.sockaddr* addr,
+                    unsigned int flags)
+    int uv_udp_send(uv_udp_send_t* req, uv_udp_t* handle,
+                    const uv_buf_t bufs[], unsigned int nbufs,
+                    const system.sockaddr* addr, uv_udp_send_cb send_cb)
+    int uv_udp_try_send(uv_udp_t* handle,
+                        const uv_buf_t bufs[], unsigned int nbufs,
+                        const system.sockaddr* addr)
+    int uv_udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloc_cb,
+                          uv_udp_recv_cb recv_cb)
+    int uv_udp_recv_stop(uv_udp_t* handle)
+    int uv_udp_set_broadcast(uv_udp_t* handle, int on)
+
+    # Polling
+
+    int uv_poll_init(uv_loop_t* loop, uv_poll_t* handle, int fd)
+    int uv_poll_init_socket(uv_loop_t* loop, uv_poll_t* handle,
+                            uv_os_sock_t socket)
+    int uv_poll_start(uv_poll_t* handle, int events, uv_poll_cb cb)
+    int uv_poll_stop(uv_poll_t* poll)
+
+    # FS Event
+
+    int uv_fs_event_init(uv_loop_t *loop, uv_fs_event_t *handle)
+    int uv_fs_event_start(uv_fs_event_t *handle, uv_fs_event_cb cb,
+                          const char *path, unsigned int flags)
+    int uv_fs_event_stop(uv_fs_event_t *handle)
+
+    # Misc
+
+    ctypedef struct uv_timeval_t:
+        long tv_sec
+        long tv_usec
+
+    ctypedef struct uv_rusage_t:
+        uv_timeval_t ru_utime   # user CPU time used
+        uv_timeval_t ru_stime   # system CPU time used
+        uint64_t ru_maxrss      # maximum resident set size
+        uint64_t ru_ixrss       # integral shared memory size
+        uint64_t ru_idrss       # integral unshared data size
+        uint64_t ru_isrss       # integral unshared stack size
+        uint64_t ru_minflt      # page reclaims (soft page faults)
+        uint64_t ru_majflt      # page faults (hard page faults)
+        uint64_t ru_nswap       # swaps
+        uint64_t ru_inblock     # block input operations
+        uint64_t ru_oublock     # block output operations
+        uint64_t ru_msgsnd      # IPC messages sent
+        uint64_t ru_msgrcv      # IPC messages received
+        uint64_t ru_nsignals    # signals received
+        uint64_t ru_nvcsw       # voluntary context switches
+        uint64_t ru_nivcsw      # involuntary context switches
+
+    int uv_getrusage(uv_rusage_t* rusage)
+
+    int uv_ip4_addr(const char* ip, int port, system.sockaddr_in* addr)
+    int uv_ip6_addr(const char* ip, int port, system.sockaddr_in6* addr)
+
+    # Memory Allocation
+
+    ctypedef void* (*uv_malloc_func)(size_t size)
+    ctypedef void* (*uv_realloc_func)(void* ptr, size_t size)
+    ctypedef void* (*uv_calloc_func)(size_t count, size_t size)
+    ctypedef void (*uv_free_func)(void* ptr)
+
+    int uv_replace_allocator(uv_malloc_func malloc_func,
+                             uv_realloc_func realloc_func,
+                             uv_calloc_func calloc_func,
+                             uv_free_func free_func)
+
+    # Process
+
+    ctypedef void (*uv_exit_cb)(uv_process_t*, int64_t exit_status,
+                                int term_signal) with gil
+
+    ctypedef enum uv_process_flags:
+        UV_PROCESS_SETUID = 1,
+        UV_PROCESS_SETGID = 2,
+        UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS = 4,
+        UV_PROCESS_DETACHED = 8,
+        UV_PROCESS_WINDOWS_HIDE = 16
+
+    ctypedef enum uv_stdio_flags:
+        UV_IGNORE = 0x00,
+        UV_CREATE_PIPE = 0x01,
+        UV_INHERIT_FD = 0x02,
+        UV_INHERIT_STREAM = 0x04,
+        UV_READABLE_PIPE = 0x10,
+        UV_WRITABLE_PIPE = 0x20
+
+    ctypedef union uv_stdio_container_data_u:
+        uv_stream_t* stream
+        int fd
+
+    ctypedef struct uv_stdio_container_t:
+        uv_stdio_flags flags
+        uv_stdio_container_data_u data
+
+    ctypedef struct uv_process_options_t:
+        uv_exit_cb exit_cb
+        char* file
+        char** args
+        char** env
+        char* cwd
+        unsigned int flags
+        int stdio_count
+        uv_stdio_container_t* stdio
+        uid_t uid
+        gid_t gid
+
+    int uv_spawn(uv_loop_t* loop, uv_process_t* handle,
+                 const uv_process_options_t* options)
+
+    int uv_process_kill(uv_process_t* handle, int signum)
+
+    unsigned int uv_version()
diff --git a/venv/lib/python3.11/site-packages/uvloop/loop.cpython-311-x86_64-linux-gnu.so b/venv/lib/python3.11/site-packages/uvloop/loop.cpython-311-x86_64-linux-gnu.so
new file mode 100755
index 0000000..58ae5dc
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/loop.cpython-311-x86_64-linux-gnu.so
diff --git a/venv/lib/python3.11/site-packages/uvloop/loop.pxd b/venv/lib/python3.11/site-packages/uvloop/loop.pxd
new file mode 100644
index 0000000..5613473
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/loop.pxd
@@ -0,0 +1,229 @@
+# cython: language_level=3
+
+
+from .includes cimport uv
+from .includes cimport system
+
+from libc.stdint cimport uint64_t, uint32_t, int64_t
+
+
+include "includes/consts.pxi"
+
+
+cdef extern from *:
+    ctypedef int vint "volatile int"
+
+
+cdef class UVHandle
+cdef class UVSocketHandle(UVHandle)
+
+cdef class UVAsync(UVHandle)
+cdef class UVTimer(UVHandle)
+cdef class UVIdle(UVHandle)
+
+cdef class UVBaseTransport(UVSocketHandle)
+
+ctypedef object (*method_t)(object)
+ctypedef object (*method1_t)(object, object)
+ctypedef object (*method2_t)(object, object, object)
+ctypedef object (*method3_t)(object, object, object, object)
+
+
+cdef class Loop:
+    cdef:
+        uv.uv_loop_t *uvloop
+
+        bint _coroutine_debug_set
+        int _coroutine_origin_tracking_saved_depth
+
+        public slow_callback_duration
+
+        readonly bint _closed
+        bint _debug
+        bint _running
+        bint _stopping
+
+        uint64_t _thread_id
+
+        object _task_factory
+        object _exception_handler
+        object _default_executor
+        object _ready
+        set _queued_streams, _executing_streams
+        Py_ssize_t _ready_len
+
+        set _servers
+
+        object _transports
+        set _processes
+        dict _fd_to_reader_fileobj
+        dict _fd_to_writer_fileobj
+
+        set _signals
+        dict _signal_handlers
+        object _ssock
+        object _csock
+        bint _listening_signals
+        int _old_signal_wakeup_id
+
+        set _timers
+        dict _polls
+
+        UVProcess active_process_handler
+
+        UVAsync handler_async
+        UVIdle handler_idle
+        UVCheck handler_check__exec_writes
+
+        object _last_error
+
+        cdef object __weakref__
+
+        object _asyncgens
+        bint _asyncgens_shutdown_called
+
+        bint _executor_shutdown_called
+
+        char _recv_buffer[UV_STREAM_RECV_BUF_SIZE]
+        bint _recv_buffer_in_use
+
+        # DEBUG fields
+        # True when compiled with DEBUG.
+        # Used only in unittests.
+        readonly bint _debug_cc
+
+        readonly object _debug_handles_total
+        readonly object _debug_handles_closed
+        readonly object _debug_handles_current
+
+        readonly uint64_t _debug_uv_handles_total
+        readonly uint64_t _debug_uv_handles_freed
+
+        readonly uint64_t _debug_cb_handles_total
+        readonly uint64_t _debug_cb_handles_count
+        readonly uint64_t _debug_cb_timer_handles_total
+        readonly uint64_t _debug_cb_timer_handles_count
+
+        readonly uint64_t _debug_stream_shutdown_errors_total
+        readonly uint64_t _debug_stream_listen_errors_total
+
+        readonly uint64_t _debug_stream_read_cb_total
+        readonly uint64_t _debug_stream_read_cb_errors_total
+        readonly uint64_t _debug_stream_read_eof_total
+        readonly uint64_t _debug_stream_read_eof_cb_errors_total
+        readonly uint64_t _debug_stream_read_errors_total
+
+        readonly uint64_t _debug_stream_write_tries
+        readonly uint64_t _debug_stream_write_errors_total
+        readonly uint64_t _debug_stream_write_ctx_total
+        readonly uint64_t _debug_stream_write_ctx_cnt
+        readonly uint64_t _debug_stream_write_cb_errors_total
+
+        readonly uint64_t _poll_read_events_total
+        readonly uint64_t _poll_read_cb_errors_total
+        readonly uint64_t _poll_write_events_total
+        readonly uint64_t _poll_write_cb_errors_total
+
+        readonly uint64_t _sock_try_write_total
+
+        readonly uint64_t _debug_exception_handler_cnt
+
+    cdef _init_debug_fields(self)
+
+    cdef _on_wake(self)
+    cdef _on_idle(self)
+
+    cdef __run(self, uv.uv_run_mode)
+    cdef _run(self, uv.uv_run_mode)
+
+    cdef _close(self)
+    cdef _stop(self, exc)
+    cdef uint64_t _time(self)
+
+    cdef inline _queue_write(self, UVStream stream)
+    cdef _exec_queued_writes(self)
+
+    cdef inline _call_soon(self, object callback, object args, object context)
+    cdef inline _append_ready_handle(self, Handle handle)
+    cdef inline _call_soon_handle(self, Handle handle)
+
+    cdef _call_later(self, uint64_t delay, object callback, object args,
+                     object context)
+
+    cdef void _handle_exception(self, object ex)
+
+    cdef inline _is_main_thread(self)
+
+    cdef inline _new_future(self)
+    cdef inline _check_signal(self, sig)
+    cdef inline _check_closed(self)
+    cdef inline _check_thread(self)
+
+    cdef _getaddrinfo(self, object host, object port,
+                      int family, int type,
+                      int proto, int flags,
+                      int unpack)
+
+    cdef _getnameinfo(self, system.sockaddr *addr, int flags)
+
+    cdef _track_transport(self, UVBaseTransport transport)
+    cdef _fileobj_to_fd(self, fileobj)
+    cdef _ensure_fd_no_transport(self, fd)
+
+    cdef _track_process(self, UVProcess proc)
+    cdef _untrack_process(self, UVProcess proc)
+
+    cdef _add_reader(self, fd, Handle handle)
+    cdef _has_reader(self, fd)
+    cdef _remove_reader(self, fd)
+
+    cdef _add_writer(self, fd, Handle handle)
+    cdef _has_writer(self, fd)
+    cdef _remove_writer(self, fd)
+
+    cdef _sock_recv(self, fut, sock, n)
+    cdef _sock_recv_into(self, fut, sock, buf)
+    cdef _sock_sendall(self, fut, sock, data)
+    cdef _sock_accept(self, fut, sock)
+
+    cdef _sock_connect(self, sock, address)
+    cdef _sock_connect_cb(self, fut, sock, address)
+
+    cdef _sock_set_reuseport(self, int fd)
+
+    cdef _setup_or_resume_signals(self)
+    cdef _shutdown_signals(self)
+    cdef _pause_signals(self)
+
+    cdef _handle_signal(self, sig)
+    cdef _read_from_self(self)
+    cdef inline _ceval_process_signals(self)
+    cdef _invoke_signals(self, bytes data)
+
+    cdef _set_coroutine_debug(self, bint enabled)
+
+    cdef _print_debug_info(self)
+
+
+include "cbhandles.pxd"
+
+include "handles/handle.pxd"
+include "handles/async_.pxd"
+include "handles/idle.pxd"
+include "handles/check.pxd"
+include "handles/timer.pxd"
+include "handles/poll.pxd"
+include "handles/basetransport.pxd"
+include "handles/stream.pxd"
+include "handles/streamserver.pxd"
+include "handles/tcp.pxd"
+include "handles/pipe.pxd"
+include "handles/process.pxd"
+include "handles/fsevent.pxd"
+
+include "request.pxd"
+include "sslproto.pxd"
+
+include "handles/udp.pxd"
+
+include "server.pxd"
diff --git a/venv/lib/python3.11/site-packages/uvloop/loop.pyi b/venv/lib/python3.11/site-packages/uvloop/loop.pyi
new file mode 100644
index 0000000..9c8c462
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/loop.pyi
@@ -0,0 +1,297 @@
+import asyncio
+import ssl
+import sys
+from socket import AddressFamily, SocketKind, _Address, _RetAddress, socket
+from typing import (
+    IO,
+    Any,
+    Awaitable,
+    Callable,
+    Dict,
+    Generator,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    TypeVar,
+    Union,
+    overload,
+)
+
+_T = TypeVar('_T')
+_Context = Dict[str, Any]
+_ExceptionHandler = Callable[[asyncio.AbstractEventLoop, _Context], Any]
+_SSLContext = Union[bool, None, ssl.SSLContext]
+_ProtocolT = TypeVar("_ProtocolT", bound=asyncio.BaseProtocol)
+
+class Loop:
+    def call_soon(
+        self, callback: Callable[..., Any], *args: Any, context: Optional[Any] = ...
+    ) -> asyncio.Handle: ...
+    def call_soon_threadsafe(
+        self, callback: Callable[..., Any], *args: Any, context: Optional[Any] = ...
+    ) -> asyncio.Handle: ...
+    def call_later(
+        self, delay: float, callback: Callable[..., Any], *args: Any, context: Optional[Any] = ...
+    ) -> asyncio.TimerHandle: ...
+    def call_at(
+        self, when: float, callback: Callable[..., Any], *args: Any, context: Optional[Any] = ...
+    ) -> asyncio.TimerHandle: ...
+    def time(self) -> float: ...
+    def stop(self) -> None: ...
+    def run_forever(self) -> None: ...
+    def close(self) -> None: ...
+    def get_debug(self) -> bool: ...
+    def set_debug(self, enabled: bool) -> None: ...
+    def is_running(self) -> bool: ...
+    def is_closed(self) -> bool: ...
+    def create_future(self) -> asyncio.Future[Any]: ...
+    def create_task(
+        self,
+        coro: Union[Awaitable[_T], Generator[Any, None, _T]],
+        *,
+        name: Optional[str] = ...,
+    ) -> asyncio.Task[_T]: ...
+    def set_task_factory(
+        self,
+        factory: Optional[
+            Callable[[asyncio.AbstractEventLoop, Generator[Any, None, _T]], asyncio.Future[_T]]
+        ],
+    ) -> None: ...
+    def get_task_factory(
+        self,
+    ) -> Optional[
+        Callable[[asyncio.AbstractEventLoop, Generator[Any, None, _T]], asyncio.Future[_T]]
+    ]: ...
+    @overload
+    def run_until_complete(self, future: Generator[Any, None, _T]) -> _T: ...
+    @overload
+    def run_until_complete(self, future: Awaitable[_T]) -> _T: ...
+    async def getaddrinfo(
+        self,
+        host: Optional[Union[str, bytes]],
+        port: Optional[Union[str, bytes, int]],
+        *,
+        family: int = ...,
+        type: int = ...,
+        proto: int = ...,
+        flags: int = ...,
+    ) -> List[
+        Tuple[
+            AddressFamily,
+            SocketKind,
+            int,
+            str,
+            Union[Tuple[str, int], Tuple[str, int, int, int]],
+        ]
+    ]: ...
+    async def getnameinfo(
+        self,
+        sockaddr: Union[
+            Tuple[str, int],
+            Tuple[str, int, int],
+            Tuple[str, int, int, int]
+        ],
+        flags: int = ...,
+    ) -> Tuple[str, str]: ...
+    async def start_tls(
+        self,
+        transport: asyncio.BaseTransport,
+        protocol: asyncio.BaseProtocol,
+        sslcontext: ssl.SSLContext,
+        *,
+        server_side: bool = ...,
+        server_hostname: Optional[str] = ...,
+        ssl_handshake_timeout: Optional[float] = ...,
+        ssl_shutdown_timeout: Optional[float] = ...,
+    ) -> asyncio.BaseTransport: ...
+    @overload
+    async def create_server(
+        self,
+        protocol_factory: asyncio.events._ProtocolFactory,
+        host: Optional[Union[str, Sequence[str]]] = ...,
+        port: int = ...,
+        *,
+        family: int = ...,
+        flags: int = ...,
+        sock: None = ...,
+        backlog: int = ...,
+        ssl: _SSLContext = ...,
+        reuse_address: Optional[bool] = ...,
+        reuse_port: Optional[bool] = ...,
+        ssl_handshake_timeout: Optional[float] = ...,
+        ssl_shutdown_timeout: Optional[float] = ...,
+        start_serving: bool = ...,
+    ) -> asyncio.AbstractServer: ...
+    @overload
+    async def create_server(
+        self,
+        protocol_factory: asyncio.events._ProtocolFactory,
+        host: None = ...,
+        port: None = ...,
+        *,
+        family: int = ...,
+        flags: int = ...,
+        sock: socket = ...,
+        backlog: int = ...,
+        ssl: _SSLContext = ...,
+        reuse_address: Optional[bool] = ...,
+        reuse_port: Optional[bool] = ...,
+        ssl_handshake_timeout: Optional[float] = ...,
+        ssl_shutdown_timeout: Optional[float] = ...,
+        start_serving: bool = ...,
+    ) -> asyncio.AbstractServer: ...
+    @overload
+    async def create_connection(
+        self,
+        protocol_factory: Callable[[], _ProtocolT],
+        host: str = ...,
+        port: int = ...,
+        *,
+        ssl: _SSLContext = ...,
+        family: int = ...,
+        proto: int = ...,
+        flags: int = ...,
+        sock: None = ...,
+        local_addr: Optional[Tuple[str, int]] = ...,
+        server_hostname: Optional[str] = ...,
+        ssl_handshake_timeout: Optional[float] = ...,
+        ssl_shutdown_timeout: Optional[float] = ...,
+    ) -> tuple[asyncio.BaseProtocol, _ProtocolT]: ...
+    @overload
+    async def create_connection(
+        self,
+        protocol_factory: Callable[[], _ProtocolT],
+        host: None = ...,
+        port: None = ...,
+        *,
+        ssl: _SSLContext = ...,
+        family: int = ...,
+        proto: int = ...,
+        flags: int = ...,
+        sock: socket,
+        local_addr: None = ...,
+        server_hostname: Optional[str] = ...,
+        ssl_handshake_timeout: Optional[float] = ...,
+        ssl_shutdown_timeout: Optional[float] = ...,
+    ) -> tuple[asyncio.BaseProtocol, _ProtocolT]: ...
+    async def create_unix_server(
+        self,
+        protocol_factory: asyncio.events._ProtocolFactory,
+        path: Optional[str] = ...,
+        *,
+        backlog: int = ...,
+        sock: Optional[socket] = ...,
+        ssl: _SSLContext = ...,
+        ssl_handshake_timeout: Optional[float] = ...,
+        ssl_shutdown_timeout: Optional[float] = ...,
+        start_serving: bool = ...,
+    ) -> asyncio.AbstractServer: ...
+    async def create_unix_connection(
+        self,
+        protocol_factory: Callable[[], _ProtocolT],
+        path: Optional[str] = ...,
+        *,
+        ssl: _SSLContext = ...,
+        sock: Optional[socket] = ...,
+        server_hostname: Optional[str] = ...,
+        ssl_handshake_timeout: Optional[float] = ...,
+        ssl_shutdown_timeout: Optional[float] = ...,
+    ) -> tuple[asyncio.BaseProtocol, _ProtocolT]: ...
+    def default_exception_handler(self, context: _Context) -> None: ...
+    def get_exception_handler(self) -> Optional[_ExceptionHandler]: ...
+    def set_exception_handler(self, handler: Optional[_ExceptionHandler]) -> None: ...
+    def call_exception_handler(self, context: _Context) -> None: ...
+    def add_reader(self, fd: Any, callback: Callable[..., Any], *args: Any) -> None: ...
+    def remove_reader(self, fd: Any) -> None: ...
+    def add_writer(self, fd: Any, callback: Callable[..., Any], *args: Any) -> None: ...
+    def remove_writer(self, fd: Any) -> None: ...
+    async def sock_recv(self, sock: socket, nbytes: int) -> bytes: ...
+    async def sock_recv_into(self, sock: socket, buf: bytearray) -> int: ...
+    async def sock_sendall(self, sock: socket, data: bytes) -> None: ...
+    async def sock_accept(self, sock: socket) -> Tuple[socket, _RetAddress]: ...
+    async def sock_connect(self, sock: socket, address: _Address) -> None: ...
+    async def sock_recvfrom(self, sock: socket, bufsize: int) -> bytes: ...
+    async def sock_recvfrom_into(self, sock: socket, buf: bytearray, nbytes: int = ...) -> int: ...
+    async def sock_sendto(self, sock: socket, data: bytes, address: _Address) -> None: ...
+    async def connect_accepted_socket(
+        self,
+        protocol_factory: Callable[[], _ProtocolT],
+        sock: socket,
+        *,
+        ssl: _SSLContext = ...,
+        ssl_handshake_timeout: Optional[float] = ...,
+        ssl_shutdown_timeout: Optional[float] = ...,
+    ) -> tuple[asyncio.BaseProtocol, _ProtocolT]: ...
+    async def run_in_executor(
+        self, executor: Any, func: Callable[..., _T], *args: Any
+    ) -> _T: ...
+    def set_default_executor(self, executor: Any) -> None: ...
+    async def subprocess_shell(
+        self,
+        protocol_factory: Callable[[], _ProtocolT],
+        cmd: Union[bytes, str],
+        *,
+        stdin: Any = ...,
+        stdout: Any = ...,
+        stderr: Any = ...,
+        **kwargs: Any,
+    ) -> tuple[asyncio.BaseProtocol, _ProtocolT]: ...
+    async def subprocess_exec(
+        self,
+        protocol_factory: Callable[[], _ProtocolT],
+        *args: Any,
+        stdin: Any = ...,
+        stdout: Any = ...,
+        stderr: Any = ...,
+        **kwargs: Any,
+    ) -> tuple[asyncio.BaseProtocol, _ProtocolT]: ...
+    async def connect_read_pipe(
+        self, protocol_factory: Callable[[], _ProtocolT], pipe: Any
+    ) -> tuple[asyncio.BaseProtocol, _ProtocolT]: ...
+    async def connect_write_pipe(
+        self, protocol_factory: Callable[[], _ProtocolT], pipe: Any
+    ) -> tuple[asyncio.BaseProtocol, _ProtocolT]: ...
+    def add_signal_handler(
+        self, sig: int, callback: Callable[..., Any], *args: Any
+    ) -> None: ...
+    def remove_signal_handler(self, sig: int) -> bool: ...
+    async def create_datagram_endpoint(
+        self,
+        protocol_factory: Callable[[], _ProtocolT],
+        local_addr: Optional[Tuple[str, int]] = ...,
+        remote_addr: Optional[Tuple[str, int]] = ...,
+        *,
+        family: int = ...,
+        proto: int = ...,
+        flags: int = ...,
+        reuse_address: Optional[bool] = ...,
+        reuse_port: Optional[bool] = ...,
+        allow_broadcast: Optional[bool] = ...,
+        sock: Optional[socket] = ...,
+    ) -> tuple[asyncio.BaseProtocol, _ProtocolT]: ...
+    async def shutdown_asyncgens(self) -> None: ...
+    async def shutdown_default_executor(
+        self,
+        timeout: Optional[float] = ...,
+    ) -> None: ...
+    # Loop doesn't implement these, but since they are marked as abstract in typeshed,
+    # we have to put them in so mypy thinks the base methods are overridden
+    async def sendfile(
+        self,
+        transport: asyncio.BaseTransport,
+        file: IO[bytes],
+        offset: int = ...,
+        count: Optional[int] = ...,
+        *,
+        fallback: bool = ...,
+    ) -> int: ...
+    async def sock_sendfile(
+        self,
+        sock: socket,
+        file: IO[bytes],
+        offset: int = ...,
+        count: Optional[int] = ...,
+        *,
+        fallback: bool = ...
+    ) -> int: ...
diff --git a/venv/lib/python3.11/site-packages/uvloop/loop.pyx b/venv/lib/python3.11/site-packages/uvloop/loop.pyx
new file mode 100644
index 0000000..334d8d5
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/loop.pyx
@@ -0,0 +1,3403 @@
+# cython: language_level=3, embedsignature=True
+
+import asyncio
+cimport cython
+
+from .includes.debug cimport UVLOOP_DEBUG
+from .includes cimport uv
+from .includes cimport system
+from .includes.python cimport (
+    PY_VERSION_HEX,
+    PyMem_RawMalloc, PyMem_RawFree,
+    PyMem_RawCalloc, PyMem_RawRealloc,
+    PyUnicode_EncodeFSDefault,
+    PyErr_SetInterrupt,
+    _Py_RestoreSignals,
+    Context_CopyCurrent,
+    Context_Enter,
+    Context_Exit,
+    PyMemoryView_FromMemory, PyBUF_WRITE,
+    PyMemoryView_FromObject, PyMemoryView_Check,
+    PyOS_AfterFork_Parent, PyOS_AfterFork_Child,
+    PyOS_BeforeFork,
+    PyUnicode_FromString
+)
+from .includes.flowcontrol cimport add_flowcontrol_defaults
+
+from libc.stdint cimport uint64_t
+from libc.string cimport memset, strerror, memcpy
+from libc cimport errno
+
+from cpython cimport PyObject
+from cpython cimport PyErr_CheckSignals, PyErr_Occurred
+from cpython cimport PyThread_get_thread_ident
+from cpython cimport Py_INCREF, Py_DECREF, Py_XDECREF, Py_XINCREF
+from cpython cimport (
+    PyObject_GetBuffer, PyBuffer_Release, PyBUF_SIMPLE,
+    Py_buffer, PyBytes_AsString, PyBytes_CheckExact,
+    PyBytes_AsStringAndSize,
+    Py_SIZE, PyBytes_AS_STRING, PyBUF_WRITABLE
+)
+from cpython.pycapsule cimport PyCapsule_New, PyCapsule_GetPointer
+
+from . import _noop
+
+
+include "includes/consts.pxi"
+include "includes/stdlib.pxi"
+
+include "errors.pyx"
+
+cdef:
+    int PY39 = PY_VERSION_HEX >= 0x03090000
+    int PY311 = PY_VERSION_HEX >= 0x030b0000
+    uint64_t MAX_SLEEP = 3600 * 24 * 365 * 100
+
+
+cdef _is_sock_stream(sock_type):
+    if SOCK_NONBLOCK == -1:
+        return sock_type == uv.SOCK_STREAM
+    else:
+        # Linux's socket.type is a bitmask that can include extra info
+        # about socket (like SOCK_NONBLOCK bit), therefore we can't do simple
+        # `sock_type == socket.SOCK_STREAM`, see
+        # https://github.com/torvalds/linux/blob/v4.13/include/linux/net.h#L77
+        # for more details.
+        return (sock_type & 0xF) == uv.SOCK_STREAM
+
+
+cdef _is_sock_dgram(sock_type):
+    if SOCK_NONBLOCK == -1:
+        return sock_type == uv.SOCK_DGRAM
+    else:
+        # Read the comment in `_is_sock_stream`.
+        return (sock_type & 0xF) == uv.SOCK_DGRAM
+
+
+cdef isfuture(obj):
+    if aio_isfuture is None:
+        return isinstance(obj, aio_Future)
+    else:
+        return aio_isfuture(obj)
+
+
+cdef inline socket_inc_io_ref(sock):
+    if isinstance(sock, socket_socket):
+        sock._io_refs += 1
+
+
+cdef inline socket_dec_io_ref(sock):
+    if isinstance(sock, socket_socket):
+        sock._decref_socketios()
+
+
+cdef inline run_in_context(context, method):
+    # This method is internally used to workaround a reference issue that in
+    # certain circumstances, inlined context.run() will not hold a reference to
+    # the given method instance, which - if deallocated - will cause segfault.
+    # See also: edgedb/edgedb#2222
+    Py_INCREF(method)
+    try:
+        return context.run(method)
+    finally:
+        Py_DECREF(method)
+
+
+cdef inline run_in_context1(context, method, arg):
+    Py_INCREF(method)
+    try:
+        return context.run(method, arg)
+    finally:
+        Py_DECREF(method)
+
+
+cdef inline run_in_context2(context, method, arg1, arg2):
+    Py_INCREF(method)
+    try:
+        return context.run(method, arg1, arg2)
+    finally:
+        Py_DECREF(method)
+
+
+# Used for deprecation and removal of `loop.create_datagram_endpoint()`'s
+# *reuse_address* parameter
+_unset = object()
+
+
+@cython.no_gc_clear
+cdef class Loop:
+    def __cinit__(self):
+        cdef int err
+
+        # Install PyMem* memory allocators if they aren't installed yet.
+        __install_pymem()
+
+        # Install pthread_atfork handlers
+        __install_atfork()
+
+        self.uvloop = <uv.uv_loop_t*>PyMem_RawMalloc(sizeof(uv.uv_loop_t))
+        if self.uvloop is NULL:
+            raise MemoryError()
+
+        self.slow_callback_duration = 0.1
+
+        self._closed = 0
+        self._debug = 0
+        self._thread_id = 0
+        self._running = 0
+        self._stopping = 0
+
+        self._transports = weakref_WeakValueDictionary()
+        self._processes = set()
+
+        # Used to keep a reference (and hence keep the fileobj alive)
+        # for as long as its registered by add_reader or add_writer.
+        # This is how the selector module and hence asyncio behaves.
+        self._fd_to_reader_fileobj = {}
+        self._fd_to_writer_fileobj = {}
+
+        self._timers = set()
+        self._polls = {}
+
+        self._recv_buffer_in_use = 0
+
+        err = uv.uv_loop_init(self.uvloop)
+        if err < 0:
+            raise convert_error(err)
+        self.uvloop.data = <void*> self
+
+        self._init_debug_fields()
+
+        self.active_process_handler = None
+
+        self._last_error = None
+
+        self._task_factory = None
+        self._exception_handler = None
+        self._default_executor = None
+
+        self._queued_streams = set()
+        self._executing_streams = set()
+        self._ready = col_deque()
+        self._ready_len = 0
+
+        self.handler_async = UVAsync.new(
+            self, <method_t>self._on_wake, self)
+
+        self.handler_idle = UVIdle.new(
+            self,
+            new_MethodHandle(
+                self, "loop._on_idle", <method_t>self._on_idle, None, self))
+
+        # Needed to call `UVStream._exec_write` for writes scheduled
+        # during `Protocol.data_received`.
+        self.handler_check__exec_writes = UVCheck.new(
+            self,
+            new_MethodHandle(
+                self, "loop._exec_queued_writes",
+                <method_t>self._exec_queued_writes, None, self))
+
+        self._signals = set()
+        self._ssock = self._csock = None
+        self._signal_handlers = {}
+        self._listening_signals = False
+        self._old_signal_wakeup_id = -1
+
+        self._coroutine_debug_set = False
+
+        # A weak set of all asynchronous generators that are
+        # being iterated by the loop.
+        self._asyncgens = weakref_WeakSet()
+
+        # Set to True when `loop.shutdown_asyncgens` is called.
+        self._asyncgens_shutdown_called = False
+        # Set to True when `loop.shutdown_default_executor` is called.
+        self._executor_shutdown_called = False
+
+        self._servers = set()
+
+    cdef inline _is_main_thread(self):
+        cdef uint64_t main_thread_id = system.MAIN_THREAD_ID
+        if system.MAIN_THREAD_ID_SET == 0:
+            main_thread_id = <uint64_t>threading_main_thread().ident
+            system.setMainThreadID(main_thread_id)
+        return main_thread_id == PyThread_get_thread_ident()
+
+    def __init__(self):
+        self.set_debug(
+            sys_dev_mode or (not sys_ignore_environment
+                             and bool(os_environ.get('PYTHONASYNCIODEBUG'))))
+
+    def __dealloc__(self):
+        if self._running == 1:
+            raise RuntimeError('deallocating a running event loop!')
+        if self._closed == 0:
+            aio_logger.error("deallocating an open event loop")
+            return
+        PyMem_RawFree(self.uvloop)
+        self.uvloop = NULL
+
+    cdef _init_debug_fields(self):
+        self._debug_cc = bool(UVLOOP_DEBUG)
+
+        if UVLOOP_DEBUG:
+            self._debug_handles_current = col_Counter()
+            self._debug_handles_closed = col_Counter()
+            self._debug_handles_total = col_Counter()
+        else:
+            self._debug_handles_current = None
+            self._debug_handles_closed = None
+            self._debug_handles_total = None
+
+        self._debug_uv_handles_total = 0
+        self._debug_uv_handles_freed = 0
+
+        self._debug_stream_read_cb_total = 0
+        self._debug_stream_read_eof_total = 0
+        self._debug_stream_read_errors_total = 0
+        self._debug_stream_read_cb_errors_total = 0
+        self._debug_stream_read_eof_cb_errors_total = 0
+
+        self._debug_stream_shutdown_errors_total = 0
+        self._debug_stream_listen_errors_total = 0
+
+        self._debug_stream_write_tries = 0
+        self._debug_stream_write_errors_total = 0
+        self._debug_stream_write_ctx_total = 0
+        self._debug_stream_write_ctx_cnt = 0
+        self._debug_stream_write_cb_errors_total = 0
+
+        self._debug_cb_handles_total = 0
+        self._debug_cb_handles_count = 0
+
+        self._debug_cb_timer_handles_total = 0
+        self._debug_cb_timer_handles_count = 0
+
+        self._poll_read_events_total = 0
+        self._poll_read_cb_errors_total = 0
+        self._poll_write_events_total = 0
+        self._poll_write_cb_errors_total = 0
+
+        self._sock_try_write_total = 0
+
+        self._debug_exception_handler_cnt = 0
+
+    cdef _setup_or_resume_signals(self):
+        if not self._is_main_thread():
+            return
+
+        if self._listening_signals:
+            raise RuntimeError('signals handling has been already setup')
+
+        if self._ssock is not None:
+            raise RuntimeError('self-pipe exists before loop run')
+
+        # Create a self-pipe and call set_signal_wakeup_fd() with one
+        # of its ends.  This is needed so that libuv knows that it needs
+        # to wakeup on ^C (no matter if the SIGINT handler is still the
+        # standard Python's one or or user set their own.)
+
+        self._ssock, self._csock = socket_socketpair()
+        try:
+            self._ssock.setblocking(False)
+            self._csock.setblocking(False)
+
+            fileno = self._csock.fileno()
+
+            self._old_signal_wakeup_id = _set_signal_wakeup_fd(fileno)
+        except Exception:
+            # Out of all statements in the try block, only the
+            # "_set_signal_wakeup_fd()" call can fail, but it shouldn't,
+            # as we ensure that the current thread is the main thread.
+            # Still, if something goes horribly wrong we want to clean up
+            # the socket pair.
+            self._ssock.close()
+            self._csock.close()
+            self._ssock = None
+            self._csock = None
+            raise
+
+        self._add_reader(
+            self._ssock,
+            new_MethodHandle(
+                self,
+                "Loop._read_from_self",
+                <method_t>self._read_from_self,
+                None,
+                self))
+
+        self._listening_signals = True
+
+    cdef _pause_signals(self):
+        if not self._is_main_thread():
+            if self._listening_signals:
+                raise RuntimeError(
+                    'cannot pause signals handling; no longer running in '
+                    'the main thread')
+            else:
+                return
+
+        if not self._listening_signals:
+            raise RuntimeError('signals handling has not been setup')
+
+        self._listening_signals = False
+
+        _set_signal_wakeup_fd(self._old_signal_wakeup_id)
+
+        self._remove_reader(self._ssock)
+        self._ssock.close()
+        self._csock.close()
+        self._ssock = None
+        self._csock = None
+
+    cdef _shutdown_signals(self):
+        if not self._is_main_thread():
+            if self._signal_handlers:
+                aio_logger.warning(
+                    'cannot cleanup signal handlers: closing the event loop '
+                    'in a non-main OS thread')
+            return
+
+        if self._listening_signals:
+            raise RuntimeError(
+                'cannot shutdown signals handling as it has not been paused')
+
+        if self._ssock:
+            raise RuntimeError(
+                'self-pipe was not cleaned up after loop was run')
+
+        for sig in list(self._signal_handlers):
+            self.remove_signal_handler(sig)
+
+    def __sighandler(self, signum, frame):
+        self._signals.add(signum)
+
+    cdef inline _ceval_process_signals(self):
+        # Invoke CPython eval loop to let process signals.
+        PyErr_CheckSignals()
+        # Calling a pure-Python function will invoke
+        # _PyEval_EvalFrameDefault which will process
+        # pending signal callbacks.
+        _noop.noop()  # Might raise ^C
+
+    cdef _read_from_self(self):
+        cdef bytes sigdata
+        sigdata = b''
+        while True:
+            try:
+                data = self._ssock.recv(65536)
+                if not data:
+                    break
+                sigdata += data
+            except InterruptedError:
+                continue
+            except BlockingIOError:
+                break
+        if sigdata:
+            self._invoke_signals(sigdata)
+
+    cdef _invoke_signals(self, bytes data):
+        cdef set sigs
+
+        self._ceval_process_signals()
+
+        sigs = self._signals.copy()
+        self._signals.clear()
+        for signum in data:
+            if not signum:
+                # ignore null bytes written by set_wakeup_fd()
+                continue
+            sigs.discard(signum)
+            self._handle_signal(signum)
+
+        for signum in sigs:
+            # Since not all signals are registered by add_signal_handler()
+            # (for instance, we use the default SIGINT handler) not all
+            # signals will trigger loop.__sighandler() callback.  Therefore
+            # we combine two datasources: one is self-pipe, one is data
+            # from __sighandler; this ensures that signals shouldn't be
+            # lost even if set_wakeup_fd() couldn't write to the self-pipe.
+            self._handle_signal(signum)
+
+    cdef _handle_signal(self, sig):
+        cdef Handle handle
+
+        try:
+            handle = <Handle>(self._signal_handlers[sig])
+        except KeyError:
+            handle = None
+
+        if handle is None:
+            self._ceval_process_signals()
+            return
+
+        if handle._cancelled:
+            self.remove_signal_handler(sig)  # Remove it properly.
+        else:
+            self._append_ready_handle(handle)
+            self.handler_async.send()
+
+    cdef _on_wake(self):
+        if ((self._ready_len > 0 or self._stopping) and
+                not self.handler_idle.running):
+            self.handler_idle.start()
+
+    cdef _on_idle(self):
+        cdef:
+            int i, ntodo
+            object popleft = self._ready.popleft
+            Handle handler
+
+        ntodo = len(self._ready)
+        if self._debug:
+            for i from 0 <= i < ntodo:
+                handler = <Handle> popleft()
+                if handler._cancelled == 0:
+                    try:
+                        started = time_monotonic()
+                        handler._run()
+                    except BaseException as ex:
+                        self._stop(ex)
+                        return
+                    else:
+                        delta = time_monotonic() - started
+                        if delta > self.slow_callback_duration:
+                            aio_logger.warning(
+                                'Executing %s took %.3f seconds',
+                                handler._format_handle(), delta)
+
+        else:
+            for i from 0 <= i < ntodo:
+                handler = <Handle> popleft()
+                if handler._cancelled == 0:
+                    try:
+                        handler._run()
+                    except BaseException as ex:
+                        self._stop(ex)
+                        return
+
+        if len(self._queued_streams):
+            self._exec_queued_writes()
+
+        self._ready_len = len(self._ready)
+        if self._ready_len == 0 and self.handler_idle.running:
+            self.handler_idle.stop()
+
+        if self._stopping:
+            uv.uv_stop(self.uvloop)  # void
+
+    cdef _stop(self, exc):
+        if exc is not None:
+            self._last_error = exc
+        if self._stopping == 1:
+            return
+        self._stopping = 1
+        if not self.handler_idle.running:
+            self.handler_idle.start()
+
+    cdef __run(self, uv.uv_run_mode mode):
+        # Although every UVHandle holds a reference to the loop,
+        # we want to do everything to ensure that the loop will
+        # never deallocate during the run -- so we do some
+        # manual refs management.
+        Py_INCREF(self)
+        with nogil:
+            err = uv.uv_run(self.uvloop, mode)
+        Py_DECREF(self)
+
+        if err < 0:
+            raise convert_error(err)
+
+    cdef _run(self, uv.uv_run_mode mode):
+        cdef int err
+
+        if self._closed == 1:
+            raise RuntimeError('unable to start the loop; it was closed')
+
+        if self._running == 1:
+            raise RuntimeError('this event loop is already running.')
+
+        if (aio_get_running_loop is not None and
+                aio_get_running_loop() is not None):
+            raise RuntimeError(
+                'Cannot run the event loop while another loop is running')
+
+        # reset _last_error
+        self._last_error = None
+
+        self._thread_id = PyThread_get_thread_ident()
+        self._running = 1
+
+        self.handler_check__exec_writes.start()
+        self.handler_idle.start()
+
+        self._setup_or_resume_signals()
+
+        if aio_set_running_loop is not None:
+            aio_set_running_loop(self)
+        try:
+            self.__run(mode)
+        finally:
+            if aio_set_running_loop is not None:
+                aio_set_running_loop(None)
+
+            self.handler_check__exec_writes.stop()
+            self.handler_idle.stop()
+
+            self._pause_signals()
+
+            self._thread_id = 0
+            self._running = 0
+            self._stopping = 0
+
+        if self._last_error is not None:
+            # The loop was stopped with an error with 'loop._stop(error)' call
+            raise self._last_error
+
+    cdef _close(self):
+        cdef int err
+
+        if self._running == 1:
+            raise RuntimeError("Cannot close a running event loop")
+
+        if self._closed == 1:
+            return
+
+        self._closed = 1
+
+        for cb_handle in self._ready:
+            cb_handle.cancel()
+        self._ready.clear()
+        self._ready_len = 0
+
+        if self._polls:
+            for poll_handle in self._polls.values():
+                (<UVHandle>poll_handle)._close()
+
+            self._polls.clear()
+
+        if self._timers:
+            for timer_cbhandle in tuple(self._timers):
+                timer_cbhandle.cancel()
+
+        # Close all remaining handles
+        self.handler_async._close()
+        self.handler_idle._close()
+        self.handler_check__exec_writes._close()
+        __close_all_handles(self)
+        self._shutdown_signals()
+        # During this run there should be no open handles,
+        # so it should finish right away
+        self.__run(uv.UV_RUN_DEFAULT)
+
+        if self._fd_to_writer_fileobj:
+            for fileobj in self._fd_to_writer_fileobj.values():
+                socket_dec_io_ref(fileobj)
+            self._fd_to_writer_fileobj.clear()
+
+        if self._fd_to_reader_fileobj:
+            for fileobj in self._fd_to_reader_fileobj.values():
+                socket_dec_io_ref(fileobj)
+            self._fd_to_reader_fileobj.clear()
+
+        if self._timers:
+            raise RuntimeError(
+                f"new timers were queued during loop closing: {self._timers}")
+
+        if self._polls:
+            raise RuntimeError(
+                f"new poll handles were queued during loop closing: "
+                f"{self._polls}")
+
+        if self._ready:
+            raise RuntimeError(
+                f"new callbacks were queued during loop closing: "
+                f"{self._ready}")
+
+        err = uv.uv_loop_close(self.uvloop)
+        if err < 0:
+            raise convert_error(err)
+
+        self.handler_async = None
+        self.handler_idle = None
+        self.handler_check__exec_writes = None
+
+        self._executor_shutdown_called = True
+        executor = self._default_executor
+        if executor is not None:
+            self._default_executor = None
+            executor.shutdown(wait=False)
+
+    cdef uint64_t _time(self):
+        # asyncio doesn't have a time cache, neither should uvloop.
+        uv.uv_update_time(self.uvloop)  # void
+        return uv.uv_now(self.uvloop)
+
+    cdef inline _queue_write(self, UVStream stream):
+        self._queued_streams.add(stream)
+        if not self.handler_check__exec_writes.running:
+            self.handler_check__exec_writes.start()
+
+    cdef _exec_queued_writes(self):
+        if len(self._queued_streams) == 0:
+            if self.handler_check__exec_writes.running:
+                self.handler_check__exec_writes.stop()
+            return
+
+        cdef:
+            UVStream stream
+
+        streams = self._queued_streams
+        self._queued_streams = self._executing_streams
+        self._executing_streams = streams
+        try:
+            for pystream in streams:
+                stream = <UVStream>pystream
+                stream._exec_write()
+        finally:
+            streams.clear()
+
+        if self.handler_check__exec_writes.running:
+            if len(self._queued_streams) == 0:
+                self.handler_check__exec_writes.stop()
+
+    cdef inline _call_soon(self, object callback, object args, object context):
+        cdef Handle handle
+        handle = new_Handle(self, callback, args, context)
+        self._call_soon_handle(handle)
+        return handle
+
+    cdef inline _append_ready_handle(self, Handle handle):
+        self._check_closed()
+        self._ready.append(handle)
+        self._ready_len += 1
+
+    cdef inline _call_soon_handle(self, Handle handle):
+        self._append_ready_handle(handle)
+        if not self.handler_idle.running:
+            self.handler_idle.start()
+
+    cdef _call_later(self, uint64_t delay, object callback, object args,
+                     object context):
+        return TimerHandle(self, callback, args, delay, context)
+
+    cdef void _handle_exception(self, object ex):
+        if isinstance(ex, Exception):
+            self.call_exception_handler({'exception': ex})
+        else:
+            # BaseException
+            self._last_error = ex
+            # Exit ASAP
+            self._stop(None)
+
+    cdef inline _check_signal(self, sig):
+        if not isinstance(sig, int):
+            raise TypeError('sig must be an int, not {!r}'.format(sig))
+
+        if not (1 <= sig < signal_NSIG):
+            raise ValueError(
+                'sig {} out of range(1, {})'.format(sig, signal_NSIG))
+
+    cdef inline _check_closed(self):
+        if self._closed == 1:
+            raise RuntimeError('Event loop is closed')
+
+    cdef inline _check_thread(self):
+        if self._thread_id == 0:
+            return
+
+        cdef uint64_t thread_id
+        thread_id = <uint64_t>PyThread_get_thread_ident()
+
+        if thread_id != self._thread_id:
+            raise RuntimeError(
+                "Non-thread-safe operation invoked on an event loop other "
+                "than the current one")
+
+    cdef inline _new_future(self):
+        return aio_Future(loop=self)
+
+    cdef _track_transport(self, UVBaseTransport transport):
+        self._transports[transport._fileno()] = transport
+
+    cdef _track_process(self, UVProcess proc):
+        self._processes.add(proc)
+
+    cdef _untrack_process(self, UVProcess proc):
+        self._processes.discard(proc)
+
+    cdef _fileobj_to_fd(self, fileobj):
+        """Return a file descriptor from a file object.
+
+        Parameters:
+        fileobj -- file object or file descriptor
+
+        Returns:
+        corresponding file descriptor
+
+        Raises:
+        ValueError if the object is invalid
+        """
+        # Copy of the `selectors._fileobj_to_fd()` function.
+        if isinstance(fileobj, int):
+            fd = fileobj
+        else:
+            try:
+                fd = int(fileobj.fileno())
+            except (AttributeError, TypeError, ValueError):
+                raise ValueError("Invalid file object: "
+                                 "{!r}".format(fileobj)) from None
+        if fd < 0:
+            raise ValueError("Invalid file descriptor: {}".format(fd))
+        return fd
+
+    cdef _ensure_fd_no_transport(self, fd):
+        cdef UVBaseTransport tr
+        try:
+            tr = <UVBaseTransport>(self._transports[fd])
+        except KeyError:
+            pass
+        else:
+            if tr._is_alive():
+                raise RuntimeError(
+                    'File descriptor {!r} is used by transport {!r}'.format(
+                        fd, tr))
+
+    cdef _add_reader(self, fileobj, Handle handle):
+        cdef:
+            UVPoll poll
+
+        self._check_closed()
+        fd = self._fileobj_to_fd(fileobj)
+        self._ensure_fd_no_transport(fd)
+
+        try:
+            poll = <UVPoll>(self._polls[fd])
+        except KeyError:
+            poll = UVPoll.new(self, fd)
+            self._polls[fd] = poll
+
+        poll.start_reading(handle)
+
+        old_fileobj = self._fd_to_reader_fileobj.pop(fd, None)
+        if old_fileobj is not None:
+            socket_dec_io_ref(old_fileobj)
+
+        self._fd_to_reader_fileobj[fd] = fileobj
+        socket_inc_io_ref(fileobj)
+
+    cdef _remove_reader(self, fileobj):
+        cdef:
+            UVPoll poll
+
+        fd = self._fileobj_to_fd(fileobj)
+        self._ensure_fd_no_transport(fd)
+
+        mapped_fileobj = self._fd_to_reader_fileobj.pop(fd, None)
+        if mapped_fileobj is not None:
+            socket_dec_io_ref(mapped_fileobj)
+
+        if self._closed == 1:
+            return False
+
+        try:
+            poll = <UVPoll>(self._polls[fd])
+        except KeyError:
+            return False
+
+        result = poll.stop_reading()
+        if not poll.is_active():
+            del self._polls[fd]
+            poll._close()
+
+        return result
+
+    cdef _has_reader(self, fileobj):
+        cdef:
+            UVPoll poll
+
+        self._check_closed()
+        fd = self._fileobj_to_fd(fileobj)
+
+        try:
+            poll = <UVPoll>(self._polls[fd])
+        except KeyError:
+            return False
+
+        return poll.is_reading()
+
+    cdef _add_writer(self, fileobj, Handle handle):
+        cdef:
+            UVPoll poll
+
+        self._check_closed()
+        fd = self._fileobj_to_fd(fileobj)
+        self._ensure_fd_no_transport(fd)
+
+        try:
+            poll = <UVPoll>(self._polls[fd])
+        except KeyError:
+            poll = UVPoll.new(self, fd)
+            self._polls[fd] = poll
+
+        poll.start_writing(handle)
+
+        old_fileobj = self._fd_to_writer_fileobj.pop(fd, None)
+        if old_fileobj is not None:
+            socket_dec_io_ref(old_fileobj)
+
+        self._fd_to_writer_fileobj[fd] = fileobj
+        socket_inc_io_ref(fileobj)
+
+    cdef _remove_writer(self, fileobj):
+        cdef:
+            UVPoll poll
+
+        fd = self._fileobj_to_fd(fileobj)
+        self._ensure_fd_no_transport(fd)
+
+        mapped_fileobj = self._fd_to_writer_fileobj.pop(fd, None)
+        if mapped_fileobj is not None:
+            socket_dec_io_ref(mapped_fileobj)
+
+        if self._closed == 1:
+            return False
+
+        try:
+            poll = <UVPoll>(self._polls[fd])
+        except KeyError:
+            return False
+
+        result = poll.stop_writing()
+        if not poll.is_active():
+            del self._polls[fd]
+            poll._close()
+
+        return result
+
+    cdef _has_writer(self, fileobj):
+        cdef:
+            UVPoll poll
+
+        self._check_closed()
+        fd = self._fileobj_to_fd(fileobj)
+
+        try:
+            poll = <UVPoll>(self._polls[fd])
+        except KeyError:
+            return False
+
+        return poll.is_writing()
+
+    cdef _getaddrinfo(self, object host, object port,
+                      int family, int type,
+                      int proto, int flags,
+                      int unpack):
+
+        if isinstance(port, str):
+            port = port.encode()
+        elif isinstance(port, int):
+            port = str(port).encode()
+        if port is not None and not isinstance(port, bytes):
+            raise TypeError('port must be a str, bytes or int')
+
+        if isinstance(host, str):
+            host = host.encode('idna')
+        if host is not None:
+            if not isinstance(host, bytes):
+                raise TypeError('host must be a str or bytes')
+
+        fut = self._new_future()
+
+        def callback(result):
+            if AddrInfo.isinstance(result):
+                try:
+                    if unpack == 0:
+                        data = result
+                    else:
+                        data = (<AddrInfo>result).unpack()
+                except (KeyboardInterrupt, SystemExit):
+                    raise
+                except BaseException as ex:
+                    if not fut.cancelled():
+                        fut.set_exception(ex)
+                else:
+                    if not fut.cancelled():
+                        fut.set_result(data)
+            else:
+                if not fut.cancelled():
+                    fut.set_exception(result)
+
+        AddrInfoRequest(self, host, port, family, type, proto, flags, callback)
+        return fut
+
+    cdef _getnameinfo(self, system.sockaddr *addr, int flags):
+        cdef NameInfoRequest nr
+        fut = self._new_future()
+
+        def callback(result):
+            if isinstance(result, tuple):
+                fut.set_result(result)
+            else:
+                fut.set_exception(result)
+
+        nr = NameInfoRequest(self, callback)
+        nr.query(addr, flags)
+        return fut
+
+    cdef _sock_recv(self, fut, sock, n):
+        if UVLOOP_DEBUG:
+            if fut.cancelled():
+                # Shouldn't happen with _SyncSocketReaderFuture.
+                raise RuntimeError(
+                    f'_sock_recv is called on a cancelled Future')
+
+            if not self._has_reader(sock):
+                raise RuntimeError(
+                    f'socket {sock!r} does not have a reader '
+                    f'in the _sock_recv callback')
+
+        try:
+            data = sock.recv(n)
+        except (BlockingIOError, InterruptedError):
+            # No need to re-add the reader, let's just wait until
+            # the poll handler calls this callback again.
+            pass
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as exc:
+            fut.set_exception(exc)
+            self._remove_reader(sock)
+        else:
+            fut.set_result(data)
+            self._remove_reader(sock)
+
+    cdef _sock_recv_into(self, fut, sock, buf):
+        if UVLOOP_DEBUG:
+            if fut.cancelled():
+                # Shouldn't happen with _SyncSocketReaderFuture.
+                raise RuntimeError(
+                    f'_sock_recv_into is called on a cancelled Future')
+
+            if not self._has_reader(sock):
+                raise RuntimeError(
+                    f'socket {sock!r} does not have a reader '
+                    f'in the _sock_recv_into callback')
+
+        try:
+            data = sock.recv_into(buf)
+        except (BlockingIOError, InterruptedError):
+            # No need to re-add the reader, let's just wait until
+            # the poll handler calls this callback again.
+            pass
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as exc:
+            fut.set_exception(exc)
+            self._remove_reader(sock)
+        else:
+            fut.set_result(data)
+            self._remove_reader(sock)
+
+    cdef _sock_sendall(self, fut, sock, data):
+        cdef:
+            Handle handle
+            int n
+
+        if UVLOOP_DEBUG:
+            if fut.cancelled():
+                # Shouldn't happen with _SyncSocketWriterFuture.
+                raise RuntimeError(
+                    f'_sock_sendall is called on a cancelled Future')
+
+            if not self._has_writer(sock):
+                raise RuntimeError(
+                    f'socket {sock!r} does not have a writer '
+                    f'in the _sock_sendall callback')
+
+        try:
+            n = sock.send(data)
+        except (BlockingIOError, InterruptedError):
+            # Try next time.
+            return
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as exc:
+            fut.set_exception(exc)
+            self._remove_writer(sock)
+            return
+
+        self._remove_writer(sock)
+
+        if n == len(data):
+            fut.set_result(None)
+        else:
+            if n:
+                if not isinstance(data, memoryview):
+                    data = memoryview(data)
+                data = data[n:]
+
+            handle = new_MethodHandle3(
+                self,
+                "Loop._sock_sendall",
+                <method3_t>self._sock_sendall,
+                None,
+                self,
+                fut, sock, data)
+
+            self._add_writer(sock, handle)
+
+    cdef _sock_accept(self, fut, sock):
+        try:
+            conn, address = sock.accept()
+            conn.setblocking(False)
+        except (BlockingIOError, InterruptedError):
+            # There is an active reader for _sock_accept, so
+            # do nothing, it will be called again.
+            pass
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as exc:
+            fut.set_exception(exc)
+            self._remove_reader(sock)
+        else:
+            fut.set_result((conn, address))
+            self._remove_reader(sock)
+
+    cdef _sock_connect(self, sock, address):
+        cdef:
+            Handle handle
+
+        try:
+            sock.connect(address)
+        except (BlockingIOError, InterruptedError):
+            pass
+        else:
+            return
+
+        fut = _SyncSocketWriterFuture(sock, self)
+        handle = new_MethodHandle3(
+            self,
+            "Loop._sock_connect",
+            <method3_t>self._sock_connect_cb,
+            None,
+            self,
+            fut, sock, address)
+
+        self._add_writer(sock, handle)
+        return fut
+
+    cdef _sock_connect_cb(self, fut, sock, address):
+        if UVLOOP_DEBUG:
+            if fut.cancelled():
+                # Shouldn't happen with _SyncSocketWriterFuture.
+                raise RuntimeError(
+                    f'_sock_connect_cb is called on a cancelled Future')
+
+            if not self._has_writer(sock):
+                raise RuntimeError(
+                    f'socket {sock!r} does not have a writer '
+                    f'in the _sock_connect_cb callback')
+
+        try:
+            err = sock.getsockopt(uv.SOL_SOCKET, uv.SO_ERROR)
+            if err != 0:
+                # Jump to any except clause below.
+                raise OSError(err, 'Connect call failed %s' % (address,))
+        except (BlockingIOError, InterruptedError):
+            # socket is still registered, the callback will be retried later
+            pass
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException as exc:
+            fut.set_exception(exc)
+            self._remove_writer(sock)
+        else:
+            fut.set_result(None)
+            self._remove_writer(sock)
+
+    cdef _sock_set_reuseport(self, int fd):
+        cdef:
+            int err
+            int reuseport_flag = 1
+
+        err = system.setsockopt(
+            fd,
+            uv.SOL_SOCKET,
+            SO_REUSEPORT,
+            <char*>&reuseport_flag,
+            sizeof(reuseport_flag))
+
+        if err < 0:
+            raise convert_error(-errno.errno)
+
+    cdef _set_coroutine_debug(self, bint enabled):
+        enabled = bool(enabled)
+        if self._coroutine_debug_set == enabled:
+            return
+
+        if enabled:
+            self._coroutine_origin_tracking_saved_depth = (
+                sys.get_coroutine_origin_tracking_depth())
+            sys.set_coroutine_origin_tracking_depth(
+                DEBUG_STACK_DEPTH)
+        else:
+            sys.set_coroutine_origin_tracking_depth(
+                self._coroutine_origin_tracking_saved_depth)
+
+        self._coroutine_debug_set = enabled
+
+    def _get_backend_id(self):
+        """This method is used by uvloop tests and is not part of the API."""
+        return uv.uv_backend_fd(self.uvloop)
+
+    cdef _print_debug_info(self):
+        cdef:
+            int err
+            uv.uv_rusage_t rusage
+
+        err = uv.uv_getrusage(&rusage)
+        if err < 0:
+            raise convert_error(err)
+
+        # OS
+
+        print('---- Process info: -----')
+        print('Process memory:            {}'.format(rusage.ru_maxrss))
+        print('Number of signals:         {}'.format(rusage.ru_nsignals))
+        print('')
+
+        # Loop
+
+        print('--- Loop debug info: ---')
+        print('Loop time:                 {}'.format(self.time()))
+        print('Errors logged:             {}'.format(
+            self._debug_exception_handler_cnt))
+        print()
+        print('Callback handles:          {: <8} | {}'.format(
+            self._debug_cb_handles_count,
+            self._debug_cb_handles_total))
+        print('Timer handles:             {: <8} | {}'.format(
+            self._debug_cb_timer_handles_count,
+            self._debug_cb_timer_handles_total))
+        print()
+
+        print('                        alive  | closed  |')
+        print('UVHandles               python | libuv   | total')
+        print('                        objs   | handles |')
+        print('-------------------------------+---------+---------')
+        for name in sorted(self._debug_handles_total):
+            print('    {: <18} {: >7} | {: >7} | {: >7}'.format(
+                name,
+                self._debug_handles_current[name],
+                self._debug_handles_closed[name],
+                self._debug_handles_total[name]))
+        print()
+
+        print('uv_handle_t (current: {}; freed: {}; total: {})'.format(
+            self._debug_uv_handles_total - self._debug_uv_handles_freed,
+            self._debug_uv_handles_freed,
+            self._debug_uv_handles_total))
+        print()
+
+        print('--- Streams debug info: ---')
+        print('Write errors:              {}'.format(
+            self._debug_stream_write_errors_total))
+        print('Write without poll:        {}'.format(
+            self._debug_stream_write_tries))
+        print('Write contexts:            {: <8} | {}'.format(
+            self._debug_stream_write_ctx_cnt,
+            self._debug_stream_write_ctx_total))
+        print('Write failed callbacks:    {}'.format(
+            self._debug_stream_write_cb_errors_total))
+        print()
+        print('Read errors:               {}'.format(
+            self._debug_stream_read_errors_total))
+        print('Read callbacks:            {}'.format(
+            self._debug_stream_read_cb_total))
+        print('Read failed callbacks:     {}'.format(
+            self._debug_stream_read_cb_errors_total))
+        print('Read EOFs:                 {}'.format(
+            self._debug_stream_read_eof_total))
+        print('Read EOF failed callbacks: {}'.format(
+            self._debug_stream_read_eof_cb_errors_total))
+        print()
+        print('Listen errors:             {}'.format(
+            self._debug_stream_listen_errors_total))
+        print('Shutdown errors            {}'.format(
+            self._debug_stream_shutdown_errors_total))
+        print()
+
+        print('--- Polls debug info: ---')
+        print('Read events:               {}'.format(
+            self._poll_read_events_total))
+        print('Read callbacks failed:     {}'.format(
+            self._poll_read_cb_errors_total))
+        print('Write events:              {}'.format(
+            self._poll_write_events_total))
+        print('Write callbacks failed:    {}'.format(
+            self._poll_write_cb_errors_total))
+        print()
+
+        print('--- Sock ops successful on 1st try: ---')
+        print('Socket try-writes:         {}'.format(
+            self._sock_try_write_total))
+
+        print(flush=True)
+
+    property print_debug_info:
+        def __get__(self):
+            if UVLOOP_DEBUG:
+                return lambda: self._print_debug_info()
+            else:
+                raise AttributeError('print_debug_info')
+
+    # Public API
+
+    def __repr__(self):
+        return '<{}.{} running={} closed={} debug={}>'.format(
+            self.__class__.__module__,
+            self.__class__.__name__,
+            self.is_running(),
+            self.is_closed(),
+            self.get_debug()
+        )
+
+    def call_soon(self, callback, *args, context=None):
+        """Arrange for a callback to be called as soon as possible.
+
+        This operates as a FIFO queue: callbacks are called in the
+        order in which they are registered.  Each callback will be
+        called exactly once.
+
+        Any positional arguments after the callback will be passed to
+        the callback when it is called.
+        """
+        if self._debug == 1:
+            self._check_thread()
+        if args:
+            return self._call_soon(callback, args, context)
+        else:
+            return self._call_soon(callback, None, context)
+
+    def call_soon_threadsafe(self, callback, *args, context=None):
+        """Like call_soon(), but thread-safe."""
+        if not args:
+            args = None
+        cdef Handle handle = new_Handle(self, callback, args, context)
+        self._append_ready_handle(handle)  # deque append is atomic
+        # libuv async handler is thread-safe while the idle handler is not -
+        # we only set the async handler here, which will start the idle handler
+        # in _on_wake() from the loop and eventually call the callback.
+        self.handler_async.send()
+        return handle
+
+    def call_later(self, delay, callback, *args, context=None):
+        """Arrange for a callback to be called at a given time.
+
+        Return a Handle: an opaque object with a cancel() method that
+        can be used to cancel the call.
+
+        The delay can be an int or float, expressed in seconds.  It is
+        always relative to the current time.
+
+        Each callback will be called exactly once.  If two callbacks
+        are scheduled for exactly the same time, it undefined which
+        will be called first.
+
+        Any positional arguments after the callback will be passed to
+        the callback when it is called.
+        """
+        cdef uint64_t when
+
+        self._check_closed()
+        if self._debug == 1:
+            self._check_thread()
+
+        if delay < 0:
+            delay = 0
+        elif delay == py_inf or delay > MAX_SLEEP:
+            # ~100 years sounds like a good approximation of
+            # infinity for a Python application.
+            delay = MAX_SLEEP
+
+        when = <uint64_t>round(delay * 1000)
+        if not args:
+            args = None
+        if when == 0:
+            return self._call_soon(callback, args, context)
+        else:
+            return self._call_later(when, callback, args, context)
+
+    def call_at(self, when, callback, *args, context=None):
+        """Like call_later(), but uses an absolute time.
+
+        Absolute time corresponds to the event loop's time() method.
+        """
+        return self.call_later(
+            when - self.time(), callback, *args, context=context)
+
+    def time(self):
+        """Return the time according to the event loop's clock.
+
+        This is a float expressed in seconds since an epoch, but the
+        epoch, precision, accuracy and drift are unspecified and may
+        differ per event loop.
+        """
+        return self._time() / 1000
+
+    def stop(self):
+        """Stop running the event loop.
+
+        Every callback already scheduled will still run.  This simply informs
+        run_forever to stop looping after a complete iteration.
+        """
+        self._call_soon_handle(
+            new_MethodHandle1(
+                self,
+                "Loop._stop",
+                <method1_t>self._stop,
+                None,
+                self,
+                None))
+
+    def run_forever(self):
+        """Run the event loop until stop() is called."""
+        self._check_closed()
+        mode = uv.UV_RUN_DEFAULT
+        if self._stopping:
+            # loop.stop() was called right before loop.run_forever().
+            # This is how asyncio loop behaves.
+            mode = uv.UV_RUN_NOWAIT
+        self._set_coroutine_debug(self._debug)
+        old_agen_hooks = sys.get_asyncgen_hooks()
+        sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,
+                               finalizer=self._asyncgen_finalizer_hook)
+        try:
+            self._run(mode)
+        finally:
+            self._set_coroutine_debug(False)
+            sys.set_asyncgen_hooks(*old_agen_hooks)
+
+    def close(self):
+        """Close the event loop.
+
+        The event loop must not be running.
+
+        This is idempotent and irreversible.
+
+        No other methods should be called after this one.
+        """
+        self._close()
+
+    def get_debug(self):
+        return bool(self._debug)
+
+    def set_debug(self, enabled):
+        self._debug = bool(enabled)
+        if self.is_running():
+            self.call_soon_threadsafe(
+                self._set_coroutine_debug, self, self._debug)
+
+    def is_running(self):
+        """Return whether the event loop is currently running."""
+        return bool(self._running)
+
+    def is_closed(self):
+        """Returns True if the event loop was closed."""
+        return bool(self._closed)
+
+    def create_future(self):
+        """Create a Future object attached to the loop."""
+        return self._new_future()
+
+    def create_task(self, coro, *, name=None, context=None):
+        """Schedule a coroutine object.
+
+        Return a task object.
+
+        If name is not None, task.set_name(name) will be called if the task
+        object has the set_name attribute, true for default Task in CPython.
+
+        An optional keyword-only context argument allows specifying a custom
+        contextvars.Context for the coro to run in. The current context copy is
+        created when no context is provided.
+        """
+        self._check_closed()
+        if PY311:
+            if self._task_factory is None:
+                task = aio_Task(coro, loop=self, context=context)
+            else:
+                task = self._task_factory(self, coro, context=context)
+        else:
+            if context is None:
+                if self._task_factory is None:
+                    task = aio_Task(coro, loop=self)
+                else:
+                    task = self._task_factory(self, coro)
+            else:
+                if self._task_factory is None:
+                    task = context.run(aio_Task, coro, self)
+                else:
+                    task = context.run(self._task_factory, self, coro)
+
+        # copied from asyncio.tasks._set_task_name (bpo-34270)
+        if name is not None:
+            try:
+                set_name = task.set_name
+            except AttributeError:
+                pass
+            else:
+                set_name(name)
+
+        return task
+
+    def set_task_factory(self, factory):
+        """Set a task factory that will be used by loop.create_task().
+
+        If factory is None the default task factory will be set.
+
+        If factory is a callable, it should have a signature matching
+        '(loop, coro)', where 'loop' will be a reference to the active
+        event loop, 'coro' will be a coroutine object.  The callable
+        must return a Future.
+        """
+        if factory is not None and not callable(factory):
+            raise TypeError('task factory must be a callable or None')
+        self._task_factory = factory
+
+    def get_task_factory(self):
+        """Return a task factory, or None if the default one is in use."""
+        return self._task_factory
+
+    def run_until_complete(self, future):
+        """Run until the Future is done.
+
+        If the argument is a coroutine, it is wrapped in a Task.
+
+        WARNING: It would be disastrous to call run_until_complete()
+        with the same coroutine twice -- it would wrap it in two
+        different Tasks and that can't be good.
+
+        Return the Future's result, or raise its exception.
+        """
+        self._check_closed()
+
+        new_task = not isfuture(future)
+        future = aio_ensure_future(future, loop=self)
+        if new_task:
+            # An exception is raised if the future didn't complete, so there
+            # is no need to log the "destroy pending task" message
+            future._log_destroy_pending = False
+
+        def done_cb(fut):
+            if not fut.cancelled():
+                exc = fut.exception()
+                if isinstance(exc, (SystemExit, KeyboardInterrupt)):
+                    # Issue #336: run_forever() already finished,
+                    # no need to stop it.
+                    return
+            self.stop()
+
+        future.add_done_callback(done_cb)
+        try:
+            self.run_forever()
+        except BaseException:
+            if new_task and future.done() and not future.cancelled():
+                # The coroutine raised a BaseException. Consume the exception
+                # to not log a warning, the caller doesn't have access to the
+                # local task.
+                future.exception()
+            raise
+        finally:
+            future.remove_done_callback(done_cb)
+        if not future.done():
+            raise RuntimeError('Event loop stopped before Future completed.')
+
+        return future.result()
+
+    @cython.iterable_coroutine
+    async def getaddrinfo(self, object host, object port, *,
+                          int family=0, int type=0, int proto=0, int flags=0):
+
+        addr = __static_getaddrinfo_pyaddr(host, port, family,
+                                           type, proto, flags)
+        if addr is not None:
+            return [addr]
+
+        return await self._getaddrinfo(
+            host, port, family, type, proto, flags, 1)
+
+    @cython.iterable_coroutine
+    async def getnameinfo(self, sockaddr, int flags=0):
+        cdef:
+            AddrInfo ai_cnt
+            system.addrinfo *ai
+            system.sockaddr_in6 *sin6
+
+        if not isinstance(sockaddr, tuple):
+            raise TypeError('getnameinfo() argument 1 must be a tuple')
+
+        sl = len(sockaddr)
+
+        if sl < 2 or sl > 4:
+            raise ValueError('sockaddr must be a tuple of 2, 3 or 4 values')
+
+        if sl > 2:
+            flowinfo = sockaddr[2]
+            if flowinfo < 0 or flowinfo > 0xfffff:
+                raise OverflowError(
+                    'getnameinfo(): flowinfo must be 0-1048575.')
+        else:
+            flowinfo = 0
+
+        if sl > 3:
+            scope_id = sockaddr[3]
+            if scope_id < 0 or scope_id > 2 ** 32:
+                raise OverflowError(
+                    'getsockaddrarg: scope_id must be unsigned 32 bit integer')
+        else:
+            scope_id = 0
+
+        ai_cnt = await self._getaddrinfo(
+            sockaddr[0], sockaddr[1],
+            uv.AF_UNSPEC,         # family
+            uv.SOCK_DGRAM,        # type
+            0,                    # proto
+            uv.AI_NUMERICHOST,    # flags
+            0)                    # unpack
+
+        ai = ai_cnt.data
+
+        if ai.ai_next:
+            raise OSError("sockaddr resolved to multiple addresses")
+
+        if ai.ai_family == uv.AF_INET:
+            if sl > 2:
+                raise OSError("IPv4 sockaddr must be 2 tuple")
+        elif ai.ai_family == uv.AF_INET6:
+            # Modify some fields in `ai`
+            sin6 = <system.sockaddr_in6*> ai.ai_addr
+            sin6.sin6_flowinfo = system.htonl(flowinfo)
+            sin6.sin6_scope_id = scope_id
+
+        return await self._getnameinfo(ai.ai_addr, flags)
+
+    @cython.iterable_coroutine
+    async def start_tls(self, transport, protocol, sslcontext, *,
+                        server_side=False,
+                        server_hostname=None,
+                        ssl_handshake_timeout=None,
+                        ssl_shutdown_timeout=None):
+        """Upgrade transport to TLS.
+
+        Return a new transport that *protocol* should start using
+        immediately.
+        """
+        if not isinstance(sslcontext, ssl_SSLContext):
+            raise TypeError(
+                f'sslcontext is expected to be an instance of ssl.SSLContext, '
+                f'got {sslcontext!r}')
+
+        if isinstance(transport, (TCPTransport, UnixTransport)):
+            context = (<UVStream>transport).context
+        elif isinstance(transport, _SSLProtocolTransport):
+            context = (<_SSLProtocolTransport>transport).context
+        else:
+            raise TypeError(
+                f'transport {transport!r} is not supported by start_tls()')
+
+        waiter = self._new_future()
+        ssl_protocol = SSLProtocol(
+            self, protocol, sslcontext, waiter,
+            server_side, server_hostname,
+            ssl_handshake_timeout=ssl_handshake_timeout,
+            ssl_shutdown_timeout=ssl_shutdown_timeout,
+            call_connection_made=False)
+
+        # Pause early so that "ssl_protocol.data_received()" doesn't
+        # have a chance to get called before "ssl_protocol.connection_made()".
+        transport.pause_reading()
+
+        transport.set_protocol(ssl_protocol)
+        conmade_cb = self.call_soon(ssl_protocol.connection_made, transport,
+                                    context=context)
+        # transport.resume_reading() will use the right context
+        # (transport.context) to call e.g. data_received()
+        resume_cb = self.call_soon(transport.resume_reading)
+        app_transport = ssl_protocol._get_app_transport(context)
+
+        try:
+            await waiter
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException:
+            app_transport.close()
+            conmade_cb.cancel()
+            resume_cb.cancel()
+            raise
+
+        return app_transport
+
+    @cython.iterable_coroutine
+    async def create_server(self, protocol_factory, host=None, port=None,
+                            *,
+                            int family=uv.AF_UNSPEC,
+                            int flags=uv.AI_PASSIVE,
+                            sock=None,
+                            backlog=100,
+                            ssl=None,
+                            reuse_address=None,
+                            reuse_port=None,
+                            ssl_handshake_timeout=None,
+                            ssl_shutdown_timeout=None,
+                            start_serving=True):
+        """A coroutine which creates a TCP server bound to host and port.
+
+        The return value is a Server object which can be used to stop
+        the service.
+
+        If host is an empty string or None all interfaces are assumed
+        and a list of multiple sockets will be returned (most likely
+        one for IPv4 and another one for IPv6). The host parameter can also be
+        a sequence (e.g. list) of hosts to bind to.
+
+        family can be set to either AF_INET or AF_INET6 to force the
+        socket to use IPv4 or IPv6. If not set it will be determined
+        from host (defaults to AF_UNSPEC).
+
+        flags is a bitmask for getaddrinfo().
+
+        sock can optionally be specified in order to use a preexisting
+        socket object.
+
+        backlog is the maximum number of queued connections passed to
+        listen() (defaults to 100).
+
+        ssl can be set to an SSLContext to enable SSL over the
+        accepted connections.
+
+        reuse_address tells the kernel to reuse a local socket in
+        TIME_WAIT state, without waiting for its natural timeout to
+        expire. If not specified will automatically be set to True on
+        UNIX.
+
+        reuse_port tells the kernel to allow this endpoint to be bound to
+        the same port as other existing endpoints are bound to, so long as
+        they all set this flag when being created. This option is not
+        supported on Windows.
+
+        ssl_handshake_timeout is the time in seconds that an SSL server
+        will wait for completion of the SSL handshake before aborting the
+        connection. Default is 60s.
+
+        ssl_shutdown_timeout is the time in seconds that an SSL server
+        will wait for completion of the SSL shutdown before aborting the
+        connection. Default is 30s.
+        """
+        cdef:
+            TCPServer tcp
+            system.addrinfo *addrinfo
+            Server server
+
+        if sock is not None and sock.family == uv.AF_UNIX:
+            if host is not None or port is not None:
+                raise ValueError(
+                    'host/port and sock can not be specified at the same time')
+            return await self.create_unix_server(
+                protocol_factory, sock=sock, backlog=backlog, ssl=ssl,
+                start_serving=start_serving)
+
+        server = Server(self)
+
+        if ssl is not None:
+            if not isinstance(ssl, ssl_SSLContext):
+                raise TypeError('ssl argument must be an SSLContext or None')
+        else:
+            if ssl_handshake_timeout is not None:
+                raise ValueError(
+                    'ssl_handshake_timeout is only meaningful with ssl')
+            if ssl_shutdown_timeout is not None:
+                raise ValueError(
+                    'ssl_shutdown_timeout is only meaningful with ssl')
+
+        if host is not None or port is not None:
+            if sock is not None:
+                raise ValueError(
+                    'host/port and sock can not be specified at the same time')
+
+            if reuse_address is None:
+                reuse_address = os_name == 'posix' and sys_platform != 'cygwin'
+            reuse_port = bool(reuse_port)
+            if reuse_port and not has_SO_REUSEPORT:
+                raise ValueError(
+                    'reuse_port not supported by socket module')
+
+            if host == '':
+                hosts = [None]
+            elif (isinstance(host, str) or not isinstance(host, col_Iterable)):
+                hosts = [host]
+            else:
+                hosts = host
+
+            fs = [self._getaddrinfo(host, port, family,
+                                    uv.SOCK_STREAM, 0, flags,
+                                    0) for host in hosts]
+
+            infos = await aio_gather(*fs)
+
+            completed = False
+            sock = None
+            try:
+                for info in infos:
+                    addrinfo = (<AddrInfo>info).data
+                    while addrinfo != NULL:
+                        if addrinfo.ai_family == uv.AF_UNSPEC:
+                            raise RuntimeError('AF_UNSPEC in DNS results')
+
+                        try:
+                            sock = socket_socket(addrinfo.ai_family,
+                                                 addrinfo.ai_socktype,
+                                                 addrinfo.ai_protocol)
+                        except socket_error:
+                            # Assume it's a bad family/type/protocol
+                            # combination.
+                            if self._debug:
+                                aio_logger.warning(
+                                    'create_server() failed to create '
+                                    'socket.socket(%r, %r, %r)',
+                                    addrinfo.ai_family,
+                                    addrinfo.ai_socktype,
+                                    addrinfo.ai_protocol, exc_info=True)
+                            addrinfo = addrinfo.ai_next
+                            continue
+
+                        if reuse_address:
+                            sock.setsockopt(uv.SOL_SOCKET, uv.SO_REUSEADDR, 1)
+                        if reuse_port:
+                            sock.setsockopt(uv.SOL_SOCKET, uv.SO_REUSEPORT, 1)
+                        # Disable IPv4/IPv6 dual stack support (enabled by
+                        # default on Linux) which makes a single socket
+                        # listen on both address families.
+                        if (addrinfo.ai_family == uv.AF_INET6 and
+                                has_IPV6_V6ONLY):
+                            sock.setsockopt(uv.IPPROTO_IPV6, IPV6_V6ONLY, 1)
+
+                        pyaddr = __convert_sockaddr_to_pyaddr(addrinfo.ai_addr)
+                        try:
+                            sock.bind(pyaddr)
+                        except OSError as err:
+                            raise OSError(
+                                err.errno, 'error while attempting '
+                                'to bind on address %r: %s'
+                                % (pyaddr, err.strerror.lower())) from None
+
+                        tcp = TCPServer.new(self, protocol_factory, server,
+                                            uv.AF_UNSPEC, backlog,
+                                            ssl, ssl_handshake_timeout,
+                                            ssl_shutdown_timeout)
+
+                        try:
+                            tcp._open(sock.fileno())
+                        except (KeyboardInterrupt, SystemExit):
+                            raise
+                        except BaseException:
+                            tcp._close()
+                            raise
+
+                        server._add_server(tcp)
+                        sock.detach()
+                        sock = None
+
+                        addrinfo = addrinfo.ai_next
+
+                completed = True
+            finally:
+                if not completed:
+                    if sock is not None:
+                        sock.close()
+                    server.close()
+        else:
+            if sock is None:
+                raise ValueError('Neither host/port nor sock were specified')
+            if not _is_sock_stream(sock.type):
+                raise ValueError(
+                    'A Stream Socket was expected, got {!r}'.format(sock))
+
+            # libuv will set the socket to non-blocking mode, but
+            # we want Python socket object to notice that.
+            sock.setblocking(False)
+
+            tcp = TCPServer.new(self, protocol_factory, server,
+                                uv.AF_UNSPEC, backlog,
+                                ssl, ssl_handshake_timeout,
+                                ssl_shutdown_timeout)
+
+            try:
+                tcp._open(sock.fileno())
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                tcp._close()
+                raise
+
+            tcp._attach_fileobj(sock)
+            server._add_server(tcp)
+
+        if start_serving:
+            server._start_serving()
+
+        server._ref()
+        return server
+
+    @cython.iterable_coroutine
+    async def create_connection(self, protocol_factory, host=None, port=None,
+                                *,
+                                ssl=None,
+                                family=0, proto=0, flags=0, sock=None,
+                                local_addr=None, server_hostname=None,
+                                ssl_handshake_timeout=None,
+                                ssl_shutdown_timeout=None):
+        """Connect to a TCP server.
+
+        Create a streaming transport connection to a given Internet host and
+        port: socket family AF_INET or socket.AF_INET6 depending on host (or
+        family if specified), socket type SOCK_STREAM. protocol_factory must be
+        a callable returning a protocol instance.
+
+        This method is a coroutine which will try to establish the connection
+        in the background.  When successful, the coroutine returns a
+        (transport, protocol) pair.
+        """
+        cdef:
+            AddrInfo ai_local = None
+            AddrInfo ai_remote
+            TCPTransport tr
+
+            system.addrinfo *rai = NULL
+            system.addrinfo *lai = NULL
+
+            system.addrinfo *rai_iter = NULL
+            system.addrinfo *lai_iter = NULL
+
+            system.addrinfo rai_static
+            system.sockaddr_storage rai_addr_static
+            system.addrinfo lai_static
+            system.sockaddr_storage lai_addr_static
+
+            object app_protocol
+            object app_transport
+            object protocol
+            object ssl_waiter
+
+        if sock is not None and sock.family == uv.AF_UNIX:
+            if host is not None or port is not None:
+                raise ValueError(
+                    'host/port and sock can not be specified at the same time')
+            return await self.create_unix_connection(
+                protocol_factory, None,
+                sock=sock, ssl=ssl, server_hostname=server_hostname)
+
+        app_protocol = protocol = protocol_factory()
+        ssl_waiter = None
+        context = Context_CopyCurrent()
+        if ssl:
+            if server_hostname is None:
+                if not host:
+                    raise ValueError('You must set server_hostname '
+                                     'when using ssl without a host')
+                server_hostname = host
+
+            ssl_waiter = self._new_future()
+            sslcontext = None if isinstance(ssl, bool) else ssl
+            protocol = SSLProtocol(
+                self, app_protocol, sslcontext, ssl_waiter,
+                False, server_hostname,
+                ssl_handshake_timeout=ssl_handshake_timeout,
+                ssl_shutdown_timeout=ssl_shutdown_timeout)
+        else:
+            if server_hostname is not None:
+                raise ValueError('server_hostname is only meaningful with ssl')
+            if ssl_handshake_timeout is not None:
+                raise ValueError(
+                    'ssl_handshake_timeout is only meaningful with ssl')
+            if ssl_shutdown_timeout is not None:
+                raise ValueError(
+                    'ssl_shutdown_timeout is only meaningful with ssl')
+
+        if host is not None or port is not None:
+            if sock is not None:
+                raise ValueError(
+                    'host/port and sock can not be specified at the same time')
+
+            fs = []
+            f1 = f2 = None
+
+            addr = __static_getaddrinfo(
+                host, port, family, uv.SOCK_STREAM,
+                proto, <system.sockaddr*>&rai_addr_static)
+
+            if addr is None:
+                f1 = self._getaddrinfo(
+                    host, port, family,
+                    uv.SOCK_STREAM, proto, flags,
+                    0)  # 0 == don't unpack
+
+                fs.append(f1)
+            else:
+                rai_static.ai_addr = <system.sockaddr*>&rai_addr_static
+                rai_static.ai_next = NULL
+                rai = &rai_static
+
+            if local_addr is not None:
+                if not isinstance(local_addr, (tuple, list)) or \
+                        len(local_addr) != 2:
+                    raise ValueError(
+                        'local_addr must be a tuple of host and port')
+
+                addr = __static_getaddrinfo(
+                    local_addr[0], local_addr[1],
+                    family, uv.SOCK_STREAM,
+                    proto, <system.sockaddr*>&lai_addr_static)
+                if addr is None:
+                    f2 = self._getaddrinfo(
+                        local_addr[0], local_addr[1], family,
+                        uv.SOCK_STREAM, proto, flags,
+                        0)  # 0 == don't unpack
+
+                    fs.append(f2)
+                else:
+                    lai_static.ai_addr = <system.sockaddr*>&lai_addr_static
+                    lai_static.ai_next = NULL
+                    lai = &lai_static
+
+            if len(fs):
+                await aio_wait(fs)
+
+            if rai is NULL:
+                ai_remote = f1.result()
+                if ai_remote.data is NULL:
+                    raise OSError('getaddrinfo() returned empty list')
+                rai = ai_remote.data
+
+            if lai is NULL and f2 is not None:
+                ai_local = f2.result()
+                if ai_local.data is NULL:
+                    raise OSError(
+                        'getaddrinfo() returned empty list for local_addr')
+                lai = ai_local.data
+
+            exceptions = []
+            rai_iter = rai
+            while rai_iter is not NULL:
+                tr = None
+                try:
+                    waiter = self._new_future()
+                    tr = TCPTransport.new(self, protocol, None, waiter,
+                                          context)
+
+                    if lai is not NULL:
+                        lai_iter = lai
+                        while lai_iter is not NULL:
+                            try:
+                                tr.bind(lai_iter.ai_addr)
+                                break
+                            except OSError as exc:
+                                exceptions.append(exc)
+                            lai_iter = lai_iter.ai_next
+                        else:
+                            tr._close()
+                            tr = None
+
+                            rai_iter = rai_iter.ai_next
+                            continue
+
+                    tr.connect(rai_iter.ai_addr)
+                    await waiter
+
+                except OSError as exc:
+                    if tr is not None:
+                        tr._close()
+                        tr = None
+                    exceptions.append(exc)
+                except (KeyboardInterrupt, SystemExit):
+                    raise
+                except BaseException:
+                    if tr is not None:
+                        tr._close()
+                        tr = None
+                    raise
+                else:
+                    break
+
+                rai_iter = rai_iter.ai_next
+
+            else:
+                # If they all have the same str(), raise one.
+                model = str(exceptions[0])
+                if all(str(exc) == model for exc in exceptions):
+                    raise exceptions[0]
+                # Raise a combined exception so the user can see all
+                # the various error messages.
+                raise OSError('Multiple exceptions: {}'.format(
+                    ', '.join(str(exc) for exc in exceptions)))
+        else:
+            if sock is None:
+                raise ValueError(
+                    'host and port was not specified and no sock specified')
+            if not _is_sock_stream(sock.type):
+                raise ValueError(
+                    'A Stream Socket was expected, got {!r}'.format(sock))
+
+            # libuv will set the socket to non-blocking mode, but
+            # we want Python socket object to notice that.
+            sock.setblocking(False)
+
+            waiter = self._new_future()
+            tr = TCPTransport.new(self, protocol, None, waiter, context)
+            try:
+                # libuv will make socket non-blocking
+                tr._open(sock.fileno())
+                tr._init_protocol()
+                await waiter
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                # It's OK to call `_close()` here, as opposed to
+                # `_force_close()` or `close()` as we want to terminate the
+                # transport immediately.  The `waiter` can only be waken
+                # up in `Transport._call_connection_made()`, and calling
+                # `_close()` before it is fine.
+                tr._close()
+                raise
+
+            tr._attach_fileobj(sock)
+
+        if ssl:
+            app_transport = protocol._get_app_transport(context)
+            try:
+                await ssl_waiter
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                app_transport.close()
+                raise
+            return app_transport, app_protocol
+        else:
+            return tr, protocol
+
+    @cython.iterable_coroutine
+    async def create_unix_server(self, protocol_factory, path=None,
+                                 *, backlog=100, sock=None, ssl=None,
+                                 ssl_handshake_timeout=None,
+                                 ssl_shutdown_timeout=None,
+                                 start_serving=True):
+        """A coroutine which creates a UNIX Domain Socket server.
+
+        The return value is a Server object, which can be used to stop
+        the service.
+
+        path is a str, representing a file systsem path to bind the
+        server socket to.
+
+        sock can optionally be specified in order to use a preexisting
+        socket object.
+
+        backlog is the maximum number of queued connections passed to
+        listen() (defaults to 100).
+
+        ssl can be set to an SSLContext to enable SSL over the
+        accepted connections.
+
+        ssl_handshake_timeout is the time in seconds that an SSL server
+        will wait for completion of the SSL handshake before aborting the
+        connection. Default is 60s.
+
+        ssl_shutdown_timeout is the time in seconds that an SSL server
+        will wait for completion of the SSL shutdown before aborting the
+        connection. Default is 30s.
+        """
+        cdef:
+            UnixServer pipe
+            Server server = Server(self)
+
+        if ssl is not None:
+            if not isinstance(ssl, ssl_SSLContext):
+                raise TypeError('ssl argument must be an SSLContext or None')
+        else:
+            if ssl_handshake_timeout is not None:
+                raise ValueError(
+                    'ssl_handshake_timeout is only meaningful with ssl')
+            if ssl_shutdown_timeout is not None:
+                raise ValueError(
+                    'ssl_shutdown_timeout is only meaningful with ssl')
+
+        if path is not None:
+            if sock is not None:
+                raise ValueError(
+                    'path and sock can not be specified at the same time')
+            orig_path = path
+
+            path = os_fspath(path)
+
+            if isinstance(path, str):
+                path = PyUnicode_EncodeFSDefault(path)
+
+            # Check for abstract socket.
+            if path[0] != 0:
+                try:
+                    if stat_S_ISSOCK(os_stat(path).st_mode):
+                        os_remove(path)
+                except FileNotFoundError:
+                    pass
+                except OSError as err:
+                    # Directory may have permissions only to create socket.
+                    aio_logger.error(
+                        'Unable to check or remove stale UNIX socket %r: %r',
+                        orig_path, err)
+
+            # We use Python sockets to create a UNIX server socket because
+            # when UNIX sockets are created by libuv, libuv removes the path
+            # they were bound to.  This is different from asyncio, which
+            # doesn't cleanup the socket path.
+            sock = socket_socket(uv.AF_UNIX)
+
+            try:
+                sock.bind(path)
+            except OSError as exc:
+                sock.close()
+                if exc.errno == errno.EADDRINUSE:
+                    # Let's improve the error message by adding
+                    # with what exact address it occurs.
+                    msg = 'Address {!r} is already in use'.format(orig_path)
+                    raise OSError(errno.EADDRINUSE, msg) from None
+                else:
+                    raise
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                sock.close()
+                raise
+
+        else:
+            if sock is None:
+                raise ValueError(
+                    'path was not specified, and no sock specified')
+
+            if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):
+                raise ValueError(
+                    'A UNIX Domain Stream Socket was expected, got {!r}'
+                    .format(sock))
+
+            # libuv will set the socket to non-blocking mode, but
+            # we want Python socket object to notice that.
+            sock.setblocking(False)
+
+        pipe = UnixServer.new(
+            self, protocol_factory, server, backlog,
+            ssl, ssl_handshake_timeout, ssl_shutdown_timeout)
+
+        try:
+            pipe._open(sock.fileno())
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException:
+            pipe._close()
+            sock.close()
+            raise
+
+        pipe._attach_fileobj(sock)
+        server._add_server(pipe)
+
+        if start_serving:
+            server._start_serving()
+
+        return server
+
+    @cython.iterable_coroutine
+    async def create_unix_connection(self, protocol_factory, path=None, *,
+                                     ssl=None, sock=None,
+                                     server_hostname=None,
+                                     ssl_handshake_timeout=None,
+                                     ssl_shutdown_timeout=None):
+
+        cdef:
+            UnixTransport tr
+            object app_protocol
+            object app_transport
+            object protocol
+            object ssl_waiter
+
+        app_protocol = protocol = protocol_factory()
+        ssl_waiter = None
+        context = Context_CopyCurrent()
+        if ssl:
+            if server_hostname is None:
+                raise ValueError('You must set server_hostname '
+                                 'when using ssl without a host')
+
+            ssl_waiter = self._new_future()
+            sslcontext = None if isinstance(ssl, bool) else ssl
+            protocol = SSLProtocol(
+                self, app_protocol, sslcontext, ssl_waiter,
+                False, server_hostname,
+                ssl_handshake_timeout=ssl_handshake_timeout,
+                ssl_shutdown_timeout=ssl_shutdown_timeout)
+        else:
+            if server_hostname is not None:
+                raise ValueError('server_hostname is only meaningful with ssl')
+            if ssl_handshake_timeout is not None:
+                raise ValueError(
+                    'ssl_handshake_timeout is only meaningful with ssl')
+            if ssl_shutdown_timeout is not None:
+                raise ValueError(
+                    'ssl_shutdown_timeout is only meaningful with ssl')
+
+        if path is not None:
+            if sock is not None:
+                raise ValueError(
+                    'path and sock can not be specified at the same time')
+
+            path = os_fspath(path)
+
+            if isinstance(path, str):
+                path = PyUnicode_EncodeFSDefault(path)
+
+            waiter = self._new_future()
+            tr = UnixTransport.new(self, protocol, None, waiter, context)
+            tr.connect(path)
+            try:
+                await waiter
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                tr._close()
+                raise
+
+        else:
+            if sock is None:
+                raise ValueError('no path and sock were specified')
+
+            if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):
+                raise ValueError(
+                    'A UNIX Domain Stream Socket was expected, got {!r}'
+                    .format(sock))
+
+            # libuv will set the socket to non-blocking mode, but
+            # we want Python socket object to notice that.
+            sock.setblocking(False)
+
+            waiter = self._new_future()
+            tr = UnixTransport.new(self, protocol, None, waiter, context)
+            try:
+                tr._open(sock.fileno())
+                tr._init_protocol()
+                await waiter
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                tr._close()
+                raise
+
+            tr._attach_fileobj(sock)
+
+        if ssl:
+            app_transport = protocol._get_app_transport(Context_CopyCurrent())
+            try:
+                await ssl_waiter
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                app_transport.close()
+                raise
+            return app_transport, app_protocol
+        else:
+            return tr, protocol
+
+    def default_exception_handler(self, context):
+        """Default exception handler.
+
+        This is called when an exception occurs and no exception
+        handler is set, and can be called by a custom exception
+        handler that wants to defer to the default behavior.
+
+        The context parameter has the same meaning as in
+        `call_exception_handler()`.
+        """
+        message = context.get('message')
+        if not message:
+            message = 'Unhandled exception in event loop'
+
+        exception = context.get('exception')
+        if exception is not None:
+            exc_info = (type(exception), exception, exception.__traceback__)
+        else:
+            exc_info = False
+
+        log_lines = [message]
+        for key in sorted(context):
+            if key in {'message', 'exception'}:
+                continue
+            value = context[key]
+            if key == 'source_traceback':
+                tb = ''.join(tb_format_list(value))
+                value = 'Object created at (most recent call last):\n'
+                value += tb.rstrip()
+            else:
+                try:
+                    value = repr(value)
+                except (KeyboardInterrupt, SystemExit):
+                    raise
+                except BaseException as ex:
+                    value = ('Exception in __repr__ {!r}; '
+                             'value type: {!r}'.format(ex, type(value)))
+            log_lines.append('{}: {}'.format(key, value))
+
+        aio_logger.error('\n'.join(log_lines), exc_info=exc_info)
+
+    def get_exception_handler(self):
+        """Return an exception handler, or None if the default one is in use.
+        """
+        return self._exception_handler
+
+    def set_exception_handler(self, handler):
+        """Set handler as the new event loop exception handler.
+
+        If handler is None, the default exception handler will
+        be set.
+
+        If handler is a callable object, it should have a
+        signature matching '(loop, context)', where 'loop'
+        will be a reference to the active event loop, 'context'
+        will be a dict object (see `call_exception_handler()`
+        documentation for details about context).
+        """
+        if handler is not None and not callable(handler):
+            raise TypeError('A callable object or None is expected, '
+                            'got {!r}'.format(handler))
+        self._exception_handler = handler
+
+    def call_exception_handler(self, context):
+        """Call the current event loop's exception handler.
+
+        The context argument is a dict containing the following keys:
+
+        - 'message': Error message;
+        - 'exception' (optional): Exception object;
+        - 'future' (optional): Future instance;
+        - 'handle' (optional): Handle instance;
+        - 'protocol' (optional): Protocol instance;
+        - 'transport' (optional): Transport instance;
+        - 'socket' (optional): Socket instance.
+
+        New keys maybe introduced in the future.
+
+        Note: do not overload this method in an event loop subclass.
+        For custom exception handling, use the
+        `set_exception_handler()` method.
+        """
+        if UVLOOP_DEBUG:
+            self._debug_exception_handler_cnt += 1
+
+        if self._exception_handler is None:
+            try:
+                self.default_exception_handler(context)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                # Second protection layer for unexpected errors
+                # in the default implementation, as well as for subclassed
+                # event loops with overloaded "default_exception_handler".
+                aio_logger.error('Exception in default exception handler',
+                                 exc_info=True)
+        else:
+            try:
+                self._exception_handler(self, context)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException as exc:
+                # Exception in the user set custom exception handler.
+                try:
+                    # Let's try default handler.
+                    self.default_exception_handler({
+                        'message': 'Unhandled error in exception handler',
+                        'exception': exc,
+                        'context': context,
+                    })
+                except (KeyboardInterrupt, SystemExit):
+                    raise
+                except BaseException:
+                    # Guard 'default_exception_handler' in case it is
+                    # overloaded.
+                    aio_logger.error('Exception in default exception handler '
+                                     'while handling an unexpected error '
+                                     'in custom exception handler',
+                                     exc_info=True)
+
+    def add_reader(self, fileobj, callback, *args):
+        """Add a reader callback."""
+        if len(args) == 0:
+            args = None
+        self._add_reader(fileobj, new_Handle(self, callback, args, None))
+
+    def remove_reader(self, fileobj):
+        """Remove a reader callback."""
+        self._remove_reader(fileobj)
+
+    def add_writer(self, fileobj, callback, *args):
+        """Add a writer callback.."""
+        if len(args) == 0:
+            args = None
+        self._add_writer(fileobj, new_Handle(self, callback, args, None))
+
+    def remove_writer(self, fileobj):
+        """Remove a writer callback."""
+        self._remove_writer(fileobj)
+
+    @cython.iterable_coroutine
+    async def sock_recv(self, sock, n):
+        """Receive data from the socket.
+
+        The return value is a bytes object representing the data received.
+        The maximum amount of data to be received at once is specified by
+        nbytes.
+
+        This method is a coroutine.
+        """
+        cdef:
+            Handle handle
+
+        if self._debug and sock.gettimeout() != 0:
+            raise ValueError("the socket must be non-blocking")
+
+        fut = _SyncSocketReaderFuture(sock, self)
+        handle = new_MethodHandle3(
+            self,
+            "Loop._sock_recv",
+            <method3_t>self._sock_recv,
+            None,
+            self,
+            fut, sock, n)
+
+        self._add_reader(sock, handle)
+        return await fut
+
+    @cython.iterable_coroutine
+    async def sock_recv_into(self, sock, buf):
+        """Receive data from the socket.
+
+        The received data is written into *buf* (a writable buffer).
+        The return value is the number of bytes written.
+
+        This method is a coroutine.
+        """
+        cdef:
+            Handle handle
+
+        if self._debug and sock.gettimeout() != 0:
+            raise ValueError("the socket must be non-blocking")
+
+        fut = _SyncSocketReaderFuture(sock, self)
+        handle = new_MethodHandle3(
+            self,
+            "Loop._sock_recv_into",
+            <method3_t>self._sock_recv_into,
+            None,
+            self,
+            fut, sock, buf)
+
+        self._add_reader(sock, handle)
+        return await fut
+
+    @cython.iterable_coroutine
+    async def sock_sendall(self, sock, data):
+        """Send data to the socket.
+
+        The socket must be connected to a remote socket. This method continues
+        to send data from data until either all data has been sent or an
+        error occurs. None is returned on success. On error, an exception is
+        raised, and there is no way to determine how much data, if any, was
+        successfully processed by the receiving end of the connection.
+
+        This method is a coroutine.
+        """
+        cdef:
+            Handle handle
+            ssize_t n
+
+        if self._debug and sock.gettimeout() != 0:
+            raise ValueError("the socket must be non-blocking")
+
+        if not data:
+            return
+
+        socket_inc_io_ref(sock)
+        try:
+            try:
+                n = sock.send(data)
+            except (BlockingIOError, InterruptedError):
+                pass
+            else:
+                if UVLOOP_DEBUG:
+                    # This can be a partial success, i.e. only part
+                    # of the data was sent
+                    self._sock_try_write_total += 1
+
+                if n == len(data):
+                    return
+                if not isinstance(data, memoryview):
+                    data = memoryview(data)
+                data = data[n:]
+
+            fut = _SyncSocketWriterFuture(sock, self)
+            handle = new_MethodHandle3(
+                self,
+                "Loop._sock_sendall",
+                <method3_t>self._sock_sendall,
+                None,
+                self,
+                fut, sock, data)
+
+            self._add_writer(sock, handle)
+            return await fut
+        finally:
+            socket_dec_io_ref(sock)
+
+    @cython.iterable_coroutine
+    async def sock_accept(self, sock):
+        """Accept a connection.
+
+        The socket must be bound to an address and listening for connections.
+        The return value is a pair (conn, address) where conn is a new socket
+        object usable to send and receive data on the connection, and address
+        is the address bound to the socket on the other end of the connection.
+
+        This method is a coroutine.
+        """
+        cdef:
+            Handle handle
+
+        if self._debug and sock.gettimeout() != 0:
+            raise ValueError("the socket must be non-blocking")
+
+        fut = _SyncSocketReaderFuture(sock, self)
+        handle = new_MethodHandle2(
+            self,
+            "Loop._sock_accept",
+            <method2_t>self._sock_accept,
+            None,
+            self,
+            fut, sock)
+
+        self._add_reader(sock, handle)
+        return await fut
+
+    @cython.iterable_coroutine
+    async def sock_connect(self, sock, address):
+        """Connect to a remote socket at address.
+
+        This method is a coroutine.
+        """
+        if self._debug and sock.gettimeout() != 0:
+            raise ValueError("the socket must be non-blocking")
+
+        socket_inc_io_ref(sock)
+        try:
+            if sock.family == uv.AF_UNIX:
+                fut = self._sock_connect(sock, address)
+            else:
+                addrs = await self.getaddrinfo(
+                    *address[:2], family=sock.family)
+
+                _, _, _, _, address = addrs[0]
+                fut = self._sock_connect(sock, address)
+            if fut is not None:
+                await fut
+        finally:
+            socket_dec_io_ref(sock)
+
+    @cython.iterable_coroutine
+    async def sock_recvfrom(self, sock, bufsize):
+        raise NotImplementedError
+
+    @cython.iterable_coroutine
+    async def sock_recvfrom_into(self, sock, buf, nbytes=0):
+        raise NotImplementedError
+
+    @cython.iterable_coroutine
+    async def sock_sendto(self, sock, data, address):
+        raise NotImplementedError
+
+    @cython.iterable_coroutine
+    async def connect_accepted_socket(self, protocol_factory, sock, *,
+                                      ssl=None,
+                                      ssl_handshake_timeout=None,
+                                      ssl_shutdown_timeout=None):
+        """Handle an accepted connection.
+
+        This is used by servers that accept connections outside of
+        asyncio but that use asyncio to handle connections.
+
+        This method is a coroutine.  When completed, the coroutine
+        returns a (transport, protocol) pair.
+        """
+
+        cdef:
+            UVStream transport = None
+
+        if ssl is not None:
+            if not isinstance(ssl, ssl_SSLContext):
+                raise TypeError('ssl argument must be an SSLContext or None')
+        else:
+            if ssl_handshake_timeout is not None:
+                raise ValueError(
+                    'ssl_handshake_timeout is only meaningful with ssl')
+            if ssl_shutdown_timeout is not None:
+                raise ValueError(
+                    'ssl_shutdown_timeout is only meaningful with ssl')
+
+        if not _is_sock_stream(sock.type):
+            raise ValueError(
+                'A Stream Socket was expected, got {!r}'.format(sock))
+
+        app_protocol = protocol_factory()
+        waiter = self._new_future()
+        transport_waiter = None
+        context = Context_CopyCurrent()
+
+        if ssl is None:
+            protocol = app_protocol
+            transport_waiter = waiter
+        else:
+            protocol = SSLProtocol(
+                self, app_protocol, ssl, waiter,
+                server_side=True,
+                server_hostname=None,
+                ssl_handshake_timeout=ssl_handshake_timeout,
+                ssl_shutdown_timeout=ssl_shutdown_timeout)
+            transport_waiter = None
+
+        if sock.family == uv.AF_UNIX:
+            transport = <UVStream>UnixTransport.new(
+                self, protocol, None, transport_waiter, context)
+        elif sock.family in (uv.AF_INET, uv.AF_INET6):
+            transport = <UVStream>TCPTransport.new(
+                self, protocol, None, transport_waiter, context)
+
+        if transport is None:
+            raise ValueError(
+                'invalid socket family, expected AF_UNIX, AF_INET or AF_INET6')
+
+        transport._open(sock.fileno())
+        transport._init_protocol()
+        transport._attach_fileobj(sock)
+
+        if ssl:
+            app_transport = protocol._get_app_transport(context)
+            try:
+                await waiter
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                app_transport.close()
+                raise
+            return app_transport, protocol
+        else:
+            try:
+                await waiter
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException:
+                transport._close()
+                raise
+            return transport, protocol
+
+    def run_in_executor(self, executor, func, *args):
+        if aio_iscoroutine(func) or aio_iscoroutinefunction(func):
+            raise TypeError("coroutines cannot be used with run_in_executor()")
+
+        self._check_closed()
+
+        if executor is None:
+            executor = self._default_executor
+            # Only check when the default executor is being used
+            self._check_default_executor()
+            if executor is None:
+                executor = cc_ThreadPoolExecutor()
+                self._default_executor = executor
+
+        return aio_wrap_future(executor.submit(func, *args), loop=self)
+
+    def set_default_executor(self, executor):
+        self._default_executor = executor
+
+    @cython.iterable_coroutine
+    async def __subprocess_run(self, protocol_factory, args,
+                               stdin=subprocess_PIPE,
+                               stdout=subprocess_PIPE,
+                               stderr=subprocess_PIPE,
+                               universal_newlines=False,
+                               shell=True,
+                               bufsize=0,
+                               preexec_fn=None,
+                               close_fds=None,
+                               cwd=None,
+                               env=None,
+                               startupinfo=None,
+                               creationflags=0,
+                               restore_signals=True,
+                               start_new_session=False,
+                               executable=None,
+                               pass_fds=(),
+                               # For tests only! Do not use in your code. Ever.
+                               __uvloop_sleep_after_fork=False):
+
+        # TODO: Implement close_fds (might not be very important in
+        # Python 3.5, since all FDs aren't inheritable by default.)
+
+        cdef:
+            int debug_flags = 0
+
+        if universal_newlines:
+            raise ValueError("universal_newlines must be False")
+        if bufsize != 0:
+            raise ValueError("bufsize must be 0")
+        if startupinfo is not None:
+            raise ValueError('startupinfo is not supported')
+        if creationflags != 0:
+            raise ValueError('creationflags is not supported')
+
+        if executable is not None:
+            args[0] = executable
+
+        if __uvloop_sleep_after_fork:
+            debug_flags |= __PROCESS_DEBUG_SLEEP_AFTER_FORK
+
+        waiter = self._new_future()
+        protocol = protocol_factory()
+        proc = UVProcessTransport.new(self, protocol,
+                                      args, env, cwd, start_new_session,
+                                      stdin, stdout, stderr, pass_fds,
+                                      waiter,
+                                      debug_flags,
+                                      preexec_fn,
+                                      restore_signals)
+
+        try:
+            await waiter
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException:
+            proc.close()
+            raise
+
+        return proc, protocol
+
+    @cython.iterable_coroutine
+    async def subprocess_shell(self, protocol_factory, cmd, *,
+                               shell=True,
+                               **kwargs):
+
+        if not shell:
+            raise ValueError("shell must be True")
+
+        args = [cmd]
+        if shell:
+            args = [b'/bin/sh', b'-c'] + args
+
+        return await self.__subprocess_run(protocol_factory, args, shell=True,
+                                           **kwargs)
+
+    @cython.iterable_coroutine
+    async def subprocess_exec(self, protocol_factory, program, *args,
+                              shell=False, **kwargs):
+
+        if shell:
+            raise ValueError("shell must be False")
+
+        args = list((program,) + args)
+
+        return await self.__subprocess_run(protocol_factory, args, shell=False,
+                                           **kwargs)
+
+    @cython.iterable_coroutine
+    async def connect_read_pipe(self, proto_factory, pipe):
+        """Register read pipe in event loop. Set the pipe to non-blocking mode.
+
+        protocol_factory should instantiate object with Protocol interface.
+        pipe is a file-like object.
+        Return pair (transport, protocol), where transport supports the
+        ReadTransport interface."""
+        cdef:
+            ReadUnixTransport transp
+
+        waiter = self._new_future()
+        proto = proto_factory()
+        transp = ReadUnixTransport.new(self, proto, None, waiter)
+        transp._add_extra_info('pipe', pipe)
+        try:
+            transp._open(pipe.fileno())
+            transp._init_protocol()
+            await waiter
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException:
+            transp._close()
+            raise
+        transp._attach_fileobj(pipe)
+        return transp, proto
+
+    @cython.iterable_coroutine
+    async def connect_write_pipe(self, proto_factory, pipe):
+        """Register write pipe in event loop.
+
+        protocol_factory should instantiate object with BaseProtocol interface.
+        Pipe is file-like object already switched to nonblocking.
+        Return pair (transport, protocol), where transport support
+        WriteTransport interface."""
+        cdef:
+            WriteUnixTransport transp
+
+        waiter = self._new_future()
+        proto = proto_factory()
+        transp = WriteUnixTransport.new(self, proto, None, waiter)
+        transp._add_extra_info('pipe', pipe)
+        try:
+            transp._open(pipe.fileno())
+            transp._init_protocol()
+            await waiter
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except BaseException:
+            transp._close()
+            raise
+        transp._attach_fileobj(pipe)
+        return transp, proto
+
+    def add_signal_handler(self, sig, callback, *args):
+        """Add a handler for a signal.  UNIX only.
+
+        Raise ValueError if the signal number is invalid or uncatchable.
+        Raise RuntimeError if there is a problem setting up the handler.
+        """
+        cdef:
+            Handle h
+
+        if not self._is_main_thread():
+            raise ValueError(
+                'add_signal_handler() can only be called from '
+                'the main thread')
+
+        if (aio_iscoroutine(callback)
+                or aio_iscoroutinefunction(callback)):
+            raise TypeError(
+                "coroutines cannot be used with add_signal_handler()")
+
+        if sig == uv.SIGCHLD:
+            if (hasattr(callback, '__self__') and
+                    isinstance(callback.__self__, aio_AbstractChildWatcher)):
+
+                warnings_warn(
+                    "!!! asyncio is trying to install its ChildWatcher for "
+                    "SIGCHLD signal !!!\n\nThis is probably because a uvloop "
+                    "instance is used with asyncio.set_event_loop(). "
+                    "The correct way to use uvloop is to install its policy: "
+                    "`asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())`"
+                    "\n\n", RuntimeWarning, source=self)
+
+                # TODO: ideally we should always raise an error here,
+                # but that would be a backwards incompatible change,
+                # because we recommended using "asyncio.set_event_loop()"
+                # in our README.  Need to start a deprecation period
+                # at some point to turn this warning into an error.
+                return
+
+            raise RuntimeError(
+                'cannot add a signal handler for SIGCHLD: it is used '
+                'by the event loop to track subprocesses')
+
+        self._check_signal(sig)
+        self._check_closed()
+
+        h = new_Handle(self, callback, args or None, None)
+        self._signal_handlers[sig] = h
+
+        try:
+            # Register a dummy signal handler to ask Python to write the signal
+            # number in the wakeup file descriptor.
+            signal_signal(sig, self.__sighandler)
+
+            # Set SA_RESTART to limit EINTR occurrences.
+            signal_siginterrupt(sig, False)
+        except OSError as exc:
+            del self._signal_handlers[sig]
+            if not self._signal_handlers:
+                try:
+                    signal_set_wakeup_fd(-1)
+                except (ValueError, OSError) as nexc:
+                    aio_logger.info('set_wakeup_fd(-1) failed: %s', nexc)
+
+            if exc.errno == errno_EINVAL:
+                raise RuntimeError('sig {} cannot be caught'.format(sig))
+            else:
+                raise
+
+    def remove_signal_handler(self, sig):
+        """Remove a handler for a signal.  UNIX only.
+
+        Return True if a signal handler was removed, False if not.
+        """
+
+        if not self._is_main_thread():
+            raise ValueError(
+                'remove_signal_handler() can only be called from '
+                'the main thread')
+
+        self._check_signal(sig)
+
+        if not self._listening_signals:
+            return False
+
+        try:
+            del self._signal_handlers[sig]
+        except KeyError:
+            return False
+
+        if sig == uv.SIGINT:
+            handler = signal_default_int_handler
+        else:
+            handler = signal_SIG_DFL
+
+        try:
+            signal_signal(sig, handler)
+        except OSError as exc:
+            if exc.errno == errno_EINVAL:
+                raise RuntimeError('sig {} cannot be caught'.format(sig))
+            else:
+                raise
+
+        return True
+
+    @cython.iterable_coroutine
+    async def create_datagram_endpoint(self, protocol_factory,
+                                       local_addr=None, remote_addr=None, *,
+                                       family=0, proto=0, flags=0,
+                                       reuse_address=_unset, reuse_port=None,
+                                       allow_broadcast=None, sock=None):
+        """A coroutine which creates a datagram endpoint.
+
+        This method will try to establish the endpoint in the background.
+        When successful, the coroutine returns a (transport, protocol) pair.
+
+        protocol_factory must be a callable returning a protocol instance.
+
+        socket family AF_INET or socket.AF_INET6 depending on host (or
+        family if specified), socket type SOCK_DGRAM.
+
+        reuse_port tells the kernel to allow this endpoint to be bound to
+        the same port as other existing endpoints are bound to, so long as
+        they all set this flag when being created. This option is not
+        supported on Windows and some UNIX's. If the
+        :py:data:`~socket.SO_REUSEPORT` constant is not defined then this
+        capability is unsupported.
+
+        allow_broadcast tells the kernel to allow this endpoint to send
+        messages to the broadcast address.
+
+        sock can optionally be specified in order to use a preexisting
+        socket object.
+        """
+        cdef:
+            UDPTransport udp = None
+            system.addrinfo * lai
+            system.addrinfo * rai
+
+        if sock is not None:
+            if not _is_sock_dgram(sock.type):
+                raise ValueError(
+                    'A UDP Socket was expected, got {!r}'.format(sock))
+            if (local_addr or remote_addr or
+                    family or proto or flags or
+                    reuse_port or allow_broadcast):
+                # show the problematic kwargs in exception msg
+                opts = dict(local_addr=local_addr, remote_addr=remote_addr,
+                            family=family, proto=proto, flags=flags,
+                            reuse_address=reuse_address, reuse_port=reuse_port,
+                            allow_broadcast=allow_broadcast)
+                problems = ', '.join(
+                    '{}={}'.format(k, v) for k, v in opts.items() if v)
+                raise ValueError(
+                    'socket modifier keyword arguments can not be used '
+                    'when sock is specified. ({})'.format(problems))
+            sock.setblocking(False)
+            udp = UDPTransport.__new__(UDPTransport)
+            udp._init(self, uv.AF_UNSPEC)
+            udp.open(sock.family, sock.fileno())
+            udp._attach_fileobj(sock)
+        else:
+            if reuse_address is not _unset:
+                if reuse_address:
+                    raise ValueError("Passing `reuse_address=True` is no "
+                                     "longer supported, as the usage of "
+                                     "SO_REUSEPORT in UDP poses a significant "
+                                     "security concern.")
+                else:
+                    warnings_warn("The *reuse_address* parameter has been "
+                                  "deprecated as of 0.15.", DeprecationWarning,
+                                  stacklevel=2)
+            reuse_port = bool(reuse_port)
+            if reuse_port and not has_SO_REUSEPORT:
+                raise ValueError(
+                    'reuse_port not supported by socket module')
+
+            lads = None
+            if local_addr is not None:
+                if (not isinstance(local_addr, (tuple, list)) or
+                        len(local_addr) != 2):
+                    raise TypeError(
+                        'local_addr must be a tuple of (host, port)')
+                lads = await self._getaddrinfo(
+                    local_addr[0], local_addr[1],
+                    family, uv.SOCK_DGRAM, proto, flags,
+                    0)
+
+            rads = None
+            if remote_addr is not None:
+                if (not isinstance(remote_addr, (tuple, list)) or
+                        len(remote_addr) != 2):
+                    raise TypeError(
+                        'remote_addr must be a tuple of (host, port)')
+                rads = await self._getaddrinfo(
+                    remote_addr[0], remote_addr[1],
+                    family, uv.SOCK_DGRAM, proto, flags,
+                    0)
+
+            excs = []
+            if lads is None:
+                if rads is not None:
+                    udp = UDPTransport.__new__(UDPTransport)
+                    rai = (<AddrInfo>rads).data
+                    udp._init(self, rai.ai_family)
+                    udp._connect(rai.ai_addr, rai.ai_addrlen)
+                    udp._set_address(rai)
+                else:
+                    if family not in (uv.AF_INET, uv.AF_INET6):
+                        raise ValueError('unexpected address family')
+                    udp = UDPTransport.__new__(UDPTransport)
+                    udp._init(self, family)
+
+                if reuse_port:
+                    self._sock_set_reuseport(udp._fileno())
+
+            else:
+                lai = (<AddrInfo>lads).data
+                while lai is not NULL:
+                    try:
+                        udp = UDPTransport.__new__(UDPTransport)
+                        udp._init(self, lai.ai_family)
+                        if reuse_port:
+                            self._sock_set_reuseport(udp._fileno())
+                        udp._bind(lai.ai_addr)
+                    except (KeyboardInterrupt, SystemExit):
+                        raise
+                    except BaseException as ex:
+                        lai = lai.ai_next
+                        excs.append(ex)
+                        continue
+                    else:
+                        break
+                else:
+                    ctx = None
+                    if len(excs):
+                        ctx = excs[0]
+                    raise OSError('could not bind to local_addr {}'.format(
+                        local_addr)) from ctx
+
+                if rads is not None:
+                    rai = (<AddrInfo>rads).data
+                    while rai is not NULL:
+                        if rai.ai_family != lai.ai_family:
+                            rai = rai.ai_next
+                            continue
+                        if rai.ai_protocol != lai.ai_protocol:
+                            rai = rai.ai_next
+                            continue
+                        udp._connect(rai.ai_addr, rai.ai_addrlen)
+                        udp._set_address(rai)
+                        break
+                    else:
+                        raise OSError(
+                            'could not bind to remote_addr {}'.format(
+                                remote_addr))
+
+        if allow_broadcast:
+            udp._set_broadcast(1)
+
+        protocol = protocol_factory()
+        waiter = self._new_future()
+        assert udp is not None
+        udp._set_protocol(protocol)
+        udp._set_waiter(waiter)
+        udp._init_protocol()
+
+        await waiter
+        return udp, protocol
+
+    def _monitor_fs(self, path: str, callback) -> asyncio.Handle:
+        cdef:
+            UVFSEvent fs_handle
+            char* c_str_path
+
+        self._check_closed()
+        fs_handle = UVFSEvent.new(self, callback, None)
+        p_bytes = path.encode('UTF-8')
+        c_str_path = p_bytes
+        flags = 0
+        fs_handle.start(c_str_path, flags)
+        return fs_handle
+
+    def _check_default_executor(self):
+        if self._executor_shutdown_called:
+            raise RuntimeError('Executor shutdown has been called')
+
+    def _asyncgen_finalizer_hook(self, agen):
+        self._asyncgens.discard(agen)
+        if not self.is_closed():
+            self.call_soon_threadsafe(self.create_task, agen.aclose())
+
+    def _asyncgen_firstiter_hook(self, agen):
+        if self._asyncgens_shutdown_called:
+            warnings_warn(
+                "asynchronous generator {!r} was scheduled after "
+                "loop.shutdown_asyncgens() call".format(agen),
+                ResourceWarning, source=self)
+
+        self._asyncgens.add(agen)
+
+    @cython.iterable_coroutine
+    async def shutdown_asyncgens(self):
+        """Shutdown all active asynchronous generators."""
+        self._asyncgens_shutdown_called = True
+
+        if not len(self._asyncgens):
+            return
+
+        closing_agens = list(self._asyncgens)
+        self._asyncgens.clear()
+
+        shutdown_coro = aio_gather(
+            *[ag.aclose() for ag in closing_agens],
+            return_exceptions=True)
+
+        results = await shutdown_coro
+        for result, agen in zip(results, closing_agens):
+            if isinstance(result, Exception):
+                self.call_exception_handler({
+                    'message': 'an error occurred during closing of '
+                               'asynchronous generator {!r}'.format(agen),
+                    'exception': result,
+                    'asyncgen': agen
+                })
+
+    @cython.iterable_coroutine
+    async def shutdown_default_executor(self, timeout=None):
+        """Schedule the shutdown of the default executor.
+
+        The timeout parameter specifies the amount of time the executor will
+        be given to finish joining. The default value is None, which means
+        that the executor will be given an unlimited amount of time.
+        """
+        self._executor_shutdown_called = True
+        if self._default_executor is None:
+            return
+        future = self.create_future()
+        thread = threading_Thread(target=self._do_shutdown, args=(future,))
+        thread.start()
+        try:
+            await future
+        finally:
+            thread.join(timeout)
+
+        if thread.is_alive():
+            warnings_warn(
+                "The executor did not finishing joining "
+                f"its threads within {timeout} seconds.",
+                RuntimeWarning,
+                stacklevel=2
+            )
+            self._default_executor.shutdown(wait=False)
+
+    def _do_shutdown(self, future):
+        try:
+            self._default_executor.shutdown(wait=True)
+            self.call_soon_threadsafe(future.set_result, None)
+        except Exception as ex:
+            self.call_soon_threadsafe(future.set_exception, ex)
+
+
+# Expose pointer for integration with other C-extensions
+def libuv_get_loop_t_ptr(loop):
+    return PyCapsule_New(<void *>(<Loop>loop).uvloop, NULL, NULL)
+
+
+def libuv_get_version():
+    return uv.uv_version()
+
+
+def _testhelper_unwrap_capsuled_pointer(obj):
+    return <uint64_t>PyCapsule_GetPointer(obj, NULL)
+
+
+cdef void __loop_alloc_buffer(
+    uv.uv_handle_t* uvhandle,
+    size_t suggested_size,
+    uv.uv_buf_t* buf
+) noexcept with gil:
+    cdef:
+        Loop loop = (<UVHandle>uvhandle.data)._loop
+
+    if loop._recv_buffer_in_use == 1:
+        buf.len = 0
+        exc = RuntimeError('concurrent allocations')
+        loop._handle_exception(exc)
+        return
+
+    loop._recv_buffer_in_use = 1
+    buf.base = loop._recv_buffer
+    buf.len = sizeof(loop._recv_buffer)
+
+
+cdef inline void __loop_free_buffer(Loop loop):
+    loop._recv_buffer_in_use = 0
+
+
+class _SyncSocketReaderFuture(aio_Future):
+
+    def __init__(self, sock, loop):
+        aio_Future.__init__(self, loop=loop)
+        self.__sock = sock
+        self.__loop = loop
+
+    def __remove_reader(self):
+        if self.__sock is not None and self.__sock.fileno() != -1:
+            self.__loop.remove_reader(self.__sock)
+            self.__sock = None
+
+    if PY39:
+        def cancel(self, msg=None):
+            self.__remove_reader()
+            aio_Future.cancel(self, msg=msg)
+
+    else:
+        def cancel(self):
+            self.__remove_reader()
+            aio_Future.cancel(self)
+
+
+class _SyncSocketWriterFuture(aio_Future):
+
+    def __init__(self, sock, loop):
+        aio_Future.__init__(self, loop=loop)
+        self.__sock = sock
+        self.__loop = loop
+
+    def __remove_writer(self):
+        if self.__sock is not None and self.__sock.fileno() != -1:
+            self.__loop.remove_writer(self.__sock)
+            self.__sock = None
+
+    if PY39:
+        def cancel(self, msg=None):
+            self.__remove_writer()
+            aio_Future.cancel(self, msg=msg)
+
+    else:
+        def cancel(self):
+            self.__remove_writer()
+            aio_Future.cancel(self)
+
+
+include "cbhandles.pyx"
+include "pseudosock.pyx"
+include "lru.pyx"
+
+include "handles/handle.pyx"
+include "handles/async_.pyx"
+include "handles/idle.pyx"
+include "handles/check.pyx"
+include "handles/timer.pyx"
+include "handles/poll.pyx"
+include "handles/basetransport.pyx"
+include "handles/stream.pyx"
+include "handles/streamserver.pyx"
+include "handles/tcp.pyx"
+include "handles/pipe.pyx"
+include "handles/process.pyx"
+include "handles/fsevent.pyx"
+
+include "request.pyx"
+include "dns.pyx"
+include "sslproto.pyx"
+
+include "handles/udp.pyx"
+
+include "server.pyx"
+
+
+# Used in UVProcess
+cdef vint __atfork_installed = 0
+cdef vint __forking = 0
+cdef Loop __forking_loop = None
+
+
+cdef void __get_fork_handler() noexcept nogil:
+    with gil:
+        if (__forking and __forking_loop is not None and
+                __forking_loop.active_process_handler is not None):
+            __forking_loop.active_process_handler._after_fork()
+
+cdef __install_atfork():
+    global __atfork_installed
+
+    if __atfork_installed:
+        return
+    __atfork_installed = 1
+
+    cdef int err
+
+    err = system.pthread_atfork(NULL, NULL, &system.handleAtFork)
+    if err:
+        __atfork_installed = 0
+        raise convert_error(-err)
+
+
+# Install PyMem* memory allocators
+cdef vint __mem_installed = 0
+cdef __install_pymem():
+    global __mem_installed
+    if __mem_installed:
+        return
+    __mem_installed = 1
+
+    cdef int err
+    err = uv.uv_replace_allocator(<uv.uv_malloc_func>PyMem_RawMalloc,
+                                  <uv.uv_realloc_func>PyMem_RawRealloc,
+                                  <uv.uv_calloc_func>PyMem_RawCalloc,
+                                  <uv.uv_free_func>PyMem_RawFree)
+    if err < 0:
+        __mem_installed = 0
+        raise convert_error(err)
+
+
+cdef _set_signal_wakeup_fd(fd):
+    if fd >= 0:
+        return signal_set_wakeup_fd(fd, warn_on_full_buffer=False)
+    else:
+        return signal_set_wakeup_fd(fd)
+
+
+# Helpers for tests
+
+@cython.iterable_coroutine
+async def _test_coroutine_1():
+    return 42
diff --git a/venv/lib/python3.11/site-packages/uvloop/lru.pyx b/venv/lib/python3.11/site-packages/uvloop/lru.pyx
new file mode 100644
index 0000000..cc7ea1d
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/lru.pyx
@@ -0,0 +1,79 @@
+cdef object _LRU_MARKER = object()
+
+
+@cython.final
+cdef class LruCache:
+
+    cdef:
+        object _dict
+        int _maxsize
+        object _dict_move_to_end
+        object _dict_get
+
+    # We use an OrderedDict for LRU implementation.  Operations:
+    #
+    # * We use a simple `__setitem__` to push a new entry:
+    #       `entries[key] = new_entry`
+    #   That will push `new_entry` to the *end* of the entries dict.
+    #
+    # * When we have a cache hit, we call
+    #       `entries.move_to_end(key, last=True)`
+    #   to move the entry to the *end* of the entries dict.
+    #
+    # * When we need to remove entries to maintain `max_size`, we call
+    #       `entries.popitem(last=False)`
+    #   to remove an entry from the *beginning* of the entries dict.
+    #
+    # So new entries and hits are always promoted to the end of the
+    # entries dict, whereas the unused one will group in the
+    # beginning of it.
+
+    def __init__(self, *, maxsize):
+        if maxsize <= 0:
+            raise ValueError(
+                f'maxsize is expected to be greater than 0, got {maxsize}')
+
+        self._dict = col_OrderedDict()
+        self._dict_move_to_end = self._dict.move_to_end
+        self._dict_get = self._dict.get
+        self._maxsize = maxsize
+
+    cdef get(self, key, default):
+        o = self._dict_get(key, _LRU_MARKER)
+        if o is _LRU_MARKER:
+            return default
+        self._dict_move_to_end(key)  # last=True
+        return o
+
+    cdef inline needs_cleanup(self):
+        return len(self._dict) > self._maxsize
+
+    cdef inline cleanup_one(self):
+        k, _ = self._dict.popitem(last=False)
+        return k
+
+    def __getitem__(self, key):
+        o = self._dict[key]
+        self._dict_move_to_end(key)  # last=True
+        return o
+
+    def __setitem__(self, key, o):
+        if key in self._dict:
+            self._dict[key] = o
+            self._dict_move_to_end(key)  # last=True
+        else:
+            self._dict[key] = o
+        while self.needs_cleanup():
+            self.cleanup_one()
+
+    def __delitem__(self, key):
+        del self._dict[key]
+
+    def __contains__(self, key):
+        return key in self._dict
+
+    def __len__(self):
+        return len(self._dict)
+
+    def __iter__(self):
+        return iter(self._dict)
diff --git a/venv/lib/python3.11/site-packages/uvloop/pseudosock.pyx b/venv/lib/python3.11/site-packages/uvloop/pseudosock.pyx
new file mode 100644
index 0000000..10a1ad6
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/pseudosock.pyx
@@ -0,0 +1,209 @@
+cdef class PseudoSocket:
+    cdef:
+        int _family
+        int _type
+        int _proto
+        int _fd
+        object _peername
+        object _sockname
+
+    def __init__(self, int family, int type, int proto, int fd):
+        self._family = family
+        self._type = type
+        self._proto = proto
+        self._fd = fd
+        self._peername = None
+        self._sockname = None
+
+    cdef _na(self, what):
+        raise TypeError('transport sockets do not support {}'.format(what))
+
+    cdef _make_sock(self):
+        return socket_socket(self._family, self._type, self._proto, self._fd)
+
+    property family:
+        def __get__(self):
+            try:
+                return socket_AddressFamily(self._family)
+            except ValueError:
+                return self._family
+
+    property type:
+        def __get__(self):
+            try:
+                return socket_SocketKind(self._type)
+            except ValueError:
+                return self._type
+
+    property proto:
+        def __get__(self):
+            return self._proto
+
+    def __repr__(self):
+        s = ("<uvloop.PseudoSocket fd={}, family={!s}, "
+             "type={!s}, proto={}").format(self.fileno(), self.family.name,
+                                           self.type.name, self.proto)
+
+        if self._fd != -1:
+            try:
+                laddr = self.getsockname()
+                if laddr:
+                    s += ", laddr=%s" % str(laddr)
+            except socket_error:
+                pass
+            try:
+                raddr = self.getpeername()
+                if raddr:
+                    s += ", raddr=%s" % str(raddr)
+            except socket_error:
+                pass
+        s += '>'
+        return s
+
+    def __getstate__(self):
+        raise TypeError("Cannot serialize socket object")
+
+    def fileno(self):
+        return self._fd
+
+    def dup(self):
+        fd = os_dup(self._fd)
+        sock = socket_socket(self._family, self._type, self._proto, fileno=fd)
+        sock.settimeout(0)
+        return sock
+
+    def get_inheritable(self):
+        return os_get_inheritable(self._fd)
+
+    def set_inheritable(self):
+        os_set_inheritable(self._fd)
+
+    def ioctl(self, *args, **kwargs):
+        pass
+
+    def getsockopt(self, *args, **kwargs):
+        sock = self._make_sock()
+        try:
+            return sock.getsockopt(*args, **kwargs)
+        finally:
+            sock.detach()
+
+    def setsockopt(self, *args, **kwargs):
+        sock = self._make_sock()
+        try:
+            return sock.setsockopt(*args, **kwargs)
+        finally:
+            sock.detach()
+
+    def getpeername(self):
+        if self._peername is not None:
+            return self._peername
+
+        sock = self._make_sock()
+        try:
+            self._peername = sock.getpeername()
+            return self._peername
+        finally:
+            sock.detach()
+
+    def getsockname(self):
+        if self._sockname is not None:
+            return self._sockname
+
+        sock = self._make_sock()
+        try:
+            self._sockname = sock.getsockname()
+            return self._sockname
+        finally:
+            sock.detach()
+
+    def share(self, process_id):
+        sock = self._make_sock()
+        try:
+            return sock.share(process_id)
+        finally:
+            sock.detach()
+
+    def accept(self):
+        self._na('accept() method')
+
+    def connect(self, *args):
+        self._na('connect() method')
+
+    def connect_ex(self, *args):
+        self._na('connect_ex() method')
+
+    def bind(self, *args):
+        self._na('bind() method')
+
+    def listen(self, *args, **kwargs):
+        self._na('listen() method')
+
+    def makefile(self):
+        self._na('makefile() method')
+
+    def sendfile(self, *args, **kwargs):
+        self._na('sendfile() method')
+
+    def close(self):
+        self._na('close() method')
+
+    def detach(self):
+        self._na('detach() method')
+
+    def shutdown(self, *args):
+        self._na('shutdown() method')
+
+    def sendmsg_afalg(self, *args, **kwargs):
+        self._na('sendmsg_afalg() method')
+
+    def sendmsg(self):
+        self._na('sendmsg() method')
+
+    def sendto(self, *args, **kwargs):
+        self._na('sendto() method')
+
+    def send(self, *args, **kwargs):
+        self._na('send() method')
+
+    def sendall(self, *args, **kwargs):
+        self._na('sendall() method')
+
+    def recv_into(self, *args, **kwargs):
+        self._na('recv_into() method')
+
+    def recvfrom_into(self, *args, **kwargs):
+        self._na('recvfrom_into() method')
+
+    def recvmsg_into(self, *args, **kwargs):
+        self._na('recvmsg_into() method')
+
+    def recvmsg(self, *args, **kwargs):
+        self._na('recvmsg() method')
+
+    def recvfrom(self, *args, **kwargs):
+        self._na('recvfrom() method')
+
+    def recv(self, *args, **kwargs):
+        self._na('recv() method')
+
+    def settimeout(self, value):
+        if value == 0:
+            return
+        raise ValueError(
+            'settimeout(): only 0 timeout is allowed on transport sockets')
+
+    def gettimeout(self):
+        return 0
+
+    def setblocking(self, flag):
+        if not flag:
+            return
+        raise ValueError(
+            'setblocking(): transport sockets cannot be blocking')
+
+    def __enter__(self):
+        self._na('context manager protocol')
+
+    def __exit__(self, *err):
+        self._na('context manager protocol')
diff --git a/venv/lib/python3.11/site-packages/uvloop/py.typed b/venv/lib/python3.11/site-packages/uvloop/py.typed
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/py.typed
diff --git a/venv/lib/python3.11/site-packages/uvloop/request.pxd b/venv/lib/python3.11/site-packages/uvloop/request.pxd
new file mode 100644
index 0000000..bafa51d
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/request.pxd
@@ -0,0 +1,8 @@
+cdef class UVRequest:
+    cdef:
+        uv.uv_req_t *request
+        bint done
+        Loop loop
+
+    cdef on_done(self)
+    cdef cancel(self)
diff --git a/venv/lib/python3.11/site-packages/uvloop/request.pyx b/venv/lib/python3.11/site-packages/uvloop/request.pyx
new file mode 100644
index 0000000..f15103a
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/request.pyx
@@ -0,0 +1,65 @@
+cdef class UVRequest:
+    """A base class for all libuv requests (uv_getaddrinfo_t, etc).
+
+    Important: it's a responsibility of the subclass to call the
+    "on_done" method in the request's callback.
+
+    If "on_done" isn't called, the request object will never die.
+    """
+
+    def __cinit__(self, Loop loop, *_):
+        self.request = NULL
+        self.loop = loop
+        self.done = 0
+        Py_INCREF(self)
+
+    cdef on_done(self):
+        self.done = 1
+        Py_DECREF(self)
+
+    cdef cancel(self):
+        # Most requests are implemented using a threadpool.  It's only
+        # possible to cancel a request when it's still in a threadpool's
+        # queue.  Once it's started to execute, we have to wait until
+        # it finishes and calls its callback (and callback *must* call
+        # UVRequest.on_done).
+
+        cdef int err
+
+        if self.done == 1:
+            return
+
+        if UVLOOP_DEBUG:
+            if self.request is NULL:
+                raise RuntimeError(
+                    '{}.cancel: .request is NULL'.format(
+                        self.__class__.__name__))
+
+            if self.request.data is NULL:
+                raise RuntimeError(
+                    '{}.cancel: .request.data is NULL'.format(
+                        self.__class__.__name__))
+
+            if <UVRequest>self.request.data is not self:
+                raise RuntimeError(
+                    '{}.cancel: .request.data is not UVRequest'.format(
+                        self.__class__.__name__))
+
+        # We only can cancel pending requests.  Let's try.
+        err = uv.uv_cancel(self.request)
+        if err < 0:
+            if err == uv.UV_EBUSY:
+                # Can't close the request -- it's executing (see the first
+                # comment).  Loop will have to wait until the callback
+                # fires.
+                pass
+            elif err == uv.UV_EINVAL:
+                # From libuv docs:
+                #
+                #     Only cancellation of uv_fs_t, uv_getaddrinfo_t,
+                #     uv_getnameinfo_t and uv_work_t requests is currently
+                #     supported.
+                return
+            else:
+                ex = convert_error(err)
+                self.loop._handle_exception(ex)
diff --git a/venv/lib/python3.11/site-packages/uvloop/server.pxd b/venv/lib/python3.11/site-packages/uvloop/server.pxd
new file mode 100644
index 0000000..ef10f81
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/server.pxd
@@ -0,0 +1,19 @@
+cdef class Server:
+    cdef:
+        list _servers
+        list _waiters
+        int _active_count
+        Loop _loop
+        bint _serving
+        object _serving_forever_fut
+        object __weakref__
+
+    cdef _add_server(self, UVStreamServer srv)
+    cdef _start_serving(self)
+    cdef _wakeup(self)
+
+    cdef _attach(self)
+    cdef _detach(self)
+
+    cdef _ref(self)
+    cdef _unref(self)
diff --git a/venv/lib/python3.11/site-packages/uvloop/server.pyx b/venv/lib/python3.11/site-packages/uvloop/server.pyx
new file mode 100644
index 0000000..845bcfd
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/server.pyx
@@ -0,0 +1,136 @@
+import asyncio
+
+
+cdef class Server:
+    def __cinit__(self, Loop loop):
+        self._loop = loop
+        self._servers = []
+        self._waiters = []
+        self._active_count = 0
+        self._serving_forever_fut = None
+
+    cdef _add_server(self, UVStreamServer srv):
+        self._servers.append(srv)
+
+    cdef _start_serving(self):
+        if self._serving:
+            return
+
+        self._serving = 1
+        for server in self._servers:
+            (<UVStreamServer>server).listen()
+
+    cdef _wakeup(self):
+        cdef list waiters
+
+        waiters = self._waiters
+        self._waiters = None
+        for waiter in waiters:
+            if not waiter.done():
+                waiter.set_result(waiter)
+
+    cdef _attach(self):
+        assert self._servers is not None
+        self._active_count += 1
+
+    cdef _detach(self):
+        assert self._active_count > 0
+        self._active_count -= 1
+        if self._active_count == 0 and self._servers is None:
+            self._wakeup()
+
+    cdef _ref(self):
+        # Keep the server object alive while it's not explicitly closed.
+        self._loop._servers.add(self)
+
+    cdef _unref(self):
+        self._loop._servers.discard(self)
+
+    # Public API
+
+    @cython.iterable_coroutine
+    async def __aenter__(self):
+        return self
+
+    @cython.iterable_coroutine
+    async def __aexit__(self, *exc):
+        self.close()
+        await self.wait_closed()
+
+    def __repr__(self):
+        return '<%s sockets=%r>' % (self.__class__.__name__, self.sockets)
+
+    def get_loop(self):
+        return self._loop
+
+    @cython.iterable_coroutine
+    async def wait_closed(self):
+        # Do not remove `self._servers is None` below
+        # because close() method only closes server sockets
+        # and existing client connections are left open.
+        if self._servers is None or self._waiters is None:
+            return
+        waiter = self._loop._new_future()
+        self._waiters.append(waiter)
+        await waiter
+
+    def close(self):
+        cdef list servers
+
+        if self._servers is None:
+            return
+
+        try:
+            servers = self._servers
+            self._servers = None
+            self._serving = 0
+
+            for server in servers:
+                (<UVStreamServer>server)._close()
+
+            if self._active_count == 0:
+                self._wakeup()
+        finally:
+            self._unref()
+
+    def is_serving(self):
+        return self._serving
+
+    @cython.iterable_coroutine
+    async def start_serving(self):
+        self._start_serving()
+
+    @cython.iterable_coroutine
+    async def serve_forever(self):
+        if self._serving_forever_fut is not None:
+            raise RuntimeError(
+                f'server {self!r} is already being awaited on serve_forever()')
+        if self._servers is None:
+            raise RuntimeError(f'server {self!r} is closed')
+
+        self._start_serving()
+        self._serving_forever_fut = self._loop.create_future()
+
+        try:
+            await self._serving_forever_fut
+        except asyncio.CancelledError:
+            try:
+                self.close()
+                await self.wait_closed()
+            finally:
+                raise
+        finally:
+            self._serving_forever_fut = None
+
+    property sockets:
+        def __get__(self):
+            cdef list sockets = []
+
+            # Guard against `self._servers is None`
+            if self._servers:
+                for server in self._servers:
+                    sockets.append(
+                        (<UVStreamServer>server)._get_socket()
+                    )
+
+            return sockets
diff --git a/venv/lib/python3.11/site-packages/uvloop/sslproto.pxd b/venv/lib/python3.11/site-packages/uvloop/sslproto.pxd
new file mode 100644
index 0000000..3da10f0
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/sslproto.pxd
@@ -0,0 +1,138 @@
+cdef enum SSLProtocolState:
+    UNWRAPPED = 0
+    DO_HANDSHAKE = 1
+    WRAPPED = 2
+    FLUSHING = 3
+    SHUTDOWN = 4
+
+
+cdef enum AppProtocolState:
+    # This tracks the state of app protocol (https://git.io/fj59P):
+    #
+    #     INIT -cm-> CON_MADE [-dr*->] [-er-> EOF?] -cl-> CON_LOST
+    #
+    # * cm: connection_made()
+    # * dr: data_received()
+    # * er: eof_received()
+    # * cl: connection_lost()
+
+    STATE_INIT = 0
+    STATE_CON_MADE = 1
+    STATE_EOF = 2
+    STATE_CON_LOST = 3
+
+
+cdef class _SSLProtocolTransport:
+    cdef:
+        Loop _loop
+        SSLProtocol _ssl_protocol
+        bint _closed
+        object context
+
+
+cdef class SSLProtocol:
+    cdef:
+        bint _server_side
+        str _server_hostname
+        object _sslcontext
+
+        object _extra
+
+        object _write_backlog
+        size_t _write_buffer_size
+
+        object _waiter
+        Loop _loop
+        _SSLProtocolTransport _app_transport
+        bint _app_transport_created
+
+        object _transport
+        object _ssl_handshake_timeout
+        object _ssl_shutdown_timeout
+
+        object _sslobj
+        object _sslobj_read
+        object _sslobj_write
+        object _incoming
+        object _incoming_write
+        object _outgoing
+        object _outgoing_read
+        char* _ssl_buffer
+        size_t _ssl_buffer_len
+        object _ssl_buffer_view
+        SSLProtocolState _state
+        size_t _conn_lost
+        AppProtocolState _app_state
+
+        bint _ssl_writing_paused
+        bint _app_reading_paused
+
+        size_t _incoming_high_water
+        size_t _incoming_low_water
+        bint _ssl_reading_paused
+
+        bint _app_writing_paused
+        size_t _outgoing_high_water
+        size_t _outgoing_low_water
+
+        object _app_protocol
+        bint _app_protocol_is_buffer
+        object _app_protocol_get_buffer
+        object _app_protocol_buffer_updated
+
+        object _handshake_start_time
+        object _handshake_timeout_handle
+        object _shutdown_timeout_handle
+
+    cdef _set_app_protocol(self, app_protocol)
+    cdef _wakeup_waiter(self, exc=*)
+    cdef _get_extra_info(self, name, default=*)
+    cdef _set_state(self, SSLProtocolState new_state)
+
+    # Handshake flow
+
+    cdef _start_handshake(self)
+    cdef _check_handshake_timeout(self)
+    cdef _do_handshake(self)
+    cdef _on_handshake_complete(self, handshake_exc)
+
+    # Shutdown flow
+
+    cdef _start_shutdown(self, object context=*)
+    cdef _check_shutdown_timeout(self)
+    cdef _do_read_into_void(self, object context)
+    cdef _do_flush(self, object context=*)
+    cdef _do_shutdown(self, object context=*)
+    cdef _on_shutdown_complete(self, shutdown_exc)
+    cdef _abort(self, exc)
+
+    # Outgoing flow
+
+    cdef _write_appdata(self, list_of_data, object context)
+    cdef _do_write(self)
+    cdef _process_outgoing(self)
+
+    # Incoming flow
+
+    cdef _do_read(self)
+    cdef _do_read__buffered(self)
+    cdef _do_read__copied(self)
+    cdef _call_eof_received(self, object context=*)
+
+    # Flow control for writes from APP socket
+
+    cdef _control_app_writing(self, object context=*)
+    cdef size_t _get_write_buffer_size(self)
+    cdef _set_write_buffer_limits(self, high=*, low=*)
+
+    # Flow control for reads to APP socket
+
+    cdef _pause_reading(self)
+    cdef _resume_reading(self, object context)
+
+    # Flow control for reads from SSL socket
+
+    cdef _control_ssl_reading(self)
+    cdef _set_read_buffer_limits(self, high=*, low=*)
+    cdef size_t _get_read_buffer_size(self)
+    cdef _fatal_error(self, exc, message=*)
diff --git a/venv/lib/python3.11/site-packages/uvloop/sslproto.pyx b/venv/lib/python3.11/site-packages/uvloop/sslproto.pyx
new file mode 100644
index 0000000..42bb764
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/uvloop/sslproto.pyx
@@ -0,0 +1,950 @@
+cdef _create_transport_context(server_side, server_hostname):
+    if server_side:
+        raise ValueError('Server side SSL needs a valid SSLContext')
+
+    # Client side may pass ssl=True to use a default
+    # context; in that case the sslcontext passed is None.
+    # The default is secure for client connections.
+    # Python 3.4+: use up-to-date strong settings.
+    sslcontext = ssl_create_default_context()
+    if not server_hostname:
+        sslcontext.check_hostname = False
+    return sslcontext
+
+
+cdef class _SSLProtocolTransport:
+
+    # TODO:
+    # _sendfile_compatible = constants._SendfileMode.FALLBACK
+
+    def __cinit__(self, Loop loop, ssl_protocol, context):
+        self._loop = loop
+        # SSLProtocol instance
+        self._ssl_protocol = ssl_protocol
+        self._closed = False
+        if context is None:
+            context = Context_CopyCurrent()
+        self.context = context
+
+    def get_extra_info(self, name, default=None):
+        """Get optional transport information."""
+        return self._ssl_protocol._get_extra_info(name, default)
+
+    def set_protocol(self, protocol):
+        self._ssl_protocol._set_app_protocol(protocol)
+
+    def get_protocol(self):
+        return self._ssl_protocol._app_protocol
+
+    def is_closing(self):
+        return self._closed
+
+    def close(self):
+        """Close the transport.
+
+        Buffered data will be flushed asynchronously.  No more data
+        will be received.  After all buffered data is flushed, the
+        protocol's connection_lost() method will (eventually) called
+        with None as its argument.
+        """
+        self._closed = True
+        self._ssl_protocol._start_shutdown(self.context.copy())
+
+    def __dealloc__(self):
+        if not self._closed:
+            self._closed = True
+            warnings_warn(
+                "unclosed transport <uvloop.loop._SSLProtocolTransport "
+                "object>", ResourceWarning)
+
+    def is_reading(self):
+        return not self._ssl_protocol._app_reading_paused
+
+    def pause_reading(self):
+        """Pause the receiving end.
+
+        No data will be passed to the protocol's data_received()
+        method until resume_reading() is called.
+        """
+        self._ssl_protocol._pause_reading()
+
+    def resume_reading(self):
+        """Resume the receiving end.
+
+        Data received will once again be passed to the protocol's
+        data_received() method.
+        """
+        self._ssl_protocol._resume_reading(self.context.copy())
+
+    def set_write_buffer_limits(self, high=None, low=None):
+        """Set the high- and low-water limits for write flow control.
+
+        These two values control when to call the protocol's
+        pause_writing() and resume_writing() methods.  If specified,
+        the low-water limit must be less than or equal to the
+        high-water limit.  Neither value can be negative.
+
+        The defaults are implementation-specific.  If only the
+        high-water limit is given, the low-water limit defaults to an
+        implementation-specific value less than or equal to the
+        high-water limit.  Setting high to zero forces low to zero as
+        well, and causes pause_writing() to be called whenever the
+        buffer becomes non-empty.  Setting low to zero causes
+        resume_writing() to be called only once the buffer is empty.
+        Use of zero for either limit is generally sub-optimal as it
+        reduces opportunities for doing I/O and computation
+        concurrently.
+        """
+        self._ssl_protocol._set_write_buffer_limits(high, low)
+        self._ssl_protocol._control_app_writing(self.context.copy())
+
+    def get_write_buffer_limits(self):
+        return (self._ssl_protocol._outgoing_low_water,
+                self._ssl_protocol._outgoing_high_water)
+
+    def get_write_buffer_size(self):
+        """Return the current size of the write buffers."""
+        return self._ssl_protocol._get_write_buffer_size()
+
+    def set_read_buffer_limits(self, high=None, low=None):
+        """Set the high- and low-water limits for read flow control.
+
+        These two values control when to call the upstream transport's
+        pause_reading() and resume_reading() methods.  If specified,
+        the low-water limit must be less than or equal to the
+        high-water limit.  Neither value can be negative.
+
+        The defaults are implementation-specific.  If only the
+        high-water limit is given, the low-water limit defaults to an
+        implementation-specific value less than or equal to the
+        high-water limit.  Setting high to zero forces low to zero as
+        well, and causes pause_reading() to be called whenever the
+        buffer becomes non-empty.  Setting low to zero causes
+        resume_reading() to be called only once the buffer is empty.
+        Use of zero for either limit is generally sub-optimal as it
+        reduces opportunities for doing I/O and computation
+        concurrently.
+        """
+        self._ssl_protocol._set_read_buffer_limits(high, low)
+        self._ssl_protocol._control_ssl_reading()
+
+    def get_read_buffer_limits(self):
+        return (self._ssl_protocol._incoming_low_water,
+                self._ssl_protocol._incoming_high_water)
+
+    def get_read_buffer_size(self):
+        """Return the current size of the read buffer."""
+        return self._ssl_protocol._get_read_buffer_size()
+
+    @property
+    def _protocol_paused(self):
+        # Required for sendfile fallback pause_writing/resume_writing logic
+        return self._ssl_protocol._app_writing_paused
+
+    def write(self, data):
+        """Write some data bytes to the transport.
+
+        This does not block; it buffers the data and arranges for it
+        to be sent out asynchronously.
+        """
+        if not isinstance(data, (bytes, bytearray, memoryview)):
+            raise TypeError(f"data: expecting a bytes-like instance, "
+                            f"got {type(data).__name__}")
+        if not data:
+            return
+        self._ssl_protocol._write_appdata((data,), self.context.copy())
+
+    def writelines(self, list_of_data):
+        """Write a list (or any iterable) of data bytes to the transport.
+
+        The default implementation concatenates the arguments and
+        calls write() on the result.
+        """
+        self._ssl_protocol._write_appdata(list_of_data, self.context.copy())
+
+    def write_eof(self):
+        """Close the write end after flushing buffered data.
+
+        This raises :exc:`NotImplementedError` right now.
+        """
+        raise NotImplementedError
+
+    def can_write_eof(self):
+        """Return True if this transport supports write_eof(), False if not."""
+        return False
+
+    def abort(self):
+        """Close the transport immediately.
+
+        Buffered data will be lost.  No more data will be received.
+        The protocol's connection_lost() method will (eventually) be
+        called with None as its argument.
+        """
+        self._force_close(None)
+
+    def _force_close(self, exc):
+        self._closed = True
+        self._ssl_protocol._abort(exc)
+
+    def _test__append_write_backlog(self, data):
+        # for test only
+        self._ssl_protocol._write_backlog.append(data)
+        self._ssl_protocol._write_buffer_size += len(data)
+
+
+cdef class SSLProtocol:
+    """SSL protocol.
+
+    Implementation of SSL on top of a socket using incoming and outgoing
+    buffers which are ssl.MemoryBIO objects.
+    """
+
+    def __cinit__(self, *args, **kwargs):
+        self._ssl_buffer_len = SSL_READ_MAX_SIZE
+        self._ssl_buffer = <char*>PyMem_RawMalloc(self._ssl_buffer_len)
+        if not self._ssl_buffer:
+            raise MemoryError()
+        self._ssl_buffer_view = PyMemoryView_FromMemory(
+            self._ssl_buffer, self._ssl_buffer_len, PyBUF_WRITE)
+
+    def __dealloc__(self):
+        self._ssl_buffer_view = None
+        PyMem_RawFree(self._ssl_buffer)
+        self._ssl_buffer = NULL
+        self._ssl_buffer_len = 0
+
+    def __init__(self, loop, app_protocol, sslcontext, waiter,
+                 server_side=False, server_hostname=None,
+                 call_connection_made=True,
+                 ssl_handshake_timeout=None,
+                 ssl_shutdown_timeout=None):
+        if ssl_handshake_timeout is None:
+            ssl_handshake_timeout = SSL_HANDSHAKE_TIMEOUT
+        elif ssl_handshake_timeout <= 0:
+            raise ValueError(
+                f"ssl_handshake_timeout should be a positive number, "
+                f"got {ssl_handshake_timeout}")
+        if ssl_shutdown_timeout is None:
+            ssl_shutdown_timeout = SSL_SHUTDOWN_TIMEOUT
+        elif ssl_shutdown_timeout <= 0:
+            raise ValueError(
+                f"ssl_shutdown_timeout should be a positive number, "
+                f"got {ssl_shutdown_timeout}")
+
+        if not sslcontext:
+            sslcontext = _create_transport_context(
+                server_side, server_hostname)
+
+        self._server_side = server_side
+        if server_hostname and not server_side:
+            self._server_hostname = server_hostname
+        else:
+            self._server_hostname = None
+        self._sslcontext = sslcontext
+        # SSL-specific extra info. More info are set when the handshake
+        # completes.
+        self._extra = dict(sslcontext=sslcontext)
+
+        # App data write buffering
+        self._write_backlog = col_deque()
+        self._write_buffer_size = 0
+
+        self._waiter = waiter
+        self._loop = loop
+        self._set_app_protocol(app_protocol)
+        self._app_transport = None
+        self._app_transport_created = False
+        # transport, ex: SelectorSocketTransport
+        self._transport = None
+        self._ssl_handshake_timeout = ssl_handshake_timeout
+        self._ssl_shutdown_timeout = ssl_shutdown_timeout
+        # SSL and state machine
+        self._sslobj = None
+        self._incoming = ssl_MemoryBIO()
+        self._incoming_write = self._incoming.write
+        self._outgoing = ssl_MemoryBIO()
+        self._outgoing_read = self._outgoing.read
+        self._state = UNWRAPPED
+        self._conn_lost = 0  # Set when connection_lost called
+        if call_connection_made:
+            self._app_state = STATE_INIT
+        else:
+            self._app_state = STATE_CON_MADE
+
+        # Flow Control
+
+        self._ssl_writing_paused = False
+
+        self._app_reading_paused = False
+
+        self._ssl_reading_paused = False
+        self._incoming_high_water = 0
+        self._incoming_low_water = 0
+        self._set_read_buffer_limits()
+
+        self._app_writing_paused = False
+        self._outgoing_high_water = 0
+        self._outgoing_low_water = 0
+        self._set_write_buffer_limits()
+
+    cdef _set_app_protocol(self, app_protocol):
+        self._app_protocol = app_protocol
+        if (hasattr(app_protocol, 'get_buffer') and
+                not isinstance(app_protocol, aio_Protocol)):
+            self._app_protocol_get_buffer = app_protocol.get_buffer
+            self._app_protocol_buffer_updated = app_protocol.buffer_updated
+            self._app_protocol_is_buffer = True
+        else:
+            self._app_protocol_is_buffer = False
+
+    cdef _wakeup_waiter(self, exc=None):
+        if self._waiter is None:
+            return
+        if not self._waiter.cancelled():
+            if exc is not None:
+                self._waiter.set_exception(exc)
+            else:
+                self._waiter.set_result(None)
+        self._waiter = None
+
+    def _get_app_transport(self, context=None):
+        if self._app_transport is None:
+            if self._app_transport_created:
+                raise RuntimeError('Creating _SSLProtocolTransport twice')
+            self._app_transport = _SSLProtocolTransport(self._loop, self,
+                                                        context)
+            self._app_transport_created = True
+        return self._app_transport
+
+    def connection_made(self, transport):
+        """Called when the low-level connection is made.
+
+        Start the SSL handshake.
+        """
+        self._transport = transport
+        self._start_handshake()
+
+    def connection_lost(self, exc):
+        """Called when the low-level connection is lost or closed.
+
+        The argument is an exception object or None (the latter
+        meaning a regular EOF is received or the connection was
+        aborted or closed).
+        """
+        self._write_backlog.clear()
+        self._outgoing_read()
+        self._conn_lost += 1
+
+        # Just mark the app transport as closed so that its __dealloc__
+        # doesn't complain.
+        if self._app_transport is not None:
+            self._app_transport._closed = True
+
+        if self._state != DO_HANDSHAKE:
+            if self._app_state == STATE_CON_MADE or \
+                    self._app_state == STATE_EOF:
+                self._app_state = STATE_CON_LOST
+                self._loop.call_soon(self._app_protocol.connection_lost, exc)
+        self._set_state(UNWRAPPED)
+        self._transport = None
+        self._app_transport = None
+        self._app_protocol = None
+        self._wakeup_waiter(exc)
+
+        if self._shutdown_timeout_handle:
+            self._shutdown_timeout_handle.cancel()
+            self._shutdown_timeout_handle = None
+        if self._handshake_timeout_handle:
+            self._handshake_timeout_handle.cancel()
+            self._handshake_timeout_handle = None
+
+    def get_buffer(self, n):
+        cdef size_t want = n
+        if want > SSL_READ_MAX_SIZE:
+            want = SSL_READ_MAX_SIZE
+        if self._ssl_buffer_len < want:
+            self._ssl_buffer = <char*>PyMem_RawRealloc(self._ssl_buffer, want)
+            if not self._ssl_buffer:
+                raise MemoryError()
+            self._ssl_buffer_len = want
+            self._ssl_buffer_view = PyMemoryView_FromMemory(
+                self._ssl_buffer, want, PyBUF_WRITE)
+        return self._ssl_buffer_view
+
+    def buffer_updated(self, nbytes):
+        self._incoming_write(PyMemoryView_FromMemory(
+            self._ssl_buffer, nbytes, PyBUF_WRITE))
+
+        if self._state == DO_HANDSHAKE:
+            self._do_handshake()
+
+        elif self._state == WRAPPED:
+            self._do_read()
+
+        elif self._state == FLUSHING:
+            self._do_flush()
+
+        elif self._state == SHUTDOWN:
+            self._do_shutdown()
+
+    def eof_received(self):
+        """Called when the other end of the low-level stream
+        is half-closed.
+
+        If this returns a false value (including None), the transport
+        will close itself.  If it returns a true value, closing the
+        transport is up to the protocol.
+        """
+        try:
+            if self._loop.get_debug():
+                aio_logger.debug("%r received EOF", self)
+
+            if self._state == DO_HANDSHAKE:
+                self._on_handshake_complete(ConnectionResetError)
+
+            elif self._state == WRAPPED or self._state == FLUSHING:
+                # We treat a low-level EOF as a critical situation similar to a
+                # broken connection - just send whatever is in the buffer and
+                # close. No application level eof_received() is called -
+                # because we don't want the user to think that this is a
+                # graceful shutdown triggered by SSL "close_notify".
+                self._set_state(SHUTDOWN)
+                self._on_shutdown_complete(None)
+
+            elif self._state == SHUTDOWN:
+                self._on_shutdown_complete(None)
+
+        except Exception:
+            self._transport.close()
+            raise
+
+    cdef _get_extra_info(self, name, default=None):
+        if name == 'uvloop.sslproto':
+            return self
+        elif name in self._extra:
+            return self._extra[name]
+        elif self._transport is not None:
+            return self._transport.get_extra_info(name, default)
+        else:
+            return default
+
+    cdef _set_state(self, SSLProtocolState new_state):
+        cdef bint allowed = False
+
+        if new_state == UNWRAPPED:
+            allowed = True
+
+        elif self._state == UNWRAPPED and new_state == DO_HANDSHAKE:
+            allowed = True
+
+        elif self._state == DO_HANDSHAKE and new_state == WRAPPED:
+            allowed = True
+
+        elif self._state == WRAPPED and new_state == FLUSHING:
+            allowed = True
+
+        elif self._state == WRAPPED and new_state == SHUTDOWN:
+            allowed = True
+
+        elif self._state == FLUSHING and new_state == SHUTDOWN:
+            allowed = True
+
+        if allowed:
+            self._state = new_state
+
+        else:
+            raise RuntimeError(
+                'cannot switch state from {} to {}'.format(
+                    self._state, new_state))
+
+    # Handshake flow
+
+    cdef _start_handshake(self):
+        if self._loop.get_debug():
+            aio_logger.debug("%r starts SSL handshake", self)
+            self._handshake_start_time = self._loop.time()
+        else:
+            self._handshake_start_time = None
+
+        self._set_state(DO_HANDSHAKE)
+
+        # start handshake timeout count down
+        self._handshake_timeout_handle = \
+            self._loop.call_later(self._ssl_handshake_timeout,
+                                  lambda: self._check_handshake_timeout())
+
+        try:
+            self._sslobj = self._sslcontext.wrap_bio(
+                self._incoming, self._outgoing,
+                server_side=self._server_side,
+                server_hostname=self._server_hostname)
+            self._sslobj_read = self._sslobj.read
+            self._sslobj_write = self._sslobj.write
+        except Exception as ex:
+            self._on_handshake_complete(ex)
+        else:
+            self._do_handshake()
+
+    cdef _check_handshake_timeout(self):
+        if self._state == DO_HANDSHAKE:
+            msg = (
+                f"SSL handshake is taking longer than "
+                f"{self._ssl_handshake_timeout} seconds: "
+                f"aborting the connection"
+            )
+            self._fatal_error(ConnectionAbortedError(msg))
+
+    cdef _do_handshake(self):
+        try:
+            self._sslobj.do_handshake()
+        except ssl_SSLAgainErrors as exc:
+            self._process_outgoing()
+        except ssl_SSLError as exc:
+            self._on_handshake_complete(exc)
+        else:
+            self._on_handshake_complete(None)
+
+    cdef _on_handshake_complete(self, handshake_exc):
+        if self._handshake_timeout_handle is not None:
+            self._handshake_timeout_handle.cancel()
+            self._handshake_timeout_handle = None
+
+        sslobj = self._sslobj
+        try:
+            if handshake_exc is None:
+                self._set_state(WRAPPED)
+            else:
+                raise handshake_exc
+
+            peercert = sslobj.getpeercert()
+        except Exception as exc:
+            self._set_state(UNWRAPPED)
+            if isinstance(exc, ssl_CertificateError):
+                msg = 'SSL handshake failed on verifying the certificate'
+            else:
+                msg = 'SSL handshake failed'
+            self._fatal_error(exc, msg)
+            self._wakeup_waiter(exc)
+            return
+
+        if self._loop.get_debug():
+            dt = self._loop.time() - self._handshake_start_time
+            aio_logger.debug("%r: SSL handshake took %.1f ms", self, dt * 1e3)
+
+        # Add extra info that becomes available after handshake.
+        self._extra.update(peercert=peercert,
+                           cipher=sslobj.cipher(),
+                           compression=sslobj.compression(),
+                           ssl_object=sslobj)
+        if self._app_state == STATE_INIT:
+            self._app_state = STATE_CON_MADE
+            self._app_protocol.connection_made(self._get_app_transport())
+        self._wakeup_waiter()
+
+        # We should wakeup user code before sending the first data below. In
+        # case of `start_tls()`, the user can only get the SSLTransport in the
+        # wakeup callback, because `connection_made()` is not called again.
+        # We should schedule the first data later than the wakeup callback so
+        # that the user get a chance to e.g. check ALPN with the transport
+        # before having to handle the first data.
+        self._loop._call_soon_handle(
+            new_MethodHandle(self._loop,
+                             "SSLProtocol._do_read",
+                             <method_t> self._do_read,
+                             None,  # current context is good
+                             self))
+
+    # Shutdown flow
+
+    cdef _start_shutdown(self, object context=None):
+        if self._state in (FLUSHING, SHUTDOWN, UNWRAPPED):
+            return
+        # we don't need the context for _abort or the timeout, because
+        # TCP transport._force_close() should be able to call
+        # connection_lost() in the right context
+        if self._app_transport is not None:
+            self._app_transport._closed = True
+        if self._state == DO_HANDSHAKE:
+            self._abort(None)
+        else:
+            self._set_state(FLUSHING)
+            self._shutdown_timeout_handle = \
+                self._loop.call_later(self._ssl_shutdown_timeout,
+                                      lambda: self._check_shutdown_timeout())
+            self._do_flush(context)
+
+    cdef _check_shutdown_timeout(self):
+        if self._state in (FLUSHING, SHUTDOWN):
+            self._transport._force_close(
+                aio_TimeoutError('SSL shutdown timed out'))
+
+    cdef _do_read_into_void(self, object context):
+        """Consume and discard incoming application data.
+
+        If close_notify is received for the first time, call eof_received.
+        """
+        cdef:
+            bint close_notify = False
+        try:
+            while True:
+                if not self._sslobj_read(SSL_READ_MAX_SIZE):
+                    close_notify = True
+                    break
+        except ssl_SSLAgainErrors as exc:
+            pass
+        except ssl_SSLZeroReturnError:
+            close_notify = True
+        if close_notify:
+            self._call_eof_received(context)
+
+    cdef _do_flush(self, object context=None):
+        """Flush the write backlog, discarding new data received.
+
+        We don't send close_notify in FLUSHING because we still want to send
+        the remaining data over SSL, even if we received a close_notify. Also,
+        no application-level resume_writing() or pause_writing() will be called
+        in FLUSHING, as we could fully manage the flow control internally.
+        """
+        try:
+            self._do_read_into_void(context)
+            self._do_write()
+            self._process_outgoing()
+            self._control_ssl_reading()
+        except Exception as ex:
+            self._on_shutdown_complete(ex)
+        else:
+            if not self._get_write_buffer_size():
+                self._set_state(SHUTDOWN)
+                self._do_shutdown(context)
+
+    cdef _do_shutdown(self, object context=None):
+        """Send close_notify and wait for the same from the peer."""
+        try:
+            # we must skip all application data (if any) before unwrap
+            self._do_read_into_void(context)
+            try:
+                self._sslobj.unwrap()
+            except ssl_SSLAgainErrors as exc:
+                self._process_outgoing()
+            else:
+                self._process_outgoing()
+                if not self._get_write_buffer_size():
+                    self._on_shutdown_complete(None)
+        except Exception as ex:
+            self._on_shutdown_complete(ex)
+
+    cdef _on_shutdown_complete(self, shutdown_exc):
+        if self._shutdown_timeout_handle is not None:
+            self._shutdown_timeout_handle.cancel()
+            self._shutdown_timeout_handle = None
+
+        # we don't need the context here because TCP transport.close() should
+        # be able to call connection_made() in the right context
+        if shutdown_exc:
+            self._fatal_error(shutdown_exc, 'Error occurred during shutdown')
+        else:
+            self._transport.close()
+
+    cdef _abort(self, exc):
+        self._set_state(UNWRAPPED)
+        if self._transport is not None:
+            self._transport._force_close(exc)
+
+    # Outgoing flow
+
+    cdef _write_appdata(self, list_of_data, object context):
+        if self._state in (FLUSHING, SHUTDOWN, UNWRAPPED):
+            if self._conn_lost >= LOG_THRESHOLD_FOR_CONNLOST_WRITES:
+                aio_logger.warning('SSL connection is closed')
+            self._conn_lost += 1
+            return
+
+        for data in list_of_data:
+            self._write_backlog.append(data)
+            self._write_buffer_size += len(data)
+
+        try:
+            if self._state == WRAPPED:
+                self._do_write()
+                self._process_outgoing()
+                self._control_app_writing(context)
+
+        except Exception as ex:
+            self._fatal_error(ex, 'Fatal error on SSL protocol')
+
+    cdef _do_write(self):
+        """Do SSL write, consumes write backlog and fills outgoing BIO."""
+        cdef size_t data_len, count
+        try:
+            while self._write_backlog:
+                data = self._write_backlog[0]
+                count = self._sslobj_write(data)
+                data_len = len(data)
+                if count < data_len:
+                    if not PyMemoryView_Check(data):
+                        data = PyMemoryView_FromObject(data)
+                    self._write_backlog[0] = data[count:]
+                    self._write_buffer_size -= count
+                else:
+                    del self._write_backlog[0]
+                    self._write_buffer_size -= data_len
+        except ssl_SSLAgainErrors as exc:
+            pass
+
+    cdef _process_outgoing(self):
+        """Send bytes from the outgoing BIO."""
+        if not self._ssl_writing_paused:
+            data = self._outgoing_read()
+            if len(data):
+                self._transport.write(data)
+
+    # Incoming flow
+
+    cdef _do_read(self):
+        if self._state != WRAPPED:
+            return
+        try:
+            if not self._app_reading_paused:
+                if self._app_protocol_is_buffer:
+                    self._do_read__buffered()
+                else:
+                    self._do_read__copied()
+                if self._write_backlog:
+                    self._do_write()
+                self._process_outgoing()
+                self._control_app_writing()
+            self._control_ssl_reading()
+        except Exception as ex:
+            self._fatal_error(ex, 'Fatal error on SSL protocol')
+
+    cdef _do_read__buffered(self):
+        cdef:
+            Py_buffer pybuf
+            bint pybuf_inited = False
+            size_t wants, offset = 0
+            int count = 1
+            object buf
+
+        buf = self._app_protocol_get_buffer(self._get_read_buffer_size())
+        wants = len(buf)
+
+        try:
+            count = self._sslobj_read(wants, buf)
+
+            if count > 0:
+                offset = count
+                if offset < wants:
+                    PyObject_GetBuffer(buf, &pybuf, PyBUF_WRITABLE)
+                    pybuf_inited = True
+                while offset < wants:
+                    buf = PyMemoryView_FromMemory(
+                        (<char*>pybuf.buf) + offset,
+                        wants - offset,
+                        PyBUF_WRITE)
+                    count = self._sslobj_read(wants - offset, buf)
+                    if count > 0:
+                        offset += count
+                    else:
+                        break
+                else:
+                    self._loop._call_soon_handle(
+                        new_MethodHandle(self._loop,
+                                         "SSLProtocol._do_read",
+                                         <method_t>self._do_read,
+                                         None,  # current context is good
+                                         self))
+        except ssl_SSLAgainErrors as exc:
+            pass
+        finally:
+            if pybuf_inited:
+                PyBuffer_Release(&pybuf)
+        if offset > 0:
+            self._app_protocol_buffer_updated(offset)
+        if not count:
+            # close_notify
+            self._call_eof_received()
+            self._start_shutdown()
+
+    cdef _do_read__copied(self):
+        cdef:
+            list data
+            bytes first, chunk = b'1'
+            bint zero = True, one = False
+
+        try:
+            while True:
+                chunk = self._sslobj_read(SSL_READ_MAX_SIZE)
+                if not chunk:
+                    break
+                if zero:
+                    zero = False
+                    one = True
+                    first = chunk
+                elif one:
+                    one = False
+                    data = [first, chunk]
+                else:
+                    data.append(chunk)
+        except ssl_SSLAgainErrors as exc:
+            pass
+        if one:
+            self._app_protocol.data_received(first)
+        elif not zero:
+            self._app_protocol.data_received(b''.join(data))
+        if not chunk:
+            # close_notify
+            self._call_eof_received()
+            self._start_shutdown()
+
+    cdef _call_eof_received(self, object context=None):
+        if self._app_state == STATE_CON_MADE:
+            self._app_state = STATE_EOF
+            try:
+                if context is None:
+                    # If the caller didn't provide a context, we assume the
+                    # caller is already in the right context, which is usually
+                    # inside the upstream callbacks like buffer_updated()
+                    keep_open = self._app_protocol.eof_received()
+                else:
+                    keep_open = run_in_context(
+                        context, self._app_protocol.eof_received,
+                    )
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException as ex:
+                self._fatal_error(ex, 'Error calling eof_received()')
+            else:
+                if keep_open:
+                    aio_logger.warning('returning true from eof_received() '
+                                       'has no effect when using ssl')
+
+    # Flow control for writes from APP socket
+
+    cdef _control_app_writing(self, object context=None):
+        cdef size_t size = self._get_write_buffer_size()
+        if size >= self._outgoing_high_water and not self._app_writing_paused:
+            self._app_writing_paused = True
+            try:
+                if context is None:
+                    # If the caller didn't provide a context, we assume the
+                    # caller is already in the right context, which is usually
+                    # inside the upstream callbacks like buffer_updated()
+                    self._app_protocol.pause_writing()
+                else:
+                    run_in_context(context, self._app_protocol.pause_writing)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException as exc:
+                self._loop.call_exception_handler({
+                    'message': 'protocol.pause_writing() failed',
+                    'exception': exc,
+                    'transport': self._app_transport,
+                    'protocol': self,
+                })
+        elif size <= self._outgoing_low_water and self._app_writing_paused:
+            self._app_writing_paused = False
+            try:
+                if context is None:
+                    # If the caller didn't provide a context, we assume the
+                    # caller is already in the right context, which is usually
+                    # inside the upstream callbacks like resume_writing()
+                    self._app_protocol.resume_writing()
+                else:
+                    run_in_context(context, self._app_protocol.resume_writing)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except BaseException as exc:
+                self._loop.call_exception_handler({
+                    'message': 'protocol.resume_writing() failed',
+                    'exception': exc,
+                    'transport': self._app_transport,
+                    'protocol': self,
+                })
+
+    cdef size_t _get_write_buffer_size(self):
+        return self._outgoing.pending + self._write_buffer_size
+
+    cdef _set_write_buffer_limits(self, high=None, low=None):
+        high, low = add_flowcontrol_defaults(
+            high, low, FLOW_CONTROL_HIGH_WATER_SSL_WRITE)
+        self._outgoing_high_water = high
+        self._outgoing_low_water = low
+
+    # Flow control for reads to APP socket
+
+    cdef _pause_reading(self):
+        self._app_reading_paused = True
+
+    cdef _resume_reading(self, object context):
+        if self._app_reading_paused:
+            self._app_reading_paused = False
+            if self._state == WRAPPED:
+                self._loop._call_soon_handle(
+                    new_MethodHandle(self._loop,
+                                     "SSLProtocol._do_read",
+                                     <method_t>self._do_read,
+                                     context,
+                                     self))
+
+    # Flow control for reads from SSL socket
+
+    cdef _control_ssl_reading(self):
+        cdef size_t size = self._get_read_buffer_size()
+        if size >= self._incoming_high_water and not self._ssl_reading_paused:
+            self._ssl_reading_paused = True
+            self._transport.pause_reading()
+        elif size <= self._incoming_low_water and self._ssl_reading_paused:
+            self._ssl_reading_paused = False
+            self._transport.resume_reading()
+
+    cdef _set_read_buffer_limits(self, high=None, low=None):
+        high, low = add_flowcontrol_defaults(
+            high, low, FLOW_CONTROL_HIGH_WATER_SSL_READ)
+        self._incoming_high_water = high
+        self._incoming_low_water = low
+
+    cdef size_t _get_read_buffer_size(self):
+        return self._incoming.pending
+
+    # Flow control for writes to SSL socket
+
+    def pause_writing(self):
+        """Called when the low-level transport's buffer goes over
+        the high-water mark.
+        """
+        assert not self._ssl_writing_paused
+        self._ssl_writing_paused = True
+
+    def resume_writing(self):
+        """Called when the low-level transport's buffer drains below
+        the low-water mark.
+        """
+        assert self._ssl_writing_paused
+        self._ssl_writing_paused = False
+
+        if self._state == WRAPPED:
+            self._process_outgoing()
+            self._control_app_writing()
+
+        elif self._state == FLUSHING:
+            self._do_flush()
+
+        elif self._state == SHUTDOWN:
+            self._do_shutdown()
+
+    cdef _fatal_error(self, exc, message='Fatal error on transport'):
+        if self._app_transport:
+            self._app_transport._force_close(exc)
+        elif self._transport:
+            self._transport._force_close(exc)
+
+        if isinstance(exc, OSError):
+            if self._loop.get_debug():
+                aio_logger.debug("%r: %s", self, message, exc_info=True)
+        elif not isinstance(exc, aio_CancelledError):
+            self._loop.call_exception_handler({
+                'message': message,
+                'exception': exc,
+                'transport': self._transport,
+                'protocol': self,
+            })