summaryrefslogtreecommitdiff
path: root/venv/lib/python3.11/site-packages/uvloop
diff options
context:
space:
mode:
authorcyfraeviolae <cyfraeviolae>2024-04-03 03:17:55 -0400
committercyfraeviolae <cyfraeviolae>2024-04-03 03:17:55 -0400
commit12cf076118570eebbff08c6b3090e0d4798447a1 (patch)
tree3ba25e17e3c3a5e82316558ba3864b955919ff72 /venv/lib/python3.11/site-packages/uvloop
parentc45662ff3923b34614ddcc8feb9195541166dcc5 (diff)
no venv
Diffstat (limited to 'venv/lib/python3.11/site-packages/uvloop')
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/__init__.py168
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/__pycache__/__init__.cpython-311.pycbin7929 -> 0 bytes
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/__pycache__/_noop.cpython-311.pycbin366 -> 0 bytes
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/__pycache__/_testbase.cpython-311.pycbin31881 -> 0 bytes
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/__pycache__/_version.cpython-311.pycbin213 -> 0 bytes
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/_noop.py3
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/_testbase.py550
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/_version.py13
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/cbhandles.pxd39
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/cbhandles.pyx434
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/dns.pyx471
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/errors.pyx113
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/async_.pxd11
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/async_.pyx56
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/basetransport.pxd54
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/basetransport.pyx293
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/check.pxd14
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/check.pyx72
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/fsevent.pxd12
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/fsevent.pyx116
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/handle.pxd48
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/handle.pyx395
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/idle.pxd14
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/idle.pyx72
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/pipe.pxd33
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/pipe.pyx226
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/poll.pxd25
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/poll.pyx233
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/process.pxd80
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/process.pyx792
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/stream.pxd50
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/stream.pyx1015
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/streamserver.pxd26
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/streamserver.pyx150
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/tcp.pxd26
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/tcp.pyx228
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/timer.pxd18
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/timer.pyx89
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/udp.pxd22
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/handles/udp.pyx409
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/includes/__init__.py23
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/includes/__pycache__/__init__.cpython-311.pycbin749 -> 0 bytes
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/includes/consts.pxi25
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/includes/debug.pxd3
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/includes/flowcontrol.pxd23
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/includes/python.pxd31
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/includes/stdlib.pxi175
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/includes/system.pxd96
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/includes/uv.pxd506
-rwxr-xr-xvenv/lib/python3.11/site-packages/uvloop/loop.cpython-311-x86_64-linux-gnu.sobin11727344 -> 0 bytes
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/loop.pxd229
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/loop.pyi297
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/loop.pyx3403
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/lru.pyx79
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/pseudosock.pyx209
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/py.typed0
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/request.pxd8
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/request.pyx65
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/server.pxd19
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/server.pyx136
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/sslproto.pxd138
-rw-r--r--venv/lib/python3.11/site-packages/uvloop/sslproto.pyx950
62 files changed, 0 insertions, 12785 deletions
diff --git a/venv/lib/python3.11/site-packages/uvloop/__init__.py b/venv/lib/python3.11/site-packages/uvloop/__init__.py
deleted file mode 100644
index 9bb6592..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/__init__.py
+++ /dev/null
@@ -1,168 +0,0 @@
-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
deleted file mode 100644
index ebc913e..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/__pycache__/__init__.cpython-311.pyc
+++ /dev/null
Binary files differ
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
deleted file mode 100644
index 155eaae..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/__pycache__/_noop.cpython-311.pyc
+++ /dev/null
Binary files differ
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
deleted file mode 100644
index ca115de..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/__pycache__/_testbase.cpython-311.pyc
+++ /dev/null
Binary files differ
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
deleted file mode 100644
index e31e416..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/__pycache__/_version.cpython-311.pyc
+++ /dev/null
Binary files differ
diff --git a/venv/lib/python3.11/site-packages/uvloop/_noop.py b/venv/lib/python3.11/site-packages/uvloop/_noop.py
deleted file mode 100644
index bfc14dc..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/_noop.py
+++ /dev/null
@@ -1,3 +0,0 @@
-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
deleted file mode 100644
index c4a7595..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/_testbase.py
+++ /dev/null
@@ -1,550 +0,0 @@
-"""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
deleted file mode 100644
index 0667c6a..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/_version.py
+++ /dev/null
@@ -1,13 +0,0 @@
-# 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
deleted file mode 100644
index e594b13..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/cbhandles.pxd
+++ /dev/null
@@ -1,39 +0,0 @@
-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
deleted file mode 100644
index 2914b42..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/cbhandles.pyx
+++ /dev/null
@@ -1,434 +0,0 @@
-@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
deleted file mode 100644
index 7aad631..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/dns.pyx
+++ /dev/null
@@ -1,471 +0,0 @@
-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
deleted file mode 100644
index d810d65..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/errors.pyx
+++ /dev/null
@@ -1,113 +0,0 @@
-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
deleted file mode 100644
index 5f0d820..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/async_.pxd
+++ /dev/null
@@ -1,11 +0,0 @@
-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
deleted file mode 100644
index 5c740cf..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/async_.pyx
+++ /dev/null
@@ -1,56 +0,0 @@
-@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
deleted file mode 100644
index ba356a7..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/basetransport.pxd
+++ /dev/null
@@ -1,54 +0,0 @@
-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
deleted file mode 100644
index 28b3079..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/basetransport.pyx
+++ /dev/null
@@ -1,293 +0,0 @@
-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
deleted file mode 100644
index 86cfd8f..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/check.pxd
+++ /dev/null
@@ -1,14 +0,0 @@
-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
deleted file mode 100644
index 1a61c4e..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/check.pyx
+++ /dev/null
@@ -1,72 +0,0 @@
-@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
deleted file mode 100644
index 3a32428..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/fsevent.pxd
+++ /dev/null
@@ -1,12 +0,0 @@
-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
deleted file mode 100644
index 6ed6433..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/fsevent.pyx
+++ /dev/null
@@ -1,116 +0,0 @@
-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
deleted file mode 100644
index 5af1c14..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/handle.pxd
+++ /dev/null
@@ -1,48 +0,0 @@
-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
deleted file mode 100644
index 6efe375..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/handle.pyx
+++ /dev/null
@@ -1,395 +0,0 @@
-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
deleted file mode 100644
index cf7b19f..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/idle.pxd
+++ /dev/null
@@ -1,14 +0,0 @@
-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
deleted file mode 100644
index 91c641f..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/idle.pyx
+++ /dev/null
@@ -1,72 +0,0 @@
-@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
deleted file mode 100644
index 56fc265..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/pipe.pxd
+++ /dev/null
@@ -1,33 +0,0 @@
-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
deleted file mode 100644
index 195576c..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/pipe.pyx
+++ /dev/null
@@ -1,226 +0,0 @@
-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
deleted file mode 100644
index d07030b..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/poll.pxd
+++ /dev/null
@@ -1,25 +0,0 @@
-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
deleted file mode 100644
index fca5981..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/poll.pyx
+++ /dev/null
@@ -1,233 +0,0 @@
-@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
deleted file mode 100644
index 970abcf..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/process.pxd
+++ /dev/null
@@ -1,80 +0,0 @@
-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
deleted file mode 100644
index 63b982a..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/process.pyx
+++ /dev/null
@@ -1,792 +0,0 @@
-@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
deleted file mode 100644
index 8ca8743..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/stream.pxd
+++ /dev/null
@@ -1,50 +0,0 @@
-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
deleted file mode 100644
index d4e02e3..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/stream.pyx
+++ /dev/null
@@ -1,1015 +0,0 @@
-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
deleted file mode 100644
index a004efd..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/streamserver.pxd
+++ /dev/null
@@ -1,26 +0,0 @@
-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
deleted file mode 100644
index 9993317..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/streamserver.pyx
+++ /dev/null
@@ -1,150 +0,0 @@
-@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
deleted file mode 100644
index 8d388ef..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/tcp.pxd
+++ /dev/null
@@ -1,26 +0,0 @@
-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
deleted file mode 100644
index d5fe827..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/tcp.pyx
+++ /dev/null
@@ -1,228 +0,0 @@
-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
deleted file mode 100644
index fda23b6..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/timer.pxd
+++ /dev/null
@@ -1,18 +0,0 @@
-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
deleted file mode 100644
index 86d46ef..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/timer.pyx
+++ /dev/null
@@ -1,89 +0,0 @@
-@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
deleted file mode 100644
index daa9a1b..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/udp.pxd
+++ /dev/null
@@ -1,22 +0,0 @@
-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
deleted file mode 100644
index bbe60d5..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/handles/udp.pyx
+++ /dev/null
@@ -1,409 +0,0 @@
-@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
deleted file mode 100644
index 2ccf9ca..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/includes/__init__.py
+++ /dev/null
@@ -1,23 +0,0 @@
-# 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
deleted file mode 100644
index a4464aa..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/includes/__pycache__/__init__.cpython-311.pyc
+++ /dev/null
Binary files differ
diff --git a/venv/lib/python3.11/site-packages/uvloop/includes/consts.pxi b/venv/lib/python3.11/site-packages/uvloop/includes/consts.pxi
deleted file mode 100644
index f765053..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/includes/consts.pxi
+++ /dev/null
@@ -1,25 +0,0 @@
-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
deleted file mode 100644
index a825def..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/includes/debug.pxd
+++ /dev/null
@@ -1,3 +0,0 @@
-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
deleted file mode 100644
index f22f1a7..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/includes/flowcontrol.pxd
+++ /dev/null
@@ -1,23 +0,0 @@
-# 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
deleted file mode 100644
index 454d5c7..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/includes/python.pxd
+++ /dev/null
@@ -1,31 +0,0 @@
-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
deleted file mode 100644
index e7957fe..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/includes/stdlib.pxi
+++ /dev/null
@@ -1,175 +0,0 @@
-# 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
deleted file mode 100644
index 367fedd..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/includes/system.pxd
+++ /dev/null
@@ -1,96 +0,0 @@
-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
deleted file mode 100644
index 8765130..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/includes/uv.pxd
+++ /dev/null
@@ -1,506 +0,0 @@
-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
deleted file mode 100755
index 58ae5dc..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/loop.cpython-311-x86_64-linux-gnu.so
+++ /dev/null
Binary files differ
diff --git a/venv/lib/python3.11/site-packages/uvloop/loop.pxd b/venv/lib/python3.11/site-packages/uvloop/loop.pxd
deleted file mode 100644
index 5613473..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/loop.pxd
+++ /dev/null
@@ -1,229 +0,0 @@
-# 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
deleted file mode 100644
index 9c8c462..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/loop.pyi
+++ /dev/null
@@ -1,297 +0,0 @@
-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
deleted file mode 100644
index 334d8d5..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/loop.pyx
+++ /dev/null
@@ -1,3403 +0,0 @@
-# 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
deleted file mode 100644
index cc7ea1d..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/lru.pyx
+++ /dev/null
@@ -1,79 +0,0 @@
-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
deleted file mode 100644
index 10a1ad6..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/pseudosock.pyx
+++ /dev/null
@@ -1,209 +0,0 @@
-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
deleted file mode 100644
index e69de29..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/py.typed
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/uvloop/request.pxd b/venv/lib/python3.11/site-packages/uvloop/request.pxd
deleted file mode 100644
index bafa51d..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/request.pxd
+++ /dev/null
@@ -1,8 +0,0 @@
-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
deleted file mode 100644
index f15103a..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/request.pyx
+++ /dev/null
@@ -1,65 +0,0 @@
-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
deleted file mode 100644
index ef10f81..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/server.pxd
+++ /dev/null
@@ -1,19 +0,0 @@
-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
deleted file mode 100644
index 845bcfd..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/server.pyx
+++ /dev/null
@@ -1,136 +0,0 @@
-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
deleted file mode 100644
index 3da10f0..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/sslproto.pxd
+++ /dev/null
@@ -1,138 +0,0 @@
-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
deleted file mode 100644
index 42bb764..0000000
--- a/venv/lib/python3.11/site-packages/uvloop/sslproto.pyx
+++ /dev/null
@@ -1,950 +0,0 @@
-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,
- })