httpware 0.1.0__py3-none-any.whl

httpware/__init__.py

@@ -0,0 +1,67 @@
+"""httpware — resilience-first async HTTP client framework for Python."""
+
+from httpware.client import AsyncClient
+from httpware.config import ClientConfig, Limits, Timeout
+from httpware.decoders import ResponseDecoder
+from httpware.decoders.pydantic import PydanticDecoder
+from httpware.errors import (
+    STATUS_TO_EXCEPTION,
+    BadRequestError,
+    ClientError,
+    ClientStatusError,
+    ConflictError,
+    ForbiddenError,
+    InternalServerError,
+    NotFoundError,
+    RateLimitedError,
+    ServerStatusError,
+    ServiceUnavailableError,
+    StatusError,
+    TimeoutError,  # noqa: A004
+    TransportError,
+    UnauthorizedError,
+    UnprocessableEntityError,
+)
+from httpware.middleware import Middleware, Next, after_response, before_request, on_error
+from httpware.request import Request
+from httpware.response import Response, StreamResponse
+from httpware.transports import Transport
+from httpware.transports.httpx2 import Httpx2Transport
+from httpware.transports.recorded import RecordedTransport
+
+
+__all__ = [
+    "STATUS_TO_EXCEPTION",
+    "AsyncClient",
+    "BadRequestError",
+    "ClientConfig",
+    "ClientError",
+    "ClientStatusError",
+    "ConflictError",
+    "ForbiddenError",
+    "Httpx2Transport",
+    "InternalServerError",
+    "Limits",
+    "Middleware",
+    "Next",
+    "NotFoundError",
+    "PydanticDecoder",
+    "RateLimitedError",
+    "RecordedTransport",
+    "Request",
+    "Response",
+    "ResponseDecoder",
+    "ServerStatusError",
+    "ServiceUnavailableError",
+    "StatusError",
+    "StreamResponse",
+    "Timeout",
+    "TimeoutError",
+    "Transport",
+    "TransportError",
+    "UnauthorizedError",
+    "UnprocessableEntityError",
+    "after_response",
+    "before_request",
+    "on_error",
+]

httpware/_internal/__init__.py

@@ -0,0 +1 @@
+"""Private cross-module helpers (not part of the public API)."""

httpware/_internal/chain.py

@@ -0,0 +1,39 @@
+"""Middleware chain composition — wires a middleware list against a Transport.
+
+Private helper. AsyncClient calls `compose` at construction time and stores the
+returned `Next` callable; per-request dispatch awaits that callable.
+"""
+
+from collections.abc import Sequence
+
+from httpware.middleware import Middleware, Next
+from httpware.request import Request
+from httpware.response import Response
+from httpware.transports import Transport
+
+
+def compose(middlewares: Sequence[Middleware], transport: Transport) -> Next:
+    """Fold `middlewares` into a single `Next` callable terminating at `transport`.
+
+    The outermost middleware in the input sequence is the first to receive the
+    request; its `next` argument forwards to the next middleware, and so on,
+    until the innermost middleware's `next` calls `transport.__call__`. An
+    empty sequence returns `transport.__call__` directly.
+
+    The returned callable is reusable across many requests; it captures
+    references to `middlewares` and `transport` by closure.
+    """
+    chain: Next = transport.__call__
+    for middleware in reversed(middlewares):
+        chain = _wrap(middleware, chain)
+    return chain
+
+
+def _wrap(middleware: Middleware, next_call: Next) -> Next:
+    async def _call(request: Request) -> Response:
+        return await middleware(request, next_call)
+
+    return _call
+
+
+__all__ = ["compose"]

httpware/_internal/import_checker.py

@@ -0,0 +1,6 @@
+"""Detect optional extras without importing them. Used by adapter modules to gate hard imports."""
+
+from importlib.util import find_spec
+
+
+is_msgspec_installed = find_spec("msgspec") is not None