internetdata 2.1.0__tar.gz → 2.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: internetdata
-Version: 2.1.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,7 +167,7 @@ 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:
+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)
@@ -173,6 +175,8 @@ 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.1.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,7 +133,7 @@ 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:
+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)
@@ -139,6 +141,8 @@ 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.1.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.1.0"
+__version__ = "2.2.0"
 
 __all__ = [
+    "DATABASE_FORMATS",
     "DEFAULT_BASE_URL",
+    "LICENSE_TYPES",
+    "STANDINGS",
     "AsyncDatabaseApi",
     "AsyncInternetData",
     "Database",

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

@@ -7,6 +7,7 @@ import asyncio
 import contextlib
 import contextvars
 import json
+import math
 import os
 import threading
 from collections.abc import Awaitable, Callable, Iterator
@@ -105,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.
 

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

@@ -26,6 +26,7 @@ from ._core import (
     assert_whole_transfer,
     build_async_transfer_client,
     build_client,
+    check_timeout,
     checksums_of,
     databases_of,
     downloads_of,
@@ -73,6 +74,7 @@ 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

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

@@ -21,6 +21,7 @@ from ._core import (
     assert_whole_transfer,
     build_client,
     build_transfer_client,
+    check_timeout,
     checksums_of,
     databases_of,
     downloads_of,
@@ -55,12 +56,13 @@ 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.
+    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.
@@ -78,6 +80,7 @@ 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
@@ -133,7 +136,7 @@ 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`.
         """
 

{internetdata-2.1.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.1.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,

{internetdata-2.1.0 → internetdata-2.2.0}/tests/test_client.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import dataclasses
 import datetime
 import inspect
@@ -9,6 +10,7 @@ import time
 from collections.abc import Callable
 from typing import Any
 
+import attrs
 import httpx
 import pytest
 from helpers import (
@@ -26,7 +28,26 @@ from helpers import (
     settle,
 )
 
-from internetdata import AsyncInternetData, InternetData, InternetDataError, _core
+from internetdata import (
+    AsyncInternetData,
+    Database,
+    DatabaseMetadata,
+    DatabaseVersion,
+    Download,
+    InternetData,
+    InternetDataError,
+    MetadataColumn,
+    _core,
+)
+from internetdata._generated.models.database import Database as WireDatabase
+from internetdata._generated.models.database_metadata import (
+    DatabaseMetadata as WireDatabaseMetadata,
+)
+from internetdata._generated.models.database_metadata_column import (
+    DatabaseMetadataColumn as WireDatabaseMetadataColumn,
+)
+from internetdata._generated.models.database_version import DatabaseVersion as WireDatabaseVersion
+from internetdata._generated.models.download import Download as WireDownload
 
 METADATA = {
     "id": "bogon_ip_v1",
@@ -141,6 +162,47 @@ def test_a_licence_with_no_end_date_reads_as_none(make_client: ClientFactory) ->
 
     assert family.starts == datetime.datetime(2026, 1, 1, tzinfo=datetime.UTC)
     assert family.expires is None
+    assert family.renews_at is None
+    assert family.notice_due_at is None
+
+
+def test_a_rolling_license_carries_its_renewal_dates(make_client: ClientFactory) -> None:
+    served = database(
+        "bogon_ip",
+        renews_at="2027-01-01T00:00:00.000Z",
+        notice_due_at="2026-10-02T00:00:00.000Z",
+    )
+    stub = Stub({LIST_PATH: {"body": {"databases": [served]}}})
+    client = make_client(transport=stub.transport)
+
+    family = client.database.list()[0]
+
+    assert family.renews_at == datetime.datetime(2027, 1, 1, tzinfo=datetime.UTC)
+    assert family.notice_due_at == datetime.datetime(2026, 10, 2, tzinfo=datetime.UTC)
+
+
+@pytest.mark.parametrize(
+    ("wire", "ours"),
+    [
+        (WireDatabase, Database),
+        (WireDatabaseVersion, DatabaseVersion),
+        (WireDatabaseMetadata, DatabaseMetadata),
+        (WireDatabaseMetadataColumn, MetadataColumn),
+        (WireDownload, Download),
+    ],
+)
+def test_every_field_the_pinned_spec_serves_is_on_the_model(wire: Any, ours: Any) -> None:
+    """The staleness pin on the hand-written models.
+
+    They parse the keys they name and nothing else, so a field a re-pin adds reaches the
+    generated code and `raw` while the typed model never hears of it: `renews_at` and
+    `notice_due_at` sat that way from the 2026-09-09 re-pin until 2.2.0. The generated
+    classes come from the same pinned spec, which makes them the list to check against.
+    The generator suffixes a name that shadows a builtin with `_`.
+    """
+    served = {f.name.rstrip("_") for f in attrs.fields(wire)} - {"additional_properties"}
+    modeled = {f.name for f in dataclasses.fields(ours)} - {"raw"}
+    assert served - modeled == set(), f"{ours.__name__} lacks what the spec serves"
 
 
 def test_a_database_cannot_be_mutated(make_client: ClientFactory) -> None:
@@ -292,6 +354,22 @@ def test_the_default_timeout_is_thirty_seconds() -> None:
         assert inspect.signature(client).parameters["timeout"].default == 30
 
 
+@pytest.mark.parametrize("client", [InternetData, AsyncInternetData])
+@pytest.mark.parametrize("timeout", [0, -1, 0.0, float("nan"), float("inf"), "30", True])
+def test_a_timeout_no_attempt_can_meet_is_refused_when_the_client_is_built(
+    client: type[InternetData | AsyncInternetData], timeout: Any
+) -> None:
+    """Accepted, each of these failed every call instead, after the retries' backoff."""
+    with pytest.raises(ValueError, match="timeout"):
+        client(API_KEY, timeout=timeout)
+
+
+@pytest.mark.parametrize("timeout", [None, 0.25, 1, 30])
+def test_a_usable_timeout_builds_a_client(timeout: float | None) -> None:
+    InternetData(API_KEY, timeout=timeout).close()
+    asyncio.run(AsyncInternetData(API_KEY, timeout=timeout).aclose())
+
+
 # Refused before the network, and never retried: a typo is the caller's, not a failure of
 # the server's to wait out.
 def test_an_unpublished_format_is_refused_before_any_request(make_client: ClientFactory) -> None:

{internetdata-2.1.0 → internetdata-2.2.0}/tests/test_conformance.py

@@ -19,7 +19,7 @@ from helpers import (
     database,
 )
 
-from internetdata import InternetDataError
+from internetdata import DATABASE_FORMATS, LICENSE_TYPES, STANDINGS, InternetDataError
 
 # One live grant, one that has run out, and one never bought. Between them these cover
 # every value the corpus pins for `standing` and `license_type`.
@@ -65,21 +65,32 @@ def test_every_error_shape_maps_to_the_same_kind_in_every_language(
             assert err.retry_after_seconds == expect["retryAfterSeconds"], name
 
 
-# The one that has caught three of four bindings: 404 is a CLIENT error. Mapping
-# 400/401/403/429 by name and letting the rest fall through to a retryable server_error
-# means an unknown database id is asked for three times before failing.
-def test_a_404_is_never_retried(make_client: ClientFactory) -> None:
-    for case in TESTDATA["errors"]:
-        if case["status"] != 404:
-            continue
-        stub = Stub({METADATA_PATH: {"status": 404, "body": case["body"]}})
+# The one that has caught three of four bindings: every 4xx but a 429 carrying Retry-After
+# is the CALLER's, and classifying by an enumerated list lets the rest (the corpus's 422)
+# fall through to a retryable server_error. Asserted with retries ON and by counting
+# requests: with retries off, one request is guaranteed and a wrong classifier passes.
+def test_no_client_error_is_ever_retried(make_client: ClientFactory) -> None:
+    cases = [case for case in TESTDATA["errors"] if not case["expect"]["retryable"]]
+    assert any(case["name"] == "unlisted-4xx-is-not-retryable" for case in cases)
+
+    for case in cases:
+        stub = Stub(
+            {
+                METADATA_PATH: {
+                    "status": case["status"],
+                    "body": case["body"],
+                    "headers": case["headers"],
+                }
+            }
+        )
         client = make_client(transport=stub.transport, retries=3)
 
         with pytest.raises(InternetDataError) as caught:
             client.database.metadata("nope_v1")
 
-        assert caught.value.retryable is False, case["name"]
+        # The count first: a retried case also ends on an error, just a later one.
         assert len(stub.requests) == 1, f"{case['name']}: issued {len(stub.requests)} requests"
+        assert caught.value.kind == case["expect"]["kind"], case["name"]
 
 
 # Both arrive as 429 and the header is the only thing separating them, so a client that
@@ -118,7 +129,7 @@ def test_the_catalog_carries_every_standing_and_license_type_the_corpus_pins(
     assert served_rights <= set(TESTDATA["license_type"]), (
         f"undocumented license_type right in {served_rights}"
     )
-    # Null when there is no licence, which is a different answer from any of the three.
+    # Null when there is no license, which is a different answer from any of the three.
     assert [f.license_type for f in families][-1] is None
     for family in families:
         assert family.versions, f"{family.base} carries no versions"
@@ -128,6 +139,17 @@ def test_the_catalog_carries_every_standing_and_license_type_the_corpus_pins(
             )
 
 
+def test_the_runtime_vocabularies_are_the_pinned_specs() -> None:
+    """The staleness pin on three hand-written Literals.
+
+    `emit.mjs` reads the corpus's lists out of the pinned spec, so a re-pin that widens a
+    vocabulary turns this red instead of leaving a published value unnamed here.
+    """
+    assert sorted(DATABASE_FORMATS) == sorted(TESTDATA["formats"])
+    assert sorted(STANDINGS) == sorted(TESTDATA["standings"])
+    assert sorted(LICENSE_TYPES) == sorted(TESTDATA["license_type"])
+
+
 # The visibility contract. A private family is one commissioned for a single customer: the
 # server leaves it out of the listing entirely for anyone else, rather than including it
 # with standing 'unlicensed'. All this library has to do is not undo that, which is a real
@@ -161,7 +183,7 @@ def test_a_listing_is_never_reused_across_clients(make_client: ClientFactory) ->
     """Two keys are two organizations, and they do not see the same catalog.
 
     So there is no listing cache at all here, per instance or otherwise: a cached one
-    would be wrong the moment a licence is granted, and a shared one would show an
+    would be wrong the moment a license is granted, and a shared one would show an
     organization a family it is not allowed to know exists.
     """
     assert "a-listing-is-never-reused-across-clients" in TESTDATA["visibility"]["clientRules"]
@@ -172,7 +194,7 @@ def test_a_listing_is_never_reused_across_clients(make_client: ClientFactory) ->
     assert len(first.database.list()) == len(CATALOG)
     assert second.database.list() == [], "the second key answered from the first one's listing"
     assert len(stub.requests) == 2
-    # A repeat on the SAME client asks again too: a licence granted between two calls has
+    # A repeat on the SAME client asks again too: a license granted between two calls has
     # to show up.
     first.database.list()
     assert len(stub.requests) == 3
@@ -210,7 +232,7 @@ def test_the_api_key_reaches_the_wire_under_the_bearer_scheme(
 def test_a_keyless_client_sends_no_authorization_header(
     make_client: ClientFactory, api_key: str | None
 ) -> None:
-    """The key is optional because what this API serves without a licence is a product
+    """The key is optional because what this API serves without a license is a product
     decision, and a client that could not be built without one would have to change
     shape to follow it. What must never go out is `Bearer ` with nothing after it, which
     reads as a wrong key rather than as none.