clientwright 0.2.1__tar.gz → 0.2.2__tar.gz

{clientwright-0.2.1 → clientwright-0.2.2}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.2.2](https://github.com/bedrock-python/clientwright/compare/clientwright-v0.2.1...clientwright-v0.2.2) (2026-09-06)
+
+
+### Bug Fixes
+
+* bound the response body by the total on the httpx family ([#28](https://github.com/bedrock-python/clientwright/issues/28)) ([5767b89](https://github.com/bedrock-python/clientwright/commit/5767b891595c7385887ecb40f2bdbf01ee615977)), closes [#25](https://github.com/bedrock-python/clientwright/issues/25)
+* give the attempt ceiling its own retryable kind and adapter error ([#26](https://github.com/bedrock-python/clientwright/issues/26)) ([e36beeb](https://github.com/bedrock-python/clientwright/commit/e36beeba169355cb7b94a1484c032a77a12995b6)), closes [#24](https://github.com/bedrock-python/clientwright/issues/24)
+
 ## [0.2.1](https://github.com/bedrock-python/clientwright/compare/clientwright-v0.2.0...clientwright-v0.2.1) (2026-09-06)
 
 

{clientwright-0.2.1 → clientwright-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: clientwright
-Version: 0.2.1
+Version: 0.2.2
 Summary: HTTP client platform: one resilience and observability core with adapters for httpx, aiohttp, requests, urllib3 and friends
 Project-URL: Repository, https://github.com/bedrock-python/clientwright
 Project-URL: Documentation, https://bedrock-python.github.io/clientwright/

{clientwright-0.2.1 → clientwright-0.2.2}/clientwright/__init__.py

@@ -60,6 +60,7 @@ from .core.contracts import (
 from .core.contracts.adapter import default_deps
 from .core.contracts.settings import client_config_from_settings
 from .core.errors import (
+    AttemptTimeoutError,
     CallError,
     CircuitOpenError,
     ClientwrightError,
@@ -117,6 +118,7 @@ __all__ = [
     "UNSET",
     "AdapterCapabilities",
     "AdapterDeps",
+    "AttemptTimeoutError",
     "CallError",
     "CallOptions",
     "CallerOverride",

clientwright-0.2.2/clientwright/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.2.2"  # x-release-please-version

{clientwright-0.2.1 → clientwright-0.2.2}/clientwright/adapters/_httpx_shared.py

@@ -13,6 +13,7 @@ one extra and one import path.
 
 from __future__ import annotations
 
+import asyncio
 import ssl
 from collections.abc import Callable, Mapping, MutableMapping
 from typing import Any
@@ -28,10 +29,11 @@ from ..core.config import ClientConfig, RedirectMode, is_set, resolve
 from ..core.contracts.adapter import AdapterDeps
 from ..core.engine.aio import AsyncAttemptEngine
 from ..core.engine.sync import SyncAttemptEngine
-from ..core.errors import CallError, CircuitOpenError, DeadlineExceededError, TooManyRedirectsError
+from ..core.errors import AttemptTimeoutError, CallError, CircuitOpenError, DeadlineExceededError, TooManyRedirectsError
 from ..core.model import IDEMPOTENT_METHODS, ConnMetrics, FailureKind, Outcome, RequestInfo, ResolvedTimeouts, origin_of
 from ..core.native import accepted_overrides, validate_native
 from ..core.plan import CallPlan, ClientHandle, ClientRuntime, compile_plan, register_handle
+from ..core.policy.budget import Deadline
 from ..core.policy.timeout import base_timeouts
 from ..core.telemetry.emitter import ClientTelemetry
 
@@ -84,6 +86,7 @@ def capabilities_for(adapter: str) -> AdapterCapabilities:
             Capability.TIMEOUT_WRITE: Support.NATIVE,
             Capability.TIMEOUT_POOL: Support.NATIVE,
             Capability.DEADLINE_HARD: Support.EMULATED,
+            Capability.DEADLINE_COVERS_BODY: Support.EMULATED,
             Capability.POOL_LIMIT_TOTAL: Support.NATIVE,
             Capability.POOL_LIMIT_PER_HOST: Support.EMULATED,
             Capability.KEEPALIVE: Support.NATIVE,
@@ -105,6 +108,7 @@ def capabilities_for(adapter: str) -> AdapterCapabilities:
                 FailureKind.READ_TIMEOUT,
                 FailureKind.WRITE_TIMEOUT,
                 FailureKind.POOL_TIMEOUT,
+                FailureKind.ATTEMPT_TIMEOUT,
                 FailureKind.TOTAL_TIMEOUT,
                 FailureKind.CONNECT_ERROR,
                 FailureKind.TLS_ERROR,
@@ -120,9 +124,17 @@ def capabilities_for(adapter: str) -> AdapterCapabilities:
         collapses={FailureKind.DNS_ERROR: FailureKind.CONNECT_ERROR},
         notes={
             "deadline_hard": "Hard cancellation on the async client only; the sync client clamps phases (soft).",
+            "attempt_timeout": (
+                "Emitted by the async client only; the sync client drops the attempt ceiling, so a stall arrives as "
+                "read_timeout."
+            ),
             "pool_limit_per_host": "Emulated as a per-origin in-flight semaphore; limits requests, not connections.",
             "dns_error": f"{adapter} wraps DNS failures into ConnectError; they surface as connect_error.",
             "proxy_from_env": "Environment proxies are parsed into mounts; NO_PROXY entries match hosts literally.",
+            "deadline_covers_body": (
+                "The response body is inside the total: the async client bounds every chunk by the remaining budget, "
+                "the sync client refuses the next chunk once the budget is gone (soft)."
+            ),
         },
     )
 
@@ -140,8 +152,6 @@ def has_ssl_cause(exc: BaseException) -> bool:
 
 def classify_family_error(sdk: Any, exc: BaseException) -> FailureKind:
     """Exception -> FailureKind for any SDK exposing the httpx error names."""
-    import asyncio  # noqa: PLC0415 - stdlib, deferred to keep module import light
-
     if isinstance(exc, asyncio.CancelledError):
         return FailureKind.CANCELLED
     if isinstance(exc, sdk.ConnectTimeout):
@@ -173,6 +183,7 @@ def make_error_translator(
     circuit_cls: type[CircuitOpenError],
     deadline_cls: type[DeadlineExceededError],
     redirects_cls: type[TooManyRedirectsError],
+    attempt_cls: type[AttemptTimeoutError],
 ) -> Callable[[CallError], BaseException]:
     """Build the CallError -> dual-family translator from the bound classes."""
 
@@ -181,6 +192,8 @@ def make_error_translator(
             return circuit_cls(error.key, error.retry_after)
         if isinstance(error, DeadlineExceededError):
             return deadline_cls(error.total)
+        if isinstance(error, AttemptTimeoutError):
+            return attempt_cls(error.attempt)
         if isinstance(error, TooManyRedirectsError):
             return redirects_cls(error.hops)
         return error
@@ -344,12 +357,21 @@ class FamilyResponseView:
 
 
 class TimedStreamCore:
-    """Times body consumption and reports read failures exactly once."""
+    """Times body consumption, keeps it inside the deadline and reports the end exactly once."""
 
-    def __init__(self, inner: Any, clock: Callable[[], float], on_done: Callable[[Outcome, float], None]) -> None:
+    def __init__(
+        self,
+        inner: Any,
+        clock: Callable[[], float],
+        on_done: Callable[[Outcome, float], None],
+        deadline: Deadline,
+        translate: Callable[[CallError], BaseException],
+    ) -> None:
         self._inner = inner
         self._clock = clock
         self._on_done = on_done
+        self._deadline = deadline
+        self._translate = translate
         self._started = clock()
         self._finished = False
 
@@ -358,14 +380,37 @@ class TimedStreamCore:
             self._finished = True
             self._on_done(outcome, self._clock() - self._started)
 
+    def _failed(self, exc: BaseException) -> None:
+        kind = FailureKind.TOTAL_TIMEOUT if isinstance(exc, DeadlineExceededError) else FailureKind.BODY_ERROR
+        self._finish(Outcome(kind=kind, exception=exc))
+
+    def _expired(self) -> BaseException:
+        return self._translate(DeadlineExceededError(self._deadline.total or 0.0))
+
+    def _check_budget(self) -> None:
+        if self._deadline.expired:
+            raise self._expired()
+
 
 class AsyncTimedStreamMixin(TimedStreamCore):
     async def __aiter__(self) -> Any:
+        chunks = self._inner.__aiter__()
         try:
-            async for chunk in self._inner:
+            while True:
+                self._check_budget()
+                scope = asyncio.timeout(self._deadline.remaining())
+                try:
+                    async with scope:
+                        chunk = await anext(chunks)
+                except StopAsyncIteration:
+                    break
+                except Exception as exc:
+                    if scope.expired():
+                        raise self._expired() from exc
+                    raise
                 yield chunk
         except Exception as exc:
-            self._finish(Outcome(kind=FailureKind.BODY_ERROR, exception=exc))
+            self._failed(exc)
             raise
         self._finish(Outcome(kind=None))
 
@@ -378,10 +423,20 @@ class AsyncTimedStreamMixin(TimedStreamCore):
 
 class SyncTimedStreamMixin(TimedStreamCore):
     def __iter__(self) -> Any:
+        # A blocked read cannot be interrupted: the deadline is soft here and
+        # refuses to START a read once the budget is gone, so the overrun is at
+        # most one chunk or one read timeout.
+        chunks = iter(self._inner)
         try:
-            yield from self._inner
+            while True:
+                self._check_budget()
+                try:
+                    chunk = next(chunks)
+                except StopIteration:
+                    break
+                yield chunk
         except Exception as exc:
-            self._finish(Outcome(kind=FailureKind.BODY_ERROR, exception=exc))
+            self._failed(exc)
             raise
         self._finish(Outcome(kind=None))
 
@@ -403,12 +458,14 @@ class AsyncFamilyNormalizer:
         sdk: Any,
         request_view: Callable[[Any], Any],
         timed_stream: Callable[..., Any],
+        translate: Callable[[CallError], BaseException],
     ) -> None:
         self._default_timeout = default_timeout
         self._clock = clock
         self._sdk = sdk
         self._request_view = request_view
         self._timed_stream = timed_stream
+        self._translate = translate
 
     def wrap_request(self, native: Any) -> Any:
         return self._request_view(native)
@@ -440,11 +497,11 @@ class AsyncFamilyNormalizer:
         except Exception:
             return None
 
-    def wrap_stream(self, response: Any, on_done: Callable[[Outcome, float], None]) -> None:
+    def wrap_stream(self, response: Any, on_done: Callable[[Outcome, float], None], deadline: Deadline) -> None:
         native = response.native
         stream = native.stream
         if isinstance(stream, self._sdk.AsyncByteStream):
-            native.stream = self._timed_stream(stream, self._clock, on_done)
+            native.stream = self._timed_stream(stream, self._clock, on_done, deadline, self._translate)
 
     def conn_metrics(self, response: Any) -> ConnMetrics | None:
         return None
@@ -461,12 +518,14 @@ class SyncFamilyNormalizer:
         sdk: Any,
         request_view: Callable[[Any], Any],
         timed_stream: Callable[..., Any],
+        translate: Callable[[CallError], BaseException],
     ) -> None:
         self._default_timeout = default_timeout
         self._clock = clock
         self._sdk = sdk
         self._request_view = request_view
         self._timed_stream = timed_stream
+        self._translate = translate
 
     def wrap_request(self, native: Any) -> Any:
         return self._request_view(native)
@@ -498,11 +557,11 @@ class SyncFamilyNormalizer:
         except Exception:
             return None
 
-    def wrap_stream(self, response: Any, on_done: Callable[[Outcome, float], None]) -> None:
+    def wrap_stream(self, response: Any, on_done: Callable[[Outcome, float], None], deadline: Deadline) -> None:
         native = response.native
         stream = native.stream
         if isinstance(stream, self._sdk.SyncByteStream):
-            native.stream = self._timed_stream(stream, self._clock, on_done)
+            native.stream = self._timed_stream(stream, self._clock, on_done, deadline, self._translate)
 
     def conn_metrics(self, response: Any) -> ConnMetrics | None:
         return None
@@ -636,7 +695,7 @@ class FamilyAdapter:
             applied.add(Capability.HTTP2)
         if config.proxy is not None:
             applied.add(Capability.PROXY)
-        emulated = {Capability.TIMEOUT_TOTAL}
+        emulated = {Capability.TIMEOUT_TOTAL, Capability.DEADLINE_COVERS_BODY}
         dropped: dict[Capability, str] = {}
         if sync:
             # The sync engine cannot cancel a blocked socket call: no hard

{clientwright-0.2.1 → clientwright-0.2.2}/clientwright/adapters/aiohttp/__init__.py

@@ -13,6 +13,7 @@ from .._lazy import lazy_attribute
 if TYPE_CHECKING:
     from .adapter import AiohttpAdapter as AiohttpAdapter
     from .capabilities import CAPABILITIES as CAPABILITIES
+    from .errors import AiohttpAttemptTimeoutError as AiohttpAttemptTimeoutError
     from .errors import AiohttpCircuitOpenError as AiohttpCircuitOpenError
     from .errors import AiohttpDeadlineExceededError as AiohttpDeadlineExceededError
     from .errors import AiohttpTooManyRedirectsError as AiohttpTooManyRedirectsError
@@ -22,6 +23,7 @@ if TYPE_CHECKING:
 _EXPORTS = {
     "CAPABILITIES": "capabilities",
     "AiohttpAdapter": "adapter",
+    "AiohttpAttemptTimeoutError": "errors",
     "AiohttpCircuitOpenError": "errors",
     "AiohttpDeadlineExceededError": "errors",
     "AiohttpTooManyRedirectsError": "errors",
@@ -37,6 +39,7 @@ def __getattr__(name: str) -> Any:
 __all__ = [
     "CAPABILITIES",
     "AiohttpAdapter",
+    "AiohttpAttemptTimeoutError",
     "AiohttpCircuitOpenError",
     "AiohttpDeadlineExceededError",
     "AiohttpTooManyRedirectsError",

{clientwright-0.2.1 → clientwright-0.2.2}/clientwright/adapters/aiohttp/capabilities.py

@@ -24,6 +24,7 @@ CAPABILITIES = AdapterCapabilities(
         Capability.TIMEOUT_WRITE: Support.ABSENT,
         Capability.TIMEOUT_POOL: Support.ABSENT,
         Capability.DEADLINE_HARD: Support.EMULATED,
+        Capability.DEADLINE_COVERS_BODY: Support.ABSENT,
         Capability.POOL_LIMIT_TOTAL: Support.NATIVE,
         Capability.POOL_LIMIT_PER_HOST: Support.NATIVE,
         Capability.KEEPALIVE: Support.NATIVE,
@@ -43,6 +44,7 @@ CAPABILITIES = AdapterCapabilities(
         {
             FailureKind.CONNECT_TIMEOUT,
             FailureKind.READ_TIMEOUT,
+            FailureKind.ATTEMPT_TIMEOUT,
             FailureKind.TOTAL_TIMEOUT,
             FailureKind.CONNECT_ERROR,
             FailureKind.DNS_ERROR,
@@ -74,6 +76,10 @@ CAPABILITIES = AdapterCapabilities(
         ),
         "ceil_threshold": "ClientTimeout.ceil_threshold is raised so aiohttp never ceils deadlines to whole seconds.",
         "body_duration": "The middleware returns at headers; body read is not instrumented (no body_duration metric).",
+        "deadline_covers_body": (
+            "The body streams outside the seam through aiohttp's StreamReader: the total stops at the headers and "
+            "only sock_read bounds a dripping body."
+        ),
         "max_keepalive": "aiohttp has no cap on the NUMBER of keep-alive connections; pool.max_keepalive is ignored.",
     },
 )

{clientwright-0.2.1 → clientwright-0.2.2}/clientwright/adapters/aiohttp/errors.py

@@ -6,7 +6,13 @@ keeps working when clientwright raises on its own authority.
 
 from __future__ import annotations
 
-from ...core.errors import CallError, CircuitOpenError, DeadlineExceededError, TooManyRedirectsError
+from ...core.errors import (
+    AttemptTimeoutError,
+    CallError,
+    CircuitOpenError,
+    DeadlineExceededError,
+    TooManyRedirectsError,
+)
 from ._imports import aiohttp
 
 
@@ -18,6 +24,10 @@ class AiohttpDeadlineExceededError(DeadlineExceededError, aiohttp.ServerTimeoutE
     """Total deadline exhausted, catchable as asyncio.TimeoutError and aiohttp.ClientError."""
 
 
+class AiohttpAttemptTimeoutError(AttemptTimeoutError, aiohttp.ServerTimeoutError):
+    """Attempt ceiling exhausted, catchable as asyncio.TimeoutError and aiohttp.ClientError."""
+
+
 class AiohttpTooManyRedirectsError(TooManyRedirectsError, aiohttp.TooManyRedirects):
     """Owned redirect limit exceeded, catchable as aiohttp.TooManyRedirects.
 
@@ -44,12 +54,15 @@ def translate_call_error(error: CallError) -> BaseException:
         return AiohttpCircuitOpenError(error.key, error.retry_after)
     if isinstance(error, DeadlineExceededError):
         return AiohttpDeadlineExceededError(error.total)
+    if isinstance(error, AttemptTimeoutError):
+        return AiohttpAttemptTimeoutError(error.attempt)
     if isinstance(error, TooManyRedirectsError):
         return AiohttpTooManyRedirectsError(error.hops)
     return error
 
 
 __all__ = [
+    "AiohttpAttemptTimeoutError",
     "AiohttpCircuitOpenError",
     "AiohttpDeadlineExceededError",
     "AiohttpTooManyRedirectsError",

{clientwright-0.2.1 → clientwright-0.2.2}/clientwright/adapters/aiohttp/normalize.py

@@ -9,6 +9,7 @@ from typing import Any
 from ...core.contracts.message import RequestView, ResponseView
 from ...core.engine.base import default_response_outcome
 from ...core.model import ConnMetrics, FailureKind, Outcome
+from ...core.policy.budget import Deadline
 from ._imports import aiohttp
 from .classify import classify_error
 from .trace import current_conn_metrics
@@ -52,9 +53,12 @@ class AsyncAiohttpNormalizer:
         except Exception:
             return None
 
-    def wrap_stream(self, response: ResponseView, on_done: Callable[[Outcome, float], None]) -> None:
-        # The middleware returns at headers; the body streams outside the seam.
-        # Declared in capabilities (note "body_duration"), not silently skipped.
+    def wrap_stream(
+        self, response: ResponseView, on_done: Callable[[Outcome, float], None], deadline: Deadline
+    ) -> None:
+        # The middleware returns at headers; the body streams outside the seam
+        # through aiohttp's own StreamReader, so neither telemetry nor the
+        # deadline reaches it. Declared in capabilities, not silently skipped.
         return None
 
     def conn_metrics(self, response: ResponseView) -> ConnMetrics | None:

{clientwright-0.2.1 → clientwright-0.2.2}/clientwright/adapters/httpx/__init__.py

@@ -13,6 +13,7 @@ from .._lazy import lazy_attribute
 if TYPE_CHECKING:
     from .adapter import HttpxAdapter as HttpxAdapter
     from .capabilities import CAPABILITIES as CAPABILITIES
+    from .errors import HttpxAttemptTimeoutError as HttpxAttemptTimeoutError
     from .errors import HttpxCircuitOpenError as HttpxCircuitOpenError
     from .errors import HttpxDeadlineExceededError as HttpxDeadlineExceededError
     from .errors import HttpxTooManyRedirectsError as HttpxTooManyRedirectsError
@@ -22,6 +23,7 @@ if TYPE_CHECKING:
 _EXPORTS = {
     "CAPABILITIES": "capabilities",
     "HttpxAdapter": "adapter",
+    "HttpxAttemptTimeoutError": "errors",
     "HttpxCircuitOpenError": "errors",
     "HttpxDeadlineExceededError": "errors",
     "HttpxTooManyRedirectsError": "errors",
@@ -39,6 +41,7 @@ __all__ = [
     "IDEMPOTENT_EXTENSION",
     "ROUTE_EXTENSION",
     "HttpxAdapter",
+    "HttpxAttemptTimeoutError",
     "HttpxCircuitOpenError",
     "HttpxDeadlineExceededError",
     "HttpxTooManyRedirectsError",

{clientwright-0.2.1 → clientwright-0.2.2}/clientwright/adapters/httpx/errors.py

@@ -6,7 +6,7 @@ keeps working when clientwright raises on its own authority.
 
 from __future__ import annotations
 
-from ...core.errors import CircuitOpenError, DeadlineExceededError, TooManyRedirectsError
+from ...core.errors import AttemptTimeoutError, CircuitOpenError, DeadlineExceededError, TooManyRedirectsError
 from .._httpx_shared import make_error_translator
 from ._imports import httpx
 
@@ -19,15 +19,20 @@ class HttpxDeadlineExceededError(DeadlineExceededError, httpx.TimeoutException):
     """Total deadline exhausted, catchable as httpx.TimeoutException."""
 
 
+class HttpxAttemptTimeoutError(AttemptTimeoutError, httpx.TimeoutException):
+    """Attempt ceiling exhausted, catchable as httpx.TimeoutException."""
+
+
 class HttpxTooManyRedirectsError(TooManyRedirectsError, httpx.TooManyRedirects):
     """Owned redirect limit exceeded, catchable as httpx.TooManyRedirects."""
 
 
 translate_call_error = make_error_translator(
-    HttpxCircuitOpenError, HttpxDeadlineExceededError, HttpxTooManyRedirectsError
+    HttpxCircuitOpenError, HttpxDeadlineExceededError, HttpxTooManyRedirectsError, HttpxAttemptTimeoutError
 )
 
 __all__ = [
+    "HttpxAttemptTimeoutError",
     "HttpxCircuitOpenError",
     "HttpxDeadlineExceededError",
     "HttpxTooManyRedirectsError",

{clientwright-0.2.1 → clientwright-0.2.2}/clientwright/adapters/httpx/normalize.py

@@ -6,6 +6,7 @@ from collections.abc import Callable
 
 from .._httpx_shared import AsyncFamilyNormalizer, AsyncTimedStreamMixin
 from ._imports import httpx
+from .errors import translate_call_error
 from .views import HttpxRequestView
 
 
@@ -21,6 +22,7 @@ class AsyncHttpxNormalizer(AsyncFamilyNormalizer):
             sdk=httpx,
             request_view=lambda native: HttpxRequestView(native, default_timeout),
             timed_stream=_TimedAsyncStream,
+            translate=translate_call_error,
         )
 
 

{clientwright-0.2.1 → clientwright-0.2.2}/clientwright/adapters/httpx/normalize_sync.py

@@ -6,6 +6,7 @@ from collections.abc import Callable
 
 from .._httpx_shared import SyncFamilyNormalizer, SyncTimedStreamMixin
 from ._imports import httpx
+from .errors import translate_call_error
 from .views import HttpxRequestView
 
 
@@ -21,6 +22,7 @@ class SyncHttpxNormalizer(SyncFamilyNormalizer):
             sdk=httpx,
             request_view=lambda native: HttpxRequestView(native, default_timeout),
             timed_stream=_TimedSyncStream,
+            translate=translate_call_error,
         )
 
 

{clientwright-0.2.1 → clientwright-0.2.2}/clientwright/adapters/httpx2/__init__.py

@@ -14,6 +14,7 @@ from .._lazy import lazy_attribute
 if TYPE_CHECKING:
     from .adapter import HttpxAdapter as HttpxAdapter
     from .capabilities import CAPABILITIES as CAPABILITIES
+    from .errors import HttpxAttemptTimeoutError as HttpxAttemptTimeoutError
     from .errors import HttpxCircuitOpenError as HttpxCircuitOpenError
     from .errors import HttpxDeadlineExceededError as HttpxDeadlineExceededError
     from .errors import HttpxTooManyRedirectsError as HttpxTooManyRedirectsError
@@ -23,6 +24,7 @@ if TYPE_CHECKING:
 _EXPORTS = {
     "CAPABILITIES": "capabilities",
     "HttpxAdapter": "adapter",
+    "HttpxAttemptTimeoutError": "errors",
     "HttpxCircuitOpenError": "errors",
     "HttpxDeadlineExceededError": "errors",
     "HttpxTooManyRedirectsError": "errors",
@@ -40,6 +42,7 @@ __all__ = [
     "IDEMPOTENT_EXTENSION",
     "ROUTE_EXTENSION",
     "HttpxAdapter",
+    "HttpxAttemptTimeoutError",
     "HttpxCircuitOpenError",
     "HttpxDeadlineExceededError",
     "HttpxTooManyRedirectsError",

{clientwright-0.2.1 → clientwright-0.2.2}/clientwright/adapters/httpx2/errors.py

@@ -7,7 +7,7 @@ mirror the httpx adapter on purpose.
 
 from __future__ import annotations
 
-from ...core.errors import CircuitOpenError, DeadlineExceededError, TooManyRedirectsError
+from ...core.errors import AttemptTimeoutError, CircuitOpenError, DeadlineExceededError, TooManyRedirectsError
 from .._httpx_shared import make_error_translator
 from ._imports import httpx2
 
@@ -20,15 +20,20 @@ class HttpxDeadlineExceededError(DeadlineExceededError, httpx2.TimeoutException)
     """Total deadline exhausted, catchable as httpx2.TimeoutException."""
 
 
+class HttpxAttemptTimeoutError(AttemptTimeoutError, httpx2.TimeoutException):
+    """Attempt ceiling exhausted, catchable as httpx2.TimeoutException."""
+
+
 class HttpxTooManyRedirectsError(TooManyRedirectsError, httpx2.TooManyRedirects):
     """Owned redirect limit exceeded, catchable as httpx2.TooManyRedirects."""
 
 
 translate_call_error = make_error_translator(
-    HttpxCircuitOpenError, HttpxDeadlineExceededError, HttpxTooManyRedirectsError
+    HttpxCircuitOpenError, HttpxDeadlineExceededError, HttpxTooManyRedirectsError, HttpxAttemptTimeoutError
 )
 
 __all__ = [
+    "HttpxAttemptTimeoutError",
     "HttpxCircuitOpenError",
     "HttpxDeadlineExceededError",
     "HttpxTooManyRedirectsError",

{clientwright-0.2.1 → clientwright-0.2.2}/clientwright/adapters/httpx2/normalize.py

@@ -6,6 +6,7 @@ from collections.abc import Callable
 
 from .._httpx_shared import AsyncFamilyNormalizer, AsyncTimedStreamMixin
 from ._imports import httpx2
+from .errors import translate_call_error
 from .views import HttpxRequestView
 
 
@@ -21,6 +22,7 @@ class AsyncHttpxNormalizer(AsyncFamilyNormalizer):
             sdk=httpx2,
             request_view=lambda native: HttpxRequestView(native, default_timeout),
             timed_stream=_TimedAsyncStream,
+            translate=translate_call_error,
         )
 
 

{clientwright-0.2.1 → clientwright-0.2.2}/clientwright/adapters/httpx2/normalize_sync.py

@@ -6,6 +6,7 @@ from collections.abc import Callable
 
 from .._httpx_shared import SyncFamilyNormalizer, SyncTimedStreamMixin
 from ._imports import httpx2
+from .errors import translate_call_error
 from .views import HttpxRequestView
 
 
@@ -21,6 +22,7 @@ class SyncHttpxNormalizer(SyncFamilyNormalizer):
             sdk=httpx2,
             request_view=lambda native: HttpxRequestView(native, default_timeout),
             timed_stream=_TimedSyncStream,
+            translate=translate_call_error,
         )
 
 

{clientwright-0.2.1 → clientwright-0.2.2}/clientwright/adapters/requests/capabilities.py

@@ -24,6 +24,7 @@ CAPABILITIES = AdapterCapabilities(
         Capability.TIMEOUT_WRITE: Support.ABSENT,
         Capability.TIMEOUT_POOL: Support.ABSENT,
         Capability.DEADLINE_HARD: Support.ABSENT,
+        Capability.DEADLINE_COVERS_BODY: Support.ABSENT,
         Capability.POOL_LIMIT_TOTAL: Support.ABSENT,
         Capability.POOL_LIMIT_PER_HOST: Support.NATIVE,
         Capability.KEEPALIVE: Support.DEGRADED,
@@ -55,12 +56,17 @@ CAPABILITIES = AdapterCapabilities(
         }
     ),
     collapses={
+        FailureKind.ATTEMPT_TIMEOUT: FailureKind.READ_TIMEOUT,
         FailureKind.POOL_TIMEOUT: FailureKind.CONNECT_TIMEOUT,
         FailureKind.PROTOCOL_ERROR: FailureKind.DISCONNECTED,
         FailureKind.WRITE_TIMEOUT: FailureKind.TOTAL_TIMEOUT,
     },
     notes={
         "sync_only": "requests has no async client; build_async raises.",
+        "attempt_timeout": (
+            "A sync runtime cannot cancel an attempt, so no ceiling ever fires; the stall it would have caught "
+            "arrives as the clamped read phase."
+        ),
         "no_session_timeout": (
             "requests has NO session-level timeout default - a bare session.get() hangs forever. The engine "
             "closes that hole: every attempt is sent with the planned (connect, read) tuple."
@@ -74,6 +80,10 @@ CAPABILITIES = AdapterCapabilities(
         "base_url": "requests has no base_url; the build rejects a config that sets one.",
         "per_call_options": "No request extensions; route/idempotency travel via the call_options() context manager.",
         "protocol_error": "requests folds protocol violations into ConnectionError; they surface as disconnected.",
+        "deadline_covers_body": (
+            "Session.send reads the body above the seam: the total stops at the headers and only the read timeout "
+            "bounds a dripping body."
+        ),
     },
 )
 

{clientwright-0.2.1 → clientwright-0.2.2}/clientwright/adapters/requests/normalize.py

@@ -8,6 +8,7 @@ from typing import Any
 from ...core.contracts.message import RequestView, ResponseView
 from ...core.engine.base import default_response_outcome
 from ...core.model import ConnMetrics, FailureKind, Outcome
+from ...core.policy.budget import Deadline
 from ._imports import requests
 from .classify import classify_error
 from .views import RequestsRequestView, RequestsResponseView
@@ -51,7 +52,9 @@ class SyncRequestsNormalizer:
         except Exception:
             return None
 
-    def wrap_stream(self, response: ResponseView, on_done: Callable[[Outcome, float], None]) -> None:
+    def wrap_stream(
+        self, response: ResponseView, on_done: Callable[[Outcome, float], None], deadline: Deadline
+    ) -> None:
         # Session.send consumes the body ABOVE this seam (unless stream=True);
         # body read is not instrumented. Declared in capabilities.
         return None

{clientwright-0.2.1 → clientwright-0.2.2}/clientwright/adapters/urllib3/capabilities.py

@@ -24,6 +24,7 @@ CAPABILITIES = AdapterCapabilities(
         Capability.TIMEOUT_WRITE: Support.ABSENT,
         Capability.TIMEOUT_POOL: Support.NATIVE,
         Capability.DEADLINE_HARD: Support.ABSENT,
+        Capability.DEADLINE_COVERS_BODY: Support.ABSENT,
         Capability.POOL_LIMIT_TOTAL: Support.ABSENT,
         Capability.POOL_LIMIT_PER_HOST: Support.NATIVE,
         Capability.KEEPALIVE: Support.DEGRADED,
@@ -56,11 +57,16 @@ CAPABILITIES = AdapterCapabilities(
         }
     ),
     collapses={
+        FailureKind.ATTEMPT_TIMEOUT: FailureKind.READ_TIMEOUT,
         FailureKind.PROTOCOL_ERROR: FailureKind.DISCONNECTED,
         FailureKind.WRITE_TIMEOUT: FailureKind.TOTAL_TIMEOUT,
     },
     notes={
         "sync_only": "urllib3 has no async client; build_async raises.",
+        "attempt_timeout": (
+            "A sync runtime cannot cancel an attempt, so no ceiling ever fires; the stall it would have caught "
+            "arrives as the clamped read phase."
+        ),
         "seam": (
             "The engine is injected as an INSTANCE urlopen on a genuine PoolManager (type(client) is "
             "urllib3.PoolManager); recursive native redirect hops re-enter it and pass straight through."
@@ -80,6 +86,10 @@ CAPABILITIES = AdapterCapabilities(
         "per_call_options": "No request object; route/idempotency travel via the call_options() context manager.",
         "base_url": "urllib3 has no base_url; the build rejects a config that sets one.",
         "proxy": "An explicit proxy builds a genuine urllib3.ProxyManager; env proxies are not read (dropped).",
+        "deadline_covers_body": (
+            "urlopen preloads or streams the body above the seam: the total stops at the headers and only the read "
+            "timeout bounds a dripping body."
+        ),
     },
 )