clientwright 0.1.0__py3-none-any.whl

clientwright/core/testing/origin.py

@@ -0,0 +1,201 @@
+"""Fault-injecting HTTP origin on the standard library, for conformance tests.
+
+Routes:
+- ``/echo``                      200 with a small JSON body (method, path, headers echo)
+- ``/status/{code}``             responds with that status
+- ``/slow/{seconds}``            sleeps, then 200
+- ``/redirect/{n}``              302 chain of n hops ending at /echo
+- ``/redirect-loop``             302 to itself forever
+- ``/flaky/{key}/{fails}``       first {fails} requests per key answer 503, then 200
+- ``/retry-after/{seconds}``     503 with a Retry-After header
+- ``/disconnect``                closes the connection without a response
+
+Chaos routes (mid-stream and protocol-level faults):
+- ``/hang-body/{seconds}``           200 announcing 10 bytes: 3 arrive, the rest after the stall
+- ``/drop-body``                     200 announcing 10 bytes but the connection dies after 3
+- ``/garbage``                       raw non-HTTP bytes instead of a status line
+- ``/reset``                         hard TCP reset (SO_LINGER 0) instead of a response
+- ``/flaky-disconnect/{key}/{fails}``  first {fails} requests per key drop the connection, then 200
+"""
+
+from __future__ import annotations
+
+import json
+import socket
+import struct
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from types import TracebackType
+
+
+class _Handler(BaseHTTPRequestHandler):
+    protocol_version = "HTTP/1.1"
+    server: OriginServer  # type: ignore[assignment]
+
+    def log_message(self, format: str, *args: object) -> None:
+        return None
+
+    def _reply(self, status: int, body: bytes = b"", headers: dict[str, str] | None = None) -> None:
+        self.send_response(status)
+        for name, value in (headers or {}).items():
+            self.send_header(name, value)
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        if body and self.command != "HEAD":
+            self.wfile.write(body)
+
+    def _handle(self) -> None:
+        server = self.server
+        with server.lock:
+            server.requests.append((self.command, self.path))
+        # ALWAYS drain the request body: on keep-alive reuse, unread body bytes
+        # would be parsed as the start of the next request line.
+        length = int(self.headers.get("Content-Length") or 0)
+        request_body = self.rfile.read(length) if length else b""
+        parts = [part for part in self.path.split("?")[0].split("/") if part]
+        if not parts or parts[0] == "echo":
+            payload = {
+                "method": self.command,
+                "path": self.path,
+                "headers": {name.lower(): value for name, value in self.headers.items()},
+                "body": request_body.decode("utf-8", errors="replace"),
+            }
+            self._reply(200, json.dumps(payload).encode(), {"Content-Type": "application/json"})
+            return
+        if parts[0] == "status":
+            self._reply(int(parts[1]))
+            return
+        if parts[0] == "slow":
+            time.sleep(float(parts[1]))
+            self._reply(200, b"slow")
+            return
+        if parts[0] == "redirect":
+            hops = int(parts[1])
+            target = "/echo" if hops <= 1 else f"/redirect/{hops - 1}"
+            self._reply(302, headers={"Location": target})
+            return
+        if parts[0] == "redirect-loop":
+            self._reply(302, headers={"Location": "/redirect-loop"})
+            return
+        if parts[0] == "flaky":
+            key, fails = parts[1], int(parts[2])
+            with server.lock:
+                seen = server.flaky_counters.get(key, 0)
+                server.flaky_counters[key] = seen + 1
+            if seen < fails:
+                self._reply(503, b"flaky")
+            else:
+                self._reply(200, b"recovered")
+            return
+        if parts[0] == "retry-after":
+            self._reply(503, b"", {"Retry-After": parts[1]})
+            return
+        if parts[0] == "disconnect":
+            self.close_connection = True
+            self.connection.close()
+            return
+        if parts[0] == "hang-body":
+            body = b"0123456789"
+            self.send_response(200)
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body[:3])
+            self.wfile.flush()
+            time.sleep(float(parts[1]))
+            try:
+                self.wfile.write(body[3:])
+            except OSError:  # the client gave up mid-stall; routine for this route
+                self.close_connection = True
+            return
+        if parts[0] == "drop-body":
+            self.send_response(200)
+            self.send_header("Content-Length", "10")
+            self.end_headers()
+            self.wfile.write(b"abc")
+            self.wfile.flush()
+            self.close_connection = True
+            self.connection.close()
+            return
+        if parts[0] == "garbage":
+            self.close_connection = True
+            self.wfile.write(b"\x16\x03\x01 banana instead of a status line\r\n\r\n")
+            self.wfile.flush()
+            self.connection.close()
+            return
+        if parts[0] == "reset":
+            self.close_connection = True
+            # SO_LINGER with a zero timeout turns close() into a TCP RST.
+            self.connection.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack("ii", 1, 0))
+            self.connection.close()
+            return
+        if parts[0] == "flaky-disconnect":
+            key, fails = parts[1], int(parts[2])
+            with server.lock:
+                seen = server.flaky_counters.get(key, 0)
+                server.flaky_counters[key] = seen + 1
+            if seen < fails:
+                self.close_connection = True
+                self.connection.close()
+                return
+            self._reply(200, b"recovered")
+            return
+        self._reply(404)
+
+    def do_GET(self) -> None:
+        self._handle()
+
+    def do_POST(self) -> None:
+        self._handle()
+
+    def do_PUT(self) -> None:
+        self._handle()
+
+    def do_HEAD(self) -> None:
+        self._handle()
+
+    def do_DELETE(self) -> None:
+        self._handle()
+
+
+class OriginServer(ThreadingHTTPServer):
+    """Context-managed origin bound to an ephemeral localhost port."""
+
+    daemon_threads = True
+
+    def handle_error(self, request: object, client_address: object) -> None:
+        """Silence per-connection tracebacks: aborted clients are the point here."""
+        return None
+
+    def __init__(self) -> None:
+        super().__init__(("127.0.0.1", 0), _Handler)
+        self.lock = threading.Lock()
+        self.requests: list[tuple[str, str]] = []
+        self.flaky_counters: dict[str, int] = {}
+        self._thread = threading.Thread(target=self.serve_forever, daemon=True)
+
+    @property
+    def url(self) -> str:
+        raw_host, port = self.server_address[0], self.server_address[1]
+        host = raw_host.decode() if isinstance(raw_host, bytes) else raw_host
+        return f"http://{host}:{port}"
+
+    def request_count(self, path_prefix: str) -> int:
+        with self.lock:
+            return sum(1 for _, path in self.requests if path.startswith(path_prefix))
+
+    def __enter__(self) -> OriginServer:
+        self._thread.start()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        self.shutdown()
+        self.server_close()
+
+
+__all__ = ["OriginServer"]

clientwright-0.1.0.dist-info/METADATA

@@ -0,0 +1,210 @@
+Metadata-Version: 2.5
+Name: clientwright
+Version: 0.1.0
+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/
+Project-URL: Changelog, https://github.com/bedrock-python/clientwright/blob/master/CHANGELOG.md
+Project-URL: Bug Tracker, https://github.com/bedrock-python/clientwright/issues
+Author-email: Alex Shalaev <shalaevad.alexey@gmail.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: aiohttp,circuit-breaker,deadline,http,http-client,httpx,observability,opentelemetry,prometheus,requests,resilience,retry,timeout,urllib3
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Monitoring
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Provides-Extra: aiohttp
+Requires-Dist: aiohttp<4,>=3.12; extra == 'aiohttp'
+Provides-Extra: all
+Requires-Dist: aiohttp<4,>=3.12; extra == 'all'
+Requires-Dist: deadline-budget<1,>=0.1; extra == 'all'
+Requires-Dist: dishka>=1.4; extra == 'all'
+Requires-Dist: httpx2<3,>=2; extra == 'all'
+Requires-Dist: httpx<1,>=0.28; extra == 'all'
+Requires-Dist: opentelemetry-api>=1.26; extra == 'all'
+Requires-Dist: prometheus-client>=0.20; extra == 'all'
+Requires-Dist: requests<3,>=2.32; extra == 'all'
+Requires-Dist: urllib3<3,>=2.2; extra == 'all'
+Provides-Extra: deadline
+Requires-Dist: deadline-budget<1,>=0.1; extra == 'deadline'
+Provides-Extra: dishka
+Requires-Dist: dishka>=1.4; extra == 'dishka'
+Provides-Extra: httpx
+Requires-Dist: httpx<1,>=0.28; extra == 'httpx'
+Provides-Extra: httpx2
+Requires-Dist: httpx2<3,>=2; extra == 'httpx2'
+Provides-Extra: metrics
+Requires-Dist: prometheus-client>=0.20; extra == 'metrics'
+Provides-Extra: observability
+Requires-Dist: opentelemetry-api>=1.26; extra == 'observability'
+Requires-Dist: prometheus-client>=0.20; extra == 'observability'
+Provides-Extra: requests
+Requires-Dist: requests<3,>=2.32; extra == 'requests'
+Provides-Extra: tracing
+Requires-Dist: opentelemetry-api>=1.26; extra == 'tracing'
+Provides-Extra: urllib3
+Requires-Dist: urllib3<3,>=2.2; extra == 'urllib3'
+Description-Content-Type: text/markdown
+
+# clientwright
+
+[![PyPI](https://img.shields.io/pypi/v/clientwright?color=blue)](https://pypi.org/project/clientwright/)
+[![Python](https://img.shields.io/pypi/pyversions/clientwright)](https://pypi.org/project/clientwright/)
+[![License](https://img.shields.io/github/license/bedrock-python/clientwright)](LICENSE)
+[![CI](https://github.com/bedrock-python/clientwright/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/bedrock-python/clientwright/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/bedrock-python/clientwright/graph/badge.svg)](https://codecov.io/gh/bedrock-python/clientwright)
+[![Docs](https://img.shields.io/badge/docs-online-blue)](https://bedrock-python.github.io/clientwright/)
+
+One resilience and observability core, many HTTP clients.
+
+**Documentation: <https://bedrock-python.github.io/clientwright/>** — a guided
+tour from first client to writing your own adapter; this README is the elevator
+version.
+
+`clientwright` is to HTTP clients what [servicewright](https://github.com/bedrock-python/servicewright)
+is to services: a zero-dependency kernel of policies (retries, circuit breaking, deadlines,
+owned redirects, telemetry) plus adapters that wire it UNDER the public API of popular HTTP
+libraries. You get back the **real native client** - a genuine `httpx.AsyncClient`, not a
+wrapper - with the whole machinery already working inside it.
+
+```python
+import httpx
+from clientwright import ClientConfig, TimeoutConfig, build, inspect
+
+config = ClientConfig(
+    service_name="google-oauth",
+    base_url="https://oauth2.googleapis.com",
+    timeout=TimeoutConfig(total=10.0, connect=2.0),
+)
+client: httpx.AsyncClient = build("httpx", config)
+assert type(client) is httpx.AsyncClient  # not a subclass, not a wrapper
+
+response = await client.post("/token", data={...})  # retries, breaker, deadline,
+# metrics and spans already apply
+
+handle = inspect(client)  # what actually got applied
+print(handle.report.dropped)  # config the adapter could not express
+```
+
+## Why
+
+- **Instrumentation under the public API.** The seam sits in the transport
+  (httpx), not above the client - taking the raw native client never loses
+  logging, metrics, retries or the circuit breaker.
+- **One engine, not N reimplementations.** A single attempt loop owns retries,
+  redirects, deadlines and telemetry for every adapter; adapters only translate
+  messages and send.
+- **Capability-honest.** Adapters declare what they can and cannot express
+  (`AdapterCapabilities`); anything you configured that cannot be honored lands
+  in a `ConfigApplicationReport` - and fails the build under
+  `on_unsupported="strict"` instead of silently lying.
+- **Owned redirects.** The engine follows redirects itself, so one logical call
+  has ONE deadline, ONE retry budget and ONE breaker signal regardless of hops.
+- **Total deadline everywhere.** httpx has no wall-clock timeout; clientwright
+  enforces one across attempts, backoff sleeps and redirect hops (hard
+  cancellation on async, phase clamping on sync).
+- **Frozen telemetry schema.** `http_client_*` metric families with mandatory
+  `adapter`/`seam` labels - backend divergence is observable on a dashboard,
+  not buried in a README.
+- **Batteries optional.** `pip install clientwright` has zero dependencies;
+  adapters and observability backends are extras with lazy import guards.
+
+## Install
+
+```bash
+pip install clientwright[httpx]            # httpx adapter (sync + async)
+pip install clientwright[aiohttp]          # aiohttp adapter (async)
+pip install clientwright[httpx,metrics]    # + Prometheus backend
+pip install clientwright[httpx,tracing]    # + OpenTelemetry backend
+```
+
+## Sync twin
+
+```python
+from clientwright import build_sync
+
+client = build_sync("httpx", config)  # a genuine httpx.Client
+```
+
+The kernel's policies are pure synchronous functions; the same retry decision
+code drives both the async and the sync engine.
+
+## Retry and idempotency
+
+Per-call channel via httpx `extensions`:
+
+```python
+from clientwright.adapters.httpx import IDEMPOTENT_EXTENSION, ROUTE_EXTENSION
+
+await client.post(
+    "/orders",
+    json=payload,
+    extensions={
+        ROUTE_EXTENSION: "/orders",  # low-cardinality metric/breaker label
+        IDEMPOTENT_EXTENSION: True,  # this POST is safe to retry
+    },
+)
+```
+
+aiohttp has no request extensions; the same channel is a context manager:
+
+```python
+from clientwright.adapters.aiohttp import call_options
+
+with call_options(route="/orders", idempotent=True):
+    await session.post("/orders", json=payload)
+```
+
+Retries respect `Retry-After`, an origin-wide token-bucket budget (max ~10%
+retry traffic by default), body replayability and the remaining deadline.
+
+## DI scope
+
+`ClientRuntime` (circuits, retry budgets, per-origin limiters) must live in
+**APP scope** and be shared across REQUEST-scoped clients via
+`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`.
+
+## Deadline budgets
+
+With `clientwright[deadline]`, the remaining budget of the request being
+served caps every outgoing call:
+
+```python
+from deadline_budget import BudgetContext
+
+from clientwright import AdapterDeps, build
+from clientwright.contrib.deadline import AmbientDeadlineSource, use_budget
+
+deps = AdapterDeps(deadline_source=AmbientDeadlineSource())
+client = build("httpx", config, deps)
+
+with use_budget(BudgetContext.create(total_seconds=5.0)):
+    await client.get("/users")  # runs with what is left of those 5 seconds
+```
+
+## Adapters
+
+| adapter | modes | notes |
+|---|---|---|
+| `httpx` | sync + async | the reference adapter; cleanest seam |
+| `httpx2` | sync + async | Pydantic's httpx successor; identical public names |
+| `aiohttp` | async | requires aiohttp >= 3.12 (client middleware) |
+| `requests` | sync | closes requests' no-default-timeout hole |
+| `urllib3` | sync | home of `RetryMode.DELEGATED` |
+
+Third-party adapters plug in via `register_adapter("name", "module:Class", "module:CAPS")`.
+
+## License
+
+Apache-2.0

clientwright-0.1.0.dist-info/RECORD

@@ -0,0 +1,102 @@
+clientwright/__init__.py,sha256=VFrgOcqolBGIkwT-joFCKq1UqyayZ7DmuJxTbTApS8k,5305
+clientwright/__version__.py,sha256=IOEzhCbX916JIkvZr03GFY4bl9YqSkfjdqLO4qJ2FOs,50
+clientwright/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+clientwright/adapters/__init__.py,sha256=jwgB4L8hAtVzrS3GXjOM0ZWIKUrJJzctuaB1jkiH30I,106
+clientwright/adapters/_httpx_shared.py,sha256=RGeuEUwQXp_8dotk2zcm31DT4Bs-5PSJ2jH1WzUwB-E,31813
+clientwright/adapters/_lazy.py,sha256=Vu6aXppMkYQgu7AF7gEcZ6-ra3ReTvEwyP_LcMNFsVk,1156
+clientwright/adapters/aiohttp/__init__.py,sha256=7lRobBHE1Ppeg53ByfSCdIz4Kr_UgLpgha-mhQO6PKQ,1415
+clientwright/adapters/aiohttp/_imports.py,sha256=rjOt8kd6xnjenb5Zkd6dRsiVeYi9gaBee2lGXVpx7rQ,1099
+clientwright/adapters/aiohttp/adapter.py,sha256=2CVuTk4DnC6TzbInvBFx_edx-oJgsaPzyHzTlRIjrQY,10112
+clientwright/adapters/aiohttp/capabilities.py,sha256=dH6QEyXNvNefVZ-Nl8tw_uhD-wJKOabyENeij2wqmsY,3538
+clientwright/adapters/aiohttp/classify.py,sha256=QvEyus3iCwyvHqI5YGYFJipoUFWhYif5jMGQb8fHs7E,2243
+clientwright/adapters/aiohttp/errors.py,sha256=HAizlzmKfDqbSB-eNsylOArtYCZSMXGzc6ufw9niCQ0,2034
+clientwright/adapters/aiohttp/middleware.py,sha256=tVJCG2ZUdUFae9EbG9n4eQ9aQRXGD6Dgea5pEgmqkcQ,3832
+clientwright/adapters/aiohttp/normalize.py,sha256=YaKasiD9ruurYtLAwCVbXiO7BTmFt1wmWoWXX8P3q0A,2390
+clientwright/adapters/aiohttp/options.py,sha256=bXc0Qmplzo11rUknshAs-fXksFyF619CpfSd7bTACro,629
+clientwright/adapters/aiohttp/trace.py,sha256=xiIKNNXsuHAYazLZz4JOfQz3mARL28AYrIbIjRM8HgE,4530
+clientwright/adapters/aiohttp/views.py,sha256=diGcCDnvGYClw-zIDPjjQoCHhHb1QaM-bjrFsMYG2Xg,3921
+clientwright/adapters/httpx/__init__.py,sha256=b9azYsEXW-cv0lk4x1dBLA2AZ87uE77IyR6NOMkSHho,1417
+clientwright/adapters/httpx/_imports.py,sha256=WJl4eKJwsZ6fV4hS-aGxN61VJasM2hwkacCpmf-IVhc,564
+clientwright/adapters/httpx/adapter.py,sha256=cK6giIydVuBfnmAkaG2GYlsiKhex9XZ66JwgEzT9Mok,1327
+clientwright/adapters/httpx/capabilities.py,sha256=urnXy_rdmRiouRpqhkOTKX7DdQsy8dtOyWUgzwdoD6g,226
+clientwright/adapters/httpx/classify.py,sha256=SdQEMJa5mr3JlAtUCZBanuXZX90PrUJImYkcP_3upb4,361
+clientwright/adapters/httpx/errors.py,sha256=xRPd9jCJFuUDzTCLhHUqSStwSIwByie5M1lSt19wTYs,1110
+clientwright/adapters/httpx/normalize.py,sha256=A1kzYupyfwRs60hNmQhBKCuP4saPccv_gVnFwtXrHrw,856
+clientwright/adapters/httpx/normalize_sync.py,sha256=4OtdoPegVepOKAap9wdx0_nSuG728MKEnnnSzwsu0-A,847
+clientwright/adapters/httpx/transport.py,sha256=0R0cCCict_0LYJAZx86-Dv8bQaOib4GUgG5UxB2vLDg,1002
+clientwright/adapters/httpx/views.py,sha256=zRR5NzwRxj27Hs6-P1Mffh8majmLXoN2IB-ifABolH8,1304
+clientwright/adapters/httpx2/__init__.py,sha256=bR_rs0hIxcaitrGzV9QZCfTwHW_k-wILau3LN2tzl1g,1485
+clientwright/adapters/httpx2/_imports.py,sha256=ts2tMt9nRfvzMH-LFf1MKsAM7HIK_WqEjqsXYG5XV-k,646
+clientwright/adapters/httpx2/adapter.py,sha256=76QP1btDc7nz_5lq3vjla0bFTGFusd7lTSziuwjrUI8,1183
+clientwright/adapters/httpx2/capabilities.py,sha256=hM0eRx4EDHg3gE79bYrgB_VaTIDK9IMdtCkPRivGBOc,229
+clientwright/adapters/httpx2/classify.py,sha256=Hh5uQIh4n2mTggefhQ2CA38gHBje3C3Lx2-ycmge9Vo,364
+clientwright/adapters/httpx2/errors.py,sha256=1gHx9WLxcMHHmiO0yHnf1dkPh5qsJY2h7abPlZGTTMk,1169
+clientwright/adapters/httpx2/normalize.py,sha256=xd7LsBfG6H2qTmWY7zeSkuRtlRhtRt_AtOC4JugxDbA,860
+clientwright/adapters/httpx2/normalize_sync.py,sha256=NlQjrbYuyr1erhgGfcs7fpMH2aLFVOL8BqJz8OhHoxY,850
+clientwright/adapters/httpx2/transport.py,sha256=FmL42IMVHueArMi0K0K4x3R8xaphI-MvOijbJBanp-E,789
+clientwright/adapters/httpx2/views.py,sha256=ETB7qpu7-t5aIIdbyznaap-EHDPZUVzQSEfZU34YDVA,1217
+clientwright/adapters/observability/__init__.py,sha256=vCDrA3ZXNAYn1A8QbISF-OQB6VEtZxJXSLBLBSSRJng,787
+clientwright/adapters/observability/_metrics/__init__.py,sha256=4oy8sErcTaXi2KqQ6Qacg6iw6WFxJVonnF0DniZY8tw,24
+clientwright/adapters/observability/_metrics/prometheus.py,sha256=ja3zzxCItZZhzeU77LegAtZbmraS5Tpg5wmsoy-Ramg,7257
+clientwright/adapters/observability/_tracing/__init__.py,sha256=MoUaNFNBM2MLUNBHpt1DmkOlYpU4hAzua4hcy4XeaGY,80
+clientwright/adapters/observability/_tracing/otel.py,sha256=kOFTMj2YaXtsQYJDdbbKbJnS4QenBsurVWjxOB24Ph0,2324
+clientwright/adapters/requests/__init__.py,sha256=JTIoZdoMOIlwTRdsol85akQg-ojV2kfZqA4la3_2fWg,1465
+clientwright/adapters/requests/_imports.py,sha256=rKIMjnNmzeXvjt2I7bvnaxZE73CEPboQiCoUF9Xc5go,778
+clientwright/adapters/requests/adapter.py,sha256=Vj4H_CRq6ChxeCSAFD1Gu_SbKP7-1M6SgPPiskCz1gY,9170
+clientwright/adapters/requests/capabilities.py,sha256=WNUy-8GpyD_-JRIdiZSho6wiDGMnY3k6ibwdwfhdZ00,3308
+clientwright/adapters/requests/classify.py,sha256=6WUPd6uiTs8L3J20GGgvu7piBTMfhXlEXavnOIYHn8g,2435
+clientwright/adapters/requests/errors.py,sha256=HM92Av9U76YEcQc3BqZTwM2ZXOWk_juaMqasUQb6-4k,1389
+clientwright/adapters/requests/normalize.py,sha256=FxTHWcVrBxQSTmRKZ8vOc76zT_vJJYiyTeoEMIyxHK0,2364
+clientwright/adapters/requests/views.py,sha256=_gXgRnAzDyxjTLskNIECoZxT7t21V_5ooxOZo12FpxE,4215
+clientwright/adapters/urllib3/__init__.py,sha256=Hv68u5d0aeiI2yfahcZlgP8-XqjOHxo0fEW2d5UR-DI,1567
+clientwright/adapters/urllib3/_imports.py,sha256=62Xqbk-26uaywjWYsIS-xdp1PHFLfapGONM_C3A-AK0,577
+clientwright/adapters/urllib3/adapter.py,sha256=3O0_-rzYwZ6bxiYX1TbPVX7gMuAZzelOjIfFrilRPj8,11779
+clientwright/adapters/urllib3/capabilities.py,sha256=NzoluBLNTo7Fo48KKsMKdTpLIPNSx2_sonSi4sDC0kA,3739
+clientwright/adapters/urllib3/classify.py,sha256=1HDXaVYhpM9yUj_8vH7TSBf8UcnyiqIAMfeYO2f8rpw,1762
+clientwright/adapters/urllib3/errors.py,sha256=3XPFxNlz7xe0PxCvvBHdnqu0HHdHl0r1Wf-lM48H2dk,1938
+clientwright/adapters/urllib3/normalize.py,sha256=PBEaFH1l_Dxloex7TdI5H6lQ_4RUa8Pt8ygVWFwLeyc,1801
+clientwright/adapters/urllib3/views.py,sha256=L_tsZ1yqR618UTzxuJJ8yDm4j7xYbdv51wyWJJ0pdaA,3893
+clientwright/contrib/__init__.py,sha256=0rneB-yKmU7BXsNX0gJ-g6kwFOWV-XUhMREXvj-dT8k,96
+clientwright/contrib/deadline.py,sha256=LThVPkeNQUnSvUplR2HJtL98L30RrOibM2z-LfokLZ0,3685
+clientwright/contrib/dishka.py,sha256=rr7-R6mRRXTeg7Bj0r9IfHD25UkWHCa2weZcZCerY54,2972
+clientwright/core/__init__.py,sha256=8SCohi1xxW-c1onlMwawmasOBhG4zWYZywziq5qf7kU,256
+clientwright/core/capabilities.py,sha256=swJIngczmK33Iu1UMdUPezEm391769t-6Qwt905l9XM,5184
+clientwright/core/config.py,sha256=83EPH3aZo40-OpesrC7dNnhkkR1cwUl7TMschNcsE8c,12012
+clientwright/core/errors.py,sha256=PHihA1LzhTcnnTnD672GXjSsHxGLVP-kJQkQNY32tOM,3744
+clientwright/core/model.py,sha256=7O_A6JDIPKPOexAAQN5aJDM2-shAqfx4M3KGlalaaAI,3863
+clientwright/core/native.py,sha256=4ch1Min3QrX0MY1WgHJ_iO9U5tGqYc8w8WRRyfungV4,3317
+clientwright/core/options.py,sha256=mU8Z7MTY3LORRDRBEfWa4C07M4Cs6YyPrVTPiXPS43A,1459
+clientwright/core/plan.py,sha256=0sHnKmRaaoWCi0d70lJTEk2Ud-_8GerMVDZO9Xul2lw,6836
+clientwright/core/registry.py,sha256=e7OHpWRrc80gtAFczZxXsCER2204w671mUDjMECbPtQ,2762
+clientwright/core/balancer/__init__.py,sha256=8wNJ6T6IZ3r63SNeZlO1lIyzArj_3jr76uOloTX0WZM,77
+clientwright/core/balancer/policy.py,sha256=bKSBppc30ev-_5GG0qj3eEArYC5k4AXOjJgQLORe9VM,660
+clientwright/core/contracts/__init__.py,sha256=Igpus2dYZpm-SiPuI-Qjjoq9P6I3OZ87BFMsjnwTcq8,1259
+clientwright/core/contracts/adapter.py,sha256=LclR2W6lNvv3du3VlOMlbP4h9HLK1VRQXJOWQUoBihU,2031
+clientwright/core/contracts/context.py,sha256=VPTuc5jJ979DsT9mttsCRNLZI021tc4aWOxVx2PAX2Y,867
+clientwright/core/contracts/message.py,sha256=Qj6AjWnBURpTPpOTFU6Lp1IAiT6DY03JWptKnc9GOzg,3730
+clientwright/core/contracts/observability.py,sha256=kwmbCCvmKbswe5mOwStBGdDkD4_teaNBpvklHO2BTgw,2612
+clientwright/core/contracts/settings.py,sha256=i91kGHulYIKj-fnjHnGecUTKi3yMrv68el5YkAyLOh8,3761
+clientwright/core/engine/__init__.py,sha256=8R4vSMN4cKQfo7C-V2AFYAyDIyr3Oao50J2BUqj_jQo,78
+clientwright/core/engine/aio.py,sha256=-vG9zZoeRyXhomNsQgSd4HqMGS0XK75YmPMTo_aWh5A,10840
+clientwright/core/engine/base.py,sha256=NqQk53qI0txDt-h_1nXJDTnxHZzjUsNeKse9S-JhT0c,2120
+clientwright/core/engine/redirects.py,sha256=ypNCBZWL0pdY2B4Jf2OId13NnVZGE1D9Ok-SlyWZ2jM,2016
+clientwright/core/engine/suppress.py,sha256=dERDmmQiCzQSfQjHg7kJ4zJhWU9ZNHoOt57ujuzLD5s,740
+clientwright/core/engine/sync.py,sha256=LVK2PYOkxTz4iKTngmJtxEQ4-gP_iyICqAQGvV3XEMk,10353
+clientwright/core/policy/__init__.py,sha256=kevw6wSG1CvJ8qRl_yxhVx0U4sEtEKarXwPMggj_Ffc,78
+clientwright/core/policy/budget.py,sha256=SwJuSUCkA_jOwloKVLS2OAAaCkTpoUlyOBVho42jz1k,2658
+clientwright/core/policy/circuit.py,sha256=y4ghWX02xYWoOxcd3U8g85AyetWGQOkKLr18f2oRjDo,6572
+clientwright/core/policy/concurrency.py,sha256=0s3_WZ4aCLnPeZd54NfkM94OSBpX1kbX5K3P1h7n3fs,3211
+clientwright/core/policy/retry.py,sha256=B0Xg6wpCLSYUMvDRhSl9_BPWjiY4hWZ25MrgdC4aBcY,3057
+clientwright/core/policy/timeout.py,sha256=SklL4FDuhM5BSVgMoAfCBnB0E2_zdInzZsj6ts_YI34,2476
+clientwright/core/telemetry/__init__.py,sha256=qm_typj2W6PCc7br6Wx251cy8EgVx8TUZQ67qVwjIik,244
+clientwright/core/telemetry/emitter.py,sha256=0ajLUwytqiu7cLZNmt9v8DRcwExzSn7fTY625RRZGwo,6314
+clientwright/core/telemetry/names.py,sha256=PIvAXFdqRP30zjBq7vwij2YTw2YoR4enw0cOE1gix0g,2290
+clientwright/core/telemetry/null.py,sha256=hk3FVKqyACqlgOJJV-PFAQc-74ZGjGqmbbHmKc9F-Jw,2133
+clientwright/core/telemetry/redaction.py,sha256=nDlRmNVZYy7-gQHo9Uc6DwzN5qb32sk1iTjM5aEOY_4,832
+clientwright/core/testing/__init__.py,sha256=dCuqJ2APDxwCeuOjOO4z4rMuE-ao4EofxB_3h8g942g,288
+clientwright/core/testing/doubles.py,sha256=Xkp8NdMKscT0fAy8OBY-oagXfxir8omBex0oBIVwC9U,3379
+clientwright/core/testing/origin.py,sha256=dyPqQEnBPaxQSCNEkaEhINqJlqWwrUNLM0CF0F_QY6k,7568
+clientwright-0.1.0.dist-info/METADATA,sha256=cGQWD74feG9_0poIuGkM1UjZ5CSqM43xMuUL9A-XazE,8793
+clientwright-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+clientwright-0.1.0.dist-info/licenses/LICENSE,sha256=HqasrACfRh7mgdbiXMVrs_X8dOCZed1b8KXY7i6Ch14,10239
+clientwright-0.1.0.dist-info/RECORD,,

clientwright-0.1.0.dist-info/WHEEL

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