httpx-hedged 0.2.0__tar.gz → 0.3.0__tar.gz

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/.github/workflows/ci.yml

@@ -15,6 +15,8 @@ jobs:
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # full history, so hatch-vcs can see tags
 
       - name: Set up uv
         uses: astral-sh/setup-uv@v5
@@ -25,12 +27,17 @@ jobs:
       - name: Set up Python ${{ matrix.python-version }}
         run: uv python install ${{ matrix.python-version }}
 
-      # If you have a requirements.txt file, uv installs it directly into an ephemeral environment
+      - name: Install dependencies
+        run: uv sync --locked --group dev
+
       - name: Run Ruff Linter
-        run: uv run --with ruff ruff check .
+        run: uv run ruff check .
 
       - name: Run Ruff Formatter Check
-        run: uv run --with ruff ruff format --check .
+        run: uv run ruff format --check .
+
+      - name: Run Mypy
+        run: uv run mypy src
 
       - name: Run Tests with Pytest
-        run: uv run --with pytest pytest
+        run: uv run pytest -q

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/.github/workflows/release.yml

@@ -19,6 +19,8 @@ jobs:
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # full history, so hatch-vcs can resolve the tag's version
 
       - name: Set up uv
         uses: astral-sh/setup-uv@v5

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/.gitignore

@@ -1,6 +1,9 @@
 # Reference clone, not part of this project
 /hedge-python/
 
+# Generated at build time by hatch-vcs from the git tag
+/src/httpx_hedged/_version.py
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[codz]

httpx_hedged-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Brendan Fahy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/PKG-INFO

@@ -1,7 +1,8 @@
 Metadata-Version: 2.4
 Name: httpx-hedged
-Version: 0.2.0
+Version: 0.3.0
 Summary: Adaptive, per-endpoint request hedging transport for httpx. Learns latency percentiles per endpoint with DDSketch, caps hedge rate with a token bucket, and stops hedging under a host/endpoint circuit breaker.
+License-Expression: MIT
 License-File: LICENSE
 Requires-Python: >=3.13
 Requires-Dist: httpx>=0.27.0
@@ -32,6 +33,10 @@ async def main():
 asyncio.run(main())
 ```
 
+For a runnable, end-to-end demo (a small backend with different latency
+profiles per route, driven by a client that prints a hedge/latency/circuit
+breaker report), see [`examples/`](examples/README.md).
+
 With no configuration, `HedgedTransport` learns a p90 latency estimate per
 host (via a [DDSketch](https://arxiv.org/abs/2004.08604) quantile sketch)
 and fires a hedge request whenever the primary exceeds it. 
@@ -39,7 +44,7 @@ and fires a hedge request whenever the primary exceeds it.
 ## Why per-endpoint?
 
 A single host can host wildly different endpoints. Learning one latency
-distribution per *host* -- rather than per endpoint -- means a handful of
+distribution per *host*, rather than per endpoint, means a handful of
 calls to a slow endpoint skew the hedge trigger for a fast one sharing the
 same host:
 
@@ -50,7 +55,7 @@ GET /api/v1/bulk-export   median 900ms, low RPS
 
 `HedgedTransport` lets you register per-endpoint config up front. Each
 registered endpoint gets its own latency sketch, rate estimate, and hedge
-budget -- all still funneled through a **single inner transport and
+budget, all still funneled through a **single inner transport and
 connection pool**, unlike using `httpx` `mounts={}`, which would mean one
 connection pool per pattern:
 
@@ -68,7 +73,7 @@ endpoints at all).
 
 Route patterns may contain `{name}` placeholders or a bare `*` for a single
 path segment, e.g. `/api/v1/users/{id}`. Patterns are matched in
-registration order -- register more specific patterns first.
+registration order, so register more specific patterns first.
 
 ## Hardcoded vs. adaptive delay
 
@@ -79,8 +84,8 @@ percentile:
 transport.register("GET", "/api/v1/search", EndpointConfig(percentile=0.95))
 ```
 
-For an endpoint where you already know the right delay -- or want
-deterministic behavior without a warmup period -- hardcode it instead:
+For an endpoint where you already know the right delay, or want
+deterministic behavior without a warmup period, hardcode it instead:
 
 ```python
 transport.register("GET", "/api/v1/health", EndpointConfig(hedge_delay=0.05))
@@ -92,7 +97,7 @@ observability; it just isn't consulted for the hedge-delay decision.
 ## Explicit endpoint override
 
 Auto-matching not precise enough for a particular call site (or you'd
-rather not register a pattern)? Tag the request directly -- this bypasses
+rather not register a pattern)? Tag the request directly; this bypasses
 pattern matching entirely:
 
 ```python
@@ -159,7 +164,7 @@ request ──────┤
 
 Only idempotent methods (`GET`, `HEAD`, `OPTIONS`) are ever hedged, to avoid
 duplicating side effects. A request with a body is also never hedged, even
-if the method is idempotent -- the primary and hedge send the same
+if the method is idempotent: the primary and hedge send the same
 `httpx.Request` object, and a body backed by a one-shot stream can't be
 safely read twice.
 
@@ -184,13 +189,13 @@ endpoint.
 
 A closed / open / half-open circuit breaker tracks request success/failure
 at **two independent tiers**: one breaker per host, one breaker per
-endpoint key. Either tripping open suppresses hedging for its scope -- a
+endpoint key. Either tripping open suppresses hedging for its scope: a
 host-level trip disables hedging for every endpoint on that host, while an
 endpoint-level trip disables hedging only for that one endpoint.
 
 Crucially, the breaker **only ever suppresses the hedge request**. The
 primary request is always sent, and its result or exception is always
-returned to the caller normally -- this is not a request-blocking circuit
+returned to the caller normally. This is not a request-blocking circuit
 breaker, so hedging can't pile extra load onto a backend that's already
 struggling.
 
@@ -201,7 +206,7 @@ HALF_OPEN ──(trial requests mostly succeed)──▶ CLOSED
 HALF_OPEN ──(trial requests mostly fail)────▶ OPEN
 ```
 
-Note: health is recorded from the *winning* task's outcome only -- a
+Note: health is recorded from the *winning* task's outcome only. A
 cancelled loser's real outcome is unknowable, and losers are cancelled
 deliberately (not doing so would defeat the point of reducing load on a
 struggling backend).
@@ -225,6 +230,20 @@ print(transport.health.host_state("api.example.com"))
 `primary_wins`, `budget_exhausted`, `warmup_requests`, `circuit_blocked`,
 and `errors` per key, plus a global aggregate.
 
+To see the learned latency estimate itself (e.g. the current p90 driving
+the hedge trigger), query `latency_quantile()` with the same key format:
+
+```python
+name = transport.register("GET", "/api/v1/search", EndpointConfig(percentile=0.90))
+# ... after running some traffic ...
+p90 = transport.latency_quantile(f"endpoint:{name}", 0.9)
+if p90 is not None:
+    print(f"p90: {p90 * 1000:.1f}ms")
+```
+
+Returns `None` if the key hasn't recorded any samples yet. You can query
+any quantile, not just the one driving the hedge decision.
+
 ### Push-based hooks: metrics and alerting
 
 Polling snapshots works for dashboards, but alerting on a circuit-breaker
@@ -267,14 +286,14 @@ async with httpx.AsyncClient(transport=transport) as client:
 ```
 
 `on_hedge_fired` is called with the key each time a hedge request is
-actually launched -- after the idempotency, circuit-breaker, and budget
+actually launched, after the idempotency, circuit-breaker, and budget
 gates have all passed, so it only fires for hedges that were genuinely
 sent. `on_circuit_open` is called once per OPEN transition (not on every
 suppressed hedge while it stays open), so it's safe to wire straight into
 an alerting/paging pipeline without flooding it.
 
 Both callbacks run synchronously on the request path, so keep them fast
-(increment a counter, log a line) -- don't do network I/O in them directly.
+(increment a counter, log a line); don't do network I/O in them directly.
 
 ## Relationship to hedge-python
 
@@ -290,11 +309,11 @@ for the motivating scenario.
 
 ## References
 
-- [The Tail at Scale](https://research.google/pubs/pub40801/) -- Google's paper on tail latency
-- [DDSketch: A fast and fully-mergeable quantile sketch with relative-error guarantees](https://arxiv.org/abs/2004.08604) -- Masson et al., VLDB 2019
-- [hedge-python](https://github.com/sunhailin-Leo/hedge-python) -- the project this one is modeled after
+- [The Tail at Scale](https://research.google/pubs/pub40801/): Google's paper on tail latency
+- [DDSketch: A fast and fully-mergeable quantile sketch with relative-error guarantees](https://arxiv.org/abs/2004.08604): Masson et al., VLDB 2019
+- [hedge-python](https://github.com/sunhailin-Leo/hedge-python): the project this one is modeled after
 - [httpx documentation](https://www.python-httpx.org/)
 
 ## License
 
-BSD 3-Clause License. See [LICENSE](LICENSE) file for details.
+MIT License. See [LICENSE](LICENSE) file for details.

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/README.md

@@ -23,6 +23,10 @@ async def main():
 asyncio.run(main())
 ```
 
+For a runnable, end-to-end demo (a small backend with different latency
+profiles per route, driven by a client that prints a hedge/latency/circuit
+breaker report), see [`examples/`](examples/README.md).
+
 With no configuration, `HedgedTransport` learns a p90 latency estimate per
 host (via a [DDSketch](https://arxiv.org/abs/2004.08604) quantile sketch)
 and fires a hedge request whenever the primary exceeds it. 
@@ -30,7 +34,7 @@ and fires a hedge request whenever the primary exceeds it.
 ## Why per-endpoint?
 
 A single host can host wildly different endpoints. Learning one latency
-distribution per *host* -- rather than per endpoint -- means a handful of
+distribution per *host*, rather than per endpoint, means a handful of
 calls to a slow endpoint skew the hedge trigger for a fast one sharing the
 same host:
 
@@ -41,7 +45,7 @@ GET /api/v1/bulk-export   median 900ms, low RPS
 
 `HedgedTransport` lets you register per-endpoint config up front. Each
 registered endpoint gets its own latency sketch, rate estimate, and hedge
-budget -- all still funneled through a **single inner transport and
+budget, all still funneled through a **single inner transport and
 connection pool**, unlike using `httpx` `mounts={}`, which would mean one
 connection pool per pattern:
 
@@ -59,7 +63,7 @@ endpoints at all).
 
 Route patterns may contain `{name}` placeholders or a bare `*` for a single
 path segment, e.g. `/api/v1/users/{id}`. Patterns are matched in
-registration order -- register more specific patterns first.
+registration order, so register more specific patterns first.
 
 ## Hardcoded vs. adaptive delay
 
@@ -70,8 +74,8 @@ percentile:
 transport.register("GET", "/api/v1/search", EndpointConfig(percentile=0.95))
 ```
 
-For an endpoint where you already know the right delay -- or want
-deterministic behavior without a warmup period -- hardcode it instead:
+For an endpoint where you already know the right delay, or want
+deterministic behavior without a warmup period, hardcode it instead:
 
 ```python
 transport.register("GET", "/api/v1/health", EndpointConfig(hedge_delay=0.05))
@@ -83,7 +87,7 @@ observability; it just isn't consulted for the hedge-delay decision.
 ## Explicit endpoint override
 
 Auto-matching not precise enough for a particular call site (or you'd
-rather not register a pattern)? Tag the request directly -- this bypasses
+rather not register a pattern)? Tag the request directly; this bypasses
 pattern matching entirely:
 
 ```python
@@ -150,7 +154,7 @@ request ──────┤
 
 Only idempotent methods (`GET`, `HEAD`, `OPTIONS`) are ever hedged, to avoid
 duplicating side effects. A request with a body is also never hedged, even
-if the method is idempotent -- the primary and hedge send the same
+if the method is idempotent: the primary and hedge send the same
 `httpx.Request` object, and a body backed by a one-shot stream can't be
 safely read twice.
 
@@ -175,13 +179,13 @@ endpoint.
 
 A closed / open / half-open circuit breaker tracks request success/failure
 at **two independent tiers**: one breaker per host, one breaker per
-endpoint key. Either tripping open suppresses hedging for its scope -- a
+endpoint key. Either tripping open suppresses hedging for its scope: a
 host-level trip disables hedging for every endpoint on that host, while an
 endpoint-level trip disables hedging only for that one endpoint.
 
 Crucially, the breaker **only ever suppresses the hedge request**. The
 primary request is always sent, and its result or exception is always
-returned to the caller normally -- this is not a request-blocking circuit
+returned to the caller normally. This is not a request-blocking circuit
 breaker, so hedging can't pile extra load onto a backend that's already
 struggling.
 
@@ -192,7 +196,7 @@ HALF_OPEN ──(trial requests mostly succeed)──▶ CLOSED
 HALF_OPEN ──(trial requests mostly fail)────▶ OPEN
 ```
 
-Note: health is recorded from the *winning* task's outcome only -- a
+Note: health is recorded from the *winning* task's outcome only. A
 cancelled loser's real outcome is unknowable, and losers are cancelled
 deliberately (not doing so would defeat the point of reducing load on a
 struggling backend).
@@ -216,6 +220,20 @@ print(transport.health.host_state("api.example.com"))
 `primary_wins`, `budget_exhausted`, `warmup_requests`, `circuit_blocked`,
 and `errors` per key, plus a global aggregate.
 
+To see the learned latency estimate itself (e.g. the current p90 driving
+the hedge trigger), query `latency_quantile()` with the same key format:
+
+```python
+name = transport.register("GET", "/api/v1/search", EndpointConfig(percentile=0.90))
+# ... after running some traffic ...
+p90 = transport.latency_quantile(f"endpoint:{name}", 0.9)
+if p90 is not None:
+    print(f"p90: {p90 * 1000:.1f}ms")
+```
+
+Returns `None` if the key hasn't recorded any samples yet. You can query
+any quantile, not just the one driving the hedge decision.
+
 ### Push-based hooks: metrics and alerting
 
 Polling snapshots works for dashboards, but alerting on a circuit-breaker
@@ -258,14 +276,14 @@ async with httpx.AsyncClient(transport=transport) as client:
 ```
 
 `on_hedge_fired` is called with the key each time a hedge request is
-actually launched -- after the idempotency, circuit-breaker, and budget
+actually launched, after the idempotency, circuit-breaker, and budget
 gates have all passed, so it only fires for hedges that were genuinely
 sent. `on_circuit_open` is called once per OPEN transition (not on every
 suppressed hedge while it stays open), so it's safe to wire straight into
 an alerting/paging pipeline without flooding it.
 
 Both callbacks run synchronously on the request path, so keep them fast
-(increment a counter, log a line) -- don't do network I/O in them directly.
+(increment a counter, log a line); don't do network I/O in them directly.
 
 ## Relationship to hedge-python
 
@@ -281,11 +299,11 @@ for the motivating scenario.
 
 ## References
 
-- [The Tail at Scale](https://research.google/pubs/pub40801/) -- Google's paper on tail latency
-- [DDSketch: A fast and fully-mergeable quantile sketch with relative-error guarantees](https://arxiv.org/abs/2004.08604) -- Masson et al., VLDB 2019
-- [hedge-python](https://github.com/sunhailin-Leo/hedge-python) -- the project this one is modeled after
+- [The Tail at Scale](https://research.google/pubs/pub40801/): Google's paper on tail latency
+- [DDSketch: A fast and fully-mergeable quantile sketch with relative-error guarantees](https://arxiv.org/abs/2004.08604): Masson et al., VLDB 2019
+- [hedge-python](https://github.com/sunhailin-Leo/hedge-python): the project this one is modeled after
 - [httpx documentation](https://www.python-httpx.org/)
 
 ## License
 
-BSD 3-Clause License. See [LICENSE](LICENSE) file for details.
+MIT License. See [LICENSE](LICENSE) file for details.

httpx_hedged-0.3.0/examples/README.md

@@ -0,0 +1,41 @@
+# Examples
+
+A runnable demo of `HedgedTransport` against a small local backend with
+three different latency profiles.
+
+| File | What it is |
+|---|---|
+| `app.py` | A tiny FastAPI backend exposing `/fast`, `/slow`, and `/flaky` routes, each with a different latency profile. |
+| `example_usage.py` | A client that registers per-endpoint hedge config, drives load through `HedgedTransport` against `app.py`, and prints a stats/latency/circuit-breaker report. |
+| `run_example.sh` | Installs deps, starts `app.py`, runs `example_usage.py` against it, and tears the server down. The easiest way to see the whole thing end to end. |
+
+## Running it
+
+From the repo root:
+
+```bash
+./examples/run_example.sh
+```
+
+Or run the pieces yourself:
+
+```bash
+uv sync --group examples
+uv run uvicorn examples.app:app --host 127.0.0.1 --port 8000 &
+uv run python examples/example_usage.py
+```
+
+## What to look for in the output
+
+- `/fast` rarely triggers a hedge, since the primary is almost always
+  faster than the learned delay.
+- `/slow` hedges often, but the hedge rarely *wins*, because the backup is
+  just as slow as the primary on this uniformly slow endpoint.
+- `/flaky` is the interesting case: after warmup, the learned p90 sits near
+  the fast latency, so the rare slow primary gets hedged against a fresh
+  (usually fast) request and the hedge usually wins the race.
+
+The final report prints per-endpoint stats (`total`, `hedged`,
+`hedge_wins`, `primary_wins`, ...), each endpoint's learned p90 latency
+estimate (via `transport.latency_quantile()`), and each endpoint's circuit
+breaker state.

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/examples/app.py

@@ -1,8 +1,8 @@
 """Tiny FastAPI backend with three latency profiles, for the hedging demo.
 
-    GET /fast   -- always responds in ~5-15ms
-    GET /slow   -- always takes 800ms
-    GET /flaky  -- 90% of requests are fast (~5-15ms), 10% take ~900ms
+    GET /fast   always responds in ~5-15ms
+    GET /slow   always takes 800ms
+    GET /flaky  90% of requests are fast (~5-15ms), 10% take ~900ms
 
 Run directly with uvicorn, e.g.:
 

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/examples/example_usage.py

@@ -39,7 +39,7 @@ CONCURRENCY = 6
 
 # The hedge token bucket auto-estimates RPS over a rolling ~10s window by
 # default, which under-counts traffic sent in a shorter burst like this
-# demo's -- so budget starves and hedges rarely fire. Pinning estimated_rps
+# demo's, so budget starves and hedges rarely fire. Pinning estimated_rps
 # (roughly concurrency / expected latency) avoids that ramp-up and keeps
 # the demo's hedge behavior visible run over run. /fast is left on the
 # default auto-estimate since it barely ever needs to hedge anyway.
@@ -91,6 +91,12 @@ def print_report(transport: HedgedTransport) -> None:
     print(f"\ntotal requests sent: {global_snap.total_requests}")
     print(f"total hedges fired:  {global_snap.hedged_requests}")
 
+    print("\n=== learned p90 latency estimates ===")
+    for route in ROUTES:
+        key = f"endpoint:{route}"
+        p90 = transport.latency_quantile(key, 0.9)
+        print(f"{key:<16} {f'{p90 * 1000:.1f}ms' if p90 is not None else 'n/a'}")
+
     print("\n=== circuit breaker state ===")
     for route in ROUTES:
         key = f"endpoint:{route}"
@@ -104,7 +110,7 @@ async def wait_for_server(client: httpx.AsyncClient) -> None:
         response.raise_for_status()
     except httpx.HTTPError:
         print(
-            f"Could not reach {BASE_URL} -- is examples/app.py running?",
+            f"Could not reach {BASE_URL}: is examples/app.py running?",
             file=sys.stderr,
         )
         sys.exit(1)

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/examples/run_example.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # Installs deps, starts the demo FastAPI backend, runs the hedging demo
-# client against it, and prints the stats report -- then tears the server
+# client against it, and prints the stats report, then tears the server
 # down. Run from anywhere:
 #
 #   ./examples/run_example.sh

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/pyproject.toml

@@ -1,8 +1,10 @@
 [project]
 name = "httpx-hedged"
-version = "0.2.0"
+dynamic = ["version"]
 description = "Adaptive, per-endpoint request hedging transport for httpx. Learns latency percentiles per endpoint with DDSketch, caps hedge rate with a token bucket, and stops hedging under a host/endpoint circuit breaker."
 readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
 requires-python = ">=3.13"
 dependencies = [
     "httpx>=0.27.0",
@@ -15,6 +17,7 @@ dev = [
     "pytest>=9.0.1",
     "pytest-asyncio>=1.3.0",
     "python-lsp-server[all]>=1.13.2",
+    "ruff>=0.14.0",
 ]
 examples = [
     "fastapi>=0.115",
@@ -22,12 +25,18 @@ examples = [
 ]
 
 [build-system]
-requires = ["hatchling"]
+requires = ["hatchling", "hatch-vcs"]
 build-backend = "hatchling.build"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/httpx_hedged"]
 
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/httpx_hedged/_version.py"
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 asyncio_mode = "auto"

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/src/httpx_hedged/__init__.py

@@ -18,6 +18,7 @@ from httpx_hedged._config import CircuitBreakerConfig, EndpointConfig, HedgeConf
 from httpx_hedged._health import CircuitBreaker, CircuitState, HealthRegistry
 from httpx_hedged._matcher import Route, UnknownHedgeEndpointError
 from httpx_hedged._stats import Stats, StatsRegistry, StatsSnapshot
+from httpx_hedged._version import __version__
 from httpx_hedged.transport import HedgedTransport
 
 __all__ = [
@@ -33,6 +34,5 @@ __all__ = [
     "StatsRegistry",
     "StatsSnapshot",
     "UnknownHedgeEndpointError",
+    "__version__",
 ]
-
-__version__ = "0.2.0"

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/src/httpx_hedged/_bounded.py

@@ -2,8 +2,8 @@
 
 Per-key state (sketches, breakers, stats) is created lazily, keyed by
 endpoint name or a per-host fallback. Nothing ever evicted those keys, so a
-caller that talks to high-cardinality hosts (per-tenant subdomains, or -- in
-the pathological case -- one key per unique URL when a request has no
+caller that talks to high-cardinality hosts (per-tenant subdomains, or, in
+the pathological case, one key per unique URL when a request has no
 parseable host) would grow these maps forever. Bounding them with LRU
 eviction keeps memory bounded without requiring callers to know about it.
 """
@@ -17,7 +17,7 @@ DEFAULT_MAX_SIZE = 10_000
 
 
 class BoundedRegistry[V]:
-    """Not thread-safe by itself -- callers hold their own lock, as with the
+    """Not thread-safe by itself. Callers hold their own lock, as with the
     plain dicts this replaces."""
 
     def __init__(self, max_size: int = DEFAULT_MAX_SIZE) -> None:

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/src/httpx_hedged/_config.py

@@ -39,7 +39,7 @@ def _validate_common(config: HedgeConfig | EndpointConfig) -> None:
 class CircuitBreakerConfig:
     """Configuration for the health circuit breaker that gates hedging.
 
-    Tripping the breaker only ever suppresses the *hedge* request -- the
+    Tripping the breaker only ever suppresses the *hedge* request. The
     primary request is always sent and its result or exception is always
     returned to the caller normally.
     """
@@ -163,7 +163,7 @@ class EndpointConfig:
 
     #: Health circuit-breaker configuration. When set, replaces the
     #: default breaker config as a whole object rather than being merged
-    #: field-by-field -- for a partial override, use
+    #: field-by-field. For a partial override, use
     #: ``dataclasses.replace(default.circuit_breaker, ...)``.
     circuit_breaker: CircuitBreakerConfig | None = None
 
@@ -175,7 +175,16 @@ class EndpointConfig:
 
 @dataclass(frozen=True, slots=True)
 class EffectiveConfig:
-    """Fully-resolved hedge configuration for a single key (no more None fields)."""
+    """Fully-resolved hedge configuration for a single key.
+
+    Every "inherit the default" field from ``EndpointConfig`` has been
+    resolved away by ``resolve()``. ``estimated_rps`` and ``hedge_delay``
+    stay ``Optional`` here regardless, since their ``None`` means something
+    different than "unresolved": ``estimated_rps=None`` means "auto-estimate
+    from traffic" and ``hedge_delay=None`` means "no hardcoded delay, learn
+    one from the sketch" (see ``is_hardcoded``). Both are real, permanent
+    states, not resolution artifacts.
+    """
 
     percentile: float
     budget_percent: float

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/src/httpx_hedged/_health.py

@@ -1,6 +1,6 @@
 """Health-based circuit breaker that suppresses hedging during outages.
 
-hedge-python has no concept of request success/failure at all -- its token
+hedge-python has no concept of request success/failure at all: its token
 bucket caps hedge *volume* but has no idea whether the backend is actually
 healthy. This module adds a circuit breaker, tracked independently at both
 the host level and the per-endpoint level, so that either "one endpoint is
@@ -9,14 +9,14 @@ requiring the two to be conflated.
 
 Tripping the breaker only ever suppresses the *hedge* request. The primary
 request always goes through and its result or exception is always returned
-to the caller -- this is deliberately not a request-blocking circuit
+to the caller. This is deliberately not a request-blocking circuit
 breaker, only a hedge-suppressing one, so hedging can't pile extra load
 onto an already-failing backend.
 
 Known limitation: health is recorded from the winning task's outcome only.
 A cancelled loser's real outcome is unknowable, and losers are cancelled
-deliberately -- not doing so would defeat the breaker's purpose of reducing
-load on a struggling backend.
+deliberately, since not doing so would defeat the breaker's purpose of
+reducing load on a struggling backend.
 """
 
 from __future__ import annotations
@@ -99,7 +99,7 @@ class CircuitBreaker:
         config: Breaker thresholds and timing.
         on_open: Called (with no arguments) each time the breaker
             transitions into the OPEN state, whether from CLOSED or from a
-            failed HALF_OPEN trial. Useful for alerting -- see the README's
+            failed HALF_OPEN trial. Useful for alerting; see the README's
             observability section for a logging example.
     """
 
@@ -136,7 +136,7 @@ class CircuitBreaker:
             return
 
         # CLOSED (or OPEN, where a result can still arrive from a primary
-        # request even though hedging is suppressed -- keep tracking it).
+        # request even though hedging is suppressed; keep tracking it).
         self._window.record(ok)
         if (
             self._state is CircuitState.CLOSED
@@ -195,7 +195,7 @@ class HealthRegistry:
             endpoint-scoped) transitions into the OPEN state, as
             ``on_circuit_open(scope, key)`` where ``scope`` is ``"host"``
             or ``"endpoint"`` and ``key`` is the host name or endpoint key
-            that tripped. Intended for alerting -- see the README's
+            that tripped. Intended for alerting; see the README's
             observability section for a logging example.
     """
 
@@ -251,7 +251,7 @@ class HealthRegistry:
         ok: bool,
     ) -> None:
         # CircuitBreaker is documented as not being thread-safe on its own
-        # ("callers hold their own lock") -- the lookup AND the mutation
+        # ("callers hold their own lock"). The lookup AND the mutation
         # below must happen under one lock acquisition, not just the
         # lookup, or concurrent callers can race on the same breaker's
         # internal counters/state transitions.

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/src/httpx_hedged/_matcher.py

@@ -4,7 +4,7 @@ hedge-python keys its latency sketch per *host* only. A service with many
 routes of very different latency/RPS profiles (e.g. ``GET /api/v1/foo`` vs.
 ``GET /api/v1/bar``) would have all of their latencies mixed into one
 sketch. This module lets callers register per-route ``EndpointConfig``
-objects up front, matched against every request's method and path -- all
+objects up front, matched against every request's method and path, all
 still funneled through a single ``httpx.AsyncBaseTransport`` / connection
 pool, so supporting many endpoints does not multiply connection pools the
 way ``httpx`` ``mounts={}`` would.

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/src/httpx_hedged/_rate.py

@@ -3,7 +3,7 @@
 hedge-python requires callers to hand-tune a single ``estimated_rps`` value
 per host. That is workable for one host, but this library tracks state per
 *endpoint*, and a service with many endpoints of very different traffic
-volumes would require hand-tuning a guess for each one -- exactly the kind
+volumes would require hand-tuning a guess for each one, exactly the kind
 of per-endpoint configuration burden this rewrite is trying to avoid. By
 default we estimate the rate automatically instead.
 """
@@ -61,7 +61,7 @@ class RollingRateCounter:
         Weights the previous window's count by the fraction of it that
         still falls within the trailing ``window_duration``-sized lookback
         from now, rather than always dividing by a fixed ``2 *
-        window_duration`` -- that fixed divisor systematically
+        window_duration``. That fixed divisor systematically
         underestimates by up to 2x right after a rotation, when the
         current window has accumulated almost nothing yet but the full
         previous window's count is still discounted as if it were only

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/src/httpx_hedged/_rotation.py

@@ -5,8 +5,8 @@ Every windowed structure in this package (``WindowedSketch``,
 current/previous pair of accumulators and decides whether to rotate or reset
 them lazily, on the next call that touches the structure, rather than via a
 background thread or asyncio task. This avoids spinning one rotation task per
-tracked key -- important once state is tracked per-endpoint rather than just
-per-host, since a service can have dozens of endpoints.
+tracked key, which matters once state is tracked per-endpoint rather than
+just per-host, since a service can have dozens of endpoints.
 """
 
 from __future__ import annotations

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/src/httpx_hedged/_scheduler.py

@@ -5,7 +5,7 @@ two changes: state is keyed per *endpoint* rather than only per *host* (see
 ``_matcher.py``), and the win/lose bookkeeping always records the outcome
 (latency + health) even when the winning task raised an exception. In
 hedge-python, ``winner_task.result()`` is called before recording, so an
-exception there silently skips recording entirely -- this rewrite records
+exception there silently skips recording entirely. This rewrite records
 first, then re-raises.
 """
 
@@ -86,15 +86,15 @@ class HedgeScheduler:
         stats_registry: Shared per-key statistics registry.
         host_circuit_breaker: Circuit-breaker configuration used for the
             *host* tier, independent of whichever endpoint's config happens
-            to be resolved for a given request -- a host isn't owned by any
+            to be resolved for a given request. A host isn't owned by any
             one endpoint, so its breaker thresholds must not depend on
             request arrival order (see ``_should_hedge``/``_finish``, which
             always pass this rather than the per-request resolved config
             for the host side of ``HealthRegistry`` calls).
         on_hedge_fired: Called with the key each time a hedge request is
-            actually launched (after all gates -- idempotency, circuit
-            breaker, budget -- have passed). Intended for metrics -- see
-            the README's observability section for an example.
+            actually launched, after the idempotency, circuit-breaker, and
+            budget gates have all passed. Intended for metrics; see the
+            README's observability section for an example.
     """
 
     def __init__(
@@ -116,11 +116,20 @@ class HedgeScheduler:
             key, lambda: _EndpointState(config, self._stats_registry.for_key(key))
         )
 
+    def latency_quantile(self, key: str, q: float) -> float | None:
+        """Return the current estimated latency (seconds) at quantile ``q``
+        for a tracked key, or None if the key isn't tracked yet or has no
+        recorded samples."""
+        state = self._states.get(key)
+        if state is None:
+            return None
+        estimate = state.sketch.quantile(q)
+        return None if math.isnan(estimate) else estimate
+
     def compute_hedge_delay(self, state: _EndpointState) -> float:
         """Compute the hedge delay in seconds for the current request on this key."""
         config = state.config
-        if config.is_hardcoded:
-            assert config.hedge_delay is not None
+        if config.hedge_delay is not None:
             return max(config.hedge_delay, config.min_delay)
 
         if state.counter <= config.warmup_requests:
@@ -219,7 +228,7 @@ class HedgeScheduler:
             return await self._finish(state, host, key, winner_task, start, classify)
         finally:
             # Reached on the happy path too, where every task is already
-            # done and this is a no-op -- but if this coroutine itself is
+            # done and this is a no-op. But if this coroutine itself is
             # cancelled (e.g. the caller wrapped the request in a timeout)
             # while blocked on one of the awaits above, asyncio.wait does
             # not cancel the tasks it was waiting on, so they'd otherwise
@@ -274,7 +283,7 @@ class HedgeScheduler:
         """Record latency and health outcome, then return the result or re-raise.
 
         Recording always happens before the result is returned or the
-        exception is re-raised -- unlike hedge-python, where an exception
+        exception is re-raised. In hedge-python, by contrast, an exception
         from ``winner_task.result()`` silently skips recording.
         """
         elapsed = time.monotonic() - start

httpx_hedged-0.3.0/src/httpx_hedged/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.3.0'
+__version_tuple__ = version_tuple = (0, 3, 0)
+
+__commit_id__ = commit_id = None

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/src/httpx_hedged/sketch/_windowed.py

@@ -18,7 +18,7 @@ class WindowedSketch:
     Quantile queries merge both sketches, giving a window that spans 1x to
     2x the configured duration. ``add`` always writes to the current
     sketch. Rotation is decided lazily on each call rather than by a
-    background thread/task -- see ``httpx_hedged._rotation`` -- since a
+    background thread/task (see ``httpx_hedged._rotation``), since a
     service can have many independently-tracked endpoints, and spinning one
     rotation task per endpoint does not scale.
 

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/src/httpx_hedged/transport.py

@@ -48,7 +48,7 @@ class HedgedTransport(httpx.AsyncBaseTransport):
 
     Wraps a single inner transport (default: ``httpx.AsyncHTTPTransport``,
     one connection pool) and races a backup request when the primary
-    exceeds its estimated latency percentile -- or a hardcoded delay, for
+    exceeds its estimated latency percentile, or a hardcoded delay, for
     endpoints registered with ``EndpointConfig(hedge_delay=...)``.
 
     Endpoints are identified by registering method + path patterns via
@@ -69,12 +69,12 @@ class HedgedTransport(httpx.AsyncBaseTransport):
         routes: Endpoints to register up front (equivalent to calling
             ``register()`` for each one after construction).
         on_hedge_fired: Called with the key each time a hedge request is
-            actually launched. Intended for metrics -- see the README's
+            actually launched. Intended for metrics; see the README's
             observability section for an example.
         on_circuit_open: Called as ``on_circuit_open(scope, key)`` each
             time a host- or endpoint-scoped circuit breaker trips open
             (``scope`` is ``"host"`` or ``"endpoint"``). Intended for
-            alerting -- see the README's observability section for an
+            alerting; see the README's observability section for an
             example.
     """
 
@@ -116,7 +116,7 @@ class HedgedTransport(httpx.AsyncBaseTransport):
         ``path_pattern`` segments may contain ``{name}`` placeholders or a
         bare ``*`` to match any single path segment (e.g.
         ``/api/v1/users/{id}``). Routes are matched in registration order,
-        first match wins -- register more specific patterns first.
+        first match wins, so register more specific patterns first.
 
         Returns the resolved endpoint name (used as the key in ``stats``
         and as the value for ``extensions={"hedge_endpoint": name}``).
@@ -133,6 +133,23 @@ class HedgedTransport(httpx.AsyncBaseTransport):
         """Host- and endpoint-level circuit breaker state."""
         return self._health
 
+    def latency_quantile(self, key: str, q: float) -> float | None:
+        """Return the current estimated latency (seconds) at quantile ``q``
+        for a tracked key, or None if nothing has been recorded for that
+        key yet.
+
+        ``key`` uses the same ``"endpoint:<name>"`` / ``"host:<hostname>"``
+        format as ``stats`` and ``health``. For example, after
+        ``name = transport.register("GET", "/search", ...)``, query it with
+        ``transport.latency_quantile(f"endpoint:{name}", 0.9)`` for the
+        current learned p90::
+
+            p90 = transport.latency_quantile(f"endpoint:{name}", 0.9)
+            if p90 is not None:
+                print(f"{name} p90: {p90 * 1000:.1f}ms")
+        """
+        return self._scheduler.latency_quantile(key, q)
+
     async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
         """Handle an outgoing request with adaptive, per-endpoint hedging."""
         host = extract_host(str(request.url))

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/tests/integration/test_httpx_transport.py

@@ -38,7 +38,7 @@ async def test_two_endpoints_share_one_transport_with_independent_delays() -> No
     transport.register("GET", "/api/v1/fast-lookup", EndpointConfig(percentile=0.9))
     transport.register("GET", "/api/v1/bulk-export", EndpointConfig(percentile=0.9))
 
-    # Prime each endpoint's own sketch directly -- this is what accumulates
+    # Prime each endpoint's own sketch directly; this is what accumulates
     # from real traffic via handle_async_request over time; injecting
     # samples here keeps the test fast and deterministic. The scheduler is
     # reached through the transport's internals deliberately, to prove the
@@ -119,6 +119,22 @@ async def test_post_never_hedges_even_when_slow() -> None:
     await transport.aclose()
 
 
+async def test_latency_quantile_reflects_traffic_through_the_transport() -> None:
+    inner = ScriptedTransport([delayed_response(0.01)])
+    transport = HedgedTransport(inner=inner, default_config=HedgeConfig(min_delay=0.0))
+    transport.register("GET", "/api/v1/search", EndpointConfig())
+
+    assert transport.latency_quantile("endpoint:GET /api/v1/search", 0.9) is None
+
+    async with httpx.AsyncClient(transport=transport) as client:
+        await client.get("https://api.example.com/api/v1/search")
+
+    p90 = transport.latency_quantile("endpoint:GET /api/v1/search", 0.9)
+    assert p90 is not None
+    assert p90 > 0
+    await transport.aclose()
+
+
 async def test_get_with_streamed_body_never_hedges_even_when_slow() -> None:
     inner = ScriptedTransport([delayed_response(0.05)])
     transport = HedgedTransport(
@@ -157,7 +173,7 @@ async def test_host_breaker_uses_transport_default_not_first_endpoint_touched()
             await client.get("https://api.example.com/aggressive")
 
     # A single failure trips the endpoint breaker (min_samples=1) but must
-    # not trip the host breaker -- the host tier always uses the
+    # not trip the host breaker: the host tier always uses the
     # transport-wide default config, regardless of which endpoint's
     # override happens to touch the host first.
     assert (

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/tests/unit/test_rate_counter.py

@@ -44,7 +44,7 @@ def test_rate_weights_previous_window_by_remaining_overlap(
     fake_clock: Callable[[float], None],
 ) -> None:
     """At steady state, the estimate should track the true rate throughout
-    the window -- not just right after a rotation -- by discounting the
+    the window, not just right after a rotation, by discounting the
     previous window's count as it falls further outside the trailing
     window_duration-sized lookback from now."""
     counter = RollingRateCounter(window_duration=10.0)
@@ -63,5 +63,5 @@ def test_long_idle_resets_rate_to_zero(fake_clock: Callable[[float], None]) -> N
     counter = RollingRateCounter(window_duration=10.0)
     for _ in range(20):
         counter.increment()
-    fake_clock(25.0)  # beyond 2x window -- reset
+    fake_clock(25.0)  # beyond 2x window, reset
     assert counter.rate_per_second() == 0.0

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/tests/unit/test_scheduler.py

@@ -84,6 +84,32 @@ def test_min_delay_floors_the_result() -> None:
     assert scheduler.compute_hedge_delay(state) == 0.05
 
 
+# --- latency_quantile ---------------------------------------------------------
+
+
+def test_latency_quantile_is_none_for_an_untracked_key() -> None:
+    scheduler, _health, _stats = make_scheduler()
+    assert scheduler.latency_quantile("never-seen", 0.9) is None
+
+
+def test_latency_quantile_is_none_before_any_samples() -> None:
+    scheduler, _health, _stats = make_scheduler()
+    config = resolve(None, HedgeConfig())
+    scheduler.state_for("k", config)  # creates the state, but adds no samples
+    assert scheduler.latency_quantile("k", 0.9) is None
+
+
+def test_latency_quantile_reflects_recorded_samples() -> None:
+    scheduler, _health, _stats = make_scheduler()
+    config = resolve(None, HedgeConfig())
+    state = scheduler.state_for("k", config)
+    for v in range(1, 101):
+        state.sketch.add(v / 1000.0)  # 0.001..0.1 seconds
+    p90 = scheduler.latency_quantile("k", 0.9)
+    assert p90 is not None
+    assert 0.085 <= p90 <= 0.095
+
+
 # --- execute_with_hedge: race behavior ---------------------------------------
 
 
@@ -304,7 +330,7 @@ async def test_external_cancellation_does_not_leak_the_primary_task() -> None:
 
 async def test_discard_releases_a_loser_that_completed_successfully() -> None:
     """When the primary and hedge finish in the same event-loop pass, the
-    non-winning task is never cancelled (it's already done) -- its result
+    non-winning task is never cancelled (it's already done), so its result
     must still be handed to ``discard`` so callers can release it (e.g.
     closing an httpx.Response to free its pooled connection)."""
     scheduler, _health, _stats = make_scheduler()
@@ -356,7 +382,7 @@ async def test_discard_skips_a_loser_that_raised() -> None:
 
 async def test_discard_not_called_for_a_genuinely_cancelled_loser_in_a_race() -> None:
     """The common case: the loser is still mid-flight when cancelled, so it
-    never produced a result -- discard must not be invoked for it."""
+    never produced a result, and discard must not be invoked for it."""
     scheduler, _health, _stats = make_scheduler()
     config = hardcoded_config(0.01)
     discarded: list[str] = []

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/tests/unit/test_windowed_sketch.py

@@ -38,7 +38,7 @@ def test_quantile_reflects_data_within_window(
     sketch = WindowedSketch(window_duration=30.0)
     for v in range(1, 51):
         sketch.add(float(v))
-    fake_clock(15.0)  # still within the first window -- no rotation
+    fake_clock(15.0)  # still within the first window, no rotation
     assert sketch.quantile(0.0) == 1.0
     assert sketch.quantile(1.0) == 50.0
 
@@ -62,7 +62,7 @@ def test_idle_beyond_two_windows_hard_resets(
 ) -> None:
     sketch = WindowedSketch(window_duration=10.0)
     sketch.add(5.0)
-    fake_clock(25.0)  # more than 2x window_duration has elapsed -- reset, not rotate
+    fake_clock(25.0)  # more than 2x window_duration has elapsed: reset, not rotate
     assert math.isnan(sketch.quantile(0.5))
 
 

{httpx_hedged-0.2.0 → httpx_hedged-0.3.0}/uv.lock

@@ -200,7 +200,6 @@ wheels = [
 
 [[package]]
 name = "httpx-hedged"
-version = "0.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },
@@ -213,6 +212,7 @@ dev = [
     { name = "pytest" },
     { name = "pytest-asyncio" },
     { name = "python-lsp-server", extra = ["all"] },
+    { name = "ruff" },
 ]
 examples = [
     { name = "fastapi" },
@@ -229,6 +229,7 @@ dev = [
     { name = "pytest", specifier = ">=9.0.1" },
     { name = "pytest-asyncio", specifier = ">=1.3.0" },
     { name = "python-lsp-server", extras = ["all"], specifier = ">=1.13.2" },
+    { name = "ruff", specifier = ">=0.14.0" },
 ]
 examples = [
     { name = "fastapi", specifier = ">=0.115" },
@@ -625,6 +626,31 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/75/35/130469d1901da2b3a5a377539b4ffcd8a5c983f1c9e3ba5ffdd8d71ae314/rope-1.14.0-py3-none-any.whl", hash = "sha256:00a7ea8c0c376fc0b053b2f2f8ef3bfb8b50fecf1ebf3eb80e4f8bd7f1941918", size = 207143, upload-time = "2025-07-12T17:46:05.928Z" },
 ]
 
+[[package]]
+name = "ruff"
+version = "0.15.21"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/36/6f65aa9989acdec45d417192d8f4e7921931d8a6cf87ac74bce3eed98a8e/ruff-0.15.21.tar.gz", hash = "sha256:d0cfc841c572283c36548f82664a54ce6565567f1b0d5b4cf2caac693d8b7500", size = 4769401, upload-time = "2026-07-09T20:01:34.005Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d0/c6/ede15cac6839f3dbce52565c8f5164a8210e669c7bc4decb03e5bdf47d0d/ruff-0.15.21-py3-none-linux_armv6l.whl", hash = "sha256:63ea0e965e5d73c90e95b2434beeafc70820536717f561b32ab6e777cb9bdf5d", size = 10854342, upload-time = "2026-07-09T20:00:53.998Z" },
+    { url = "https://files.pythonhosted.org/packages/28/9d/d825b07ee7ea9e2d61df92a860033c94e06e7300d50a1c2653aac27d24fe/ruff-0.15.21-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:0f212c5d7d54c01bbfe6dcab02b724a39300f3e34ed7acbe995ccb320a2c58bd", size = 11139539, upload-time = "2026-07-09T20:00:57.809Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/de/3b107712e642f063c7a9e0887c427b22cb44097de5aab36c05f2e280670c/ruff-0.15.21-py3-none-macosx_11_0_arm64.whl", hash = "sha256:e6312e41bc96791299614995ea3a977c5857c3b5662b1ecef6755b02b87cb646", size = 10595437, upload-time = "2026-07-09T20:01:00.006Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/6f/b4523cc90ba239ede441447a19d0c968846a3012e5a0b0c5b62831a3d5e3/ruff-0.15.21-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:01d65b4831c6b2a4ba8ee6faa84049d44d982b7a706e622c4094c509e51673be", size = 10990053, upload-time = "2026-07-09T20:01:02.187Z" },
+    { url = "https://files.pythonhosted.org/packages/92/cc/c6a9872a5375f0628875481cf2f66b13d7d865bf3ca2e57f91c7e762d976/ruff-0.15.21-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2c5a913a589120ce67933d5d05fd6ddbcc2481c6a054980ee767f7414c72b4fd", size = 10666096, upload-time = "2026-07-09T20:01:04.299Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/97/c621f7a17e097f1790fa3af6374138823b330b2d03fc38337945daca212c/ruff-0.15.21-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5ef04b681d02ad4dc9620f00f83ac5c22f652d0e9a9cfe431d219b16ad5ccc41", size = 11537011, upload-time = "2026-07-09T20:01:06.771Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/51/d928727e476e25ccc57c6f449ffd80241a651a973ad949d39cfb2a771d28/ruff-0.15.21-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:16d090c0740916594157e75b80d666eab8e78083b39b3b0e1d698f4670a17b86", size = 12347101, upload-time = "2026-07-09T20:01:08.859Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/88/8cd62026802b16018ad06931d87997cf795ba2a6239ab659606c87d96bf0/ruff-0.15.21-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3a10e74757dd65004d779b73e2f3c5210156d9980b41224d50d2ebcf1db51e67", size = 11572001, upload-time = "2026-07-09T20:01:11.092Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/97/f63084cf55444fc110e8cb985ebfcc592af47f597d44453d778cb81bc156/ruff-0.15.21-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bab0905d2f29e0d9fbc3c373ed23db0095edaa3f71f1f4f519ec15134d9e85c8", size = 11549239, upload-time = "2026-07-09T20:01:13.27Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/77/f107da4a2874b7715914b03f09ba9c54424de3ff8a1cc5d015d3ee2ce0ac/ruff-0.15.21-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:00eca240af5789fec6fe7df74c088cc1f9644ed83027113468efba7c92b94075", size = 11535340, upload-time = "2026-07-09T20:01:15.206Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/e9/601deb322d3303a7bf212b0100ead6f2ee3f6a044d89c30f2f92bf83c731/ruff-0.15.21-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:262ab31557a75141325e32d3357f3597645a7f084e732b6b054dde428ecd9341", size = 10964048, upload-time = "2026-07-09T20:01:17.723Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/2e/0f2176d1e99c15192caea19c8c3a0a955246b4cb4de795042eeb616345cd/ruff-0.15.21-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:659c4e7a4212f83306045ec7c5e5a356d16d9a6ef4ae0c7a4d872914fc655d9d", size = 10667055, upload-time = "2026-07-09T20:01:19.73Z" },
+    { url = "https://files.pythonhosted.org/packages/48/60/abd74a02e0c4214f12a68becfd30af7165cfdcb0e661ecdc60bbb949c09a/ruff-0.15.21-py3-none-musllinux_1_2_i686.whl", hash = "sha256:9e866eab611a5f959d36df2d10e446973a3610bc42b0c15b31dc27977d59c233", size = 11242043, upload-time = "2026-07-09T20:01:21.947Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/c6/583075d8ccabb4b229345edcaf1545eb3d8d6be90f686a479d7e94088bbf/ruff-0.15.21-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e89bc93c0d3803ba870b55c29671bad9dc6d94bb1eb181b056b52eb05b52854f", size = 11648064, upload-time = "2026-07-09T20:01:24.023Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/3c/37d0ecb729a7cc2d393ea7dce316fc585680f35d93b8d62139d7d0a3700c/ruff-0.15.21-py3-none-win32.whl", hash = "sha256:01f8d5be84823c172b389e123174f781f9daf86d6c58719d603f941932195cdd", size = 10896555, upload-time = "2026-07-09T20:01:26.941Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/b8/e43466b2a6067ce91e669068f6e28d6c719a920f014b070d5c8731725de3/ruff-0.15.21-py3-none-win_amd64.whl", hash = "sha256:d4b8d9a2f0f12b816b50447f6eccb9f4bb01a6b82c86b50fb3b5354b458dc6d3", size = 12038772, upload-time = "2026-07-09T20:01:29.497Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/75/e90ab9aeece218a9fc5a5bc3ec97d0ee6bb3c4ff95869463c1de58e29a1c/ruff-0.15.21-py3-none-win_arm64.whl", hash = "sha256:6e83115d4b9377c1cbc13abf0e051f069fab0ef815ea0504a8a008cee24dd0a8", size = 11375265, upload-time = "2026-07-09T20:01:31.772Z" },
+]
+
 [[package]]
 name = "sniffio"
 version = "1.3.1"

httpx_hedged-0.2.0/LICENSE

@@ -1,28 +0,0 @@
-BSD 3-Clause License
-
-Copyright (c) 2025, Brendan Fahy
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.