internetdata 2.2.0__tar.gz → 2.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: internetdata
-Version: 2.2.0
+Version: 2.3.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
@@ -167,12 +167,15 @@ 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:
+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` where it is set:
 
 ```python
 client = InternetData(api_key, timeout=10)
+catalog = client.database.list(timeout=2)
 ```
 
+From 2.3.0, `list`, `metadata`, `checksums`, `downloads` and `download_url` each take a keyword-only `timeout` in seconds, bounding each attempt at that one call in place of the client's; `None` there means the client's own rather than no bound. `download` and `download_bytes` deliberately take none and raise `TypeError` if handed one, rather than accepting it and quietly doing nothing: a transfer runs to gigabytes and minutes, so any bound that suits a JSON call would abandon a healthy download. `download_url` does take one, because minting the link is an ordinary API request - it bounds that request, not whatever you do with the link afterwards.
+
 **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.

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

@@ -133,12 +133,15 @@ 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:
+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` where it is set:
 
 ```python
 client = InternetData(api_key, timeout=10)
+catalog = client.database.list(timeout=2)
 ```
 
+From 2.3.0, `list`, `metadata`, `checksums`, `downloads` and `download_url` each take a keyword-only `timeout` in seconds, bounding each attempt at that one call in place of the client's; `None` there means the client's own rather than no bound. `download` and `download_bytes` deliberately take none and raise `TypeError` if handed one, rather than accepting it and quietly doing nothing: a transfer runs to gigabytes and minutes, so any bound that suits a JSON call would abandon a healthy download. `download_url` does take one, because minting the link is an ordinary API request - it bounds that request, not whatever you do with the link afterwards.
+
 **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.

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

@@ -29,7 +29,7 @@ from .models import (
     Standing,
 )
 
-__version__ = "2.2.0"
+__version__ = "2.3.0"
 
 __all__ = [
     "DATABASE_FORMATS",

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

@@ -96,6 +96,10 @@ class AsyncInternetData:
     ) -> None:
         await self.aclose()
 
+    # A per-call timeout, checked, or the client's own when the call gave none.
+    def _bound(self, timeout: float | None) -> float | None:
+        return self._timeout if timeout is None else check_timeout(timeout)
+
     async def _retrying(self, call: Callable[[], Awaitable[T]], retries: int) -> T:
         attempt = 0
         while True:
@@ -115,12 +119,17 @@ class AsyncDatabaseApi:
 
     `list` is a method here, which shadows the builtin for everything else in the class
     body, so the return annotations name `builtins.list` explicitly.
+
+    Every call here that asks the API a question takes `timeout`, in seconds, bounding
+    each ATTEMPT of that call alone and overriding the client's. The two transfers take
+    none and refuse one rather than ignoring it: a database runs to gigabytes and minutes,
+    so any bound that suits a JSON call would abandon a healthy download.
     """
 
     def __init__(self, owner: AsyncInternetData) -> None:
         self._owner = owner
 
-    async def list(self) -> builtins.list[Database]:
+    async def list(self, *, timeout: float | None = None) -> builtins.list[Database]:
         """The published catalog as YOUR organization may see it.
 
         Every family carries a `standing`, so one you have never bought is listed as
@@ -128,33 +137,43 @@ class AsyncDatabaseApi:
         single customer, which is absent entirely for everyone else. Nothing is cached
         and nothing is reconstructed here - what you get is what the server sent for the
         key you are holding.
+
+        `timeout` bounds each attempt at this call alone, in place of the client's.
         """
 
         async def call() -> builtins.list[Database]:
-            res = await request_async(list_databases, self._client, self._owner._timeout)
+            res = await request_async(list_databases, self._client, self._bound(timeout))
             return parse_body(unwrap(res), databases_of)
 
         return await self._retrying(call)
 
-    async def metadata(self, database_id: str) -> DatabaseMetadata:
-        """What is inside one database: freshness, row count, columns, samples and sizes."""
+    async def metadata(self, database_id: str, *, timeout: float | None = None) -> DatabaseMetadata:
+        """What is inside one database: freshness, row count, columns, samples and sizes.
+
+        `timeout` bounds each attempt at this call alone, in place of the client's.
+        """
 
         async def call() -> DatabaseMetadata:
             res = await request_async(
-                database_metadata_v2, self._client, self._owner._timeout, id=database_id
+                database_metadata_v2, self._client, self._bound(timeout), id=database_id
             )
             return parse_body(unwrap(res), to_metadata)
 
         return await self._retrying(call)
 
-    async def checksums(self, database_id: str, format: Format) -> dict[str, str]:
-        """Every checksum published for one database file, keyed by algorithm."""
+    async def checksums(
+        self, database_id: str, format: Format, *, timeout: float | None = None
+    ) -> dict[str, str]:
+        """Every checksum published for one database file, keyed by algorithm.
+
+        `timeout` bounds each attempt at this call alone, in place of the client's.
+        """
 
         async def call() -> dict[str, str]:
             res = await request_async(
                 database_checksum_v2,
                 self._client,
-                self._owner._timeout,
+                self._bound(timeout),
                 id=database_id,
                 format_=DatabaseFormat(format),
             )
@@ -162,18 +181,25 @@ class AsyncDatabaseApi:
 
         return await self._retrying(call)
 
-    async def downloads(self, limit: int = DEFAULT_DOWNLOADS_LIMIT) -> builtins.list[Download]:
-        """Your organization's recent download attempts, newest first."""
+    async def downloads(
+        self, limit: int = DEFAULT_DOWNLOADS_LIMIT, *, timeout: float | None = None
+    ) -> builtins.list[Download]:
+        """Your organization's recent download attempts, newest first.
+
+        `timeout` bounds each attempt at this call alone, in place of the client's.
+        """
 
         async def call() -> builtins.list[Download]:
             res = await request_async(
-                list_downloads, self._client, self._owner._timeout, limit=limit
+                list_downloads, self._client, self._bound(timeout), limit=limit
             )
             return parse_body(unwrap(res), downloads_of)
 
         return await self._retrying(call)
 
-    async def download_url(self, database_id: str, format: Format) -> str:
+    async def download_url(
+        self, database_id: str, format: Format, *, timeout: float | None = None
+    ) -> str:
         """The time-limited URL for one database file.
 
         The API answers `302` to object storage, and the link carries its own signature,
@@ -181,13 +207,16 @@ class AsyncDatabaseApi:
         rather than followed so the caller decides how to move a file that reaches
         gigabytes; the link authorizes the START of a transfer, so one already running is
         not interrupted when it lapses.
+
+        `timeout` bounds each attempt at MINTING the link, which is an ordinary API
+        request, and says nothing about the transfer you then run with it.
         """
 
         async def call() -> str:
             res = await request_async(
                 download_database_v2,
                 self._client,
-                self._owner._timeout,
+                self._bound(timeout),
                 id=database_id,
                 format_=DatabaseFormat(format),
             )
@@ -266,5 +295,8 @@ class AsyncDatabaseApi:
     def _client(self) -> AuthenticatedClient:
         return self._owner._client
 
+    def _bound(self, timeout: float | None) -> float | None:
+        return self._owner._bound(timeout)
+
     async def _retrying(self, call: Callable[[], Awaitable[T]]) -> T:
         return await self._owner._retrying(call, self._owner._retries)

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

@@ -61,8 +61,10 @@ class InternetData:
 
     `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.
+    transfer is exempt. Every `database` call but the two transfers also takes `timeout`,
+    which overrides the client's for that call alone. Anything else that is not a finite
+    number greater than 0 is a `ValueError` where it is set, 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.
@@ -102,6 +104,10 @@ class InternetData:
     ) -> None:
         self.close()
 
+    # A per-call timeout, checked, or the client's own when the call gave none.
+    def _bound(self, timeout: float | None) -> float | None:
+        return self._timeout if timeout is None else check_timeout(timeout)
+
     def _retrying(self, call: Callable[[], T], retries: int) -> T:
         attempt = 0
         while True:
@@ -121,12 +127,17 @@ class DatabaseApi:
 
     `list` is a method here, which shadows the builtin for everything else in the class
     body, so the return annotations name `builtins.list` explicitly.
+
+    Every call here that asks the API a question takes `timeout`, in seconds, bounding
+    each ATTEMPT of that call alone and overriding the client's. The two transfers take
+    none and refuse one rather than ignoring it: a database runs to gigabytes and minutes,
+    so any bound that suits a JSON call would abandon a healthy download.
     """
 
     def __init__(self, owner: InternetData) -> None:
         self._owner = owner
 
-    def list(self) -> builtins.list[Database]:
+    def list(self, *, timeout: float | None = None) -> builtins.list[Database]:
         """The published catalog as YOUR organization may see it.
 
         Every family carries a `standing`, so one you have never bought is listed as
@@ -138,39 +149,47 @@ class DatabaseApi:
 
         A license covers a FAMILY, while a download names a version, so the ids for the
         other calls come from each entry's `versions`.
+
+        `timeout` bounds each attempt at this call alone, in place of the client's.
         """
 
         def call() -> builtins.list[Database]:
-            res = request(list_databases, self._client, self._owner._timeout)
+            res = request(list_databases, self._client, self._bound(timeout))
             return parse_body(unwrap(res), databases_of)
 
         return self._retrying(call)
 
-    def metadata(self, database_id: str) -> DatabaseMetadata:
+    def metadata(self, database_id: str, *, timeout: float | None = None) -> DatabaseMetadata:
         """What is inside one database: freshness, row count, columns, samples and sizes.
 
         Cheap enough to poll: it answers `updated` and `entries` without moving the
         build. `size` is the number to budget a transfer against before starting one.
+
+        `timeout` bounds each attempt at this call alone, in place of the client's.
         """
 
         def call() -> DatabaseMetadata:
-            res = request(database_metadata_v2, self._client, self._owner._timeout, id=database_id)
+            res = request(database_metadata_v2, self._client, self._bound(timeout), id=database_id)
             return parse_body(unwrap(res), to_metadata)
 
         return self._retrying(call)
 
-    def checksums(self, database_id: str, format: Format) -> dict[str, str]:
+    def checksums(
+        self, database_id: str, format: Format, *, timeout: float | None = None
+    ) -> dict[str, str]:
         """Every checksum published for one database file, keyed by algorithm.
 
         Keyed rather than one digest because the API publishes md5, sha1, sha256 and
         sha512 side by side and which of them you want is your verifier's business.
+
+        `timeout` bounds each attempt at this call alone, in place of the client's.
         """
 
         def call() -> dict[str, str]:
             res = request(
                 database_checksum_v2,
                 self._client,
-                self._owner._timeout,
+                self._bound(timeout),
                 id=database_id,
                 format_=DatabaseFormat(format),
             )
@@ -178,20 +197,26 @@ class DatabaseApi:
 
         return self._retrying(call)
 
-    def downloads(self, limit: int = DEFAULT_DOWNLOADS_LIMIT) -> builtins.list[Download]:
+    def downloads(
+        self, limit: int = DEFAULT_DOWNLOADS_LIMIT, *, timeout: float | None = None
+    ) -> builtins.list[Download]:
         """Your organization's recent download attempts, newest first.
 
         Refusals are listed too: a denial is what answers "it stopped working", and its
         absence answers nothing.
+
+        `timeout` bounds each attempt at this call alone, in place of the client's.
         """
 
         def call() -> builtins.list[Download]:
-            res = request(list_downloads, self._client, self._owner._timeout, limit=limit)
+            res = request(list_downloads, self._client, self._bound(timeout), limit=limit)
             return parse_body(unwrap(res), downloads_of)
 
         return self._retrying(call)
 
-    def download_url(self, database_id: str, format: Format) -> str:
+    def download_url(
+        self, database_id: str, format: Format, *, timeout: float | None = None
+    ) -> str:
         """The time-limited URL for one database file.
 
         The API answers `302` to object storage, and the link carries its own signature,
@@ -199,13 +224,16 @@ class DatabaseApi:
         rather than followed so the caller decides how to move a file that reaches
         gigabytes; the link authorizes the START of a transfer, so one already running is
         not interrupted when it lapses.
+
+        `timeout` bounds each attempt at MINTING the link, which is an ordinary API
+        request, and says nothing about the transfer you then run with it.
         """
 
         def call() -> str:
             res = request(
                 download_database_v2,
                 self._client,
-                self._owner._timeout,
+                self._bound(timeout),
                 id=database_id,
                 format_=DatabaseFormat(format),
             )
@@ -279,5 +307,8 @@ class DatabaseApi:
     def _client(self) -> AuthenticatedClient:
         return self._owner._client
 
+    def _bound(self, timeout: float | None) -> float | None:
+        return self._owner._bound(timeout)
+
     def _retrying(self, call: Callable[[], T]) -> T:
         return self._owner._retrying(call, self._owner._retries)

{internetdata-2.2.0 → internetdata-2.3.0}/tests/helpers.py

@@ -83,32 +83,34 @@ class DatabaseAdapter:
     def __init__(self, client: InternetData | AsyncInternetData) -> None:
         self._client = client
 
-    def list(self) -> Any:
-        return self._call("list")
+    def list(self, **kwargs: Any) -> Any:
+        return self._call("list", **kwargs)
 
-    def metadata(self, database_id: str) -> Any:
-        return self._call("metadata", database_id)
+    def metadata(self, database_id: str, **kwargs: Any) -> Any:
+        return self._call("metadata", database_id, **kwargs)
 
-    def checksums(self, database_id: str, format: str) -> Any:
-        return self._call("checksums", database_id, format)
+    def checksums(self, database_id: str, format: str, **kwargs: Any) -> Any:
+        return self._call("checksums", database_id, format, **kwargs)
 
-    def downloads(self, *args: Any) -> Any:
-        return self._call("downloads", *args)
+    def downloads(self, *args: Any, **kwargs: Any) -> Any:
+        return self._call("downloads", *args, **kwargs)
 
-    def download_url(self, database_id: str, format: str) -> Any:
-        return self._call("download_url", database_id, format)
+    def download_url(self, database_id: str, format: str, **kwargs: Any) -> Any:
+        return self._call("download_url", database_id, format, **kwargs)
 
-    def download(self, database_id: str, format: str, path: Any) -> Any:
-        return self._call("download", database_id, format, path)
+    def download(self, database_id: str, format: str, path: Any, **kwargs: Any) -> Any:
+        return self._call("download", database_id, format, path, **kwargs)
 
-    def download_bytes(self, database_id: str, format: str) -> Any:
-        return self._call("download_bytes", database_id, format)
+    def download_bytes(self, database_id: str, format: str, **kwargs: Any) -> Any:
+        return self._call("download_bytes", database_id, format, **kwargs)
 
-    def _call(self, name: str, *args: Any) -> Any:
+    # Keyword arguments are forwarded untouched and none is named here: a `timeout`
+    # in this signature would swallow the TypeError a transfer must raise for one.
+    def _call(self, name: str, *args: Any, **kwargs: Any) -> Any:
         method = getattr(self._client.database, name)
         if isinstance(self._client, InternetData):
-            return method(*args)
-        return asyncio.run(method(*args))
+            return method(*args, **kwargs)
+        return asyncio.run(method(*args, **kwargs))
 
 
 class Stub:

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

@@ -8,7 +8,8 @@ import datetime
 import inspect
 import time
 from collections.abc import Callable
-from typing import Any
+from pathlib import Path
+from typing import Any, get_args
 
 import attrs
 import httpx
@@ -20,7 +21,6 @@ from helpers import (
     DOWNLOADS_PATH,
     LIST_PATH,
     METADATA_PATH,
-    ClientAdapter,
     ClientFactory,
     SlowBody,
     Stub,
@@ -37,6 +37,7 @@ from internetdata import (
     InternetData,
     InternetDataError,
     MetadataColumn,
+    Outcome,
     _core,
 )
 from internetdata._generated.models.database import Database as WireDatabase
@@ -48,6 +49,7 @@ from internetdata._generated.models.database_metadata_column import (
 )
 from internetdata._generated.models.database_version import DatabaseVersion as WireDatabaseVersion
 from internetdata._generated.models.download import Download as WireDownload
+from internetdata._generated.models.download_outcome import DownloadOutcome as WireDownloadOutcome
 
 METADATA = {
     "id": "bogon_ip_v1",
@@ -98,13 +100,28 @@ TIMEOUT = 0.3
 TRICKLE = 0.02
 # What starting a thread or an event loop may add to a deadline.
 SLACK = 0.25
+# The client's bound sits far above the call's, so an override accepted and ignored fails
+# on how long the call took rather than passing on the timeout it hit anyway.
+CLIENT_TIMEOUT = 0.6
+CALL_TIMEOUT = 0.1
+
+# Every call that asks the API a question, called with the keyword arguments given.
+JSON_CALLS: dict[str, Callable[..., Any]] = {
+    "list": lambda client, **kw: client.database.list(**kw),
+    "metadata": lambda client, **kw: client.database.metadata("bogon_ip_v1", **kw),
+    "checksums": lambda client, **kw: client.database.checksums("bogon_ip_v1", "csvgz", **kw),
+    "downloads": lambda client, **kw: client.database.downloads(**kw),
+    "download_url": lambda client, **kw: client.database.download_url("bogon_ip_v1", "csvgz", **kw),
+}
 
-JSON_CALLS: dict[str, Callable[[ClientAdapter], Any]] = {
-    "list": lambda client: client.database.list(),
-    "metadata": lambda client: client.database.metadata("bogon_ip_v1"),
-    "checksums": lambda client: client.database.checksums("bogon_ip_v1", "csvgz"),
-    "downloads": lambda client: client.database.downloads(),
-    "download_url": lambda client: client.database.download_url("bogon_ip_v1", "csvgz"),
+# The two transfers, which must REFUSE a per-call timeout rather than ignore one.
+TRANSFERS: dict[str, Callable[..., Any]] = {
+    "download": lambda client, path, **kw: client.database.download(
+        "bogon_ip_v1", "csvgz", path, **kw
+    ),
+    "download_bytes": lambda client, _path, **kw: client.database.download_bytes(
+        "bogon_ip_v1", "csvgz", **kw
+    ),
 }
 
 
@@ -205,6 +222,13 @@ def test_every_field_the_pinned_spec_serves_is_on_the_model(wire: Any, ours: Any
     assert served - modeled == set(), f"{ours.__name__} lacks what the spec serves"
 
 
+def test_the_outcome_vocabulary_is_the_pinned_specs() -> None:
+    """The staleness pin on `Outcome`, the one hand-written Literal the corpus does not
+    carry: the generated enum comes from the same pinned spec, so a re-pin that adds an
+    outcome turns this red instead of leaving the type a member short."""
+    assert sorted(get_args(Outcome)) == sorted(member.value for member in WireDownloadOutcome)
+
+
 def test_a_database_cannot_be_mutated(make_client: ClientFactory) -> None:
     stub = Stub({LIST_PATH: {"body": {"databases": [database("bogon_ip")]}}})
     client = make_client(transport=stub.transport)
@@ -349,6 +373,66 @@ def test_a_timed_out_attempt_is_retried_under_a_bound_of_its_own(
     )
 
 
+@pytest.mark.parametrize("call", JSON_CALLS)
+def test_a_per_call_timeout_bounds_a_trickling_body_and_leaves_the_clients_own_alone(
+    make_client: ClientFactory, call: str
+) -> None:
+    with SlowBody(trickle=TRICKLE) as server:
+        client = make_client(base_url=server.url, timeout=CLIENT_TIMEOUT, retries=0)
+        overridden, first = _timed(lambda: JSON_CALLS[call](client, timeout=CALL_TIMEOUT))
+        default, second = _timed(lambda: JSON_CALLS[call](client))
+
+    _assert_timed_out(first)
+    _assert_bounded_by(overridden, CALL_TIMEOUT)
+    # A per-call value written onto the one httpx client every call shares passes the
+    # call above and fails this one, which is what the second call is here for.
+    _assert_timed_out(second)
+    _assert_bounded_by(default, CLIENT_TIMEOUT)
+
+
+@pytest.mark.parametrize("timeout", [0, -1, float("nan"), float("inf"), "30", True])
+@pytest.mark.parametrize("call", JSON_CALLS)
+def test_a_per_call_timeout_no_attempt_can_meet_is_refused_before_any_request(
+    make_client: ClientFactory, call: str, timeout: Any
+) -> None:
+    """Accepted, each of these failed the call instead, after the retries' backoff."""
+    stub = Stub({})
+    client = make_client(transport=stub.transport, retries=0)
+
+    with pytest.raises(ValueError, match="timeout"):
+        JSON_CALLS[call](client, timeout=timeout)
+
+    assert stub.requests == []
+
+
+@pytest.mark.parametrize("call", TRANSFERS)
+def test_a_transfer_refuses_a_per_call_timeout(
+    make_client: ClientFactory, call: str, tmp_path: Path
+) -> None:
+    """A transfer is exempt from the deadline, so the option is not in its signature and
+    Python refuses it for us. Accepted and quietly ignored, a caller would be told
+    nothing; honored, a bound that suits a JSON call would abandon a healthy download."""
+    stub = Stub({})
+    client = make_client(transport=stub.transport, retries=0)
+    path = tmp_path / "bogon_ip_v1.csv.gz"
+
+    with pytest.raises(TypeError, match="timeout"):
+        TRANSFERS[call](client, path, timeout=CALL_TIMEOUT)
+
+    assert stub.requests == []
+    assert not path.exists()
+
+
+@pytest.mark.parametrize("name", JSON_CALLS)
+def test_every_json_call_takes_a_per_call_timeout(make_client: ClientFactory, name: str) -> None:
+    """The other half of the refusal above, which without this would pass just as well on
+    a surface that had never been given a per-call timeout at all."""
+    timeout = inspect.signature(getattr(make_client().client.database, name)).parameters["timeout"]
+
+    assert timeout.kind is inspect.Parameter.KEYWORD_ONLY
+    assert timeout.default is None
+
+
 def test_the_default_timeout_is_thirty_seconds() -> None:
     for client in (InternetData, AsyncInternetData):
         assert inspect.signature(client).parameters["timeout"].default == 30
@@ -424,6 +508,13 @@ def _assert_timed_out(outcome: Any) -> None:
 
 
 def _assert_one_bound(elapsed: float) -> None:
-    assert TIMEOUT - 0.05 <= elapsed < TIMEOUT + SLACK, (
-        f"gave up after {elapsed:.2f}s against a {TIMEOUT}s bound"
+    _assert_bounded_by(elapsed, TIMEOUT)
+
+
+def _assert_bounded_by(elapsed: float, bound: float) -> None:
+    """One bound's worth of waiting, with an UPPER and a LOWER limit: without the upper a
+    call that gave up at some other bound passes, and without the lower one abandoned at
+    its first chunk does."""
+    assert bound - 0.05 <= elapsed < bound + SLACK, (
+        f"gave up after {elapsed:.2f}s against a {bound}s bound"
     )

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

@@ -200,6 +200,23 @@ def test_a_listing_is_never_reused_across_clients(make_client: ClientFactory) ->
     assert len(stub.requests) == 3
 
 
+# Each visibility rule the corpus names, and the test above that holds it. The three tests
+# each check that their own rule is still in the corpus; this checks the other direction,
+# so a rule added to the corpus fails here until something in this module holds it.
+VISIBILITY_RULES = {
+    "listing-is-returned-as-served": test_the_listing_is_returned_exactly_as_served,
+    "no-catalog-is-compiled-into-the-client": test_no_catalog_is_compiled_into_the_client,
+    "a-listing-is-never-reused-across-clients": test_a_listing_is_never_reused_across_clients,
+}
+
+
+def test_every_visibility_rule_in_the_corpus_is_held_here() -> None:
+    rules = TESTDATA["visibility"]["clientRules"]
+    assert rules, "the corpus pins no visibility rules"
+    unheld = sorted(set(rules) - set(VISIBILITY_RULES))
+    assert unheld == [], f"the corpus adds {unheld} and this suite does not check it"
+
+
 def test_checksums_unwrap_past_the_envelope(make_client: ClientFactory) -> None:
     """`checksums` nests under a key, beside `id` and `format`.