dccd 3.6.2__tar.gz → 3.6.3__tar.gz

{dccd-3.6.2 → dccd-3.6.3}/CHANGELOG.md

@@ -16,6 +16,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Removed
 
+## [3.6.3] - 2026-06-20
+
+### Fixed
+
+- `POST /login` no longer returns a 500 on a non-ASCII submitted token:
+  `secrets.compare_digest` raises `TypeError` on a `str` with non-ASCII
+  characters, so the handler now compares UTF-8 bytes — a junk token (scanners POST
+  arbitrary bytes) is rejected cleanly with the usual invalid-login response. (#174)
+- `AsyncHTTPClient.__aexit__` now nulls the shared client reference **before**
+  awaiting `aclose()`, closing a reference-count race: `aclose()` yields, and a
+  concurrent `__aenter__` during that await previously reused the closing client,
+  so a scheduled backfill could fail with `Cannot send a request, as the client
+  has been closed` (observed ~1×/day across exchanges). The re-entrant user now
+  builds a fresh client instead. (#173)
+
 ## [3.6.2] - 2026-06-20
 
 ### Fixed

{dccd-3.6.2 → dccd-3.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dccd
-Version: 3.6.2
+Version: 3.6.3
 Summary: Download Crypto Currency Data — hexagonal architecture, async-first.
 Author-email: Arthur Bernard <arthur.bernard.92@gmail.com>
 License: MIT

{dccd-3.6.2 → dccd-3.6.3}/dccd/interfaces/api/app.py

@@ -918,7 +918,12 @@ def create_app(
             fields = parse_qs((await request.body()).decode("utf-8", "replace"))
             submitted = (fields.get("token") or [""])[0]
             nxt = _safe_next((fields.get("next") or ["/"])[0])
-            if not token or not secrets.compare_digest(submitted, token):
+            # Compare UTF-8 bytes: ``compare_digest`` raises ``TypeError`` on a
+            # ``str`` containing non-ASCII characters, so a junk token (scanners
+            # POST arbitrary bytes) must be rejected cleanly, not 500.
+            if not token or not secrets.compare_digest(
+                submitted.encode("utf-8"), token.encode("utf-8")
+            ):
                 try:
                     ver = _pkg_version("dccd")
                 except Exception:

{dccd-3.6.2 → dccd-3.6.3}/dccd/tests/v3/test_api.py

@@ -121,6 +121,15 @@ class TestAuthSession:
         )
         assert r.status_code == 401
 
+    def test_login_non_ascii_token_rejected_not_500(self, auth_client):
+        # A non-ASCII submitted token must be rejected cleanly (401), never crash
+        # with a 500 — ``secrets.compare_digest`` raises TypeError on non-ASCII
+        # ``str``; the handler compares UTF-8 bytes instead.
+        r = auth_client.post(
+            "/login", data={"token": "hé€llo", "next": "/"}, follow_redirects=False
+        )
+        assert r.status_code == 401
+
     def test_login_sets_httponly_lax_cookie_and_grants_access(self, cfg):
         with TestClient(create_app(config=cfg)) as c:
             r = c.post(

{dccd-3.6.2 → dccd-3.6.3}/dccd/tests/v3/test_transport.py

@@ -40,6 +40,50 @@ async def test_concurrent_context_does_not_close_client_early():
     assert http._client is None
 
 
+@pytest.mark.asyncio
+async def test_reentry_during_close_gets_fresh_client():
+    """A ``__aenter__`` while a previous ``__aexit__`` is awaiting ``aclose()``
+    must observe a FRESH client, never the closing one.
+
+    Reproduces the refcount race behind the production "Cannot send a request,
+    as the client has been closed" failures: ``__aexit__`` must null
+    ``self._client`` *before* awaiting ``aclose()`` (which yields), otherwise the
+    re-entrant user reuses the dying client. A fake client whose ``aclose()``
+    yields lets us interleave deterministically.
+    """
+    created: list[Any] = []
+
+    class FakeClient:
+        def __init__(self, **_: Any) -> None:
+            self.closed = False
+            created.append(self)
+
+        async def aclose(self) -> None:
+            await asyncio.sleep(0)  # yield so a concurrent __aenter__ can run
+            self.closed = True
+
+    with patch("httpx.AsyncClient", FakeClient):
+        http = AsyncHTTPClient()
+        await http.__aenter__()  # depth 1, client = fake #0
+        first = http._client
+        assert first is created[0]
+
+        # Start the exit (depth -> 0): it nulls the ref then awaits aclose().
+        exit_task = asyncio.create_task(http.__aexit__())
+        await asyncio.sleep(0)  # let __aexit__ reach the aclose() await
+
+        # Re-enter concurrently: must build a fresh, open client.
+        await http.__aenter__()
+        observed = http._client
+        assert observed is not None
+        assert not observed.closed  # the re-entrant user sees a live client
+        assert observed is not first  # and it is NOT the one being closed
+
+        await exit_task
+        assert first.closed  # the original client still got closed
+        await http.__aexit__()
+
+
 @pytest.mark.asyncio
 async def test_operation_level_context_one_pool_per_backfill(monkeypatch):
     """Operation-level ``async with adapter._http`` creates ONE httpx.AsyncClient.

{dccd-3.6.2 → dccd-3.6.3}/dccd/transport/http.py

@@ -72,8 +72,9 @@ class AsyncHTTPClient:
         # one) the first to finish would otherwise close the shared httpx client
         # mid-flight for the other ("Cannot send a request, as the client has
         # been closed"). Reference-count the context so the client is created on
-        # first entry and closed only when the last concurrent user exits. Safe
-        # under asyncio: the counter is mutated without intervening awaits.
+        # first entry and closed only when the last concurrent user exits. The
+        # counter is mutated without intervening awaits, but ``__aexit__`` must
+        # still null the reference *before* awaiting ``aclose()`` (see there).
         self._depth = 0
 
     async def __aenter__(self) -> "AsyncHTTPClient":
@@ -88,10 +89,17 @@ class AsyncHTTPClient:
 
     async def __aexit__(self, *args: Any) -> None:
         self._depth -= 1
-        if self._depth <= 0 and self._client:
+        if self._depth <= 0 and self._client is not None:
+            # Ordering matters: null the shared reference BEFORE awaiting
+            # ``aclose()``. ``aclose()`` yields, and a concurrent ``__aenter__``
+            # during that await would otherwise see the still-set (closing)
+            # client, skip creation, bump the depth and ``get()`` a dead client
+            # ("Cannot send a request, as the client has been closed"). Nulling
+            # first makes that re-entry build a FRESH client instead.
             self._depth = 0
-            await self._client.aclose()
+            client = self._client
             self._client = None
+            await client.aclose()
 
     async def get(self, url: str, params: dict[str, Any] | None = None) -> Any:
         """Perform a GET request with retry/backoff. Returns parsed JSON."""

{dccd-3.6.2 → dccd-3.6.3}/dccd.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dccd
-Version: 3.6.2
+Version: 3.6.3
 Summary: Download Crypto Currency Data — hexagonal architecture, async-first.
 Author-email: Arthur Bernard <arthur.bernard.92@gmail.com>
 License: MIT

{dccd-3.6.2 → dccd-3.6.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dccd"
-version = "3.6.2"
+version = "3.6.3"
 description = "Download Crypto Currency Data — hexagonal architecture, async-first."
 readme = "README.md"
 license = { text = "MIT" }