internetdata 2.7.0__tar.gz → 2.7.2__tar.gz

{internetdata-2.7.0 → internetdata-2.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: internetdata
-Version: 2.7.0
+Version: 2.7.2
 Summary: Official Python client library for the InternetData API. Download and verify licensed IP datasets.
 Project-URL: Homepage, https://internetdata.io
 Project-URL: Documentation, https://docs.internetdata.io

{internetdata-2.7.0 → internetdata-2.7.2}/spec/openapi.yaml

@@ -12,7 +12,7 @@ info:
     email: support@internetdata.io
     url: https://internetdata.io
   termsOfService: https://internetdata.io/terms
-  version: 2026.10.08
+  version: 2026.10.09
 servers:
   - url: https://internetdata.io
 tags:
@@ -501,10 +501,13 @@ paths:
       summary: Rotate
       description: |
         Replaces the secret behind a key, keeping its id, name and settings.
-        The previous secret stops working immediately.
+        The previous secret stops working immediately. The new secret comes
+        back in the answer, so this needs `apikeys.reveal` as well as
+        `apikeys.manage`.
       security:
         - BearerAuth:
             - apikeys.manage
+            - apikeys.reveal
       parameters:
         - $ref: '#/components/parameters/ApikeyIdParam'
       responses:

{internetdata-2.7.0 → internetdata-2.7.2}/src/internetdata/__init__.py

@@ -39,7 +39,7 @@ from .models import (
     TokenResponse,
 )
 
-__version__ = "2.7.0"
+__version__ = "2.7.2"
 
 __all__ = [
     "DATABASE_FORMATS",

{internetdata-2.7.0 → internetdata-2.7.2}/src/internetdata/_core.py

@@ -14,7 +14,7 @@ import os
 import secrets
 import threading
 import time
-from collections.abc import Awaitable, Callable, Iterator
+from collections.abc import Callable, Iterator
 from pathlib import Path
 from types import ModuleType
 from typing import IO, Any, TypeVar, cast
@@ -23,7 +23,6 @@ from urllib.parse import quote
 import httpx
 
 from ._generated.client import AuthenticatedClient, Client
-from ._generated.types import Response
 from .errors import InternetDataError, error_from_response, oauth_error_from
 from .models import Database, Download, Pkce, to_database, to_download
 
@@ -81,10 +80,11 @@ def build_client(
     `set_httpx_client()`, which silently bypasses auth: the generated client only adds
     the `Authorization` header when it CONSTRUCTS the httpx client itself.
     """
+    api_key = check_api_key(api_key)
     httpx_args: dict[str, Any] = {}
     if transport is not None:
         httpx_args["transport"] = transport
-    if not api_key:
+    if api_key is None:
         return cast(
             AuthenticatedClient,
             Client(base_url=base_url, timeout=httpx.Timeout(timeout), httpx_args=httpx_args),
@@ -132,6 +132,25 @@ def build_async_transfer_client(
     )
 
 
+def check_api_key(api_key: str | None) -> str | None:
+    """`api_key` without the blanks around it, or None when nothing else is left.
+
+    Refused where it is SET when a control character remains: httpx refuses a header
+    holding a CR, LF or NUL, so every call failed as a retried `network` error with nothing
+    sent, while a tab or DEL inside the key went out on the wire. Untrimmed, a key of blanks
+    was sent as one rather than as no key, and failed every call the same way (2.7.1,
+    measured 2026-10-12).
+    """
+    if api_key is None:
+        return None
+    if not isinstance(api_key, str):
+        raise TypeError(f"api_key must be a string or None, not {type(api_key).__name__}")
+    key = api_key.strip()
+    if any(ord(char) < 0x20 or ord(char) == 0x7F for char in key):
+        raise ValueError("api_key holds a control character")
+    return key or None
+
+
 def check_timeout(timeout: float | None) -> float | None:
     """`timeout`, once it is a bound an attempt can meet.
 
@@ -218,67 +237,51 @@ def part_file(destination: str | os.PathLike[str]) -> Iterator[IO[bytes]]:
         raise
 
 
-def send(call: Callable[[], Response[Any]]) -> Response[Any]:
-    """One generated endpoint call.
-
-    The generated code eagerly decodes the body of every DOCUMENTED status into its model
-    before anything here sees the response, and it raises three different ways doing it: a
-    503 carrying an intermediary's HTML error page is a `ValueError` out of `json()`, a
-    200 missing a required key is a `KeyError`, and a `standing` this pinned spec predates
-    is a `ValueError` out of an enum constructor. All three are the server sending
-    something this client cannot read, which is a failed request rather than a bug in the
-    caller's code, so all three become the one error type here.
-
-    The call does nothing but build one generated request, send it and hand the answer to
-    the generated decoder, which is what keeps this catch from swallowing a fault of our own.
-    An argument is converted before it, so a format this client does not publish is the
-    caller's `ValueError` rather than the server's failure.
-    """
-    try:
-        return call()
-    except (KeyError, TypeError, ValueError) as exc:
-        raise malformed(exc) from exc
-
-
-async def send_async(call: Callable[[], Awaitable[Response[Any]]]) -> Response[Any]:
-    """`send`, awaited."""
-    try:
-        return await call()
-    except (KeyError, TypeError, ValueError) as exc:
-        raise malformed(exc) from exc
-
-
 def request(
     endpoint: ModuleType, client: AuthenticatedClient, bound: float | None, **params: Any
-) -> Response[Any]:
-    """`send` for one generated endpoint, one attempt of it finished within `bound` seconds,
-    or unbounded when that is None.
+) -> httpx.Response:
+    """One attempt at one generated endpoint, finished within `bound` seconds, or unbounded
+    when that is None, and its answer checked by `decoded`.
 
     Assembled from the endpoint module's `_get_kwargs` and `_build_response` because its
     `sync_detailed` sends through httpx alone, and httpx has no bound on the attempt.
     """
-
-    def call() -> Response[Any]:
-        http = client.get_httpx_client()
-        req = http.build_request(**endpoint._get_kwargs(**params), timeout=httpx.Timeout(bound))
-        res = exchange(http, req, bound)
-        return cast(Response[Any], endpoint._build_response(client=client, response=res))
-
-    return send(call)
+    http = client.get_httpx_client()
+    req = http.build_request(**endpoint._get_kwargs(**params), timeout=httpx.Timeout(bound))
+    return decoded(endpoint, client, exchange(http, req, bound))
 
 
 async def request_async(
     endpoint: ModuleType, client: AuthenticatedClient, bound: float | None, **params: Any
-) -> Response[Any]:
+) -> httpx.Response:
     """`request`, awaited."""
+    http = client.get_async_httpx_client()
+    req = http.build_request(**endpoint._get_kwargs(**params), timeout=httpx.Timeout(bound))
+    return decoded(endpoint, client, await exchange_async(http, req, bound))
 
-    async def call() -> Response[Any]:
-        http = client.get_async_httpx_client()
-        req = http.build_request(**endpoint._get_kwargs(**params), timeout=httpx.Timeout(bound))
-        res = await exchange_async(http, req, bound)
-        return cast(Response[Any], endpoint._build_response(client=client, response=res))
 
-    return await send_async(call)
+def decoded(
+    endpoint: ModuleType, client: AuthenticatedClient, res: httpx.Response
+) -> httpx.Response:
+    """`res`, once the generated decoder has read it, where it is a 2xx.
+
+    The generated code eagerly decodes the body of every DOCUMENTED status into its model,
+    and it raises three different ways doing it: a body that is not JSON is a `ValueError`
+    out of `json()`, an object missing a required key a `KeyError`, and a `standing` this
+    pinned spec predates a `ValueError` out of an enum constructor. On a 2xx each is the
+    server sending an answer this client cannot read, so each is the one error type here,
+    a retried `server_error` carrying the status.
+
+    Any other status is left to `unwrap`, which classifies it by the status alone, whatever
+    its body. Decoded too, a proxy's HTML page on a 401, a 404 or an empty 403 was a
+    retried `server_error` with no status, sent three times (2.7.1, measured 2026-10-12).
+    """
+    if 200 <= res.status_code < 300:
+        try:
+            endpoint._build_response(client=client, response=res)
+        except (KeyError, TypeError, ValueError) as exc:
+            raise malformed(exc, res.status_code) from exc
+    return res
 
 
 def exchange(http: httpx.Client, req: httpx.Request, bound: float | None) -> httpx.Response:
@@ -458,16 +461,16 @@ class AsyncClock:
         await asyncio.sleep(seconds)
 
 
-def malformed(exc: Exception) -> InternetDataError:
-    return InternetDataError("server_error", f"malformed response from the API: {exc}")
+def malformed(exc: Exception, status: int) -> InternetDataError:
+    return InternetDataError("server_error", f"malformed response from the API: {exc}", status)
 
 
-def unwrap(res: Response[Any]) -> dict[str, Any]:
+def unwrap(res: httpx.Response) -> dict[str, Any]:
     """The response body as it came off the wire, or the failure it describes."""
     body = _decode(res.content)
-    status = int(res.status_code)
+    status = res.status_code
     if not 200 <= status < 300:
-        raise error_from_response(status, _headers(res), body)
+        raise error_from_response(status, res.headers, body)
     if not isinstance(body, dict):
         raise InternetDataError("server_error", "the API answered with a non-object body", status)
     return body
@@ -484,23 +487,27 @@ def as_error(exc: InternetDataError | httpx.HTTPError) -> InternetDataError:
     return InternetDataError("network", str(exc) or type(exc).__name__)
 
 
-def parse_body(body: dict[str, Any], parse: Callable[[dict[str, Any]], T]) -> T:
+def parse_body(res: httpx.Response, parse: Callable[[dict[str, Any]], T]) -> T:
     """A served body through the model layer, with a malformed one reported as the
-    server's failure rather than as a traceback out of a dataclass constructor."""
+    server's failure, carrying its status, rather than as a traceback out of a dataclass
+    constructor."""
+    body = unwrap(res)
     try:
         return parse(body)
-    except (KeyError, TypeError, ValueError) as exc:
-        raise malformed(exc) from exc
+    # AttributeError too: metadata's `schema` or `sample` as an array instead of an object
+    # escaped 2.7.1 raw, out of `.items()` (measured 2026-10-12).
+    except (AttributeError, KeyError, TypeError, ValueError) as exc:
+        raise malformed(exc, res.status_code) from exc
 
 
-def redirect_location(res: Response[Any]) -> str:
+def redirect_location(res: httpx.Response) -> str:
     """Where a `302` points, or whatever the API said instead."""
-    location: str | None = _headers(res).get("location")
-    if int(res.status_code) == 302 and location:
+    location: str | None = res.headers.get("location")
+    if res.status_code == 302 and location:
         return location
     unwrap(res)
     raise InternetDataError(
-        "server_error", "expected a redirect to object storage", int(res.status_code)
+        "server_error", "expected a redirect to object storage", res.status_code
     )
 
 
@@ -519,13 +526,18 @@ def downloads_of(body: dict[str, Any]) -> list[Download]:
 
 
 def checksums_of(body: dict[str, Any]) -> dict[str, str]:
-    """The digests, unwrapped one level past the envelope.
+    """The digests, unwrapped one level past the envelope, the four the spec requires
+    among them as strings.
 
     The response carries `id` and `format` beside them, so reading a top-level `sha256`
     finds nothing. That exact mistake shipped in another binding's 1.0.x, which is why
     the shared corpus pins the depth.
     """
-    return dict(body["checksums"])
+    digests = dict(body["checksums"])
+    for algorithm in ("md5", "sha1", "sha256", "sha512"):
+        if not isinstance(digests[algorithm], str):
+            raise TypeError(f"the {algorithm} checksum is not a string: {digests[algorithm]!r}")
+    return digests
 
 
 def retry_delay(err: InternetDataError, attempt: int, retries: int) -> float | None:
@@ -596,13 +608,6 @@ def _deadline_passed(bound: float) -> InternetDataError:
     return InternetDataError("network", f"the request did not complete within {bound:g} seconds")
 
 
-# The generated Response declares a plain MutableMapping, but always carries httpx's
-# case-insensitive Headers. Rebuilding one keeps a header lookup case-blind whichever it
-# turns out to be, which matters for `Retry-After`.
-def _headers(res: Response[Any]) -> httpx.Headers:
-    return httpx.Headers(res.headers)
-
-
 def _decode(content: bytes) -> Any:
     try:
         return json.loads(content)

{internetdata-2.7.0 → internetdata-2.7.2}/src/internetdata/_generated/api/api_keys/account_rotate_apikey.py

@@ -74,7 +74,9 @@ def sync_detailed(
     """Rotate
 
      Replaces the secret behind a key, keeping its id, name and settings.
-    The previous secret stops working immediately.
+    The previous secret stops working immediately. The new secret comes
+    back in the answer, so this needs `apikeys.reveal` as well as
+    `apikeys.manage`.
 
     Args:
         id (UUID):
@@ -106,7 +108,9 @@ def sync(
     """Rotate
 
      Replaces the secret behind a key, keeping its id, name and settings.
-    The previous secret stops working immediately.
+    The previous secret stops working immediately. The new secret comes
+    back in the answer, so this needs `apikeys.reveal` as well as
+    `apikeys.manage`.
 
     Args:
         id (UUID):
@@ -133,7 +137,9 @@ async def asyncio_detailed(
     """Rotate
 
      Replaces the secret behind a key, keeping its id, name and settings.
-    The previous secret stops working immediately.
+    The previous secret stops working immediately. The new secret comes
+    back in the answer, so this needs `apikeys.reveal` as well as
+    `apikeys.manage`.
 
     Args:
         id (UUID):
@@ -163,7 +169,9 @@ async def asyncio(
     """Rotate
 
      Replaces the secret behind a key, keeping its id, name and settings.
-    The previous secret stops working immediately.
+    The previous secret stops working immediately. The new secret comes
+    back in the answer, so this needs `apikeys.reveal` as well as
+    `apikeys.manage`.
 
     Args:
         id (UUID):

{internetdata-2.7.0 → internetdata-2.7.2}/src/internetdata/aio.py

@@ -48,7 +48,6 @@ from ._core import (
     request_async,
     retry_delay,
     storage_refusal,
-    unwrap,
 )
 from ._generated.api.database_v_2 import (
     database_checksum_v2,
@@ -172,7 +171,7 @@ class AsyncDatabaseApi:
 
         async def call() -> builtins.list[Database]:
             res = await request_async(list_databases, self._client, self._bound(timeout))
-            return parse_body(unwrap(res), databases_of)
+            return parse_body(res, databases_of)
 
         return await self._retrying(call)
 
@@ -186,7 +185,7 @@ class AsyncDatabaseApi:
             res = await request_async(
                 database_metadata_v2, self._client, self._bound(timeout), id=database_id
             )
-            return parse_body(unwrap(res), to_metadata)
+            return parse_body(res, to_metadata)
 
         return await self._retrying(call)
 
@@ -206,7 +205,7 @@ class AsyncDatabaseApi:
                 id=database_id,
                 format_=DatabaseFormat(format),
             )
-            return parse_body(unwrap(res), checksums_of)
+            return parse_body(res, checksums_of)
 
         return await self._retrying(call)
 
@@ -222,7 +221,7 @@ class AsyncDatabaseApi:
             res = await request_async(
                 list_downloads, self._client, self._bound(timeout), limit=limit
             )
-            return parse_body(unwrap(res), downloads_of)
+            return parse_body(res, downloads_of)
 
         return await self._retrying(call)
 

{internetdata-2.7.0 → internetdata-2.7.2}/src/internetdata/client.py

@@ -43,7 +43,6 @@ from ._core import (
     request,
     retry_delay,
     storage_refusal,
-    unwrap,
 )
 from ._generated.api.database_v_2 import (
     database_checksum_v2,
@@ -184,7 +183,7 @@ class DatabaseApi:
 
         def call() -> builtins.list[Database]:
             res = request(list_databases, self._client, self._bound(timeout))
-            return parse_body(unwrap(res), databases_of)
+            return parse_body(res, databases_of)
 
         return self._retrying(call)
 
@@ -199,7 +198,7 @@ class DatabaseApi:
 
         def call() -> DatabaseMetadata:
             res = request(database_metadata_v2, self._client, self._bound(timeout), id=database_id)
-            return parse_body(unwrap(res), to_metadata)
+            return parse_body(res, to_metadata)
 
         return self._retrying(call)
 
@@ -222,7 +221,7 @@ class DatabaseApi:
                 id=database_id,
                 format_=DatabaseFormat(format),
             )
-            return parse_body(unwrap(res), checksums_of)
+            return parse_body(res, checksums_of)
 
         return self._retrying(call)
 
@@ -239,7 +238,7 @@ class DatabaseApi:
 
         def call() -> builtins.list[Download]:
             res = request(list_downloads, self._client, self._bound(timeout), limit=limit)
-            return parse_body(unwrap(res), downloads_of)
+            return parse_body(res, downloads_of)
 
         return self._retrying(call)
 

{internetdata-2.7.0 → internetdata-2.7.2}/src/internetdata/errors.py

@@ -3,8 +3,8 @@
 from __future__ import annotations
 
 import datetime
-import email.utils
 import math
+import re
 from typing import Any, Literal
 
 import httpx
@@ -170,21 +170,65 @@ def _message_of(body: Any) -> str | None:
     return None
 
 
+# `Retry-After` is a count of seconds or an HTTP date in one of RFC 9110's three forms,
+# always GMT, and nothing else: `float()` also read `+1`, `1_0`, `1e3` and `1.5` as counts,
+# and `email.utils` read a date in any zone, without its day name or with a two-digit year,
+# so `1_0` held a call ten seconds and a `PST` date eight hours (2.7.1, measured 2026-10-12).
+_SECONDS = re.compile(r"[0-9]+")
+_MONTH = r"(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)"
+_CLOCK = r"([0-9]{2}):([0-9]{2}):([0-9]{2})"
+_IMF_FIXDATE = re.compile(
+    rf"(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), ([0-9]{{2}}) {_MONTH} ([0-9]{{4}}) {_CLOCK} GMT"
+)
+_RFC850_DATE = re.compile(
+    rf"(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), ([0-9]{{2}})-{_MONTH}-([0-9]{{2}}) {_CLOCK} GMT"
+)
+_ASCTIME_DATE = re.compile(
+    rf"(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) {_MONTH} ([0-9]{{2}}| [0-9]) {_CLOCK} ([0-9]{{4}})"
+)
+_MONTHS = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec")
+
+
 def _parse_retry_after(value: str | None) -> float | None:
-    if value is None or value.strip() == "":
+    if value is None:
         return None
-    try:
-        seconds = float(value)
-    except ValueError:
-        pass
-    else:
-        return seconds if seconds >= 0 else None
-    # The header also permits an HTTP date.
-    try:
-        when = email.utils.parsedate_to_datetime(value)
-    except (TypeError, ValueError):
+    value = value.strip(" \t")
+    if _SECONDS.fullmatch(value):
+        # A count of any length: float() reads one past its range as inf, never raising.
+        return float(value)
+    when = _http_date(value)
+    if when is None:
         return None
-    if when.tzinfo is None:
-        when = when.replace(tzinfo=datetime.UTC)
     delta = (when - datetime.datetime.now(datetime.UTC)).total_seconds()
     return max(0.0, math.ceil(delta))
+
+
+# The moment an HTTP date names, or None for anything else, a day no calendar has included.
+def _http_date(value: str) -> datetime.datetime | None:
+    if match := _IMF_FIXDATE.fullmatch(value):
+        day, month, year, hour, minute, second = match.groups()
+        full_year = int(year)
+    elif match := _RFC850_DATE.fullmatch(value):
+        day, month, year, hour, minute, second = match.groups()
+        # RFC 9110: a two-digit year more than 50 years ahead is the most recent past one.
+        this_year = datetime.datetime.now(datetime.UTC).year
+        full_year = this_year - this_year % 100 + int(year)
+        if full_year > this_year + 50:
+            full_year -= 100
+    elif match := _ASCTIME_DATE.fullmatch(value):
+        month, day, hour, minute, second, year = match.groups()
+        full_year = int(year)
+    else:
+        return None
+    try:
+        return datetime.datetime(
+            full_year,
+            _MONTHS.index(month) + 1,
+            int(day),
+            int(hour),
+            int(minute),
+            int(second),
+            tzinfo=datetime.UTC,
+        )
+    except ValueError:
+        return None

{internetdata-2.7.0 → internetdata-2.7.2}/src/internetdata/models.py

@@ -175,36 +175,36 @@ class Download:
 
 def to_database(body: dict[str, Any]) -> Database:
     return Database(
-        base=body["base"],
-        name=body["name"],
-        summary=body["summary"],
-        standing=body["standing"],
+        base=_present(body, "base"),
+        name=_present(body, "name"),
+        summary=_present(body, "summary"),
+        standing=_present(body, "standing"),
         license_type=body["license_type"],
         starts=_datetime(body["starts"]),
         expires=_datetime(body["expires"]),
         renews_at=_datetime(body["renews_at"]),
         notice_due_at=_datetime(body["notice_due_at"]),
-        versions=tuple(to_version(v) for v in body["versions"]),
+        versions=tuple(to_version(v) for v in _present(body, "versions")),
         raw=body,
-        open=body["open"],
+        open=_present(body, "open"),
     )
 
 
 def to_version(body: dict[str, Any]) -> DatabaseVersion:
     return DatabaseVersion(
-        id=body["id"],
-        version=body["version"],
-        summary=body["summary"],
-        formats=tuple(body["formats"]),
+        id=_present(body, "id"),
+        version=_present(body, "version"),
+        summary=_present(body, "summary"),
+        formats=tuple(_present(body, "formats")),
         sample_formats=_optional_tuple(body.get("sample_formats")),
     )
 
 
 def to_metadata(body: dict[str, Any]) -> DatabaseMetadata:
     return DatabaseMetadata(
-        id=body["id"],
+        id=_present(body, "id"),
         updated=datetime.date.fromisoformat(body["updated"]),
-        entries=body["entries"],
+        entries=_present(body, "entries"),
         schema={
             fmt: tuple(to_column(c) for c in columns) for fmt, columns in body["schema"].items()
         },
@@ -218,25 +218,42 @@ def to_metadata(body: dict[str, Any]) -> DatabaseMetadata:
 
 
 def to_column(body: dict[str, Any]) -> MetadataColumn:
-    return MetadataColumn(name=body["name"], type=body["type"], description=body.get("description"))
+    return MetadataColumn(
+        name=_present(body, "name"),
+        type=_present(body, "type"),
+        description=body.get("description"),
+    )
 
 
 def to_download(body: dict[str, Any]) -> Download:
     return Download(
-        dataset_id=body["dataset_id"],
-        format=body["format"],
-        outcome=body["outcome"],
+        dataset_id=_present(body, "dataset_id"),
+        format=_present(body, "format"),
+        outcome=_present(body, "outcome"),
         created=datetime.datetime.fromisoformat(body["created"]),
         bytes=body["bytes"],
         http_status=body["http_status"],
         apikey_id=body["apikey_id"],
         client_ip=body["client_ip"],
         user_agent=body["user_agent"],
-        sample=body["sample"],
-        open=body["open"],
+        sample=_present(body, "sample"),
+        open=_present(body, "open"),
     )
 
 
+def _present(body: dict[str, Any], name: str) -> Any:
+    """A member the spec requires and never sends as null.
+
+    A null one is the server's failure, raised for the caller to report as one, rather
+    than handed back in the answer: 2.7.1 listed a family whose `base` was null as a
+    family with no base (measured 2026-10-12).
+    """
+    value = body[name]
+    if value is None:
+        raise ValueError(f"{name} is null")
+    return value
+
+
 def _optional_tuple(value: Any) -> tuple[Any, ...] | None:
     return tuple(value) if value is not None else None
 

{internetdata-2.7.0 → internetdata-2.7.2}/tests/helpers.py

@@ -301,6 +301,11 @@ class Stub:
         route = self.routes.get(request.url.path)
         if route is None:
             return httpx.Response(404, json={"rc": "UNKNOWN_DATASET"})
+        if "raw" in route:
+            # Bytes as they are, for a body that is not JSON at all.
+            return httpx.Response(
+                route.get("status", 200), content=route["raw"], headers=route.get("headers")
+            )
         return httpx.Response(
             route.get("status", 200), json=self._body(route), headers=route.get("headers")
         )

{internetdata-2.7.0 → internetdata-2.7.2}/tests/test_client.py

@@ -9,7 +9,7 @@ import inspect
 import time
 from collections.abc import Callable
 from pathlib import Path
-from typing import Any, get_args
+from typing import Any, cast, get_args
 
 import attrs
 import httpx
@@ -18,6 +18,7 @@ from helpers import (
     API,
     API_KEY,
     CHECKSUM_PATH,
+    DOWNLOAD_PATH,
     DOWNLOADS_PATH,
     LIST_PATH,
     METADATA_PATH,
@@ -60,6 +61,7 @@ from internetdata._generated.models.download import Download as WireDownload
 from internetdata._generated.models.download_outcome import DownloadOutcome as WireDownloadOutcome
 from internetdata._generated.models.oauth_metadata import OauthMetadata as WireOauthMetadata
 from internetdata._generated.models.token_response import TokenResponse as WireTokenResponse
+from internetdata.errors import error_from_response
 
 METADATA = {
     "id": "bogon_ip_v1",
@@ -319,6 +321,157 @@ def test_a_malformed_body_is_the_servers_failure_not_a_traceback(
     assert "malformed response" in caught.value.message
 
 
+JSON_CALL_PATHS = {
+    "list": LIST_PATH,
+    "metadata": METADATA_PATH,
+    "checksums": CHECKSUM_PATH,
+    "downloads": DOWNLOADS_PATH,
+    "download_url": DOWNLOAD_PATH,
+}
+
+UNREADABLE_2XX = {
+    "html": b"<html><body>Bad gateway</body></html>",
+    "cut off": b'{"databases": [',
+    "empty": b"",
+    "null": b"null",
+    "array": b"[]",
+    "empty object": b"{}",
+}
+
+
+@pytest.mark.parametrize("body", UNREADABLE_2XX)
+@pytest.mark.parametrize("call", JSON_CALLS)
+def test_a_2xx_the_call_cannot_read_is_a_retried_server_error_with_its_status(
+    make_client: ClientFactory, monkeypatch: pytest.MonkeyPatch, call: str, body: str
+) -> None:
+    """Retried, but with no status, through 2.7.1. For `download_url` a 200 stands for the
+    302 it did not send."""
+    monkeypatch.setattr(_core, "_BACKOFF_BASE", 0.0)
+    stub = Stub({JSON_CALL_PATHS[call]: {"raw": UNREADABLE_2XX[body]}})
+    client = make_client(transport=stub.transport, retries=2)
+
+    with pytest.raises(InternetDataError) as caught:
+        JSON_CALLS[call](client)
+
+    assert caught.value.kind == "server_error"
+    assert caught.value.status == 200
+    assert len(stub.requests) == 3
+
+
+def _without(member: str, entry: dict[str, Any]) -> dict[str, Any]:
+    return {**entry, member: None}
+
+
+def _version_without(member: str) -> dict[str, Any]:
+    family = database("bogon_ip")
+    return {**family, "versions": [_without(member, family["versions"][0])]}
+
+
+DIGESTS = {"md5": "m", "sha1": "s1", "sha256": "s256", "sha512": "s512"}
+
+# Each member the spec requires and never sends as null, sent as null; and metadata's two
+# maps sent as arrays, which escaped 2.7.1 as a raw AttributeError.
+UNREADABLE_MEMBERS: dict[str, tuple[str, dict[str, Any]]] = {
+    **{
+        f"list {m}": (LIST_PATH, {"databases": [_without(m, database("bogon_ip"))]})
+        for m in ("base", "name", "summary", "standing", "open", "versions")
+    },
+    **{
+        f"list version {m}": (LIST_PATH, {"databases": [_version_without(m)]})
+        for m in ("id", "version", "summary", "formats")
+    },
+    **{
+        f"metadata {m}": (METADATA_PATH, _without(m, METADATA))
+        for m in ("id", "updated", "entries", "schema", "size")
+    },
+    "metadata column name": (
+        METADATA_PATH,
+        {**METADATA, "schema": {"csvgz": [{"name": None, "type": "string"}]}},
+    ),
+    "metadata schema array": (METADATA_PATH, {**METADATA, "schema": []}),
+    "metadata sample array": (METADATA_PATH, {**METADATA, "sample": []}),
+    **{
+        f"downloads {m}": (
+            DOWNLOADS_PATH,
+            {"downloads": [_without(m, cast(list[dict[str, Any]], DOWNLOADS["downloads"])[0])]},
+        )
+        for m in ("dataset_id", "format", "outcome", "sample", "open", "created")
+    },
+    **{
+        f"checksums {m}": (
+            CHECKSUM_PATH,
+            {"id": "bogon_ip_v1", "format": "csvgz", "checksums": _without(m, DIGESTS)},
+        )
+        for m in ("md5", "sha256")
+    },
+    "checksums number": (
+        CHECKSUM_PATH,
+        {"id": "bogon_ip_v1", "format": "csvgz", "checksums": {**DIGESTS, "sha1": 5}},
+    ),
+}
+
+MEMBER_CALLS = {LIST_PATH: "list", METADATA_PATH: "metadata", DOWNLOADS_PATH: "downloads"}
+
+
+@pytest.mark.parametrize("case", UNREADABLE_MEMBERS)
+def test_an_answer_missing_what_the_spec_requires_is_a_retried_server_error(
+    make_client: ClientFactory, monkeypatch: pytest.MonkeyPatch, case: str
+) -> None:
+    """2.7.1 handed a null required member back in the answer, and raised a raw
+    AttributeError for metadata's `schema` or `sample` sent as an array."""
+    monkeypatch.setattr(_core, "_BACKOFF_BASE", 0.0)
+    path, body = UNREADABLE_MEMBERS[case]
+    stub = Stub({path: {"body": body}})
+    client = make_client(transport=stub.transport, retries=2)
+
+    with pytest.raises(InternetDataError) as caught:
+        JSON_CALLS[MEMBER_CALLS.get(path, "checksums")](client)
+
+    assert (caught.value.kind, caught.value.status) == ("server_error", 200)
+    assert len(stub.requests) == 3
+
+
+@pytest.mark.parametrize(
+    ("status", "body", "kind"),
+    [
+        (401, b"<html>401</html>", "unauthorized"),
+        (401, b"{}", "unauthorized"),
+        (403, b"", "forbidden"),
+        (404, b"<html>Not Found</html>", "bad_request"),
+        (400, b"null", "bad_request"),
+    ],
+)
+@pytest.mark.parametrize("call", JSON_CALLS)
+def test_a_4xx_is_classified_by_its_status_whatever_its_body(
+    make_client: ClientFactory, call: str, status: int, body: bytes, kind: str
+) -> None:
+    """A proxy's page on a 4xx is still the client's error, sent once. Read through the
+    generated decoder, it was a retried server error with no status (2.7.1)."""
+    stub = Stub({JSON_CALL_PATHS[call]: {"status": status, "raw": body}})
+    client = make_client(transport=stub.transport, retries=2)
+
+    with pytest.raises(InternetDataError) as caught:
+        JSON_CALLS[call](client)
+
+    assert (caught.value.kind, caught.value.status) == (kind, status)
+    assert len(stub.requests) == 1
+
+
+@pytest.mark.parametrize("call", JSON_CALLS)
+def test_a_5xx_page_is_a_retried_server_error_with_its_status(
+    make_client: ClientFactory, monkeypatch: pytest.MonkeyPatch, call: str
+) -> None:
+    monkeypatch.setattr(_core, "_BACKOFF_BASE", 0.0)
+    stub = Stub({JSON_CALL_PATHS[call]: {"status": 503, "raw": b"<html>503</html>"}})
+    client = make_client(transport=stub.transport, retries=2)
+
+    with pytest.raises(InternetDataError) as caught:
+        JSON_CALLS[call](client)
+
+    assert (caught.value.kind, caught.value.status) == ("server_error", 503)
+    assert len(stub.requests) == 3
+
+
 def test_a_server_error_is_retried_and_then_reported(make_client: ClientFactory) -> None:
     stub = Stub({LIST_PATH: {"status": 503, "body": {"rc": "UNAVAILABLE"}}})
     client = make_client(transport=stub.transport, retries=2)
@@ -374,7 +527,7 @@ def test_a_rate_limit_is_retried_and_honors_retry_after(make_client: ClientFacto
 
 
 @pytest.mark.parametrize(
-    "retry_after", ["2147484", "9223372036854775807", "1e400", "Fri, 31 Dec 9999 23:59:59 GMT"]
+    "retry_after", ["2147484", "9223372036854775807", "9" * 400, "Fri, 31 Dec 9999 23:59:59 GMT"]
 )
 def test_a_retry_after_past_the_ceiling_waits_the_backoff_and_stays_a_throttle(
     make_client: ClientFactory, monkeypatch: pytest.MonkeyPatch, retry_after: str
@@ -393,6 +546,69 @@ def test_a_retry_after_past_the_ceiling_waits_the_backoff_and_stays_a_throttle(
     assert len(stub.requests) == 2
 
 
+@pytest.mark.parametrize(
+    "retry_after",
+    [
+        "-1",
+        "x",
+        "tomorrow",
+        "+1",
+        "0x10",
+        "1_0",
+        "1e3",
+        "1.5",
+        "inf",
+        "1e400",
+        "2026-10-12T06:00:00Z",
+        "Mon, 12 Oct 2026 06:00:00 +0500",
+        "Mon, 12 Oct 2026 06:00:00 PST",
+        "12 Oct 2026 06:00:00 GMT",
+        "Mon, 12 Oct 26 06:00:00 GMT",
+        "Tue, 31 Nov 2026 10:00:00 GMT",
+        "Mon, 12 Oct 2026 25:61:61 GMT",
+    ],
+)
+def test_a_retry_after_that_is_neither_seconds_nor_an_http_date_is_a_spent_quota(
+    make_client: ClientFactory, retry_after: str
+) -> None:
+    """`float()` and `email.utils` read `+1` as a second, `1_0` as ten, `1e3` as a thousand
+    and a date in any zone (2.7.1). RFC 9110 admits digits, or a date in one of three
+    forms, in GMT."""
+    headers = {"Retry-After": retry_after}
+    stub = Stub({LIST_PATH: {"status": 429, "body": {"rc": "LIMITED"}, "headers": headers}})
+    # No retries, so a value misread as a long wait fails here rather than holding the run.
+    client = make_client(transport=stub.transport, retries=0)
+
+    with pytest.raises(InternetDataError) as caught:
+        client.database.list()
+
+    assert caught.value.kind == "quota_exceeded"
+    assert caught.value.retry_after_seconds is None
+
+
+@pytest.mark.parametrize(
+    "form",
+    [
+        lambda when: when.strftime("%a, %d %b %Y %H:%M:%S GMT"),
+        lambda when: when.strftime("%A, %d-%b-%y %H:%M:%S GMT"),
+        lambda when: when.strftime("%a %b ") + f"{when.day:2d}" + when.strftime(" %H:%M:%S %Y"),
+    ],
+    ids=["imf-fixdate", "rfc850", "asctime"],
+)
+def test_a_retry_after_date_is_read_in_each_of_rfc_9110s_three_forms(
+    form: Callable[[datetime.datetime], str],
+) -> None:
+    # Computed as the case runs: a date made up front can have passed by the time it is read.
+    when = datetime.datetime.now(datetime.UTC) + datetime.timedelta(seconds=100)
+    headers = httpx.Headers({"Retry-After": form(when)})
+
+    err = error_from_response(429, headers, None)
+
+    assert err.kind == "rate_limited"
+    assert err.retry_after_seconds is not None
+    assert 98 <= err.retry_after_seconds <= 101
+
+
 def test_a_retry_after_is_waited_as_given_up_to_the_ceiling() -> None:
     def throttled(seconds: float) -> InternetDataError:
         return InternetDataError("rate_limited", "RATE_LIMITED", 429, seconds)

{internetdata-2.7.0 → internetdata-2.7.2}/tests/test_conformance.py

@@ -245,7 +245,7 @@ def test_the_api_key_reaches_the_wire_under_the_bearer_scheme(
     assert stub.requests[0].headers.get("authorization") == f"Bearer {API_KEY}"
 
 
-@pytest.mark.parametrize("api_key", [None, ""])
+@pytest.mark.parametrize("api_key", [None, "", "   ", "\t", "\r\n"])
 def test_a_keyless_client_sends_no_authorization_header(
     make_client: ClientFactory, api_key: str | None
 ) -> None:
@@ -260,3 +260,26 @@ def test_a_keyless_client_sends_no_authorization_header(
     client.database.list()
 
     assert "authorization" not in stub.requests[0].headers
+
+
+def test_the_api_key_is_trimmed(make_client: ClientFactory) -> None:
+    """A key pasted with a line ending around it went out padded, which httpx refuses, so
+    every call failed as a retried network error with nothing sent (2.7.1)."""
+    stub = Stub({LIST_PATH: {"body": {"databases": []}}})
+    client = make_client(transport=stub.transport, api_key=f" {API_KEY}\r\n")
+
+    client.database.list()
+
+    assert stub.requests[0].headers.get("authorization") == f"Bearer {API_KEY}"
+
+
+@pytest.mark.parametrize(
+    "api_key", ["key\r\nX-Injected: 1", "ke\ty", "key\x00", "key\x7f", "k\ney"]
+)
+def test_a_control_character_in_the_api_key_is_refused_where_it_is_set(
+    make_client: ClientFactory, api_key: str
+) -> None:
+    """Accepted, a CR, LF or NUL failed every call as a retried network error with nothing
+    sent, and a tab or DEL went out on the wire inside the header (2.7.1)."""
+    with pytest.raises(ValueError, match="control character"):
+        make_client(api_key=api_key)