internetdata 2.9.2__tar.gz → 2.9.3__tar.gz

{internetdata-2.9.2 → internetdata-2.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: internetdata
-Version: 2.9.2
+Version: 2.9.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
@@ -180,7 +180,7 @@ From 2.3.0, `list`, `metadata`, `checksums`, `downloads` and `download_url` each
 
 **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.
+`rate_limited` is a 429 that carries `Retry-After`, and the library retries it for you, as it does server and network failures. `quota_exceeded` is a 429 without one, which it never retries, and it retries nothing else you sent either. InternetData's database API has no quota, so you won't see `quota_exceeded` from it.
 
 ### Sign in with OAuth (device flow)
 

{internetdata-2.9.2 → internetdata-2.9.3}/README.md

@@ -146,7 +146,7 @@ From 2.3.0, `list`, `metadata`, `checksums`, `downloads` and `download_url` each
 
 **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.
+`rate_limited` is a 429 that carries `Retry-After`, and the library retries it for you, as it does server and network failures. `quota_exceeded` is a 429 without one, which it never retries, and it retries nothing else you sent either. InternetData's database API has no quota, so you won't see `quota_exceeded` from it.
 
 ### Sign in with OAuth (device flow)
 

{internetdata-2.9.2 → internetdata-2.9.3}/src/internetdata/__init__.py

@@ -40,7 +40,7 @@ from .models import (
     TokenResponse,
 )
 
-__version__ = "2.9.2"
+__version__ = "2.9.3"
 
 __all__ = [
     "DATABASE_FORMATS",

{internetdata-2.9.2 → internetdata-2.9.3}/src/internetdata/_core.py

@@ -167,15 +167,17 @@ def check_timeout(timeout: float | None) -> float | None:
     `server_error` blaming the API. So is anything past `WAIT_CEILING`, infinity
     included, since the sync client's wait cannot hold it: 1e300 failed every call with
     a raw `OverflowError` (2.6.0, measured 2026-09-30). None is the spelling for no bound.
+
+    Compared rather than handed to `math.isfinite`, which raised a raw `OverflowError` for
+    an integer too large for a float, such as 10**400 (2.9.2, measured 2026-10-25). NaN
+    fails both comparisons.
     """
     if timeout is None:
         return None
     if (
         isinstance(timeout, bool)
         or not isinstance(timeout, int | float)
-        or not math.isfinite(timeout)
-        or timeout <= 0
-        or timeout > WAIT_CEILING
+        or not 0 < timeout <= WAIT_CEILING
     ):
         raise ValueError(
             f"timeout must be a number of seconds greater than 0 and at most "
@@ -184,6 +186,25 @@ def check_timeout(timeout: float | None) -> float | None:
     return timeout
 
 
+def check_retries(retries: float) -> float:
+    """`retries`, once it is a count of retries: a whole number from 0, or `math.inf` to
+    retry a failing call until it succeeds.
+
+    Refused where it is SET, because nothing downstream refuses it: NaN compares false with
+    every attempt number, so a failing call was retried until it succeeded, a negative read
+    as 0, 1.5 as two retries, and a string or None raised a raw `TypeError` out of every
+    call that failed, a 404 included (2.9.2, measured 2026-10-25).
+    """
+    if (
+        isinstance(retries, bool)
+        or not isinstance(retries, int | float)
+        or not retries >= 0
+        or (isinstance(retries, float) and not (retries.is_integer() or retries == math.inf))
+    ):
+        raise ValueError(f"retries must be a whole number from 0, or math.inf, not {retries!r}")
+    return retries
+
+
 def storage_refusal(res: httpx.Response) -> InternetDataError:
     """What object storage refusing a download link becomes.
 
@@ -553,12 +574,22 @@ def databases_of(body: dict[str, Any]) -> list[Database]:
     Nothing is added here, and nothing may be: a family built for a single customer is
     absent from this array for every organization that does not license it, so filling a
     gap from any other source would publish the fact that the family exists.
+
+    An object where the list is due is refused rather than read as one with nothing in it:
+    `{"databases": {}}` answered an empty catalog (2.9.2, measured 2026-10-25).
     """
-    return [to_database(d) for d in body["databases"]]
+    return [to_database(d) for d in _listed(body, "databases")]
 
 
 def downloads_of(body: dict[str, Any]) -> list[Download]:
-    return [to_download(d) for d in body["downloads"]]
+    return [to_download(d) for d in _listed(body, "downloads")]
+
+
+def _listed(body: dict[str, Any], name: str) -> list[Any]:
+    value = body[name]
+    if not isinstance(value, list):
+        raise TypeError(f"{name} is not a list: {value!r}")
+    return value
 
 
 def checksums_of(body: dict[str, Any]) -> dict[str, str]:
@@ -568,7 +599,16 @@ def checksums_of(body: dict[str, Any]) -> dict[str, str]:
     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.
+
+    `id` and `format` are read too, though nothing returns them: a null or numeric `id`
+    came back as a whole answer, and so did `checksums` sent as a list of pairs (2.9.2,
+    measured 2026-10-25).
     """
+    for member in ("id", "format"):
+        if not isinstance(body[member], str):
+            raise TypeError(f"the checksum answer's {member} is not a string: {body[member]!r}")
+    if not isinstance(body["checksums"], dict):
+        raise TypeError(f"checksums is not an object: {body['checksums']!r}")
     digests = dict(body["checksums"])
     for algorithm in ("md5", "sha1", "sha256", "sha512"):
         if not isinstance(digests[algorithm], str):
@@ -576,7 +616,7 @@ def checksums_of(body: dict[str, Any]) -> dict[str, str]:
     return digests
 
 
-def retry_delay(err: InternetDataError, attempt: int, retries: int) -> float | None:
+def retry_delay(err: InternetDataError, attempt: int, retries: float) -> float | None:
     """How long to wait before attempt `attempt + 1`, or None when there must not be one.
 
     A server-supplied `Retry-After` wins over the backoff schedule outright: it is the

{internetdata-2.9.2 → internetdata-2.9.3}/src/internetdata/aio.py

@@ -35,6 +35,7 @@ from ._core import (
     authorization_url,
     build_async_transfer_client,
     build_client,
+    check_retries,
     check_timeout,
     checksums_of,
     create_pkce,
@@ -109,7 +110,7 @@ class AsyncInternetData:
         self._client = build_client(api_key, base_url, timeout, transport)
         self._base_url = base_url
         self._transfer = build_async_transfer_client(timeout, transport)
-        self._retries = retries
+        self._retries = check_retries(retries)
         self._timeout = timeout
         self.database = AsyncDatabaseApi(self)
         self.oauth = AsyncOauthApi(self)
@@ -133,7 +134,7 @@ class AsyncInternetData:
     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:
+    async def _retrying(self, call: Callable[[], Awaitable[T]], retries: float) -> T:
         attempt = 0
         while True:
             try:

{internetdata-2.9.2 → internetdata-2.9.3}/src/internetdata/client.py

@@ -30,6 +30,7 @@ from ._core import (
     authorization_url,
     build_client,
     build_transfer_client,
+    check_retries,
     check_timeout,
     checksums_of,
     create_pkce,
@@ -94,6 +95,10 @@ class InternetData:
     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.
 
+    `retries` is how many times a failed attempt is retried, 2 unless given: a whole number
+    from 0, or `math.inf` to retry until the call succeeds. Anything else is a `ValueError`
+    here too.
+
     Holds an HTTP connection pool, so use it as a context manager or call `close()` when
     you are done with it.
     """
@@ -117,7 +122,7 @@ class InternetData:
         self._client = build_client(api_key, base_url, timeout, transport)
         self._base_url = base_url
         self._transfer = build_transfer_client(timeout, transport)
-        self._retries = retries
+        self._retries = check_retries(retries)
         self._timeout = timeout
         self.database = DatabaseApi(self)
         self.oauth = OauthApi(self)
@@ -141,7 +146,7 @@ class InternetData:
     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:
+    def _retrying(self, call: Callable[[], T], retries: float) -> T:
         attempt = 0
         while True:
             try:

{internetdata-2.9.2 → internetdata-2.9.3}/src/internetdata/models.py

@@ -10,6 +10,7 @@ them so a field this pinned spec predates is still reachable.
 from __future__ import annotations
 
 import datetime
+import re
 from dataclasses import dataclass, field
 from typing import Any, Literal, get_args
 
@@ -177,12 +178,12 @@ def to_database(body: dict[str, Any]) -> Database:
         base=_present(body, "base", str),
         name=_present(body, "name", str),
         summary=_present(body, "summary", str),
-        standing=_present(body, "standing", str),
-        license_type=_nullable(body, "license_type", str),
-        starts=_datetime(body["starts"]),
-        expires=_datetime(body["expires"]),
-        renews_at=_datetime(body["renews_at"]),
-        notice_due_at=_datetime(body["notice_due_at"]),
+        standing=_one_of(_present(body, "standing", str), STANDINGS, "standing"),
+        license_type=_one_of(_nullable(body, "license_type", str), LICENSE_TYPES, "license_type"),
+        starts=_datetime(body["starts"], "starts"),
+        expires=_datetime(body["expires"], "expires"),
+        renews_at=_datetime(body["renews_at"], "renews_at"),
+        notice_due_at=_datetime(body["notice_due_at"], "notice_due_at"),
         versions=tuple(to_version(v) for v in _present(body, "versions", list)),
         raw=body,
         open=_present(body, "open", bool),
@@ -190,26 +191,37 @@ def to_database(body: dict[str, Any]) -> Database:
 
 
 def to_version(body: dict[str, Any]) -> DatabaseVersion:
+    sample_formats = _nullable(body, "sample_formats", list, absent=True)
     return DatabaseVersion(
         id=_present(body, "id", str),
         version=_present(body, "version", int),
         summary=_present(body, "summary", str),
         formats=_strings(_present(body, "formats", list), "formats"),
-        sample_formats=_optional_tuple(body.get("sample_formats")),
+        sample_formats=None
+        if sample_formats is None
+        else _strings(sample_formats, "sample_formats"),
     )
 
 
 def to_metadata(body: dict[str, Any]) -> DatabaseMetadata:
+    schema = _present(body, "schema", dict)
+    sample = _of_type(body.get("sample", {}), "sample", dict)
     return DatabaseMetadata(
         id=_present(body, "id", str),
-        updated=datetime.date.fromisoformat(body["updated"]),
+        updated=_date(_present(body, "updated", str), "updated"),
         entries=_present(body, "entries", int),
         schema={
-            fmt: tuple(to_column(c) for c in columns) for fmt, columns in body["schema"].items()
+            fmt: tuple(
+                to_column(_of_type(c, "schema", dict)) for c in _of_type(cols, "schema", list)
+            )
+            for fmt, cols in schema.items()
         },
         size=_sizes(_present(body, "size", dict), "size"),
-        update_freq=body.get("update_freq"),
-        sample={fmt: tuple(rows) for fmt, rows in body.get("sample", {}).items()},
+        update_freq=_nullable(body, "update_freq", str, absent=True),
+        sample={
+            fmt: tuple(_of_type(row, "sample", dict) for row in _of_type(rows, "sample", list))
+            for fmt, rows in sample.items()
+        },
         raw=body,
         sample_size=_sizes(body["sample_size"], "sample_size")
         if body.get("sample_size") is not None
@@ -222,7 +234,7 @@ def to_column(body: dict[str, Any]) -> MetadataColumn:
     return MetadataColumn(
         name=_present(body, "name", str),
         type=_present(body, "type", str),
-        description=body.get("description"),
+        description=_nullable(body, "description", str, absent=True),
     )
 
 
@@ -230,13 +242,13 @@ def to_download(body: dict[str, Any]) -> Download:
     return Download(
         dataset_id=_present(body, "dataset_id", str),
         format=_present(body, "format", str),
-        outcome=_present(body, "outcome", str),
-        created=datetime.datetime.fromisoformat(body["created"]),
+        outcome=_one_of(_present(body, "outcome", str), get_args(Outcome), "outcome"),
+        created=_date_time(_present(body, "created", str), "created"),
         bytes=_nullable(body, "bytes", int),
         http_status=_nullable(body, "http_status", int),
-        apikey_id=body["apikey_id"],
-        client_ip=body["client_ip"],
-        user_agent=body["user_agent"],
+        apikey_id=_nullable(body, "apikey_id", str),
+        client_ip=_nullable(body, "client_ip", str),
+        user_agent=_nullable(body, "user_agent", str),
         sample=_present(body, "sample", bool),
         open=_present(body, "open", bool),
     )
@@ -273,25 +285,74 @@ def _strings(values: list[Any], name: str) -> tuple[Any, ...]:
     return tuple(_of_type(v, name, str) for v in values)
 
 
-def _sizes(sizes: Any, name: str) -> dict[str, int]:
-    return {fmt: _of_type(n, name, int) for fmt, n in _of_type(sizes, name, dict).items()}
+def _one_of(value: Any, allowed: tuple[str, ...], name: str) -> Any:
+    """`value`, a member of `allowed`, or None. One outside it is a value this client was not
+    built for: `license_type` came back as served while its type promised one of three, and
+    `standing` beside it was refused (2.9.2, measured 2026-10-25)."""
+    if value is not None and value not in allowed:
+        raise ValueError(f"{name} is not one of {', '.join(allowed)}: {value!r}")
+    return value
 
 
-def _optional_tuple(value: Any) -> tuple[Any, ...] | None:
-    return tuple(value) if value is not None else None
+def _sizes(sizes: Any, name: str) -> dict[str, int]:
+    return {fmt: _of_type(n, name, int) for fmt, n in _of_type(sizes, name, dict).items()}
 
 
-def _datetime(value: Any) -> datetime.datetime | None:
+def _datetime(value: Any, name: str) -> datetime.datetime | None:
     """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
-    raises, and the caller reports it as the server's failure rather than as None, which
-    would quietly read as "no end date".
+    A value that is neither null nor readable raises, and the caller reports it as the
+    server's failure rather than as None, which would quietly read as "no end date".
     """
-    if value is None:
-        return None
-    return datetime.datetime.fromisoformat(value)
+    return None if value is None else _date_time(value, name)
+
+
+# The spec's `date-time` and `date` are RFC 3339's, and only those are read: `fromisoformat`
+# took a date-time with no offset as a naive datetime, which no aware one can be compared
+# with, a date alone as midnight, `+0500`, `+05`, `+05:00:30`, `+05:60` as an hour more,
+# a space for the `T`, no seconds, a comma for the point, week dates and `20261005`
+# (2.9.2, measured 2026-10-25). RFC 3339 allows a lowercase `t` and `z`, which it refused.
+_DIGITS2 = "([0-9]{2})"
+_FULL_DATE = re.compile(rf"([0-9]{{4}})-{_DIGITS2}-{_DIGITS2}")
+_DATE_TIME = re.compile(
+    rf"([0-9]{{4}})-{_DIGITS2}-{_DIGITS2}[Tt]{_DIGITS2}:{_DIGITS2}:{_DIGITS2}(?:\.([0-9]+))?"
+    rf"(?:[Zz]|([+-]){_DIGITS2}:{_DIGITS2})"
+)
+
+
+def _date(value: str, name: str) -> datetime.date:
+    match = _FULL_DATE.fullmatch(value)
+    if match is None:
+        raise ValueError(f"{name} is not an RFC 3339 date: {value!r}")
+    # A day its month lacks, 30 February, raises here.
+    return datetime.date(*(int(part) for part in match.groups()))
+
+
+def _date_time(value: Any, name: str) -> datetime.datetime:
+    match = _DATE_TIME.fullmatch(_of_type(value, name, str))
+    if match is None:
+        raise ValueError(f"{name} is not an RFC 3339 date-time: {value!r}")
+    year, month, day, hour, minute, second, fraction, sign, offset_hour, offset_minute = (
+        match.groups()
+    )
+    zone = datetime.UTC
+    if sign is not None:
+        if int(offset_hour) > 23 or int(offset_minute) > 59:
+            raise ValueError(f"{name} has no such offset: {value!r}")
+        offset = datetime.timedelta(hours=int(offset_hour), minutes=int(offset_minute))
+        zone = datetime.timezone(-offset if sign == "-" else offset)
+    # A day its month lacks, an hour of 24 and a leap second's 60 raise here; past six
+    # digits a fraction is cut, as `fromisoformat` cuts it.
+    return datetime.datetime(
+        int(year),
+        int(month),
+        int(day),
+        int(hour),
+        int(minute),
+        int(second),
+        int((fraction or "")[:6].ljust(6, "0")),
+        tzinfo=zone,
+    )
 
 
 @dataclass(frozen=True, slots=True)

{internetdata-2.9.2 → internetdata-2.9.3}/tests/test_client.py

@@ -454,6 +454,86 @@ UNREADABLE_MEMBERS.update(
     }
 )
 
+_CHECKSUM = {"id": "bogon_ip_v1", "format": "csvgz", "checksums": DIGESTS}
+
+# Each of these came back from 2.9.2 as an answer (measured 2026-10-25): an object where a
+# list is due as an empty one, a member typed nowhere but the spec as served, a
+# `license_type` outside its three, and a checksum answer's unread `id` whatever it held.
+UNREADABLE_MEMBERS.update(
+    {
+        "list databases as an object": (LIST_PATH, {"databases": {}}),
+        "downloads as an object": (DOWNLOADS_PATH, {"downloads": {}}),
+        "list license_type outside its enum": (
+            LIST_PATH,
+            {"databases": [_with("license_type", "trial", database("bogon_ip"))]},
+        ),
+        "list sample_formats as an object": (
+            LIST_PATH,
+            {"databases": [_version_with("sample_formats", {})]},
+        ),
+        "metadata update_freq as a number": (METADATA_PATH, _with("update_freq", 1, METADATA)),
+        "metadata column description as a number": (
+            METADATA_PATH,
+            {**METADATA, "schema": {"csvgz": [{"name": "ip", "type": "string", "description": 1}]}},
+        ),
+        "metadata columns as an object": (METADATA_PATH, {**METADATA, "schema": {"csvgz": {}}}),
+        "metadata sample rows as an object": (METADATA_PATH, {**METADATA, "sample": {"csvgz": {}}}),
+        "metadata sample row as pairs": (
+            METADATA_PATH,
+            {**METADATA, "sample": {"csvgz": [[["first_ip", "10.0.0.0"]]]}},
+        ),
+        **{
+            f"downloads {m} as a number": (DOWNLOADS_PATH, {"downloads": [_with(m, 7, _DOWNLOAD)]})
+            for m in ("apikey_id", "client_ip", "user_agent")
+        },
+        "checksums id as null": (CHECKSUM_PATH, _with("id", None, _CHECKSUM)),
+        "checksums id as a number": (CHECKSUM_PATH, _with("id", 7, _CHECKSUM)),
+        "checksums as pairs": (CHECKSUM_PATH, _with("checksums", list(DIGESTS.items()), _CHECKSUM)),
+    }
+)
+
+# What `fromisoformat` read as a date-time and RFC 3339 does not (2.9.2, measured
+# 2026-10-25): no offset, which made a naive datetime, a date alone, a space for the `T`,
+# offsets without their colon, with seconds or past 23:59, no seconds, a comma for the
+# point, the basic format and a week date. Then what neither reads.
+NOT_DATE_TIMES = [
+    "2026-10-05T10:00:00",
+    "2026-10-05",
+    "2026-10-05 10:00:00Z",
+    "2026-10-05T10:00:00+0500",
+    "2026-10-05T10:00:00+05",
+    "2026-10-05T10:00:00+05:00:30",
+    "2026-10-05T10:00:00+05:60",
+    "2026-10-05T10:00:00+24:00",
+    "2026-10-05T10:00Z",
+    "2026-10-05T10:00:00,5Z",
+    "20261005T100000Z",
+    "2026-W41-1T10:00:00Z",
+    "2026-10-5T10:00:00Z",
+    " 2026-10-05T10:00:00Z",
+    "2026-02-30T10:00:00Z",
+    "2026-10-05T23:59:60Z",
+    "tomorrow",
+]
+
+# The same for `updated`, a `date`: the basic format and week dates were read.
+NOT_DATES = ["20261005", "2026-W41-1", "2026-W41", "2026-10-5", "2026-02-30", "2026-10-05T00:00Z"]
+
+for _value in NOT_DATE_TIMES:
+    UNREADABLE_MEMBERS[f"list starts {_value!r}"] = (
+        LIST_PATH,
+        {"databases": [database("bogon_ip", starts=_value)]},
+    )
+    UNREADABLE_MEMBERS[f"downloads created {_value!r}"] = (
+        DOWNLOADS_PATH,
+        {"downloads": [_with("created", _value, _DOWNLOAD)]},
+    )
+for _value in NOT_DATES:
+    UNREADABLE_MEMBERS[f"metadata updated {_value!r}"] = (
+        METADATA_PATH,
+        _with("updated", _value, METADATA),
+    )
+
 MEMBER_CALLS = {LIST_PATH: "list", METADATA_PATH: "metadata", DOWNLOADS_PATH: "downloads"}
 
 
@@ -475,6 +555,32 @@ def test_an_answer_missing_what_the_spec_requires_is_a_retried_server_error(
     assert len(stub.requests) == 3
 
 
+@pytest.mark.parametrize(
+    "value",
+    [
+        "2026-10-05T10:00:00Z",
+        "2026-10-05t10:00:00z",
+        "2026-10-05T10:00:00-00:00",
+        "2026-10-05T15:30:00+05:30",
+        "2026-10-05T05:00:00.123456789-05:00",
+    ],
+)
+def test_an_rfc_3339_date_time_is_read_as_the_instant_it_names(
+    make_client: ClientFactory, value: str
+) -> None:
+    """In each of RFC 3339's spellings, the lowercase ones `fromisoformat` refused included;
+    past six digits a fraction is cut."""
+    stub = Stub({LIST_PATH: {"body": {"databases": [database("bogon_ip", starts=value)]}}})
+    client = make_client(transport=stub.transport)
+
+    starts = client.database.list()[0].starts
+
+    assert starts is not None and starts.utcoffset() is not None
+    expected = datetime.datetime(2026, 10, 5, 10, tzinfo=datetime.UTC)
+    assert starts.replace(microsecond=0) == expected
+    assert starts.microsecond == (123456 if "." in value else 0)
+
+
 @pytest.mark.parametrize(
     ("status", "body", "kind"),
     [
@@ -538,6 +644,51 @@ def test_retries_are_configurable_on_the_client(make_client: ClientFactory) -> N
     assert len(stub.requests) == 1
 
 
+@pytest.mark.parametrize("client", [InternetData, AsyncInternetData])
+@pytest.mark.parametrize(
+    "retries", [-1, float("nan"), 1.5, float("-inf"), "2", None, True, 10**400 * -1]
+)
+def test_a_retry_count_that_is_not_a_whole_number_from_0_is_refused_when_the_client_is_built(
+    client: type[InternetData | AsyncInternetData], retries: Any
+) -> None:
+    """Accepted by 2.9.2: NaN retried a failing call until it succeeded, -1 read as 0, 1.5 as
+    two retries, and a string or None raised a raw TypeError out of every failing call."""
+    with pytest.raises(ValueError, match="retries"):
+        client(API_KEY, retries=retries)
+
+
+@pytest.mark.parametrize("retries", [0, 2, 2.0])
+def test_a_whole_retry_count_is_what_a_failing_call_spends(
+    make_client: ClientFactory, monkeypatch: pytest.MonkeyPatch, retries: float
+) -> None:
+    monkeypatch.setattr(_core, "_BACKOFF_BASE", 0.0)
+    stub = Stub({LIST_PATH: {"status": 503, "body": {"rc": "UNAVAILABLE"}}})
+    client = make_client(transport=stub.transport, retries=retries)
+
+    with pytest.raises(InternetDataError):
+        client.database.list()
+
+    assert len(stub.requests) == retries + 1
+
+
+def test_an_infinite_retry_count_retries_until_the_call_succeeds(
+    make_client: ClientFactory, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setattr(_core, "_BACKOFF_BASE", 0.0)
+    sent: list[httpx.Request] = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        sent.append(request)
+        if len(sent) <= 6:
+            return httpx.Response(503, json={"rc": "UNAVAILABLE"})
+        return httpx.Response(200, json={"databases": []})
+
+    client = make_client(transport=httpx.MockTransport(handler), retries=float("inf"))
+
+    assert client.database.list() == []
+    assert len(sent) == 7
+
+
 def test_a_spent_quota_is_never_retried(make_client: ClientFactory) -> None:
     stub = Stub({LIST_PATH: {"status": 429, "body": {"rc": "QUOTA_EXCEEDED"}}})
     client = make_client(transport=stub.transport, retries=3)
@@ -745,7 +896,7 @@ def test_a_per_call_timeout_bounds_a_trickling_body_and_leaves_the_clients_own_a
     _assert_bounded_by(default, CLIENT_TIMEOUT)
 
 
-@pytest.mark.parametrize("timeout", [0, -1, float("nan"), float("inf"), 1e300, "30", True])
+@pytest.mark.parametrize("timeout", [0, -1, float("nan"), float("inf"), 1e300, 10**400, "30", True])
 @pytest.mark.parametrize("call", PER_CALL)
 def test_a_per_call_timeout_no_attempt_can_meet_is_refused_before_any_request(
     make_client: ClientFactory, call: str, timeout: Any
@@ -799,7 +950,7 @@ def test_the_default_timeout_is_thirty_seconds() -> None:
 
 @pytest.mark.parametrize("client", [InternetData, AsyncInternetData])
 @pytest.mark.parametrize(
-    "timeout", [0, -1, 0.0, float("nan"), float("inf"), 9223372037, 1e300, "30", True]
+    "timeout", [0, -1, 0.0, float("nan"), float("inf"), 9223372037, 1e300, 10**400, "30", True]
 )
 def test_a_timeout_no_attempt_can_meet_is_refused_when_the_client_is_built(
     client: type[InternetData | AsyncInternetData], timeout: Any