clientwright 0.3.0__tar.gz → 0.4.1__tar.gz

{clientwright-0.3.0 → clientwright-0.4.1}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.4.1](https://github.com/bedrock-python/clientwright/compare/clientwright-v0.4.0...clientwright-v0.4.1) (2026-09-14)
+
+
+### Bug Fixes
+
+* client_config_from_settings passes a BaseClientSettings through to to_config ([fc3af5e](https://github.com/bedrock-python/clientwright/commit/fc3af5e21821c8c506f10c43733aa4d66c563c39)), closes [#38](https://github.com/bedrock-python/clientwright/issues/38)
+
+## [0.4.0](https://github.com/bedrock-python/clientwright/compare/clientwright-v0.3.0...clientwright-v0.4.0) (2026-09-14)
+
+
+### Features
+
+* component= and client_type= on ClientwrightProvider, and the circuit-state gauge on its runtime ([0ac6cdf](https://github.com/bedrock-python/clientwright/commit/0ac6cdfd179e1e5bd57ba3d4a49c95892cf6d844)), closes [#35](https://github.com/bedrock-python/clientwright/issues/35)
+
 ## [0.3.0](https://github.com/bedrock-python/clientwright/compare/clientwright-v0.2.2...clientwright-v0.3.0) (2026-09-14)
 
 

{clientwright-0.3.0 → clientwright-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: clientwright
-Version: 0.3.0
+Version: 0.4.1
 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/
@@ -189,6 +189,9 @@ retry traffic by default), body replayability and the remaining deadline.
 `AdapterDeps(runtime=...)` - otherwise breaker state dies with every request.
 With `clientwright[dishka]`, `contrib.dishka.ClientwrightProvider` does both:
 APP-scope runtime and a generator provide that closes the client in `finally`.
+Several upstreams in one container are Dishka components — one
+`ClientwrightProvider("httpx", config, component="github-api", client_type=httpx.AsyncClient)`
+per upstream, injected as `Annotated[httpx.AsyncClient, FromComponent("github-api")]`.
 
 ## Deadline budgets
 

{clientwright-0.3.0 → clientwright-0.4.1}/README.md

@@ -127,6 +127,9 @@ retry traffic by default), body replayability and the remaining deadline.
 `AdapterDeps(runtime=...)` - otherwise breaker state dies with every request.
 With `clientwright[dishka]`, `contrib.dishka.ClientwrightProvider` does both:
 APP-scope runtime and a generator provide that closes the client in `finally`.
+Several upstreams in one container are Dishka components — one
+`ClientwrightProvider("httpx", config, component="github-api", client_type=httpx.AsyncClient)`
+per upstream, injected as `Annotated[httpx.AsyncClient, FromComponent("github-api")]`.
 
 ## Deadline budgets
 

{clientwright-0.3.0 → clientwright-0.4.1}/clientwright/__init__.py

@@ -55,6 +55,7 @@ from .core.contracts import (
     MaskerProtocol,
     RetrySettingsProtocol,
     SpanProtocol,
+    SupportsToConfig,
     TracerProtocol,
 )
 from .core.contracts.adapter import default_deps
@@ -158,6 +159,7 @@ __all__ = [
     "SeamGranularity",
     "SpanProtocol",
     "Support",
+    "SupportsToConfig",
     "TimeoutConfig",
     "TlsConfig",
     "TooManyRedirectsError",

clientwright-0.4.1/clientwright/__version__.py

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

clientwright-0.4.1/clientwright/contrib/dishka.py

@@ -0,0 +1,120 @@
+"""Dishka integration (``[dishka]`` extra): APP-scope runtime, leak-free lifecycle.
+
+Two lessons from the legacy kit are structural here:
+
+- ``ClientRuntime`` (circuits, retry budgets, per-origin limiters) is APP
+  scope. A REQUEST-scoped runtime resets breaker state on every request and
+  turns the circuit breaker into decoration.
+- The client is provided by a GENERATOR provide whose finally closes it - the
+  legacy provider parked ``aclose`` on an AsyncExitStack that nothing ever
+  closed, leaking a client per request.
+
+Usage::
+
+    container = make_async_container(
+        ClientwrightProvider("httpx", config),
+        ...,
+    )
+    handle = await container.get(ClientHandle[Any])
+    client: httpx.AsyncClient = handle.client
+
+Several upstreams in one container are Dishka components: one provider per
+upstream, each in its own component, and ``client_type`` for injection sites
+that want the native client rather than the handle::
+
+    container = make_async_container(
+        ClientwrightProvider("httpx", login_config, component="github-oauth", client_type=httpx.AsyncClient),
+        ClientwrightProvider("httpx", api_config, component="github-api", client_type=httpx.AsyncClient),
+    )
+    api = await container.get(httpx.AsyncClient, component="github-api")
+
+The runtime built here carries the ``http_client_circuit_state`` listener the
+way a runtime built by an adapter does; a runtime passed in through
+``deps.runtime`` is handed back as it came.
+"""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from dataclasses import replace
+from typing import Any
+
+try:
+    from dishka import Provider, Scope, provide
+except ImportError as exc:  # pragma: no cover - exercised only without the extra
+    raise ImportError("Dishka integration requires clientwright[dishka]; install it.") from exc
+
+from ..core.config import ClientConfig
+from ..core.contracts.adapter import AdapterDeps, default_deps
+from ..core.plan import ClientHandle, ClientRuntime
+from ..core.registry import resolve_adapter
+from ..core.telemetry.emitter import ClientTelemetry
+
+
+class ClientwrightProvider(Provider):
+    """One async native client with an APP-scope runtime and guaranteed close.
+
+    ``component`` puts everything the provider gives out in a Dishka component,
+    which is how several upstreams share one container: resolve with
+    ``container.get(..., component="github-api")`` or inject with
+    ``Annotated[..., FromComponent("github-api")]``. ``client_type`` also
+    provides the native client under that type (``httpx.AsyncClient``, ...),
+    the same object the handle holds.
+    """
+
+    scope = Scope.APP
+
+    def __init__(
+        self,
+        adapter: str,
+        config: ClientConfig,
+        deps: AdapterDeps | None = None,
+        *,
+        component: str | None = None,
+        client_type: type[Any] | None = None,
+    ) -> None:
+        super().__init__(component=component)
+        self._adapter = adapter
+        self._config = config
+        self._deps = deps or default_deps()
+        if client_type is not None:
+            self.provide(self._native_client, provides=client_type)
+
+    @provide
+    def client_runtime(self) -> ClientRuntime:
+        if self._deps.runtime is not None:
+            return self._deps.runtime
+        # An adapter wires the circuit-state gauge only to a runtime it builds
+        # itself; this runtime is built here, so the wiring happens here.
+        adapter = resolve_adapter(self._adapter)()
+        telemetry = ClientTelemetry(
+            service=self._config.service_name,
+            adapter=adapter.name,
+            seam=adapter.capabilities.seam,
+            config=self._config.observability,
+            metrics=self._deps.metrics,
+            tracer=None,
+        )
+        return ClientRuntime.for_config(
+            self._config, clock=self._deps.clock, circuit_listener=telemetry.circuit_state_changed
+        )
+
+    @provide
+    async def client_handle(self, runtime: ClientRuntime) -> AsyncIterator[ClientHandle[Any]]:
+        adapter = resolve_adapter(self._adapter)()
+        handle: ClientHandle[Any] = adapter.build_async(self._config, replace(self._deps, runtime=runtime))
+        try:
+            yield handle
+        finally:
+            # The whole point: close travels WITH the provide, not on a stack
+            # nobody closes.
+            if handle.aclose is not None:
+                await handle.aclose()
+            elif handle.close is not None:
+                handle.close()
+
+    def _native_client(self, handle: ClientHandle[Any]) -> Any:
+        return handle.client
+
+
+__all__ = ["ClientwrightProvider"]

{clientwright-0.3.0 → clientwright-0.4.1}/clientwright/contrib/settings.py

@@ -283,7 +283,11 @@ class BaseClientSettings(BaseModel):
     )
 
     def to_config(self, service_name: str) -> ClientConfig:
-        """The ``ClientConfig`` these settings describe, labelled ``service_name``."""
+        """The ``ClientConfig`` these settings describe, labelled ``service_name``.
+
+        The one translation for the shipped models. ``client_config_from_settings``
+        is the flat legacy route and passes a ``BaseClientSettings`` straight here.
+        """
         return ClientConfig(
             service_name=service_name,
             base_url=self.base_url,

{clientwright-0.3.0 → clientwright-0.4.1}/clientwright/core/contracts/__init__.py

@@ -15,6 +15,7 @@ from .observability import TracerProtocol as TracerProtocol
 from .settings import CircuitBreakerSettingsProtocol as CircuitBreakerSettingsProtocol
 from .settings import ClientSettingsProtocol as ClientSettingsProtocol
 from .settings import RetrySettingsProtocol as RetrySettingsProtocol
+from .settings import SupportsToConfig as SupportsToConfig
 
 __all__ = [
     "AdapterDeps",
@@ -30,6 +31,7 @@ __all__ = [
     "ResponseView",
     "RetrySettingsProtocol",
     "SpanProtocol",
+    "SupportsToConfig",
     "SyncNormalizer",
     "TracerProtocol",
 ]

{clientwright-0.3.0 → clientwright-0.4.1}/clientwright/core/contracts/settings.py

@@ -4,6 +4,12 @@ Services keep their own settings models (pydantic or otherwise); anything with
 these read-only properties satisfies the contract - the org convention set by
 grpc-client-kit. ``client_config_from_settings`` converts the structural shape
 into a ``ClientConfig``.
+
+This is the flat, legacy shape. The shipped models in
+``clientwright.contrib.settings`` are the nested one and carry their own
+translation, ``BaseClientSettings.to_config(service_name)``; the converter
+passes anything with a ``to_config`` through to it, so either call builds
+the same config.
 """
 
 from __future__ import annotations
@@ -50,7 +56,12 @@ class CircuitBreakerSettingsProtocol(Protocol):
 
 @runtime_checkable
 class ClientSettingsProtocol(Protocol):
-    """Mirror of the legacy ``RestClientSettingsProtocol`` reachable surface."""
+    """Mirror of the legacy ``RestClientSettingsProtocol`` reachable surface.
+
+    Flat names for a settings model of your own. The shipped nested models
+    (``clientwright.contrib.settings.BaseClientSettings``) do not satisfy this
+    protocol; they carry ``to_config(service_name)`` instead.
+    """
 
     @property
     def base_url(self) -> str: ...
@@ -89,8 +100,26 @@ class ClientSettingsProtocol(Protocol):
     def circuit_breaker(self) -> CircuitBreakerSettingsProtocol | None: ...
 
 
-def client_config_from_settings(settings: ClientSettingsProtocol, service_name: str) -> ClientConfig:
-    """Build a ClientConfig from the structural settings shape used by services."""
+@runtime_checkable
+class SupportsToConfig(Protocol):
+    """Settings that build their own ``ClientConfig`` - the shape of ``BaseClientSettings``."""
+
+    def to_config(self, service_name: str) -> ClientConfig: ...
+
+
+def client_config_from_settings(settings: ClientSettingsProtocol | SupportsToConfig, service_name: str) -> ClientConfig:
+    """Build a ClientConfig from the structural settings shape used by services.
+
+    For a settings object that builds its own config - the shipped
+    ``clientwright.contrib.settings.BaseClientSettings`` - this is
+    ``settings.to_config(service_name)``, and that is what it returns: the
+    nested sections (pool, tls, proxy, headers, redirects, observability, ...)
+    all reach the config. Call ``to_config`` directly where you can; the flat
+    ``ClientSettingsProtocol`` route is for a model of your own that predates
+    the shipped ones.
+    """
+    if isinstance(settings, SupportsToConfig):
+        return settings.to_config(service_name)
     retry_settings = settings.retry
     retry = (
         RetryConfig(
@@ -136,5 +165,6 @@ __all__ = [
     "CircuitBreakerSettingsProtocol",
     "ClientSettingsProtocol",
     "RetrySettingsProtocol",
+    "SupportsToConfig",
     "client_config_from_settings",
 ]

{clientwright-0.3.0 → clientwright-0.4.1}/tests/integration/contrib/test_dishka.py

@@ -65,3 +65,45 @@ async def test__two_container_generations__breaker_state_lives_in_the_runtime(or
         await rebuilt.client.get("/status/500")  # rejected locally: state survived the rebuild
     assert origin.request_count("/status/500") == 1
     await second.close()
+
+
+async def test__two_components__each_upstream_has_its_own_breaker_and_the_trip_reaches_metrics(
+    origin: OriginServer,
+) -> None:
+    # The reporter's shape: two upstreams in one container, each on its own
+    # runtime, each closed with the container - and the tripped breaker is
+    # exported although the provider, not the adapter, built the runtime.
+    metrics = RecordingMetrics()
+    deps = AdapterDeps(metrics=metrics)
+
+    def config(service: str) -> ClientConfig:
+        return ClientConfig(
+            service_name=service,
+            base_url=origin.url,
+            retry=None,
+            circuit_breaker=CircuitBreakerConfig(fail_threshold=1, recovery_timeout=60.0),
+        )
+
+    container = make_async_container(
+        ClientwrightProvider(
+            "httpx", config("github-oauth"), deps, component="github-oauth", client_type=httpx.AsyncClient
+        ),
+        ClientwrightProvider(
+            "httpx", config("github-api"), deps, component="github-api", client_type=httpx.AsyncClient
+        ),
+    )
+    login = await container.get(httpx.AsyncClient, component="github-oauth")
+    api = await container.get(httpx.AsyncClient, component="github-api")
+    assert login is not api
+
+    trip = await api.get("/status/500")
+    assert trip.status_code == 500  # one 5xx signal arms github-api's breaker
+    with pytest.raises(httpx.HTTPError):
+        await api.get("/status/500")  # rejected locally
+    assert (await login.get("/status/500")).status_code == 500  # github-oauth's breaker is its own
+    assert origin.request_count("/status/500") == 2
+    assert [record["state"] for record in metrics.circuit_states] == ["open", "open"]
+
+    await container.close()
+    assert login.is_closed
+    assert api.is_closed

clientwright-0.4.1/tests/unit/contrib/test_dishka.py

@@ -0,0 +1,124 @@
+"""contrib units: the dishka provider lifecycle."""
+
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+import pytest
+
+pytest.importorskip("dishka", reason="requires the [dishka] extra")
+httpx = pytest.importorskip("httpx", reason="requires the [httpx] extra")
+
+from dishka import FromComponent, Provider, Scope, make_async_container, provide  # noqa: E402
+
+import clientwright  # noqa: E402
+from clientwright import AdapterDeps, CircuitBreakerConfig, FailureKind, Outcome  # noqa: E402
+from clientwright.contrib.dishka import ClientwrightProvider  # noqa: E402
+from clientwright.core.plan import ClientHandle, ClientRuntime  # noqa: E402
+from clientwright.core.telemetry import names  # noqa: E402
+
+
+async def test__provider__builds_client_and_closes_it_with_container() -> None:
+    config = clientwright.ClientConfig(service_name="di-test")
+    container = make_async_container(ClientwrightProvider("httpx", config))
+    handle = await container.get(ClientHandle[Any])
+    assert type(handle.client) is httpx.AsyncClient
+    runtime = await container.get(ClientRuntime)
+    assert handle.runtime is runtime  # APP-scope runtime shared through DI
+    assert not handle.client.is_closed
+    await container.close()
+    assert handle.client.is_closed  # the generator provide's finally ran
+
+
+async def test__request_scope__leaves_the_client_open_until_the_container_closes() -> None:
+    # Close travels with the APP-scope provide: a request scope coming and going
+    # must not touch the client (the legacy kit parked aclose on a
+    # request-scoped exit stack and leaked a client per request).
+    config = clientwright.ClientConfig(service_name="di-scope")
+    container = make_async_container(ClientwrightProvider("httpx", config))
+    async with container() as request:
+        handle = await request.get(ClientHandle[Any])
+    assert not handle.client.is_closed
+    await container.close()
+    assert handle.client.is_closed
+
+
+async def test__two_components__serve_two_upstreams_from_one_container() -> None:
+    login = clientwright.ClientConfig(service_name="github-oauth", base_url="https://github.com")
+    api = clientwright.ClientConfig(service_name="github-api", base_url="https://api.github.com")
+    container = make_async_container(
+        ClientwrightProvider("httpx", login, component="github-oauth"),
+        ClientwrightProvider("httpx", api, component="github-api"),
+    )
+    login_handle = await container.get(ClientHandle[Any], component="github-oauth")
+    api_handle = await container.get(ClientHandle[Any], component="github-api")
+    assert login_handle is not api_handle
+    assert login_handle.plan.config.service_name == "github-oauth"
+    assert api_handle.plan.config.service_name == "github-api"
+    # Each component resolves its own runtime: two upstreams are two breakers.
+    assert login_handle.runtime is not api_handle.runtime
+    assert login_handle.runtime is await container.get(ClientRuntime, component="github-oauth")
+    await container.close()
+    assert login_handle.client.is_closed
+    assert api_handle.client.is_closed
+
+
+async def test__client_type__provides_the_native_client_the_handle_holds() -> None:
+    config = clientwright.ClientConfig(service_name="di-typed")
+    container = make_async_container(ClientwrightProvider("httpx", config, client_type=httpx.AsyncClient))
+    client = await container.get(httpx.AsyncClient)
+    handle = await container.get(ClientHandle[Any])
+    assert client is handle.client
+    await container.close()
+    assert client.is_closed
+
+
+class GitHubOAuthProvider:
+    """The reporter's shape: two clientwright clients handed to one object."""
+
+    def __init__(
+        self,
+        login_client: Annotated[httpx.AsyncClient, FromComponent("github-oauth")],
+        api_client: Annotated[httpx.AsyncClient, FromComponent("github-api")],
+    ) -> None:
+        self.login_client = login_client
+        self.api_client = api_client
+
+
+class ServiceProvider(Provider):
+    scope = Scope.APP
+    github = provide(GitHubOAuthProvider)
+
+
+async def test__client_type_per_component__injects_each_upstream_by_name() -> None:
+    login = clientwright.ClientConfig(service_name="github-oauth", base_url="https://github.com")
+    api = clientwright.ClientConfig(service_name="github-api", base_url="https://api.github.com")
+    container = make_async_container(
+        ClientwrightProvider("httpx", login, component="github-oauth", client_type=httpx.AsyncClient),
+        ClientwrightProvider("httpx", api, component="github-api", client_type=httpx.AsyncClient),
+        ServiceProvider(),
+    )
+    github = await container.get(GitHubOAuthProvider)
+    login_handle = await container.get(ClientHandle[Any], component="github-oauth")
+    api_handle = await container.get(ClientHandle[Any], component="github-api")
+    assert github.login_client is login_handle.client
+    assert github.api_client is api_handle.client
+    await container.close()
+    assert github.login_client.is_closed
+    assert github.api_client.is_closed
+
+
+async def test__runtime_built_by_provider__moves_the_circuit_state_gauge() -> None:
+    prometheus_client = pytest.importorskip("prometheus_client", reason="requires the [metrics] extra")
+    from clientwright.adapters.observability import PrometheusClientMetrics  # noqa: PLC0415 - behind the extra
+
+    registry = prometheus_client.CollectorRegistry()
+    config = clientwright.ClientConfig(service_name="di-gauge", circuit_breaker=CircuitBreakerConfig(fail_threshold=1))
+    deps = AdapterDeps(metrics=PrometheusClientMetrics(registry=registry))
+    container = make_async_container(ClientwrightProvider("httpx", config, deps))
+    handle = await container.get(ClientHandle[Any])
+    assert handle.runtime.circuits is not None
+    handle.runtime.circuits.record("https://wh.example.com:443", Outcome(kind=FailureKind.STATUS, status_code=503))
+    labels = {"service": "di-gauge", "adapter": "httpx", "key": "https://wh.example.com:443"}
+    assert registry.get_sample_value(names.CIRCUIT_STATE, labels) == 2.0  # open
+    await container.close()

{clientwright-0.3.0 → clientwright-0.4.1}/tests/unit/contrib/test_settings.py

@@ -27,6 +27,7 @@ from clientwright import (
     TlsConfig,
     UnsupportedPolicy,
     build_sync,
+    client_config_from_settings,
 )
 from clientwright.contrib import settings as settings_module
 from clientwright.contrib.settings import (
@@ -203,6 +204,27 @@ def test__bad_values__fail_at_load_with_the_field_path() -> None:
         BaseProxySettings(url="http://proxy:3128", from_env=True)
 
 
+# --- the legacy converter ---
+
+
+def test__the_legacy_converter__passes_a_base_client_settings_through_to_to_config() -> None:
+    settings = BaseClientSettings(
+        base_url="https://auth.example.com",
+        pool={"max_connections": 7},
+        retry={"multiplier": 3.0},
+        tls={"verify": False},
+        proxy={"url": "http://proxy:3128"},
+    )
+
+    config = client_config_from_settings(settings, "auth-orchestrator")
+
+    assert config == settings.to_config("auth-orchestrator")
+    assert config.pool.max_connections == 7
+    assert config.retry is not None and config.retry.multiplier == 3.0
+    assert config.tls == TlsConfig(verify=False)
+    assert config.proxy == ProxyConfig(url="http://proxy:3128")
+
+
 def test__a_config_from_settings__builds_the_native_client() -> None:
     httpx = pytest.importorskip("httpx", reason="requires the [httpx] extra")
     config = BaseClientSettings(base_url="https://api.example.com", pool={"http2": False}).to_config("api")

{clientwright-0.3.0 → clientwright-0.4.1}/tests/unit/core/test_settings.py

@@ -32,3 +32,13 @@ def test__structural_settings__mapped_into_config() -> None:
     assert config.retry is not None and config.retry.max_attempts == 5
     assert config.circuit_breaker is None
     assert config.observability.tracing is False
+
+
+def test__settings_with_to_config__are_passed_through_to_it() -> None:
+    class Settings:
+        def to_config(self, service_name: str) -> clientwright.ClientConfig:
+            return clientwright.ClientConfig(service_name=service_name, base_url="https://api.example.com")
+
+    config = clientwright.client_config_from_settings(Settings(), "svc")
+    assert config == clientwright.ClientConfig(service_name="svc", base_url="https://api.example.com")
+    assert isinstance(Settings(), clientwright.SupportsToConfig)

clientwright-0.3.0/clientwright/__version__.py

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

clientwright-0.3.0/clientwright/contrib/dishka.py

@@ -1,80 +0,0 @@
-"""Dishka integration (``[dishka]`` extra): APP-scope runtime, leak-free lifecycle.
-
-Two lessons from the legacy kit are structural here:
-
-- ``ClientRuntime`` (circuits, retry budgets, per-origin limiters) is APP
-  scope. A REQUEST-scoped runtime resets breaker state on every request and
-  turns the circuit breaker into decoration.
-- The client is provided by a GENERATOR provide whose finally closes it - the
-  legacy provider parked ``aclose`` on an AsyncExitStack that nothing ever
-  closed, leaking a client per request.
-
-Usage::
-
-    container = make_async_container(
-        ClientwrightProvider("httpx", config),
-        ...,
-    )
-    handle = await container.get(ClientHandle)
-    client: httpx.AsyncClient = handle.client
-
-Known limitation: the ``http_client_circuit_state`` gauge is wired when the
-ADAPTER builds the runtime; a runtime built here (to be shared) has no
-telemetry listener, so state-change events are not exported as a gauge.
-"""
-
-from __future__ import annotations
-
-from collections.abc import AsyncIterator
-from dataclasses import replace
-from typing import Any
-
-try:
-    from dishka import Provider, Scope, provide
-except ImportError as exc:  # pragma: no cover - exercised only without the extra
-    raise ImportError("Dishka integration requires clientwright[dishka]; install it.") from exc
-
-from ..core.config import ClientConfig
-from ..core.contracts.adapter import AdapterDeps, default_deps
-from ..core.plan import ClientHandle, ClientRuntime
-from ..core.registry import resolve_adapter
-
-
-class ClientwrightProvider(Provider):
-    """One async native client with an APP-scope runtime and guaranteed close.
-
-    For several upstreams, instantiate one provider per upstream in separate
-    containers, or subclass and add typed aliases (e.g. a provider returning
-    ``httpx.AsyncClient`` from the handle) for ergonomic injection.
-    """
-
-    scope = Scope.APP
-
-    def __init__(self, adapter: str, config: ClientConfig, deps: AdapterDeps | None = None) -> None:
-        super().__init__()
-        self._adapter = adapter
-        self._config = config
-        self._deps = deps or default_deps()
-
-    @provide
-    def client_runtime(self) -> ClientRuntime:
-        if self._deps.runtime is not None:
-            return self._deps.runtime
-        return ClientRuntime.for_config(self._config, clock=self._deps.clock)
-
-    @provide
-    async def client_handle(self, runtime: ClientRuntime) -> AsyncIterator[ClientHandle[Any]]:
-        adapter = resolve_adapter(self._adapter)()
-        handle: ClientHandle[Any] = adapter.build_async(self._config, replace(self._deps, runtime=runtime))
-        try:
-            yield handle
-        finally:
-            # The whole point: close travels WITH the provide, not on a stack
-            # nobody closes.
-            if handle.aclose is not None:
-                await handle.aclose()
-            elif handle.close is not None:
-                handle.close()
-
-
-__all__ = ["ClientwrightProvider"]

clientwright-0.3.0/tests/unit/contrib/test_dishka.py

@@ -1,28 +0,0 @@
-"""contrib units: the dishka provider lifecycle."""
-
-from __future__ import annotations
-
-from typing import Any
-
-import pytest
-
-pytest.importorskip("dishka", reason="requires the [dishka] extra")
-httpx = pytest.importorskip("httpx", reason="requires the [httpx] extra")
-
-from dishka import make_async_container  # noqa: E402
-
-import clientwright  # noqa: E402
-from clientwright.contrib.dishka import ClientwrightProvider  # noqa: E402
-from clientwright.core.plan import ClientHandle, ClientRuntime  # noqa: E402
-
-
-async def test__provider__builds_client_and_closes_it_with_container() -> None:
-    config = clientwright.ClientConfig(service_name="di-test")
-    container = make_async_container(ClientwrightProvider("httpx", config))
-    handle = await container.get(ClientHandle[Any])
-    assert type(handle.client) is httpx.AsyncClient
-    runtime = await container.get(ClientRuntime)
-    assert handle.runtime is runtime  # APP-scope runtime shared through DI
-    assert not handle.client.is_closed
-    await container.close()
-    assert handle.client.is_closed  # the generator provide's finally ran