summaryrefslogtreecommitdiff
path: root/venv/lib/python3.11/site-packages/uvloop/handles
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/handles
parentc45662ff3923b34614ddcc8feb9195541166dcc5 (diff)
no venv
Diffstat (limited to 'venv/lib/python3.11/site-packages/uvloop/handles')
-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
28 files changed, 0 insertions, 4579 deletions
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)