zuvloop 0.0.2__tar.gz → 0.0.3__tar.gz

{zuvloop-0.0.2 → zuvloop-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: zuvloop
-Version: 0.0.2
+Version: 0.0.3
 Summary: A libuv event loop for asyncio, written in Zig.
 Project-URL: Source, https://github.com/Kludex/zuvloop
 Author-email: Marcelo Trylesinski <marcelotryle@gmail.com>
@@ -122,9 +122,11 @@ That's it. That's the migration. 🎉
 ## Observability
 
 zuvloop emits plain OpenTelemetry. The only runtime dependency is `opentelemetry-api` — not the
-SDK, nothing vendor-specific. Configure providers before starting the loop; zuvloop checks for them
-at each `run_forever()` entry. Until then the instruments are no-ops and slow-callback timing stays
-off.
+SDK, nothing vendor-specific. Providers can be configured before the loop starts or from inside
+it — `logfire.configure()` in `main()` works: zuvloop checks at each `run_forever()` entry and
+re-checks on its sampling interval (`loop.metrics_interval`, 10 seconds by default) while the
+loop runs. Until a provider is installed the instruments are no-ops and slow-callback timing
+stays off.
 
 Anything that speaks OpenTelemetry can collect it. For example, with
 <a href="https://logfire.pydantic.dev" target="_blank">Logfire</a>:
@@ -144,8 +146,8 @@ zuvloop.run(main())
 
 That's all — there is no zuvloop-specific setup. Spans and counters are emitted
 as events happen, and the loop gauges are sampled automatically while the loop
-runs (only when a real provider is installed, so an uninstrumented program never
-pays for sampling).
+runs (published only once a real provider is installed; without one the
+snapshot is dropped).
 
 You get:
 
@@ -193,7 +195,7 @@ zuvloop keeps its timer heap in native code and reads the clock directly, so mon
 returns and nothing else. A loop that needs a controllable clock should schedule against one
 explicitly.
 
-Also not implemented: `sendfile()` and `sock_sendfile()` raise `NotImplementedError`. Handles
+One more deliberate divergence: handles
 returned by `call_soon` implement the `asyncio.Handle` interface but are not instances of it:
 the base class is 56 bytes of storage such a handle never writes, measured at 2% of `call_soon`,
 which is the object the loop allocates more often than any other. `call_later` and `call_at`

{zuvloop-0.0.2 → zuvloop-0.0.3}/README.md

@@ -98,9 +98,11 @@ That's it. That's the migration. 🎉
 ## Observability
 
 zuvloop emits plain OpenTelemetry. The only runtime dependency is `opentelemetry-api` — not the
-SDK, nothing vendor-specific. Configure providers before starting the loop; zuvloop checks for them
-at each `run_forever()` entry. Until then the instruments are no-ops and slow-callback timing stays
-off.
+SDK, nothing vendor-specific. Providers can be configured before the loop starts or from inside
+it — `logfire.configure()` in `main()` works: zuvloop checks at each `run_forever()` entry and
+re-checks on its sampling interval (`loop.metrics_interval`, 10 seconds by default) while the
+loop runs. Until a provider is installed the instruments are no-ops and slow-callback timing
+stays off.
 
 Anything that speaks OpenTelemetry can collect it. For example, with
 <a href="https://logfire.pydantic.dev" target="_blank">Logfire</a>:
@@ -120,8 +122,8 @@ zuvloop.run(main())
 
 That's all — there is no zuvloop-specific setup. Spans and counters are emitted
 as events happen, and the loop gauges are sampled automatically while the loop
-runs (only when a real provider is installed, so an uninstrumented program never
-pays for sampling).
+runs (published only once a real provider is installed; without one the
+snapshot is dropped).
 
 You get:
 
@@ -169,7 +171,7 @@ zuvloop keeps its timer heap in native code and reads the clock directly, so mon
 returns and nothing else. A loop that needs a controllable clock should schedule against one
 explicitly.
 
-Also not implemented: `sendfile()` and `sock_sendfile()` raise `NotImplementedError`. Handles
+One more deliberate divergence: handles
 returned by `call_soon` implement the `asyncio.Handle` interface but are not instances of it:
 the base class is 56 bytes of storage such a handle never writes, measured at 2% of `call_soon`,
 which is the object the loop allocates more often than any other. `call_later` and `call_at`

{zuvloop-0.0.2 → zuvloop-0.0.3}/pyproject.toml

@@ -1,14 +1,18 @@
 [build-system]
-requires = ["hatchling", "hatch-ziglang", "ziglang==0.16.0"]
+# hatch-ziglang is pinned exactly: it runs during the isolated wheel build and
+# invokes the native compiler, so a future version resolved from a lower bound
+# could execute unreviewed code into the wheels the publish job trusts. The
+# compiler is pinned for the same reason. Bump both deliberately.
+requires = ["hatchling", "hatch-vcs", "hatch-ziglang==0.2.1", "ziglang==0.16.0"]
 build-backend = "hatchling.build"
 
 [project]
 name = "zuvloop"
-version = "0.0.2"
 description = "A libuv event loop for asyncio, written in Zig."
 readme = "README.md"
 requires-python = ">=3.14"
 license = "MIT"
+dynamic = ["version"]
 # libuv is compiled into the extension, so its licence ships with the wheel.
 license-files = ["LICENSE", "vendor/libuv/LICENSE*"]
 authors = [{ name = "Marcelo Trylesinski", email = "marcelotryle@gmail.com" }]
@@ -40,6 +44,17 @@ dev = [
 bench = ["aiohttp", "httptools", "pytest-codspeed>=5", "uvicorn", "uvloop>=0.21"]
 docs = ["zensical"]
 
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.version.raw-options]
+# A tag is the version; commits after it are the next patch's dev builds, so an
+# untagged build can never claim to be the release. `no-local-version` drops the
+# `+<hash>` segment, which PyPI refuses on upload.
+version_scheme = "guess-next-dev"
+local_scheme = "no-local-version"
+fallback_version = "0.0.0"
+
 [tool.hatch.build.targets.wheel]
 packages = ["zuvloop"]
 

{zuvloop-0.0.2 → zuvloop-0.0.3}/zig/transport.zig

@@ -1005,6 +1005,10 @@ fn forceCloseMethod(self_obj: *py.Object, exc: *py.Object) py.Error!*py.Object {
     return py.noneRef();
 }
 
+fn getProtocolPaused(self_obj: ?*py.Object, _: ?*anyopaque) callconv(.c) ?*py.Object {
+    return py.boolRef(asTransport(self_obj.?).flags & PROTOCOL_PAUSED != 0);
+}
+
 // ---------------------------------------------------------------------------
 // construction
 
@@ -1225,12 +1229,19 @@ var methods = [_]c.PyMethodDef{
     py.sentinel,
 };
 
+// asyncio's name for this state; its sendfile machinery reads it off transports.
+var getsets = [_]c.PyGetSetDef{
+    .{ .name = "_protocol_paused", .get = getProtocolPaused, .set = null, .doc = "Whether flow control has paused the protocol.", .closure = null },
+    .{ .name = null, .get = null, .set = null, .doc = null, .closure = null },
+};
+
 var slots = [_]c.PyType_Slot{
     .{ .slot = c.Py_tp_dealloc, .pfunc = @ptrCast(@constCast(&dealloc)) },
     .{ .slot = c.Py_tp_traverse, .pfunc = @ptrCast(@constCast(&traverse)) },
     .{ .slot = c.Py_tp_clear, .pfunc = @ptrCast(@constCast(&clear_)) },
     .{ .slot = c.Py_tp_repr, .pfunc = @ptrCast(@constCast(&repr)) },
     .{ .slot = c.Py_tp_methods, .pfunc = @ptrCast(&methods) },
+    .{ .slot = c.Py_tp_getset, .pfunc = @ptrCast(&getsets) },
     .{ .slot = c.Py_tp_doc, .pfunc = @ptrCast(@constCast("A libuv-backed stream transport.")) },
     .{ .slot = 0, .pfunc = null },
 };

{zuvloop-0.0.2 → zuvloop-0.0.3}/zuvloop/_base.py

@@ -36,8 +36,10 @@ class LoopBase(_zuvloop.Loop, asyncio.AbstractEventLoop):  # type: ignore[misc]
     orchestration that runs once per loop or once per connection.
     """
 
-    # How often the loop gauges are sampled while a real OpenTelemetry meter
-    # provider is installed. Assign before running the loop to change it.
+    # How often the native sampler fires while the loop runs. It publishes the
+    # loop gauges when a meter provider is installed, and it is also how quickly
+    # a provider configured after the loop started is noticed. Assign before
+    # running the loop to change it.
     metrics_interval: float = 10.0
 
     def __init__(self) -> None:
@@ -52,6 +54,8 @@ class LoopBase(_zuvloop.Loop, asyncio.AbstractEventLoop):  # type: ignore[misc]
         self._sock_watchers: dict[tuple[int, bool], object] = {}
         self._wakeup_fd_attached = False
         self._instrumentation = Instrumentation()
+        self._monitoring_armed = False
+        self._metrics_armed = False
         self._setup_self_pipe()
 
     def __del__(self, _warn: Callable[..., object] = warnings.warn) -> None:
@@ -100,11 +104,10 @@ class LoopBase(_zuvloop.Loop, asyncio.AbstractEventLoop):  # type: ignore[misc]
         self._attach_wakeup_fd()
         _events._set_running_loop(self)
         sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter, finalizer=self._asyncgen_finalizer)
-        # Gauges cost nothing to skip and something to sample, so the sampler
-        # runs exactly when there is somewhere for the numbers to go.
-        if metrics_provider_installed():
-            self._start_metrics(self.metrics_interval, publish_metrics)
-        self._set_slow_callback_monitoring(instrumentation_provider_installed())
+        self._monitoring_armed = instrumentation_provider_installed()
+        self._metrics_armed = metrics_provider_installed()
+        self._set_slow_callback_monitoring(self._monitoring_armed)
+        self._start_metrics(self.metrics_interval, self._on_sample)
         try:
             self._run()
         finally:
@@ -253,6 +256,15 @@ class LoopBase(_zuvloop.Loop, asyncio.AbstractEventLoop):  # type: ignore[misc]
     def _on_slow_callback(self, handle: object, duration: float) -> None:
         self._instrumentation.report_slow_callback(handle, duration)
 
+    def _on_sample(self, snapshot: dict[str, int]) -> None:
+        if not self._monitoring_armed and instrumentation_provider_installed():
+            self._monitoring_armed = True
+            self._set_slow_callback_monitoring(True)
+        if not self._metrics_armed:
+            self._metrics_armed = metrics_provider_installed()
+        if self._metrics_armed:
+            publish_metrics(snapshot)
+
     # -- internals ---------------------------------------------------------
 
     def _check_closed(self) -> None:

{zuvloop-0.0.2 → zuvloop-0.0.3}/zuvloop/_connect.py

@@ -15,15 +15,15 @@ from typing import Any, cast
 
 from . import _zuvloop
 from ._process import Popen
+from ._sendfile import SendfileOperations
 from ._server import Server
-from ._sockets import SocketOperations
 
 # What `getaddrinfo` hands back: family, kind, protocol, canonical name, address.
 type _AddrInfo = tuple[int, int, int, str, tuple[str, int] | tuple[str, int, int, int]]
 _SSLArg = ssl_module.SSLContext | bool | None
 
 
-class ConnectionOperations(SocketOperations):
+class ConnectionOperations(SendfileOperations):
     """Connection and server setup.
 
     Sockets are created and bound here; once connected the descriptor is handed

{zuvloop-0.0.2 → zuvloop-0.0.3}/zuvloop/_instrumentation.py

@@ -64,10 +64,10 @@ class Instrumentation:
                     "code.callback": repr(handle),
                     "duration": duration,
                     "asyncio.call_graph": capture_call_graph(handle),
+                    "logfire.level_num": 13,
                 }
             ),
         )
-        span.set_status(Status(StatusCode.ERROR, "callback exceeded slow_callback_duration"))
         span.end(end_time=ended)
 
     def report_exception(self, context: dict[str, Any]) -> None:

zuvloop-0.0.3/zuvloop/_sendfile.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+
+import asyncio
+import errno
+import os
+import socket
+import ssl
+from asyncio.constants import _SendfileMode
+from typing import IO, cast
+
+from . import _zuvloop
+from ._sockets import SocketOperations
+
+# CPython's fallback read sizes: large reads straight to a socket, smaller ones
+# through a transport so flow control gets a say between chunks.
+_SOCKET_CHUNK = 256 * 1024
+_TRANSPORT_CHUNK = 16 * 1024
+
+
+class SendfileOperations(SocketOperations):
+    """`sendfile()` and `sock_sendfile()`: `os.sendfile` straight to the
+    descriptor when the target is a plain socket, chunked writes when it is
+    behind TLS or not a regular file."""
+
+    async def sock_sendfile(  # type: ignore[override]  # typeshed allows fallback=None
+        self, sock: socket.socket, file: IO[bytes], offset: int = 0, count: int | None = None, *, fallback: bool = True
+    ) -> int:
+        self._check_non_blocking(sock)
+        _check_sendfile_params(sock, file, offset, count)
+        try:
+            return await self._sendfile_to_fd(sock.fileno(), file, offset, count)
+        except asyncio.SendfileNotAvailableError:
+            if not fallback:
+                raise
+        return await self._sock_sendfile_fallback(sock, file, offset, count)
+
+    async def sendfile(
+        self,
+        transport: asyncio.WriteTransport,
+        file: IO[bytes],
+        offset: int = 0,
+        count: int | None = None,
+        *,
+        fallback: bool = True,
+    ) -> int:
+        if transport.is_closing():
+            raise RuntimeError("Transport is closing")
+        _check_file_params(file, offset, count)
+        if isinstance(transport, _zuvloop.Transport):
+            sock = transport.get_extra_info("socket")
+            if sock is not None:
+                try:
+                    return await self._transport_sendfile_native(transport, sock, file, offset, count)
+                except asyncio.SendfileNotAvailableError:
+                    if not fallback:
+                        raise
+            elif not fallback:
+                raise asyncio.SendfileNotAvailableError(f"native sendfile is not supported for transport {transport!r}")
+            return await self._sendfile_fallback(transport, file, offset, count)
+        mode = getattr(transport, "_sendfile_compatible", _SendfileMode.UNSUPPORTED)
+        if mode == _SendfileMode.UNSUPPORTED:
+            raise RuntimeError(f"sendfile is not supported for transport {transport!r}")
+        if not fallback and mode != _SendfileMode.TRY_NATIVE:
+            raise RuntimeError(f"fallback is disabled and native sendfile is not supported for transport {transport!r}")
+        if not fallback:
+            raise asyncio.SendfileNotAvailableError(f"native sendfile is not supported for transport {transport!r}")
+        return await self._sendfile_fallback(transport, file, offset, count)
+
+    async def _transport_sendfile_native(
+        self, transport: _zuvloop.Transport, sock: socket.socket, file: IO[bytes], offset: int, count: int | None
+    ) -> int:
+        # Reject non-regular files before disturbing the transport at all.
+        fileno = _regular_fileno(file)
+        waiter = _SendfileProtocol(self, transport, transport._protocol_paused)
+        low, high = transport.get_write_buffer_limits()
+        # With both marks at zero, `resume_writing` fires exactly when libuv has
+        # handed the last buffered byte to the socket - the point after which
+        # writing to the descriptor directly cannot reorder data.
+        transport.set_write_buffer_limits(high=0, low=0)
+        try:
+            if transport.get_write_buffer_size() > 0:
+                await waiter.drain()
+            # libuv allows one handle per descriptor, so readiness is polled
+            # through a duplicate; both name the same socket.
+            fd = os.dup(sock.fileno())
+            try:
+                return await self._sendfile_to_fd(fd, file, offset, count, fileno)
+            finally:
+                os.close(fd)
+        finally:
+            transport.set_write_buffer_limits(high=high, low=low)
+            waiter.restore()
+
+    async def _sendfile_to_fd(
+        self, fd: int, file: IO[bytes], offset: int, count: int | None, fileno: int | None = None
+    ) -> int:
+        if fileno is None:
+            fileno = _regular_fileno(file)
+        blocksize = count if count is not None else os.fstat(fileno).st_size
+        total_sent = 0
+        try:
+            while blocksize > 0:
+                try:
+                    sent = cast("int", await self._retry_ready(fd, True, os.sendfile, (fd, fileno, offset, blocksize)))
+                except OSError as exc:
+                    if total_sent == 0:
+                        # The main reason to get here is `file` not being a
+                        # regular mmap-able file; the fallback's plain writes
+                        # will either work or report the real failure.
+                        raise asyncio.SendfileNotAvailableError("os.sendfile call failed") from exc
+                    if exc.errno == errno.ENOTCONN and not isinstance(exc, ConnectionError):
+                        # A disconnect surfaces as ENOTCONN on some platforms;
+                        # every caller should see it as the same failure.
+                        raise ConnectionError("socket is not connected", errno.ENOTCONN) from exc
+                    raise
+                if sent == 0:
+                    break
+                offset += sent
+                total_sent += sent
+                if count is not None:
+                    blocksize = count - total_sent
+            return total_sent
+        finally:
+            if total_sent > 0:
+                os.lseek(fileno, offset, os.SEEK_SET)
+
+    async def _sock_sendfile_fallback(
+        self, sock: socket.socket, file: IO[bytes], offset: int, count: int | None
+    ) -> int:
+        if offset:
+            file.seek(offset)
+        blocksize = min(count, _SOCKET_CHUNK) if count is not None else _SOCKET_CHUNK
+        total_sent = 0
+        try:
+            while blocksize > 0:
+                data = await self.run_in_executor(None, file.read, blocksize)
+                if not data:
+                    break
+                await self.sock_sendall(sock, data)
+                total_sent += len(data)
+                if count is not None:
+                    blocksize = min(count - total_sent, _SOCKET_CHUNK)
+            return total_sent
+        finally:
+            if total_sent > 0 and hasattr(file, "seek"):
+                file.seek(offset + total_sent)
+
+    async def _sendfile_fallback(
+        self, transport: asyncio.WriteTransport, file: IO[bytes], offset: int, count: int | None
+    ) -> int:
+        if offset:
+            file.seek(offset)
+        blocksize = min(count, _TRANSPORT_CHUNK) if count is not None else _TRANSPORT_CHUNK
+        total_sent = 0
+        waiter = _SendfileProtocol(self, transport, bool(getattr(transport, "_protocol_paused", False)))
+        try:
+            while blocksize > 0:
+                data = await self.run_in_executor(None, file.read, blocksize)
+                if not data:
+                    break
+                await waiter.drain()
+                transport.write(data)
+                total_sent += len(data)
+                if count is not None:
+                    blocksize = min(count - total_sent, _TRANSPORT_CHUNK)
+            return total_sent
+        finally:
+            if total_sent > 0 and hasattr(file, "seek"):
+                file.seek(offset + total_sent)
+            waiter.restore()
+
+
+class _SendfileProtocol(asyncio.Protocol):
+    """Stands in for the transport's protocol while `sendfile()` owns the stream.
+
+    Reading pauses for the duration; writability is answered through the flow
+    control callbacks the transport already makes. `restore()` reinstates the
+    real protocol and replays the flow-control state it last saw.
+    """
+
+    def __init__(self, loop: SendfileOperations, transport: asyncio.WriteTransport, paused: bool) -> None:
+        self._loop = loop
+        self._transport = cast("asyncio.Transport", transport)
+        self._protocol = self._transport.get_protocol()
+        self._should_resume_reading = self._transport.is_reading()
+        self._should_resume_writing = paused
+        self._waiter: asyncio.Future[None] | None = loop.create_future() if paused else None
+        self._transport.pause_reading()
+        self._transport.set_protocol(self)
+
+    def connection_made(self, transport: asyncio.BaseTransport) -> None:
+        raise RuntimeError("Invalid state: connection should have been established already")
+
+    def connection_lost(self, exc: Exception | None) -> None:
+        if self._waiter is not None and not self._waiter.done():
+            self._waiter.set_exception(exc if exc is not None else ConnectionError("Connection is closed by peer"))
+        self._protocol.connection_lost(exc)
+
+    def data_received(self, data: bytes) -> None:
+        raise RuntimeError("Invalid state: reading should be paused")
+
+    def eof_received(self) -> bool:
+        raise RuntimeError("Invalid state: reading should be paused")
+
+    def pause_writing(self) -> None:
+        if self._waiter is None:
+            self._waiter = self._loop.create_future()
+
+    def resume_writing(self) -> None:
+        if self._waiter is not None:
+            self._waiter.set_result(None)
+            self._waiter = None
+
+    async def drain(self) -> None:
+        if self._transport.is_closing():
+            raise ConnectionError("Connection closed by peer")
+        if self._waiter is not None:
+            await self._waiter
+
+    def restore(self) -> None:
+        self._transport.set_protocol(self._protocol)
+        if self._should_resume_reading:
+            self._transport.resume_reading()
+        if self._waiter is not None:
+            if not self._waiter.done():
+                self._waiter.cancel()
+            elif not self._waiter.cancelled():
+                # A failure connection_lost() recorded that nobody awaited
+                # would otherwise be reported as an unretrieved exception.
+                self._waiter.exception()
+            self._waiter = None
+        # A transport still over its high-water mark delivers its own
+        # resume_writing() once it drains; replaying one now would be an
+        # invitation to write into the backlog.
+        if self._should_resume_writing and not getattr(self._transport, "_protocol_paused", False):
+            self._protocol.resume_writing()
+
+
+def _check_sendfile_params(sock: socket.socket, file: IO[bytes], offset: int, count: int | None) -> None:
+    if isinstance(sock, ssl.SSLSocket):
+        raise TypeError("Socket cannot be of type SSLSocket")
+    if sock.type != socket.SOCK_STREAM:
+        raise ValueError("only SOCK_STREAM type sockets are supported")
+    _check_file_params(file, offset, count)
+
+
+def _check_file_params(file: IO[bytes], offset: int, count: int | None) -> None:
+    if "b" not in getattr(file, "mode", "b"):
+        raise ValueError("file should be opened in binary mode")
+    if count is not None:
+        if not isinstance(count, int):
+            raise TypeError(f"count must be a positive integer (got {count!r})")
+        if count <= 0:
+            raise ValueError(f"count must be a positive integer (got {count!r})")
+    if not isinstance(offset, int):
+        raise TypeError(f"offset must be a non-negative integer (got {offset!r})")
+    if offset < 0:
+        raise ValueError(f"offset must be a non-negative integer (got {offset!r})")
+
+
+def _regular_fileno(file: IO[bytes]) -> int:
+    """The descriptor `os.sendfile` can read, or `SendfileNotAvailableError`."""
+    try:
+        fileno = file.fileno()
+        os.fstat(fileno)
+    except (AttributeError, OSError) as exc:
+        raise asyncio.SendfileNotAvailableError("not a regular file") from exc
+    return fileno

{zuvloop-0.0.2 → zuvloop-0.0.3}/zuvloop/_sockets.py

@@ -34,18 +34,23 @@ class SocketOperations(LoopBase):
         self, sock: socket.socket, op: Callable[..., Any], *args: Any, write: bool = False
     ) -> Any:
         """Run `op`, retrying it each time `sock` reports itself ready."""
-        _check_non_blocking(sock)
+        self._check_non_blocking(sock)
+        return await self._retry_ready(sock.fileno(), write, op, args)
+
+    async def _retry_ready(self, fd: int, write: bool, op: Callable[..., Any], args: tuple[Any, ...]) -> Any:
         future = self.create_future()
         if _attempt(future, op, args):
             return await future
-
-        fd = sock.fileno()
         token = self._watch(fd, write, _attempt, future, op, args)
         try:
             return await future
         finally:
             self._unwatch(fd, write, token)
 
+    def _check_non_blocking(self, sock: socket.socket) -> None:
+        if sock.gettimeout() != 0:
+            raise ValueError("the socket must be non-blocking")
+
     async def sock_recv(self, sock: socket.socket, nbytes: int) -> bytes:
         return await self._retry_until_ready(sock, sock.recv, nbytes)  # type: ignore[no-any-return]
 
@@ -73,7 +78,7 @@ class SocketOperations(LoopBase):
             sent += await self._retry_until_ready(sock, _send_chunk, sock, view, sent, write=True)
 
     async def sock_connect(self, sock: socket.socket, address: Any) -> None:
-        _check_non_blocking(sock)
+        self._check_non_blocking(sock)
         if sock.family in (socket.AF_INET, socket.AF_INET6):
             resolved = await self.getaddrinfo(*address[:2], family=sock.family, type=sock.type, proto=sock.proto)
             address = resolved[0][4]
@@ -101,22 +106,6 @@ class SocketOperations(LoopBase):
         finally:
             self._unwatch(fd, True, token)
 
-    async def sock_sendfile(  # type: ignore[override]  # typeshed allows fallback=None
-        self, sock: socket.socket, file: Any, offset: int = 0, count: int | None = None, *, fallback: bool = True
-    ) -> int:
-        raise NotImplementedError("zuvloop does not implement sock_sendfile(); read and sock_sendall() instead")
-
-    async def sendfile(
-        self,
-        transport: Any,
-        file: Any,
-        offset: int = 0,
-        count: int | None = None,
-        *,
-        fallback: bool = True,
-    ) -> int:
-        raise NotImplementedError("zuvloop does not implement sendfile(); write the file contents instead")
-
 
 def _attempt(future: asyncio.Future[Any], op: Callable[..., Any], args: tuple[Any, ...]) -> bool:
     """Settle `future` from one attempt at `op`; False means "not ready yet"."""
@@ -142,8 +131,3 @@ def _send_chunk(sock: socket.socket, view: memoryview, sent: int) -> int:
 def _sendto(sock: socket.socket, data: Any, address: Any) -> int:
     """Resolved per attempt, not bound once: callers rebind `sendto` between retries."""
     return sock.sendto(data, address)
-
-
-def _check_non_blocking(sock: socket.socket) -> None:
-    if sock.gettimeout() != 0:
-        raise ValueError("the socket must be non-blocking")

{zuvloop-0.0.2 → zuvloop-0.0.3}/zuvloop/_zuvloop.pyi

@@ -77,6 +77,8 @@ class Process:
     def send_signal(self, signum: int) -> None: ...
 
 class Transport(asyncio.Transport):
+    @property
+    def _protocol_paused(self) -> bool: ...
     def _adopt_pipe(self, pipe: Any) -> None: ...
     def get_extra_info(self, name: str, default: Any = None) -> Any: ...
     def is_closing(self) -> bool: ...