internetdata 2.0.0__tar.gz → 2.2.0__tar.gz

{internetdata-2.0.0 → internetdata-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: internetdata
-Version: 2.0.0
+Version: 2.2.0
 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
@@ -72,7 +72,7 @@ with InternetData(api_key) as client:
 
 ### The catalog
 
-`list` answers database FAMILIES. A licence is held against a family, while a download names a specific version, so the ids the other calls take come from each family's `versions`:
+`list` answers database FAMILIES. A license is held against a family, while a download names a specific version, so the ids the other calls take come from each family's `versions`:
 
 ```python
 for family in client.database.list():
@@ -82,7 +82,9 @@ for family in client.database.list():
         print(version.id, version.formats)   # 'bogon_ip_v1' ('csvgz', 'mmdb')
 ```
 
-`standing` is `licensed`, `expired` or `unlicensed`, and `license_type` is what your licence lets you do with the data (`evaluation`, `standard`, `redistribute`, or `None` when there is no licence). A family you have never bought is still listed, as `unlicensed`, so you can see what else exists.
+`standing` is `licensed`, `expired` or `unlicensed`, and `license_type` is what your license lets you do with the data (`evaluation`, `standard`, `redistribute`, or `None` when there is no license). A family you have never bought is still listed, as `unlicensed`, so you can see what else exists.
+
+A rolling license also carries `renews_at`, when it next renews, and `notice_due_at`, the last day you can give notice of non-renewal for that term. Both are `None` when there is no license, when it has no defined term, or when `expires` sets a hard stop instead. `DATABASE_FORMATS`, `STANDINGS` and `LICENSE_TYPES` hold the published values at runtime, for checking one that came from a flag or a form before you make a call.
 
 ### What is inside a build
 
@@ -165,6 +167,16 @@ except InternetDataError as err:
 
 `kind` is one of `bad_request`, `unauthorized`, `forbidden`, `rate_limited`, `quota_exceeded`, `server_error` or `network`. `message` is the API's own result code, passed through as it was sent, so you can switch on `NOT_LICENSED` against `LICENSE_EXPIRED` without reading the status.
 
+A request that runs past its `timeout` fails with `network`, and is retried like any other network failure. The default is 30 seconds per attempt, body included, so a retried call can take longer in total. A database transfer is exempt, so `download` and `download_bytes` are never cut off part way through a large file. Set it on the client, in seconds, or pass `None` for no bound. Anything else that is not a number greater than 0 raises `ValueError` when the client is built:
+
+```python
+client = InternetData(api_key, timeout=10)
+```
+
+**Changed in 2.1.0:** the default was 10 seconds, and it bounded each read of a response rather than the whole attempt, so a response trickling in slowly could run past it for as long as the server kept sending.
+
+**Changed in 2.2.0:** a timeout of 0 or less, NaN or a string used to be accepted, and failed every call.
+
 Note that `rate_limited` and `quota_exceeded` both arrive as HTTP 429 and are not the same thing. A rate limit is the API facing a traffic burst, and retrying later works; a spent quota needs your allowance raised or the window to roll over. The library retries rate limits for you, and server and network failures, but never a spent quota or anything else you sent.
 
 ## Other Libraries

{internetdata-2.0.0 → internetdata-2.2.0}/README.md

@@ -38,7 +38,7 @@ with InternetData(api_key) as client:
 
 ### The catalog
 
-`list` answers database FAMILIES. A licence is held against a family, while a download names a specific version, so the ids the other calls take come from each family's `versions`:
+`list` answers database FAMILIES. A license is held against a family, while a download names a specific version, so the ids the other calls take come from each family's `versions`:
 
 ```python
 for family in client.database.list():
@@ -48,7 +48,9 @@ for family in client.database.list():
         print(version.id, version.formats)   # 'bogon_ip_v1' ('csvgz', 'mmdb')
 ```
 
-`standing` is `licensed`, `expired` or `unlicensed`, and `license_type` is what your licence lets you do with the data (`evaluation`, `standard`, `redistribute`, or `None` when there is no licence). A family you have never bought is still listed, as `unlicensed`, so you can see what else exists.
+`standing` is `licensed`, `expired` or `unlicensed`, and `license_type` is what your license lets you do with the data (`evaluation`, `standard`, `redistribute`, or `None` when there is no license). A family you have never bought is still listed, as `unlicensed`, so you can see what else exists.
+
+A rolling license also carries `renews_at`, when it next renews, and `notice_due_at`, the last day you can give notice of non-renewal for that term. Both are `None` when there is no license, when it has no defined term, or when `expires` sets a hard stop instead. `DATABASE_FORMATS`, `STANDINGS` and `LICENSE_TYPES` hold the published values at runtime, for checking one that came from a flag or a form before you make a call.
 
 ### What is inside a build
 
@@ -131,6 +133,16 @@ except InternetDataError as err:
 
 `kind` is one of `bad_request`, `unauthorized`, `forbidden`, `rate_limited`, `quota_exceeded`, `server_error` or `network`. `message` is the API's own result code, passed through as it was sent, so you can switch on `NOT_LICENSED` against `LICENSE_EXPIRED` without reading the status.
 
+A request that runs past its `timeout` fails with `network`, and is retried like any other network failure. The default is 30 seconds per attempt, body included, so a retried call can take longer in total. A database transfer is exempt, so `download` and `download_bytes` are never cut off part way through a large file. Set it on the client, in seconds, or pass `None` for no bound. Anything else that is not a number greater than 0 raises `ValueError` when the client is built:
+
+```python
+client = InternetData(api_key, timeout=10)
+```
+
+**Changed in 2.1.0:** the default was 10 seconds, and it bounded each read of a response rather than the whole attempt, so a response trickling in slowly could run past it for as long as the server kept sending.
+
+**Changed in 2.2.0:** a timeout of 0 or less, NaN or a string used to be accepted, and failed every call.
+
 Note that `rate_limited` and `quota_exceeded` both arrive as HTTP 429 and are not the same thing. A rate limit is the API facing a traffic burst, and retrying later works; a spent quota needs your allowance raised or the window to roll over. The library retries rate limits for you, and server and network failures, but never a spent quota or anything else you sent.
 
 ## Other Libraries

{internetdata-2.0.0 → internetdata-2.2.0}/src/internetdata/__init__.py

@@ -15,6 +15,9 @@ from .aio import AsyncDatabaseApi, AsyncInternetData
 from .client import DatabaseApi, InternetData
 from .errors import ErrorKind, InternetDataError
 from .models import (
+    DATABASE_FORMATS,
+    LICENSE_TYPES,
+    STANDINGS,
     Database,
     DatabaseMetadata,
     DatabaseVersion,
@@ -26,10 +29,13 @@ from .models import (
     Standing,
 )
 
-__version__ = "2.0.0"
+__version__ = "2.2.0"
 
 __all__ = [
+    "DATABASE_FORMATS",
     "DEFAULT_BASE_URL",
+    "LICENSE_TYPES",
+    "STANDINGS",
     "AsyncDatabaseApi",
     "AsyncInternetData",
     "Database",

{internetdata-2.0.0 → internetdata-2.2.0}/src/internetdata/_core.py

@@ -1,13 +1,18 @@
-"""Plumbing the sync and the async client both need: transport wiring, response
-unwrapping, and the retry policy."""
+"""Plumbing the sync and the async client both need: transport wiring, the deadline on
+each attempt, response unwrapping, and the retry policy."""
 
 from __future__ import annotations
 
+import asyncio
 import contextlib
+import contextvars
 import json
+import math
 import os
+import threading
 from collections.abc import Awaitable, Callable, Iterator
 from pathlib import Path
+from types import ModuleType
 from typing import IO, Any, TypeVar, cast
 
 import httpx
@@ -19,7 +24,7 @@ from .models import Database, Download, to_database, to_download
 
 DEFAULT_BASE_URL = "https://internetdata.io"
 DEFAULT_RETRIES = 2
-DEFAULT_TIMEOUT = 10.0
+DEFAULT_TIMEOUT = 30.0
 DEFAULT_DOWNLOADS_LIMIT = 50
 
 # One chunk of a transfer, and therefore the ceiling on what a download of any size
@@ -101,6 +106,30 @@ def build_async_transfer_client(
     )
 
 
+def check_timeout(timeout: float | None) -> float | None:
+    """`timeout`, once it is a bound an attempt can meet.
+
+    Refused where it is SET, because nothing downstream refuses it: zero, a negative
+    number, NaN or a string reached the first call and failed it, and every call after,
+    as a retried `network` error after three seconds of backoff, or for a string as a
+    `server_error` blaming the API. Infinity is refused too, since the sync client's wait
+    cannot hold it (`OverflowError`); None is the spelling for no bound.
+    """
+    if timeout is None:
+        return None
+    if (
+        isinstance(timeout, bool)
+        or not isinstance(timeout, int | float)
+        or not math.isfinite(timeout)
+        or timeout <= 0
+    ):
+        raise ValueError(
+            f"timeout must be a number of seconds greater than 0, or None for no bound, "
+            f"not {timeout!r}"
+        )
+    return timeout
+
+
 def storage_refusal(res: httpx.Response) -> InternetDataError:
     """What object storage refusing a download link becomes.
 
@@ -172,8 +201,10 @@ def send(call: Callable[[], Response[Any]]) -> Response[Any]:
     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 lambda does nothing but call the generated function, which is what keeps this
-    catch from swallowing a fault of our own.
+    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()
@@ -189,6 +220,91 @@ async def send_async(call: Callable[[], Awaitable[Response[Any]]]) -> Response[A
         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.
+
+    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)
+
+
+async def request_async(
+    endpoint: ModuleType, client: AuthenticatedClient, bound: float | None, **params: Any
+) -> Response[Any]:
+    """`request`, awaited."""
+
+    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 exchange(http: httpx.Client, req: httpx.Request, bound: float | None) -> httpx.Response:
+    """One attempt at `req`, its whole body read, finished within `bound` seconds or failed
+    as a `network` error.
+
+    httpx bounds each PHASE of a request (connect, write, every read), not the attempt, so a
+    body trickling in a byte at a time outlasts any timeout it is given. The attempt runs on
+    a thread of its own and the caller waits at most `bound` for it; one abandoned stops at
+    its next chunk, or at the per-phase bound `req` also carries.
+    """
+    if bound is None:
+        return http.send(req)
+    finished = threading.Event()
+    abandoned = threading.Event()
+    outcome: list[httpx.Response | BaseException] = []
+    context = contextvars.copy_context()
+
+    def attempt() -> None:
+        try:
+            outcome.append(context.run(_read_whole, http, req, abandoned))
+        except BaseException as exc:  # noqa: BLE001 - raised again on the caller's thread
+            outcome.append(exc)
+        finally:
+            finished.set()
+
+    threading.Thread(target=attempt, name="internetdata-attempt", daemon=True).start()
+    try:
+        if not finished.wait(bound):
+            raise _deadline_passed(bound)
+    finally:
+        abandoned.set()
+    if isinstance(outcome[0], BaseException):
+        raise outcome[0]
+    return outcome[0]
+
+
+async def exchange_async(
+    http: httpx.AsyncClient, req: httpx.Request, bound: float | None
+) -> httpx.Response:
+    """`exchange`, awaited. Cancelling the attempt closes its connection, so no thread is
+    needed to leave it behind."""
+    if bound is None:
+        return await http.send(req)
+    deadline = asyncio.timeout(bound)
+    try:
+        async with deadline:
+            return await http.send(req)
+    except TimeoutError:
+        if not deadline.expired():
+            raise
+        raise _deadline_passed(bound) from None
+
+
 def malformed(exc: Exception) -> InternetDataError:
     return InternetDataError("server_error", f"malformed response from the API: {exc}")
 
@@ -273,6 +389,41 @@ def retry_delay(err: InternetDataError, attempt: int, retries: int) -> float | N
     return _BACKOFF_BASE * (2.0**attempt)
 
 
+def _read_whole(
+    http: httpx.Client, req: httpx.Request, abandoned: threading.Event
+) -> httpx.Response:
+    res = http.send(req, stream=True)
+    try:
+        if isinstance(res.stream, httpx.SyncByteStream):
+            res.stream = _Abandonable(res.stream, abandoned, req)
+        res.read()
+    finally:
+        res.close()
+    return res
+
+
+class _Abandonable(httpx.SyncByteStream):
+    def __init__(
+        self, inner: httpx.SyncByteStream, abandoned: threading.Event, req: httpx.Request
+    ) -> None:
+        self._inner = inner
+        self._abandoned = abandoned
+        self._req = req
+
+    def __iter__(self) -> Iterator[bytes]:
+        for chunk in self._inner:
+            if self._abandoned.is_set():
+                raise httpx.ReadError("abandoned once its deadline passed", request=self._req)
+            yield chunk
+
+    def close(self) -> None:
+        self._inner.close()
+
+
+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`.

{internetdata-2.0.0 → internetdata-2.2.0}/src/internetdata/aio.py

@@ -26,14 +26,15 @@ from ._core import (
     assert_whole_transfer,
     build_async_transfer_client,
     build_client,
+    check_timeout,
     checksums_of,
     databases_of,
     downloads_of,
     parse_body,
     part_file,
     redirect_location,
+    request_async,
     retry_delay,
-    send_async,
     storage_refusal,
     unwrap,
 )
@@ -73,9 +74,11 @@ class AsyncInternetData:
         timeout: float | None = DEFAULT_TIMEOUT,
         transport: httpx.AsyncBaseTransport | None = None,
     ) -> None:
+        timeout = check_timeout(timeout)
         self._client = build_client(api_key, base_url, timeout, transport)
         self._transfer = build_async_transfer_client(timeout, transport)
         self._retries = retries
+        self._timeout = timeout
         self.database = AsyncDatabaseApi(self)
 
     async def aclose(self) -> None:
@@ -128,7 +131,7 @@ class AsyncDatabaseApi:
         """
 
         async def call() -> builtins.list[Database]:
-            res = await send_async(lambda: list_databases.asyncio_detailed(client=self._client))
+            res = await request_async(list_databases, self._client, self._owner._timeout)
             return parse_body(unwrap(res), databases_of)
 
         return await self._retrying(call)
@@ -137,8 +140,8 @@ class AsyncDatabaseApi:
         """What is inside one database: freshness, row count, columns, samples and sizes."""
 
         async def call() -> DatabaseMetadata:
-            res = await send_async(
-                lambda: database_metadata_v2.asyncio_detailed(client=self._client, id=database_id)
+            res = await request_async(
+                database_metadata_v2, self._client, self._owner._timeout, id=database_id
             )
             return parse_body(unwrap(res), to_metadata)
 
@@ -148,12 +151,12 @@ class AsyncDatabaseApi:
         """Every checksum published for one database file, keyed by algorithm."""
 
         async def call() -> dict[str, str]:
-            res = await send_async(
-                lambda: database_checksum_v2.asyncio_detailed(
-                    client=self._client,
-                    id=database_id,
-                    format_=DatabaseFormat(format),
-                )
+            res = await request_async(
+                database_checksum_v2,
+                self._client,
+                self._owner._timeout,
+                id=database_id,
+                format_=DatabaseFormat(format),
             )
             return parse_body(unwrap(res), checksums_of)
 
@@ -163,8 +166,8 @@ class AsyncDatabaseApi:
         """Your organization's recent download attempts, newest first."""
 
         async def call() -> builtins.list[Download]:
-            res = await send_async(
-                lambda: list_downloads.asyncio_detailed(client=self._client, limit=limit)
+            res = await request_async(
+                list_downloads, self._client, self._owner._timeout, limit=limit
             )
             return parse_body(unwrap(res), downloads_of)
 
@@ -181,12 +184,12 @@ class AsyncDatabaseApi:
         """
 
         async def call() -> str:
-            res = await send_async(
-                lambda: download_database_v2.asyncio_detailed(
-                    client=self._client,
-                    id=database_id,
-                    format_=DatabaseFormat(format),
-                )
+            res = await request_async(
+                download_database_v2,
+                self._client,
+                self._owner._timeout,
+                id=database_id,
+                format_=DatabaseFormat(format),
             )
             return redirect_location(res)
 

{internetdata-2.0.0 → internetdata-2.2.0}/src/internetdata/client.py

@@ -21,14 +21,15 @@ from ._core import (
     assert_whole_transfer,
     build_client,
     build_transfer_client,
+    check_timeout,
     checksums_of,
     databases_of,
     downloads_of,
     parse_body,
     part_file,
     redirect_location,
+    request,
     retry_delay,
-    send,
     storage_refusal,
     unwrap,
 )
@@ -55,9 +56,14 @@ class InternetData:
     Every database published today is licensed, so create a key carrying the
     `db.download` scope in the console and pass it in. The argument is optional
     nonetheless, and an absent or empty one sends no `Authorization` header at all
-    rather than an empty one: what this API serves without a licence is a product
+    rather than an empty one: what this API serves without a license is a product
     decision, not the client's to refuse.
 
+    `timeout` is how long one attempt at a request may take, in seconds, body included, so a
+    call that is retried can take longer in total; None means no bound, and a database
+    transfer is exempt. Anything else that is not a finite number greater than 0 is a
+    `ValueError` here, rather than a failure of every call.
+
     Holds an HTTP connection pool, so use it as a context manager or call `close()` when
     you are done with it.
     """
@@ -74,9 +80,11 @@ class InternetData:
         timeout: float | None = DEFAULT_TIMEOUT,
         transport: httpx.BaseTransport | None = None,
     ) -> None:
+        timeout = check_timeout(timeout)
         self._client = build_client(api_key, base_url, timeout, transport)
         self._transfer = build_transfer_client(timeout, transport)
         self._retries = retries
+        self._timeout = timeout
         self.database = DatabaseApi(self)
 
     def close(self) -> None:
@@ -128,12 +136,12 @@ class DatabaseApi:
         customer. Nothing is cached and nothing is reconstructed here - what you get is
         what the server sent for the key you are holding.
 
-        A licence covers a FAMILY, while a download names a version, so the ids for the
+        A license covers a FAMILY, while a download names a version, so the ids for the
         other calls come from each entry's `versions`.
         """
 
         def call() -> builtins.list[Database]:
-            res = send(lambda: list_databases.sync_detailed(client=self._client))
+            res = request(list_databases, self._client, self._owner._timeout)
             return parse_body(unwrap(res), databases_of)
 
         return self._retrying(call)
@@ -146,9 +154,7 @@ class DatabaseApi:
         """
 
         def call() -> DatabaseMetadata:
-            res = send(
-                lambda: database_metadata_v2.sync_detailed(client=self._client, id=database_id)
-            )
+            res = request(database_metadata_v2, self._client, self._owner._timeout, id=database_id)
             return parse_body(unwrap(res), to_metadata)
 
         return self._retrying(call)
@@ -161,12 +167,12 @@ class DatabaseApi:
         """
 
         def call() -> dict[str, str]:
-            res = send(
-                lambda: database_checksum_v2.sync_detailed(
-                    client=self._client,
-                    id=database_id,
-                    format_=DatabaseFormat(format),
-                )
+            res = request(
+                database_checksum_v2,
+                self._client,
+                self._owner._timeout,
+                id=database_id,
+                format_=DatabaseFormat(format),
             )
             return parse_body(unwrap(res), checksums_of)
 
@@ -180,7 +186,7 @@ class DatabaseApi:
         """
 
         def call() -> builtins.list[Download]:
-            res = send(lambda: list_downloads.sync_detailed(client=self._client, limit=limit))
+            res = request(list_downloads, self._client, self._owner._timeout, limit=limit)
             return parse_body(unwrap(res), downloads_of)
 
         return self._retrying(call)
@@ -196,12 +202,12 @@ class DatabaseApi:
         """
 
         def call() -> str:
-            res = send(
-                lambda: download_database_v2.sync_detailed(
-                    client=self._client,
-                    id=database_id,
-                    format_=DatabaseFormat(format),
-                )
+            res = request(
+                download_database_v2,
+                self._client,
+                self._owner._timeout,
+                id=database_id,
+                format_=DatabaseFormat(format),
             )
             return redirect_location(res)
 

{internetdata-2.0.0 → internetdata-2.2.0}/src/internetdata/models.py

@@ -11,9 +11,12 @@ from __future__ import annotations
 
 import datetime
 from dataclasses import dataclass, field
-from typing import Any, Literal
+from typing import Any, Literal, get_args
 
 __all__ = [
+    "DATABASE_FORMATS",
+    "LICENSE_TYPES",
+    "STANDINGS",
     "Database",
     "DatabaseMetadata",
     "DatabaseVersion",
@@ -37,7 +40,20 @@ Standing = Literal["licensed", "expired", "unlicensed"]
 """Where your organization stands with one database family."""
 
 LicenseType = Literal["evaluation", "standard", "redistribute"]
-"""What a licence permits you to do with the data. `None` when there is no licence."""
+"""What a license permits you to do with the data. `None` when there is no license."""
+
+DATABASE_FORMATS: tuple[Format, ...] = get_args(Format)
+"""Every `Format`, at runtime.
+
+A `Literal` is erased to nothing a program can check against, so a format read from a
+flag, a form or a config file has these to be tested against before a call.
+"""
+
+STANDINGS: tuple[Standing, ...] = get_args(Standing)
+"""Every `Standing`, at runtime."""
+
+LICENSE_TYPES: tuple[LicenseType, ...] = get_args(LicenseType)
+"""Every `LicenseType`, at runtime. `None`, for no license, is not one of them."""
 
 Outcome = Literal["ok", "unauthorized", "denied", "expired", "unknown", "unavailable"]
 """How one download attempt ended, refusals included."""
@@ -49,7 +65,7 @@ class DatabaseVersion:
 
     Old versions are frozen rather than migrated, so several stay downloadable at once.
     `id` is what `download`, `checksums` and `metadata` take; the family `base` is what a
-    licence is held against.
+    license is held against.
     """
 
     id: str
@@ -60,13 +76,18 @@ class DatabaseVersion:
 
 @dataclass(frozen=True, slots=True)
 class Database:
-    """One database FAMILY, with your organization's licence beside it.
+    """One database FAMILY, with your organization's license beside it.
 
     A family your organization has never licensed is still listed, with `standing` set to
     `unlicensed`, so you can see what else exists. A family commissioned for a single
     customer is a different matter: it is absent from this listing entirely for everyone
     who does not license it. Absence here means "not yours to see", never "does not
     exist", so the catalog is not the same document for every key.
+
+    A rolling license carries `renews_at`, when it next renews, and `notice_due_at`, the
+    last day notice of non-renewal can be given for the term ending then. Both are None
+    when there is no license, when it has no defined term, or when `expires` sets a hard
+    stop instead; `notice_due_at` is None too when the agreement records no notice period.
     """
 
     base: str
@@ -76,6 +97,10 @@ class Database:
     license_type: LicenseType | None
     starts: datetime.datetime | None
     expires: datetime.datetime | None
+    # Keyword-only with a default, so a Database built by hand before 2.2.0 still builds;
+    # the parser always sets both.
+    renews_at: datetime.datetime | None = field(default=None, kw_only=True)
+    notice_due_at: datetime.datetime | None = field(default=None, kw_only=True)
     versions: tuple[DatabaseVersion, ...]
     raw: dict[str, Any] = field(default_factory=dict)
 
@@ -137,6 +162,8 @@ def to_database(body: dict[str, Any]) -> Database:
         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"]),
         raw=body,
     )
@@ -185,7 +212,7 @@ def to_download(body: dict[str, Any]) -> Download:
 
 
 def _datetime(value: Any) -> datetime.datetime | None:
-    """A NULLABLE wire timestamp. A licence with no end date carries `expires: null`.
+    """A NULLABLE wire timestamp. A license with no end date carries `expires: null`.
 
     `fromisoformat` only learned to read a trailing `Z` in 3.11, which is one of the
     three reasons this package floors there. A value that is neither null nor readable

{internetdata-2.0.0 → internetdata-2.2.0}/testdata/testdata.json

@@ -27,7 +27,7 @@
       }
     },
     {
-      "name": "licence-lapsed",
+      "name": "license-lapsed",
       "status": 403,
       "headers": {},
       "body": {
@@ -78,6 +78,20 @@
         "message": "INVALID_FORMAT"
       }
     },
+    {
+      "name": "unlisted-4xx-is-not-retryable",
+      "why": "The RANGE is the rule, not a list of statuses. An SDK that enumerated 400 and 404 passed every other case here while a 422 fell through to the retryable server_error default.",
+      "status": 422,
+      "headers": {},
+      "body": {
+        "rc": "INVALID_REQUEST"
+      },
+      "expect": {
+        "kind": "bad_request",
+        "retryable": false,
+        "message": "INVALID_REQUEST"
+      }
+    },
     {
       "name": "rate-limited-transient",
       "status": 429,