httpware 0.9.0__tar.gz → 0.9.1__tar.gz

{httpware-0.9.0 → httpware-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpware
-Version: 0.9.0
+Version: 0.9.1
 Summary: Resilience-first async HTTP client framework for Python
 Keywords: http,async,client,resilience,retry,circuit-breaker,middleware,httpx,pydantic
 Author: Artur Shiriev
@@ -80,7 +80,7 @@ with Client(base_url="https://example.test") as client:
     print(response.json())
 ```
 
-Typed decoding via `response_model=` works in both worlds — requires `pip install httpware[pydantic]`. Decode failures (malformed body, schema mismatch) raise `httpware.DecodeError`, a `ClientError` subclass — so `except httpware.ClientError` covers them alongside transport and status errors.
+Typed decoding via `response_model=` works in both worlds — install either `pip install httpware[pydantic]` or `pip install httpware[msgspec]` (or both; pydantic is tried first when both are present). Decode failures (malformed body, schema mismatch) raise `httpware.DecodeError`, a `ClientError` subclass — so `except httpware.ClientError` covers them alongside transport and status errors.
 
 ```python
 from httpware import AsyncClient

{httpware-0.9.0 → httpware-0.9.1}/README.md

@@ -50,7 +50,7 @@ with Client(base_url="https://example.test") as client:
     print(response.json())
 ```
 
-Typed decoding via `response_model=` works in both worlds — requires `pip install httpware[pydantic]`. Decode failures (malformed body, schema mismatch) raise `httpware.DecodeError`, a `ClientError` subclass — so `except httpware.ClientError` covers them alongside transport and status errors.
+Typed decoding via `response_model=` works in both worlds — install either `pip install httpware[pydantic]` or `pip install httpware[msgspec]` (or both; pydantic is tried first when both are present). Decode failures (malformed body, schema mismatch) raise `httpware.DecodeError`, a `ClientError` subclass — so `except httpware.ClientError` covers them alongside transport and status errors.
 
 ```python
 from httpware import AsyncClient

{httpware-0.9.0 → httpware-0.9.1}/pyproject.toml

@@ -26,7 +26,7 @@ classifiers = [
     "Topic :: Internet :: WWW/HTTP",
     "Framework :: AsyncIO",
 ]
-version = "0.9.0"
+version = "0.9.1"
 dependencies = [
     "httpx2>=2.0.0,<3.0",
 ]

{httpware-0.9.0 → httpware-0.9.1}/src/httpware/decoders/__init__.py

@@ -19,6 +19,13 @@ class ResponseDecoder(Protocol):
         list ordering encodes the caller's preference for shared shapes.
         Native types of another library (e.g. `PydanticDecoder` vs
         `msgspec.Struct`) MUST be rejected.
+
+        `can_decode` MUST NOT raise. It runs at dispatch time — before the HTTP
+        call and outside the `DecodeError` wrap that protects `decode` — so an
+        exception here escapes the `ClientError` contract rather than being
+        translated. A decoder that cannot determine support for `model` must
+        return False (decline), not raise; the built-in decoders treat any
+        probe failure as False.
         """
         ...
 

httpware-0.9.1/src/httpware/decoders/msgspec.py

@@ -0,0 +1,116 @@
+"""MsgspecDecoder — opt-in ResponseDecoder backed by a per-instance msgspec.json.Decoder cache."""
+
+import typing
+from typing import TypeVar
+
+from httpware._internal import import_checker
+
+
+if import_checker.is_msgspec_installed:
+    import msgspec
+
+
+MISSING_DEPENDENCY_MESSAGE = "MsgspecDecoder requires the 'msgspec' extra. Install with: pip install httpware[msgspec]"
+
+T = TypeVar("T")
+
+
+def _contains_custom_type(info: "msgspec.inspect.Type") -> bool:
+    """Return True if `info` is a CustomType or nests one in its parameters.
+
+    Walks generic-container parameterization (list/dict/set/tuple/union element
+    types) by visiting any attribute that is itself a `msgspec.inspect.Type` or a
+    tuple of them. It deliberately does NOT descend into `StructType`/dataclass
+    fields: those expose `fields` as `Field` objects (not `Type`), so the walk
+    stops at the boundary of a type msgspec natively owns. That boundary is what
+    makes the walk both correct (a Struct is a valid target) and safe against
+    infinite recursion on self-referential struct definitions.
+    """
+    if isinstance(info, msgspec.inspect.CustomType):
+        return True
+    for name in dir(info):
+        if name.startswith("_"):
+            continue
+        value = getattr(info, name, None)
+        if isinstance(value, msgspec.inspect.Type):
+            if _contains_custom_type(value):
+                return True
+        elif (
+            isinstance(value, tuple)
+            and value
+            and all(isinstance(item, msgspec.inspect.Type) for item in value)
+            and any(_contains_custom_type(item) for item in value)
+        ):
+            return True
+    return False
+
+
+class MsgspecDecoder:
+    """Decode raw response bytes via a per-instance cached `msgspec.json.Decoder(model)`.
+
+    Requires the `msgspec` extra: `pip install httpware[msgspec]`. Importing
+    this module without the extra works (the `msgspec` import is guarded by a
+    `find_spec` check), but instantiating the decoder raises `ImportError`.
+    """
+
+    _msgspec_decoders: dict[type, "msgspec.json.Decoder[typing.Any]"]
+    _can_decode_results: dict[type, bool]
+
+    def __init__(self) -> None:
+        if not import_checker.is_msgspec_installed:
+            raise ImportError(MISSING_DEPENDENCY_MESSAGE)
+        self._msgspec_decoders = {}
+        self._can_decode_results = {}
+
+    def _get_msgspec_decoder(self, model: type[T]) -> "msgspec.json.Decoder[T]":
+        decoder = self._msgspec_decoders.get(model)
+        if decoder is None:
+            decoder = msgspec.json.Decoder(model)
+            self._msgspec_decoders[model] = decoder
+        return decoder
+
+    def can_decode(self, model: type) -> bool:
+        """Return True iff msgspec natively understands `model` end-to-end.
+
+        The verdict is memoized per `model`: the probe below (an uncached
+        `type_info` call plus a recursive tree walk) runs once per type, not on
+        every dispatch. Unhashable models skip the cache and probe fresh.
+        """
+        try:
+            cached = self._can_decode_results.get(model)
+        except TypeError:  # unhashable model — can't memoize, probe fresh
+            return self._probe_can_decode(model)
+        if cached is not None:
+            return cached
+        result = self._probe_can_decode(model)
+        self._can_decode_results[model] = result
+        return result
+
+    def _probe_can_decode(self, model: type) -> bool:
+        """Decide whether msgspec natively decodes `model` (the uncached path).
+
+        msgspec builds a Decoder for almost any class via a generic CustomType
+        fallback; the Decoder constructor does NOT raise on unsupported types
+        (e.g. pydantic.BaseModel, or a container parameterized by one). We walk
+        msgspec.inspect.type_info and reject if a CustomType appears anywhere in
+        the type tree, so MissingDecoderError fires before a request is sent.
+        """
+        try:
+            info = msgspec.inspect.type_info(model)
+        except Exception:  # noqa: BLE001 — can_decode is a probe; any failure means no
+            return False
+        if _contains_custom_type(info):
+            return False
+        try:
+            self._get_msgspec_decoder(model)
+        except Exception:  # noqa: BLE001 — can_decode is a probe; any failure means no
+            return False
+        return True
+
+    def decode(self, content: bytes, model: type[T]) -> T:
+        """Validate `content` as JSON against `model` in a single parse pass."""
+        try:
+            decoder = self._get_msgspec_decoder(model)
+        except TypeError:
+            decoder = msgspec.json.Decoder(model)
+        return decoder.decode(content)

{httpware-0.9.0 → httpware-0.9.1}/src/httpware/decoders/pydantic.py

@@ -26,11 +26,13 @@ class PydanticDecoder:
     """Decode raw response bytes into `model` via a per-instance cached `pydantic.TypeAdapter`."""
 
     _adapters: dict[type, TypeAdapter[typing.Any]]
+    _can_decode_results: dict[type, bool]
 
     def __init__(self) -> None:
         if not import_checker.is_pydantic_installed:
             raise ImportError(MISSING_DEPENDENCY_MESSAGE)
         self._adapters = {}
+        self._can_decode_results = {}
 
     def _get_adapter(self, model: type[T]) -> "TypeAdapter[T]":
         adapter = self._adapters.get(model)
@@ -42,6 +44,23 @@ class PydanticDecoder:
     def can_decode(self, model: type) -> bool:
         """Return True iff pydantic can build a schema for `model`.
 
+        The verdict is memoized per `model` so a rejection (which costs a
+        `PydanticSchemaGenerationError` round-trip) is not re-probed on every
+        dispatch. Unhashable models skip the cache and probe fresh.
+        """
+        try:
+            cached = self._can_decode_results.get(model)
+        except TypeError:  # unhashable model — can't memoize, probe fresh
+            return self._probe_can_decode(model)
+        if cached is not None:
+            return cached
+        result = self._probe_can_decode(model)
+        self._can_decode_results[model] = result
+        return result
+
+    def _probe_can_decode(self, model: type) -> bool:
+        """Decide whether pydantic can build a schema for `model` (uncached).
+
         Probes via `_get_adapter`; subsequent calls (including `decode`) reuse
         the cached `TypeAdapter`. Rejects `msgspec.Struct` subclasses —
         pydantic raises `PydanticSchemaGenerationError` (a `TypeError`) when

httpware-0.9.0/src/httpware/decoders/msgspec.py

@@ -1,66 +0,0 @@
-"""MsgspecDecoder — opt-in ResponseDecoder backed by a per-instance msgspec.json.Decoder cache."""
-
-import typing
-from typing import TypeVar
-
-from httpware._internal import import_checker
-
-
-if import_checker.is_msgspec_installed:
-    import msgspec
-
-
-MISSING_DEPENDENCY_MESSAGE = "MsgspecDecoder requires the 'msgspec' extra. Install with: pip install httpware[msgspec]"
-
-T = TypeVar("T")
-
-
-class MsgspecDecoder:
-    """Decode raw response bytes via a per-instance cached `msgspec.json.Decoder(model)`.
-
-    Requires the `msgspec` extra: `pip install httpware[msgspec]`. Importing
-    this module without the extra works (the `msgspec` import is guarded by a
-    `find_spec` check), but instantiating the decoder raises `ImportError`.
-    """
-
-    _msgspec_decoders: dict[type, "msgspec.json.Decoder[typing.Any]"]
-
-    def __init__(self) -> None:
-        if not import_checker.is_msgspec_installed:
-            raise ImportError(MISSING_DEPENDENCY_MESSAGE)
-        self._msgspec_decoders = {}
-
-    def _get_msgspec_decoder(self, model: type[T]) -> "msgspec.json.Decoder[T]":
-        decoder = self._msgspec_decoders.get(model)
-        if decoder is None:
-            decoder = msgspec.json.Decoder(model)
-            self._msgspec_decoders[model] = decoder
-        return decoder
-
-    def can_decode(self, model: type) -> bool:
-        """Return True iff msgspec natively understands `model`.
-
-        msgspec builds a Decoder for almost any class via a generic CustomType
-        fallback; the Decoder constructor itself does NOT raise on unsupported
-        types (e.g. pydantic.BaseModel). We use msgspec.inspect.type_info
-        to detect the fallback and reject CustomType results explicitly.
-        """
-        try:
-            info = msgspec.inspect.type_info(model)
-        except Exception:  # noqa: BLE001 — can_decode is a probe; any failure means no
-            return False
-        if isinstance(info, msgspec.inspect.CustomType):
-            return False
-        try:
-            self._get_msgspec_decoder(model)
-        except Exception:  # noqa: BLE001 — can_decode is a probe; any failure means no
-            return False
-        return True
-
-    def decode(self, content: bytes, model: type[T]) -> T:
-        """Validate `content` as JSON against `model` in a single parse pass."""
-        try:
-            decoder = self._get_msgspec_decoder(model)
-        except TypeError:
-            decoder = msgspec.json.Decoder(model)
-        return decoder.decode(content)