httpware 0.1.0__py3-none-any.whl

httpware/transports/recorded.py

@@ -0,0 +1,84 @@
+"""RecordedTransport — built-in Transport test double."""
+
+from collections.abc import Mapping
+from contextlib import AbstractAsyncContextManager
+
+from httpware.request import Request
+from httpware.response import Response, StreamResponse
+
+
+class RecordedTransport:
+    """Built-in Transport test double.
+
+    Construct with a route table mapping (method, url) → Response | BaseException.
+    `await transport(request)` looks up `(request.method.upper(), request.url)`; on
+    match returns the Response or raises the Exception. On no-match, uses the
+    `default` (Response, BaseException, or RuntimeError("No route for METHOD URL")
+    when None).
+
+    Every call appends the Request to `transport.requests`. Tests can assert on
+    `transport.last_request`, iterate `transport.requests`, or count
+    `transport.aclose_calls` for lifecycle assertions.
+
+    Routes fire indefinitely — the same (method, url) yields the same canned
+    Response on every match. To express "different replies on repeat calls",
+    swap the route between calls via `add_route(...)` or construct a new
+    transport per call.
+
+    Route and default values may be `BaseException` (not just `Exception`) so
+    test code can express `asyncio.CancelledError`, `SystemExit`, or
+    `KeyboardInterrupt` — useful for cancellation/shutdown propagation tests.
+    These do NOT get caught by user code's `except Exception:`.
+
+    `stream()` raises NotImplementedError; streaming lands in Epic 4 (Story 4-1).
+    """
+
+    def __init__(
+        self,
+        routes: Mapping[tuple[str, str], Response | BaseException] | None = None,
+        *,
+        default: Response | BaseException | None = None,
+    ) -> None:
+        self._routes: dict[tuple[str, str], Response | BaseException] = (
+            {(m.upper(), u): v for (m, u), v in routes.items()} if routes is not None else {}
+        )
+        self._default = default
+        self.requests: list[Request] = []
+        self.aclose_calls = 0
+
+    @property
+    def last_request(self) -> Request | None:
+        """The most recently observed Request, or None if no calls have been made."""
+        return self.requests[-1] if self.requests else None
+
+    def add_route(
+        self,
+        method: str,
+        url: str,
+        response_or_exception: Response | BaseException,
+    ) -> None:
+        """Add or replace a route entry."""
+        self._routes[(method.upper(), url)] = response_or_exception
+
+    async def __call__(self, request: Request) -> Response:
+        self.requests.append(request)
+        key = (request.method.upper(), request.url)
+        result: Response | BaseException | None
+        result = self._routes.get(key, self._default)
+        if isinstance(result, BaseException):
+            raise result
+        if result is None:
+            msg = f"No route for {request.method} {request.url}"
+            raise RuntimeError(msg)
+        return result
+
+    def stream(
+        self,
+        request: Request,
+    ) -> AbstractAsyncContextManager[StreamResponse]:
+        """Streaming not implemented in v0 — landing in Epic 4 (Story 4-1)."""
+        msg = "RecordedTransport.stream() is not implemented; streaming lands in Epic 4"
+        raise NotImplementedError(msg)
+
+    async def aclose(self) -> None:
+        self.aclose_calls += 1

httpware-0.1.0.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: httpware
+Version: 0.1.0
+Summary: Resilience-first async HTTP client framework for Python
+Keywords: http,async,client,resilience,retry,circuit-breaker,middleware,httpx,pydantic
+Author: Artur Shiriev
+Author-email: Artur Shiriev <me@shiriev.ru>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Framework :: AsyncIO
+Requires-Dist: httpx2>=2.0.0,<3.0
+Requires-Dist: pydantic>=2.0,<3.0
+Requires-Dist: httpware[msgspec,otel,niquests] ; extra == 'all'
+Requires-Dist: msgspec>=0.18 ; extra == 'msgspec'
+Requires-Dist: niquests>=3.18 ; extra == 'niquests'
+Requires-Dist: opentelemetry-api>=1.20 ; extra == 'otel'
+Requires-Dist: opentelemetry-sdk>=1.20 ; extra == 'otel'
+Requires-Python: >=3.11, <4
+Project-URL: repository, https://github.com/modern-python/httpware
+Project-URL: docs, https://httpware.readthedocs.io
+Provides-Extra: all
+Provides-Extra: msgspec
+Provides-Extra: niquests
+Provides-Extra: otel
+Description-Content-Type: text/markdown
+
+# httpware
+
+[![Test](https://github.com/modern-python/httpware/actions/workflows/ci.yml/badge.svg)](https://github.com/modern-python/httpware/actions/workflows/ci.yml)
+[![PyPI version](https://badge.fury.io/py/httpware.svg)](https://pypi.org/project/httpware/)
+[![Python versions](https://img.shields.io/pypi/pyversions/httpware.svg)](https://pypi.org/project/httpware/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**Async HTTP client framework for Python.**
+
+`httpware` is a typed, async HTTP client library built on `httpx2` with a protocol-based seam so the transport is swappable. Middleware composes via an onion model. Pydantic and msgspec response decoding ship out of the box. `RecordedTransport` replaces respx for transport-level tests.
+
+> **Status:** Pre-1.0 (0.1.0 alpha). Public API is subject to change between minor releases until v1.0. Resilience middleware (retry / timeout / bulkhead), streaming, and observability are not yet shipped — track progress on GitHub.
+
+## Install
+
+```bash
+pip install httpware
+```
+
+Optional extras:
+
+```bash
+pip install httpware[msgspec]    # MsgspecDecoder
+```
+
+(`otel`, `niquests`, and `all` extras are declared but their integrations have not shipped yet.)
+
+## Quickstart
+
+```python
+from httpware import AsyncClient
+from pydantic import BaseModel
+
+
+class User(BaseModel):
+    id: int
+    name: str
+
+
+async def main() -> None:
+    async with AsyncClient(base_url="https://api.example.com") as client:
+        user = await client.get("/users/1", response_model=User)
+        print(user.name)
+```
+
+## What ships in 0.1.0
+
+- **`AsyncClient`** — eight HTTP method shortcuts (`get`, `post`, `put`, `patch`, `delete`, `head`, `options`, `request`) with typed `response_model` overloads; per-call overrides for `headers`, `params`, `cookies`, `timeout`, `json`, `content`; httpx-style `base_url` join; `with_options(...)` returns a view sharing the same transport.
+- **Transport-agnostic seam.** `httpx2` is confined to `httpware.transports.httpx2.Httpx2Transport`. Implement the `Transport` protocol to swap backends.
+- **Middleware foundation.** `Middleware` protocol, `Next` type alias, recursive-closure `compose()` chain composition, and phase decorators (`@before_request`, `@after_response`, `@on_error`).
+- **Pluggable response decoding.** `PydanticDecoder` (default) with cached `TypeAdapter`; `MsgspecDecoder` via `httpware[msgspec]`.
+- **`RecordedTransport`** — built-in test double with a route table, observed-request list, and `aclose_calls` counter.
+- **Status-keyed exception hierarchy** — `StatusError`, 4xx / 5xx subclasses, plain typed fields (`status: int`, `body: bytes`, `headers`, `json`, `request_method`, `request_url`). Pickleable; userinfo redacted in `__repr__`.
+- **No `httpx2` exception types** leak through `httpware`. The transport seam maps them to `httpware` exceptions.
+
+## Part of `modern-python`
+
+Browse the full list of templates and libraries in [`modern-python`](https://github.com/modern-python) — see the org profile for the categorized index.
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

httpware-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+httpware/__init__.py,sha256=ou3ZG7AJNUWby5VT8eUDIEVhWs__5eA_t6TteXsMSCg,1733
+httpware/_internal/__init__.py,sha256=xRyN_CoQ1XZCzo2h15x2v5vZd3buM5n5MsMi4qGfj5o,65
+httpware/_internal/chain.py,sha256=u5IUs-LLMfCIrMSYT3srHwY3AsJc2_5yFRnKx7gdYFE,1383
+httpware/_internal/import_checker.py,sha256=XWgqP9TJO9O3TjYAMPsoAR8cLxRVmMSMCMuIxKCvzUY,195
+httpware/client.py,sha256=c9dSj0IAU7zsOmtLLn2h22EGu1BVwMPaFampIoYwOU0,19829
+httpware/config.py,sha256=MmtLbb8C8x3r3nAPWo9oyR843xeUqnMcJ2APjyMnB1A,1190
+httpware/decoders/__init__.py,sha256=ZriYOpgse0cd9K_R4u0Bo8xKQdOcafhvcIdUmBa_sFA,470
+httpware/decoders/msgspec.py,sha256=4ohALyeumX3DcosFEDVScZ_GtzdO7LaIzgPG0mhNhsE,1066
+httpware/decoders/pydantic.py,sha256=fxwkc1_njsWG8yD6FbHJHLX1khy-jYq7GNsUpHnm0H0,756
+httpware/errors.py,sha256=yvQ6Z1MujYhxguVI_Q26mim7xbAu2MKuEuDUXfm0gmo,6079
+httpware/middleware/__init__.py,sha256=6jR0s_lKmd3dDaNg4vxbDDEUlAA06C6ypvDd9ZcXp_c,3262
+httpware/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+httpware/request.py,sha256=LISPQH5FbxM5P3anycw0kFd8VxOA1fDjNfnjr8E1e3I,2458
+httpware/response.py,sha256=VbavHF5ZCX3VnMXbQfoI3U91Qvqe263drGRKGV-NATI,1998
+httpware/transports/__init__.py,sha256=tZ414G7aXs8MAHs5hqubRBmrrdF_naRlw5Jp89gBqro,831
+httpware/transports/httpx2.py,sha256=gTMfM98_UOq2mK_ZV7k8DZJw8XjTldI2z_TmsezhQxg,7082
+httpware/transports/recorded.py,sha256=RV_82s4bqTSXzYbfp7npWCKLwqT51UYWAq-1YVph63c,3302
+httpware-0.1.0.dist-info/WHEEL,sha256=Q9FtwzuR2QE37l-JIkuyklGnJJiCBHKnsPVQ9vzCMzQ,81
+httpware-0.1.0.dist-info/METADATA,sha256=EkZq_GMtftccfjoTxLK4tgdEnA5Xy1I9ZJbIrArIGzs,4430
+httpware-0.1.0.dist-info/RECORD,,

httpware-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.17
+Root-Is-Purelib: true
+Tag: py3-none-any