internetdata 2.7.1__tar.gz → 2.7.3__tar.gz

{internetdata-2.7.1 → internetdata-2.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: internetdata
-Version: 2.7.1
+Version: 2.7.3
 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.1 → internetdata-2.7.3}/spec/openapi.yaml

@@ -12,7 +12,7 @@ info:
     email: support@internetdata.io
     url: https://internetdata.io
   termsOfService: https://internetdata.io/terms
-  version: 2026.10.09
+  version: 2026.10.13
 servers:
   - url: https://internetdata.io
 tags:
@@ -29,8 +29,9 @@ tags:
 
       Access is granted by CONTRACT, one dataset family at a time: there is no
       self-service purchase and no subscription behind it. The Open databases
-      are the exception: any organization downloads one with its key, licensed
-      or not, under CC BY-SA 4.0. `list` marks them `open`.
+      are licensed to every organization from the start, a `standard` license
+      to each, and are free under CC BY-SA 4.0 besides. `list` marks them
+      `open`.
 
       A successful download answers `302` with a time-limited URL pointing
       straight at object storage. Follow the redirect (`curl -L`); the link
@@ -60,7 +61,6 @@ paths:
         The whole published catalog, with your organization's license beside
         each entry, so `standing` says whether a database is yours today
         (`licensed`), was (`expired`), or has never been bought (`unlicensed`).
-        An `open` database downloads whatever its `standing`.
       security:
         - ApiKeyQueryAuth: []
         - ApiKeyHeaderAuth: []
@@ -902,8 +902,7 @@ components:
       description: |
         Where your license for a database family stands today. `licensed` is a
         live grant, `expired` one whose term has ended, and `unlicensed` a
-        database published but never bought. An Open database (`open`)
-        downloads whatever this says.
+        database published but never bought.
       enum:
         - licensed
         - expired
@@ -942,11 +941,11 @@ components:
         open:
           type: boolean
           description: |
-            An Open database: any organization downloads it, and fetches its
-            checksums, with no license, under CC BY-SA 4.0 (credit
-            InternetData, https://internetdata.io, and share what you build
-            from it under the same license). `standing` still reports your
-            own license, which grants more where you hold one.
+            An Open database: free under CC BY-SA 4.0 (credit InternetData,
+            https://internetdata.io, and share what you build from it under
+            the same license). Every organization holds a `standard` license
+            to it from the start, which `standing` and `license_type` report
+            like any other.
         license_type:
           type: string
           nullable: true
@@ -1056,9 +1055,7 @@ components:
         open:
           type: boolean
           description: |
-            Taken under the Open license rather than one of your licenses: an
-            Open database downloaded while your organization held no license
-            in term for it.
+            A download of an Open database.
         bytes:
           type: integer
           format: int64
@@ -1647,7 +1644,7 @@ components:
     V2NotLicensed:
       description: |
         Your organization holds no license for this database, or its term has
-        ended. Never for an Open database.
+        ended.
         `rc`: `NOT_LICENSED`, `LICENSE_EXPIRED`.
       content:
         application/json:

{internetdata-2.7.1 → internetdata-2.7.3}/src/internetdata/__init__.py

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

{internetdata-2.7.1 → internetdata-2.7.3}/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.1 → internetdata-2.7.3}/src/internetdata/_generated/api/database_v_2/list_databases.py

@@ -59,7 +59,6 @@ def sync_detailed(
      The whole published catalog, with your organization's license beside
     each entry, so `standing` says whether a database is yours today
     (`licensed`), was (`expired`), or has never been bought (`unlicensed`).
-    An `open` database downloads whatever its `standing`.
 
     Raises:
         errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
@@ -87,7 +86,6 @@ def sync(
      The whole published catalog, with your organization's license beside
     each entry, so `standing` says whether a database is yours today
     (`licensed`), was (`expired`), or has never been bought (`unlicensed`).
-    An `open` database downloads whatever its `standing`.
 
     Raises:
         errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
@@ -111,7 +109,6 @@ async def asyncio_detailed(
      The whole published catalog, with your organization's license beside
     each entry, so `standing` says whether a database is yours today
     (`licensed`), was (`expired`), or has never been bought (`unlicensed`).
-    An `open` database downloads whatever its `standing`.
 
     Raises:
         errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
@@ -137,7 +134,6 @@ async def asyncio(
      The whole published catalog, with your organization's license beside
     each entry, so `standing` says whether a database is yours today
     (`licensed`), was (`expired`), or has never been bought (`unlicensed`).
-    An `open` database downloads whatever its `standing`.
 
     Raises:
         errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.

{internetdata-2.7.1 → internetdata-2.7.3}/src/internetdata/_generated/models/database.py

@@ -31,13 +31,12 @@ class Database:
             summary (str): One line on what the newest version contains.
             standing (Standing): Where your license for a database family stands today. `licensed` is a
                 live grant, `expired` one whose term has ended, and `unlicensed` a
-                database published but never bought. An Open database (`open`)
-                downloads whatever this says.
-            open_ (bool): An Open database: any organization downloads it, and fetches its
-                checksums, with no license, under CC BY-SA 4.0 (credit
-                InternetData, https://internetdata.io, and share what you build
-                from it under the same license). `standing` still reports your
-                own license, which grants more where you hold one.
+                database published but never bought.
+            open_ (bool): An Open database: free under CC BY-SA 4.0 (credit InternetData,
+                https://internetdata.io, and share what you build from it under
+                the same license). Every organization holds a `standard` license
+                to it from the start, which `standing` and `license_type` report
+                like any other.
             license_type (DatabaseLicenseTypeType1 | DatabaseLicenseTypeType2Type1 | DatabaseLicenseTypeType3Type1 | None):
                 What your license permits you to do with the data. Null when there
                 is no license, which is every family with standing `unlicensed`.

{internetdata-2.7.1 → internetdata-2.7.3}/src/internetdata/_generated/models/download.py

@@ -21,9 +21,7 @@ class Download:
         format_ (str):
         outcome (DownloadOutcome):
         sample (bool): The evaluation sample rather than the database itself.
-        open_ (bool): Taken under the Open license rather than one of your licenses: an
-            Open database downloaded while your organization held no license
-            in term for it.
+        open_ (bool): A download of an Open database.
         bytes_ (int | None): Object size at redirect time, NOT bytes delivered: the transfer is a
             presigned redirect straight to object storage, so we never observe
             how much of it was taken.

{internetdata-2.7.1 → internetdata-2.7.3}/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.1 → internetdata-2.7.3}/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.1 → internetdata-2.7.3}/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