pyfect-dev 0.1.0__py3-none-any.whl

pyfect/http/middleware/_decompression.py

@@ -0,0 +1,274 @@
+"""Decoding compressed request bodies (Effect's
+``HttpMiddleware.decompression`` and its ``DecompressedRequest``)."""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+import zlib
+from collections.abc import Callable
+from functools import cached_property
+from typing import Any, Literal
+
+from pyfect._cached import memoize
+from pyfect._core import Effect, _WithFiber
+from pyfect._fiber import Fiber
+from pyfect._primitives import _Locally
+from pyfect.byte_size import Input as ByteSizeInput
+from pyfect.byte_size import from_input_unsafe, mebibytes
+from pyfect.effect import fail, succeed
+from pyfect.http.headers import Headers
+from pyfect.http.headers import Input as HeadersInput
+from pyfect.http.incoming_message import MaxBodySize
+from pyfect.http.method import HttpMethod, has_body
+from pyfect.http.middleware._types import AppMiddleware
+from pyfect.http.server_error import HttpServerError, RequestParseError, request_parse_error
+from pyfect.http.server_request import HttpServerRequest, RequestProtocol, ServerRequest
+from pyfect.http.server_response import HttpServerResponse, empty
+from pyfect.socket import SocketService
+from pyfect.stream import Stream, from_effect, unwrap
+
+type Coding = Literal["gzip", "deflate"]
+
+_DEFAULT_MAX = mebibytes(10)
+_WBITS: dict[Coding, int] = {"gzip": 31, "deflate": 15}
+MAX_CODINGS = 2
+"""How many codings may be stacked on one body."""
+_PIECE = 64 * 1024
+
+
+def parse_content_encoding(header: str) -> tuple[Coding, ...] | None:
+    """The codings of a ``content-encoding`` header in the order applied
+    (``identity`` dropped); ``None`` when one is not supported or more than
+    ``MAX_CODINGS`` are stacked."""
+    codings: list[Coding] = []
+    for member in header.split(","):
+        coding = member.strip().lower()
+        if coding in ("", "identity"):
+            continue
+        if coding not in ("gzip", "deflate"):
+            return None
+        codings.append("gzip" if coding == "gzip" else "deflate")
+    return tuple(codings) if len(codings) <= MAX_CODINGS else None
+
+
+class _TooLarge(Exception):
+    pass
+
+
+class _Decoders:
+    """Stacked decoders that inflate at most ``_PIECE`` bytes per call, each
+    coding's total output counted against ``limit``: a bomb fails before
+    more than about ``limit`` bytes exist."""
+
+    def __init__(self, codings: tuple[Coding, ...], limit: int) -> None:
+        # The coding applied last is decoded first.
+        self._decoders = [zlib.decompressobj(_WBITS[coding]) for coding in reversed(codings)]
+        self._produced = [0] * len(self._decoders)
+        self._limit = limit
+
+    def feed(self, data: bytes) -> bytes:
+        output: list[bytes] = []
+        self._run(0, data, output)
+        return b"".join(output)
+
+    def finish(self) -> bytes | None:
+        """The rest of the body; ``None`` when a coding is truncated."""
+        output: list[bytes] = []
+        for level, decoder in enumerate(self._decoders):
+            self._emit(level, decoder.flush(), output)
+            if not decoder.eof:
+                return None
+        return b"".join(output)
+
+    def _run(self, level: int, data: bytes, output: list[bytes]) -> None:
+        decoder = self._decoders[level]
+        while True:
+            piece = decoder.decompress(data, _PIECE)
+            data = decoder.unconsumed_tail
+            self._emit(level, piece, output)
+            if not data and len(piece) < _PIECE:
+                return
+
+    def _emit(self, level: int, piece: bytes, output: list[bytes]) -> None:
+        self._produced[level] += len(piece)
+        if self._produced[level] > self._limit:
+            raise _TooLarge
+        if level + 1 < len(self._decoders):
+            self._run(level + 1, piece, output)
+        elif piece:
+            output.append(piece)
+
+
+class DecompressedRequest(ServerRequest):
+    """``inner`` with its body decoded, without its ``content-encoding``
+    and ``content-length``. The decoded body may be at most
+    ``max_decompressed_size`` (else ``MaxBodySize``, else 10 MiB) bytes."""
+
+    def __init__(
+        self, inner: ServerRequest, codings: tuple[Coding, ...], max_decompressed_size: int | None
+    ) -> None:
+        super().__init__(None, inner.headers.remove_many(("content-encoding", "content-length")))
+        self.inner = inner
+        self.codings = codings
+        self.max_decompressed_size = max_decompressed_size
+
+    @property
+    def source(self) -> object:
+        return self.inner.source
+
+    @property
+    def original_url(self) -> str:
+        return self.inner.original_url
+
+    @property
+    def url(self) -> str:
+        return self.inner.url
+
+    @property
+    def method(self) -> HttpMethod:
+        return self.inner.method
+
+    @property
+    def remote_address(self) -> str | None:
+        return self.inner.remote_address
+
+    @property
+    def peer_address(self) -> str | None:
+        return self.inner.peer_address
+
+    @property
+    def protocol(self) -> RequestProtocol | None:
+        return self.inner.protocol
+
+    def _source_headers(self) -> Headers:
+        return self.inner.headers
+
+    def _copy(self) -> ServerRequest:
+        return DecompressedRequest(self.inner, self.codings, self.max_decompressed_size)
+
+    def modify(
+        self,
+        *,
+        url: str | None = None,
+        headers: Headers | None = None,
+        remote_address: Any = ...,
+        peer_address: str | None = None,
+        protocol: RequestProtocol | None = None,
+    ) -> ServerRequest:
+        options: dict[str, Any] = {
+            "url": url,
+            "headers": headers,
+            "peer_address": peer_address,
+            "protocol": protocol,
+        }
+        if remote_address is not ...:
+            options["remote_address"] = remote_address
+        return DecompressedRequest(
+            self.inner.modify(**options), self.codings, self.max_decompressed_size
+        )
+
+    def upgrade_with(
+        self, *, headers: HeadersInput | None = None
+    ) -> Effect[SocketService, HttpServerError]:
+        return self.inner.upgrade_with(headers=headers)
+
+    def _error(
+        self,
+        cause: object,
+        description: str | None = None,
+        kind: Literal["Parse", "BodyTooLarge"] = "Parse",
+    ) -> HttpServerError:
+        return request_parse_error(self, description, cause, kind)
+
+    @property
+    def stream(self) -> Stream[bytes, HttpServerError]:
+        """Read from the inner body only once pulled."""
+
+        def make(fiber: Fiber[Any, Any]) -> Effect[Stream[bytes, HttpServerError]]:
+            limit = self.max_decompressed_size
+            if limit is None:
+                limit = fiber.get_ref(MaxBodySize)
+            if limit is None:
+                limit = _DEFAULT_MAX
+            decoders = _Decoders(self.codings, limit)
+
+            def decode(step: Callable[[], bytes | None]) -> Effect[bytes, HttpServerError]:
+                try:
+                    data = step()
+                except zlib.error as cause:
+                    return fail(self._error(cause))
+                except _TooLarge:
+                    description = f"Decompressed request body exceeds {limit} bytes"
+                    return fail(self._error(None, description, "BodyTooLarge"))
+                if data is None:
+                    return fail(self._error(None, "Truncated compressed body"))
+                return succeed(data)
+
+            def feed(chunk: bytes) -> Effect[bytes, HttpServerError]:
+                return decode(lambda: decoders.feed(chunk))
+
+            def finish() -> Effect[bytes, HttpServerError]:
+                return decode(decoders.finish)
+
+            decoded = self.inner.stream.map_effect(feed).concat(
+                from_effect(_WithFiber(lambda _: finish()))
+            )
+            return succeed(decoded.filter(lambda chunk: len(chunk) > 0))
+
+        return unwrap(_WithFiber(make))
+
+    @cached_property
+    def _bytes(self) -> Effect[bytes, HttpServerError]:
+        return memoize(self.stream.run_collect().map(b"".join))
+
+    @property
+    def bytes_(self) -> Effect[bytes, HttpServerError]:
+        return self._bytes
+
+    @property
+    def json(self) -> Effect[Any, HttpServerError]:
+        return self.text.flat_map(
+            lambda text: succeed(None) if text == "" else self._parse_json(text)
+        )
+
+    @property
+    def multipart_stream(self) -> Stream[Any, Any]:
+        from pyfect.http.multipart import MultipartError, make_channel
+
+        def convert(cause: HttpServerError) -> MultipartError:
+            # Failures of this request come from the client's data; those of
+            # the inner request are transport errors.
+            reason = cause.reason
+            if isinstance(reason, RequestParseError) and reason.request is self:
+                return MultipartError.from_reason(reason.kind, cause)
+            return MultipartError.from_reason("InternalError", cause)
+
+        return self.stream.map_error(convert).pipe_through_channel(make_channel(self.headers))
+
+
+def decompression(
+    *, max_decompressed_size: ByteSizeInput | None = None
+) -> AppMiddleware[HttpServerRequest]:
+    """Middleware decoding gzip and deflate request bodies; an unsupported
+    coding is answered with 415 before the app runs."""
+    limit = None if max_decompressed_size is None else from_input_unsafe(max_decompressed_size)
+
+    def middleware[E, R](
+        app: Effect[HttpServerResponse, E, R],
+    ) -> Effect[HttpServerResponse, E, R | HttpServerRequest]:
+        def body(fiber: Fiber[Any, Any]) -> Effect[HttpServerResponse, E, R]:
+            request = fiber._context.get_unsafe(HttpServerRequest)
+            encoding = request.headers.get("content-encoding")
+            if encoding is None or not has_body(request.method):
+                return app
+            codings = parse_content_encoding(encoding)
+            if codings is None:
+                return succeed(empty(status=415, headers={"accept-encoding": "gzip, deflate"}))
+            if not codings:
+                return app
+            decompressed = DecompressedRequest(request, codings, limit)
+            return _Locally(app, lambda ctx: ctx.add(HttpServerRequest, decompressed))
+
+        return _WithFiber(body)
+
+    return middleware

pyfect/http/middleware/_forwarded.py

@@ -0,0 +1,113 @@
+"""Trusting ``X-Forwarded-*`` headers from known proxies (Effect's
+``HttpMiddleware.xForwardedHeaders``)."""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from typing import Any
+
+from pyfect._core import Effect, _WithFiber
+from pyfect._fiber import Fiber
+from pyfect._primitives import _Locally
+from pyfect.http._authority import parse_authority
+from pyfect.http.middleware._types import AppMiddleware
+from pyfect.http.server_request import HttpServerRequest, ServerRequest
+from pyfect.http.server_response import HttpServerResponse
+from pyfect.net import ip_network
+from pyfect.net.ip_network import IpNetwork
+from pyfect.net.net_address import (
+    IpAddress,
+    format_ip,
+    inet_address_from_string,
+    ip_from_string,
+    to_canonical,
+)
+from pyfect.result import Ok
+
+type TrustedProxies = Sequence[IpNetwork] | Callable[[IpAddress], bool]
+"""The proxies whose forwarded headers are believed: networks, or a test."""
+
+
+def _split(value: str | None) -> list[str] | None:
+    return None if value is None else [part.strip() for part in value.split(",")]
+
+
+def _aligned(header: str | None, length: int, index: int) -> str | None:
+    """A host or proto list belongs to the hops only with one value per
+    ``X-Forwarded-For`` entry."""
+    values = _split(header)
+    return values[index] if values is not None and len(values) == length else None
+
+
+def _address(text: str | None) -> IpAddress | None:
+    if text is None:
+        return None
+    bare = text[1:-1] if text.startswith("[") and text.endswith("]") else text
+    match ip_from_string(bare):
+        case Ok(ip):
+            return to_canonical(ip)
+        case _:
+            pass
+    match inet_address_from_string(text):
+        case Ok(inet):
+            return to_canonical(inet.address)
+        case _:
+            return None
+
+
+def _apply(request: ServerRequest, trusted: Callable[[IpAddress], bool]) -> ServerRequest:
+    peer = _address(request.peer_address)
+    if peer is None or not trusted(peer):
+        return request
+    addresses = _split(request.headers.get("x-forwarded-for"))
+    if addresses is None:
+        return request
+    for index in range(len(addresses) - 1, -1, -1):
+        address = _address(addresses[index])
+        if address is None:
+            return request
+        if index > 0 and trusted(address):
+            continue
+        host = _aligned(request.headers.get("x-forwarded-host"), len(addresses), index)
+        protocol = _aligned(request.headers.get("x-forwarded-proto"), len(addresses), index)
+        protocol = None if protocol is None else protocol.lower()
+        return request.modify(
+            remote_address=format_ip(address),
+            peer_address=request.peer_address,
+            headers=request.headers.set("host", host)
+            if host is not None and parse_authority(host) is not None
+            else None,
+            protocol="https" if protocol == "https" else "http" if protocol == "http" else None,
+        )
+    return request
+
+
+def x_forwarded_headers(
+    trusted_proxies: TrustedProxies,
+) -> AppMiddleware[HttpServerRequest]:
+    """Middleware taking the client address (and its aligned
+    ``X-Forwarded-Host`` / ``-Proto``) from ``X-Forwarded-For`` when the
+    transport peer is a trusted proxy: the rightmost hop that is not one,
+    stopping at an entry that is not an address."""
+    trusted: Callable[[IpAddress], bool]
+    if callable(trusted_proxies):
+        trusted = trusted_proxies
+    else:
+        networks = tuple(trusted_proxies)
+
+        def in_networks(address: IpAddress) -> bool:
+            return any(ip_network.contains(network, address) for network in networks)
+
+        trusted = in_networks
+
+    def middleware[E, R](
+        app: Effect[HttpServerResponse, E, R],
+    ) -> Effect[HttpServerResponse, E, R | HttpServerRequest]:
+        def body(fiber: Fiber[Any, Any]) -> Effect[HttpServerResponse, E, R]:
+            request = _apply(fiber._context.get_unsafe(HttpServerRequest), trusted)
+            return _Locally(app, lambda ctx: ctx.add(HttpServerRequest, request))
+
+        return _WithFiber(body)
+
+    return middleware

pyfect/http/middleware/_logger.py

@@ -0,0 +1,73 @@
+"""Logging each response (Effect's ``HttpMiddleware.logger``)."""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+from typing import Any
+
+from pyfect._core import Effect, _WithFiber
+from pyfect._effect_args import require_effect
+from pyfect._fiber import Fiber
+from pyfect.cause import Interrupt
+from pyfect.effect import from_exit
+from pyfect.exit import Exit, Failure
+from pyfect.http import _request_state
+from pyfect.http.server_error import ClientAbort, cause_response_stripped
+from pyfect.http.server_request import HttpServerRequest
+from pyfect.http.server_response import HttpServerResponse
+from pyfect.logger import log
+
+
+def strip_search_and_hash(url: str) -> str:
+    """``url`` without its query and fragment."""
+    ends = [index for index in (url.find("?"), url.find("#")) if index != -1]
+    return url[: min(ends)] if ends else url
+
+
+def with_logger_disabled[A, E, R](eff: Effect[A, E, R]) -> Effect[A, E, R | HttpServerRequest]:
+    """``eff``, and the request it runs in is not logged."""
+    require_effect(eff, "eff")
+
+    def body(fiber: Fiber[Any, Any]) -> Effect[A, E, R]:
+        state = _request_state.get(fiber._context)
+        if state is not None:
+            state.logger_disabled = True
+        return eff
+
+    return _WithFiber(body)
+
+
+def logger[E, R](
+    app: Effect[HttpServerResponse, E, R],
+) -> Effect[HttpServerResponse, E, R | HttpServerRequest]:
+    """Log ``"Sent HTTP response"`` (or the failure's cause) with the
+    method, path and status, in an ``http.span`` log span."""
+    require_effect(app, "app")
+
+    def body(fiber: Fiber[Any, Any]) -> Effect[HttpServerResponse, E, R | HttpServerRequest]:
+        request = fiber._context.get_unsafe(HttpServerRequest)
+        state = _request_state.get(fiber._context)
+        path = strip_search_and_hash(request.url)
+
+        def after(exit: Exit[HttpServerResponse, E]) -> Effect[HttpServerResponse, E]:
+            if state is not None and state.logger_disabled:
+                return from_exit(exit)
+            message: object = "Sent HTTP response"
+            if isinstance(exit, Failure):
+                response, cause = cause_response_stripped(exit.cause)
+                if cause is not None and not all(
+                    isinstance(reason, Interrupt) and ClientAbort in reason.annotations
+                    for reason in cause.reasons
+                ):
+                    message = cause
+                status = response.status
+            else:
+                status = exit.value.status
+            logged = log(message).annotate_logs(
+                {"http.method": request.method, "http.url": path, "http.status": status}
+            )
+            return logged.and_then(from_exit(exit))
+
+        return app.exit().flat_map(after).with_log_span("http.span")
+
+    return _WithFiber(body)

pyfect/http/middleware/_search_params.py

@@ -0,0 +1,34 @@
+"""Parsing the query once for the app (Effect's
+``HttpMiddleware.searchParamsParser``)."""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+from typing import Any
+
+from pyfect._core import Effect, _WithFiber
+from pyfect._effect_args import require_effect
+from pyfect._fiber import Fiber
+from pyfect._primitives import _Locally
+from pyfect.http.server_request import (
+    HttpServerRequest,
+    ParsedSearchParams,
+    search_params_from_url,
+)
+from pyfect.http.server_response import HttpServerResponse
+from pyfect.http.url import parse
+
+
+def search_params_parser[E, R](
+    app: Effect[HttpServerResponse, E, R | ParsedSearchParams],
+) -> Effect[HttpServerResponse, E, R | HttpServerRequest]:
+    """``app`` with ``ParsedSearchParams``: the request URL's query as a
+    record (a repeated key gives a list)."""
+    require_effect(app, "app")
+
+    def body(fiber: Fiber[Any, Any]) -> Effect[HttpServerResponse, E, R]:
+        request = fiber._context.get_unsafe(HttpServerRequest)
+        params = search_params_from_url(parse(request.original_url, "http://localhost"))
+        return _Locally(app, lambda ctx: ctx.add(ParsedSearchParams, params))
+
+    return _WithFiber(body)

pyfect/http/middleware/_tracer.py

@@ -0,0 +1,153 @@
+"""The server span of a request (Effect's ``HttpMiddleware.tracer``)."""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from typing import Any, Literal
+
+from pyfect._core import Effect, _WithFiber
+from pyfect._effect_args import require_effect
+from pyfect._fiber import Fiber
+from pyfect._primitives import Restore, _Locally, uninterruptible_mask
+from pyfect._tracer_ref import CurrentTracer
+from pyfect.cause import fail
+from pyfect.clock import Clock
+from pyfect.context import Reference
+from pyfect.effect import sync
+from pyfect.exit import Exit, Failure, Success
+from pyfect.http import headers as _headers
+from pyfect.http import trace_context
+from pyfect.http import url_params as _url_params
+from pyfect.http.client._make import _add_header_attributes, _add_url_attributes
+from pyfect.http.server_error import (
+    HttpServerError,
+    ResponseError,
+    cause_response_stripped,
+)
+from pyfect.http.server_request import HttpServerRequest, ServerRequest, to_url
+from pyfect.http.server_response import HttpServerResponse
+from pyfect.layer import Layer
+from pyfect.layer import succeed as layer_succeed
+from pyfect.tracer import ParentSpan, Span, TracerEnabled, native_tracer
+from pyfect.tracer._model import SpanOptions
+from pyfect.tracer._spans import make_span_unsafe
+
+type Phase = Literal["request", "response"]
+
+
+class TracerDisabledWhen(Reference[Callable[[ServerRequest], bool]]):
+    """Requests handled without a server span."""
+
+    @classmethod
+    def default(cls) -> Callable[[ServerRequest], bool]:
+        return lambda _request: False
+
+
+def layer_tracer_disabled_for_urls(urls: Sequence[str]) -> Layer[TracerDisabledWhen]:
+    """No spans for requests to exactly these URLs."""
+    disabled = tuple(urls)
+    return layer_succeed(TracerDisabledWhen, lambda request: request.url in disabled)
+
+
+class SpanNameGenerator(Reference[Callable[[ServerRequest], str]]):
+    """The name of a request's span; its method by default."""
+
+    @classmethod
+    def default(cls) -> Callable[[ServerRequest], str]:
+        return lambda request: request.method
+
+
+class TracerHeaderFilter(Reference[Callable[[str, Phase], bool]]):
+    """The headers recorded as span attributes, by name and phase (none by
+    default)."""
+
+    @classmethod
+    def default(cls) -> Callable[[str, Phase], bool]:
+        return lambda _name, _phase: False
+
+
+def is_tracer_disabled_unsafe(fiber: Fiber[Any, Any], request: ServerRequest) -> bool:
+    return not fiber.get_ref(TracerEnabled) or fiber.get_ref(TracerDisabledWhen)(request)
+
+
+def uses_native_tracer(fiber: Fiber[Any, Any]) -> bool:
+    """The native tracer keeps spans nobody can observe."""
+    return fiber.get_ref(CurrentTracer) is native_tracer
+
+
+def _response_span_exit(
+    request: ServerRequest, response: HttpServerResponse
+) -> Exit[HttpServerResponse, HttpServerError]:
+    # OpenTelemetry fails server spans of 5xx responses.
+    if not 500 <= response.status < 600:
+        return Success(response)
+    return Failure(fail(HttpServerError(ResponseError(request, response))))
+
+
+def _end(fiber: Fiber[Any, Any], span: Span, request: ServerRequest, exit: Exit[Any, Any]) -> None:
+    end_time = fiber.get_ref(Clock).now_nanos_unsafe()
+    if isinstance(exit, Success) and (
+        not span.sampled or fiber.get_ref(CurrentTracer) is native_tracer
+    ):
+        span.end(end_time, _response_span_exit(request, exit.value))
+        return
+    redacted_headers = fiber.get_ref(_headers.CurrentRedactedNames)
+    accept = fiber.get_ref(TracerHeaderFilter)
+    span_exit: Exit[Any, Any]
+    if isinstance(exit, Failure):
+        response, cause = cause_response_stripped(exit.cause)
+        # Only 5xx responses fail a server span; interrupts still do.
+        if cause is not None and (response.status >= 500 or cause.has_interrupts):
+            span_exit = Failure(cause)
+        else:
+            span_exit = _response_span_exit(request, response)
+    else:
+        response = exit.value
+        span_exit = _response_span_exit(request, response)
+    if span.sampled:
+        span.attribute("http.request.method", request.method)
+        url = to_url(request)
+        if url is not None:
+            _add_url_attributes(span, url, fiber.get_ref(_url_params.CurrentRedactedNames))
+        user_agent = request.headers.get("user-agent")
+        if user_agent is not None:
+            span.attribute("user_agent.original", user_agent)
+        _add_header_attributes(span, "request", request.headers, accept, redacted_headers)
+        if request.remote_address is not None:
+            span.attribute("client.address", request.remote_address)
+        span.attribute("http.response.status_code", response.status)
+        _add_header_attributes(span, "response", response.headers, accept, redacted_headers)
+    span.end(end_time, span_exit)
+
+
+def tracer[E, R](
+    app: Effect[HttpServerResponse, E, R],
+) -> Effect[HttpServerResponse, E, R | HttpServerRequest]:
+    """Run ``app`` in a server span named by ``SpanNameGenerator``, a child
+    of the span in the request's trace headers, with the HTTP attributes of
+    the request and response."""
+    require_effect(app, "app")
+
+    def body(
+        fiber: Fiber[Any, Any], restore: Restore
+    ) -> Effect[HttpServerResponse, E, R | HttpServerRequest]:
+        request = fiber._context.get_unsafe(HttpServerRequest)
+        if is_tracer_disabled_unsafe(fiber, request):
+            return restore(app)
+        parent = trace_context.from_headers(request.headers)
+        options: SpanOptions = {"kind": "server"}
+        if parent is not None:
+            options["parent"] = parent
+        span = make_span_unsafe(fiber, fiber.get_ref(SpanNameGenerator)(request), options)
+
+        def finish(exit: Exit[HttpServerResponse, E]) -> Effect[None]:
+            return sync(lambda: _end(fiber, span, request, exit))
+
+        inner: Effect[HttpServerResponse, E, R | HttpServerRequest] = _Locally(
+            app, lambda ctx: ctx.add(ParentSpan, span)
+        )
+        return restore(inner).on_exit(finish)
+
+    # The span is made and its end registered in one uninterruptible step.
+    return uninterruptible_mask(lambda restore: _WithFiber(lambda fiber: body(fiber, restore)))

pyfect/http/middleware/_types.py

@@ -0,0 +1,16 @@
+"""The type of a configured middleware (``cors(...)``, ``compression(...)``):
+generic in the app it wraps, so the app's errors and requirements pass
+through, with ``RM`` the requirements the middleware adds."""
+
+from __future__ import annotations
+
+from typing import Protocol
+
+from pyfect._core import Effect
+from pyfect.http.server_response import HttpServerResponse
+
+
+class AppMiddleware[RM](Protocol):
+    def __call__[E, R](
+        self, app: Effect[HttpServerResponse, E, R], /
+    ) -> Effect[HttpServerResponse, E, R | RM]: ...