internetdata 2.6.0__tar.gz → 2.6.1__tar.gz

{internetdata-2.6.0 → internetdata-2.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: internetdata
-Version: 2.6.0
+Version: 2.6.1
 Summary: Official Python client library for the InternetData API. Download and verify licensed IP datasets.
 Project-URL: Homepage, https://internetdata.io
 Project-URL: Documentation, https://docs.internetdata.io

{internetdata-2.6.0 → internetdata-2.6.1}/src/internetdata/__init__.py

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

{internetdata-2.6.0 → internetdata-2.6.1}/src/internetdata/_core.py

@@ -45,6 +45,20 @@ TRANSFER_CHUNK_BYTES = 1 << 20
 
 _BACKOFF_BASE = 1.0
 
+# The longest wait the sync client's clock can count, about 292 years: past it a lock's
+# wait, `socket.settimeout` and `time.sleep` all raise OverflowError instead.
+WAIT_CEILING = threading.TIMEOUT_MAX
+
+# The longest `Retry-After` waited as given, 2^31 - 1 ms, the bound every SDK takes. One
+# past it is still a throttle, waited out on the backoff: as given, 2147484 held a call
+# for 24.8 days, and 9223372036854775807, 1e400 or a year-9999 date raised a raw
+# OverflowError from the sync client's sleep (measured on 2.6.0, 2026-09-30).
+RETRY_AFTER_CEILING = 2147483.647
+
+# An `expires_in` past this, about 146 billion years, is a deadline nobody reaches. The
+# cap keeps the poll's deadline a float: past 1.8e308 adding it to the clock raises.
+POLL_DEADLINE_CAP = 2**62
+
 T = TypeVar("T")
 
 
@@ -124,8 +138,9 @@ def check_timeout(timeout: float | None) -> float | None:
     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.
+    `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.
     """
     if timeout is None:
         return None
@@ -134,10 +149,11 @@ def check_timeout(timeout: float | None) -> float | None:
         or not isinstance(timeout, int | float)
         or not math.isfinite(timeout)
         or timeout <= 0
+        or timeout > WAIT_CEILING
     ):
         raise ValueError(
-            f"timeout must be a number of seconds greater than 0, or None for no bound, "
-            f"not {timeout!r}"
+            f"timeout must be a number of seconds greater than 0 and at most "
+            f"{WAIT_CEILING:.0f}, or None for no bound, not {timeout!r}"
         )
     return timeout
 
@@ -425,7 +441,11 @@ class Clock:
         return time.monotonic()
 
     def sleep(self, seconds: float) -> None:
-        time.sleep(seconds)
+        # In parts, since `time.sleep` raises past WAIT_CEILING rather than waiting.
+        while seconds > 0:
+            part = min(seconds, WAIT_CEILING)
+            time.sleep(part)
+            seconds -= part
 
 
 class AsyncClock:
@@ -513,11 +533,12 @@ def retry_delay(err: InternetDataError, attempt: int, retries: int) -> float | N
 
     A server-supplied `Retry-After` wins over the backoff schedule outright: it is the
     only thing that makes a 429 worth retrying at all, so second-guessing it with a
-    shorter wait would just spend the next attempt on the same rejection.
+    shorter wait would just spend the next attempt on the same rejection. One past
+    `RETRY_AFTER_CEILING` is waited out on the backoff instead.
     """
     if attempt >= retries or not err.retryable:
         return None
-    if err.retry_after_seconds is not None:
+    if err.retry_after_seconds is not None and err.retry_after_seconds <= RETRY_AFTER_CEILING:
         return err.retry_after_seconds
     return _BACKOFF_BASE * (2.0**attempt)
 

{internetdata-2.6.0 → internetdata-2.6.1}/src/internetdata/aio.py

@@ -26,6 +26,7 @@ from ._core import (
     OAUTH_METADATA_PATH,
     OAUTH_REVOKE_PATH,
     OAUTH_TOKEN_PATH,
+    POLL_DEADLINE_CAP,
     TRANSFER_CHUNK_BYTES,
     AsyncClock,
     as_error,
@@ -451,9 +452,14 @@ class AsyncOauthApi:
         # Refused before the first wait, not after it.
         check_timeout(timeout)
         interval = device.interval if device.interval >= 1 else 5
-        deadline = self._clock.now() + device.expires_in
+        # Capped where a deadline stops meaning anything, since the clock is a float and
+        # `expires_in` is the server's integer, of any size.
+        deadline = self._clock.now() + min(device.expires_in, POLL_DEADLINE_CAP)
         while True:
-            await self._clock.sleep(interval)
+            # No wait runs past the deadline: an interval ending after it waits only the
+            # time left, and the expiry follows with nothing sent. In full, an interval of
+            # 2147483647 held a poll with 2 s left for 68 years (2.6.0).
+            await self._clock.sleep(min(interval, max(deadline - self._clock.now(), 0)))
             if self._clock.now() >= deadline:
                 raise OauthExpiredTokenError()
             try:

{internetdata-2.6.0 → internetdata-2.6.1}/src/internetdata/client.py

@@ -21,6 +21,7 @@ from ._core import (
     OAUTH_METADATA_PATH,
     OAUTH_REVOKE_PATH,
     OAUTH_TOKEN_PATH,
+    POLL_DEADLINE_CAP,
     TRANSFER_CHUNK_BYTES,
     Clock,
     as_error,
@@ -497,9 +498,14 @@ class OauthApi:
         # Refused before the first wait, not after it.
         check_timeout(timeout)
         interval = device.interval if device.interval >= 1 else 5
-        deadline = self._clock.now() + device.expires_in
+        # Capped where a deadline stops meaning anything, since the clock is a float and
+        # `expires_in` is the server's integer, of any size.
+        deadline = self._clock.now() + min(device.expires_in, POLL_DEADLINE_CAP)
         while True:
-            self._clock.sleep(interval)
+            # No wait runs past the deadline: an interval ending after it waits only the
+            # time left, and the expiry follows with nothing sent. In full, an interval of
+            # 2147483647 held a poll with 2 s left for 68 years (2.6.0).
+            self._clock.sleep(min(interval, max(deadline - self._clock.now(), 0)))
             if self._clock.now() >= deadline:
                 raise OauthExpiredTokenError()
             try:

{internetdata-2.6.0 → internetdata-2.6.1}/testdata/testdata.json

@@ -1215,6 +1215,72 @@
               5
             ]
           }
+        },
+        {
+          "name": "interval-past-the-deadline-sleeps-only-to-it",
+          "clientId": "internetdata-cli",
+          "device": {
+            "device_code": "mo_dc_poll",
+            "user_code": "BCDF-GHJK",
+            "verification_uri": "https://app.internetdata.io/device",
+            "verification_uri_complete": "https://app.internetdata.io/device?user_code=BCDF-GHJK",
+            "expires_in": 2,
+            "interval": 2147483647
+          },
+          "why": "A sleep that would end past the local deadline ends at it, and the local expiry follows with no request sent: the outcome the full sleep reaches anyway, without asking the runtime for a sleep it may not hold (.NET's Task.Delay throws past ~49.7 days). 2147483647 is the largest interval every SDK's type holds.",
+          "responses": [
+            {
+              "status": 400,
+              "body": {
+                "error": "authorization_pending"
+              }
+            }
+          ],
+          "expect": {
+            "outcome": "expiredToken",
+            "requests": 0,
+            "waits": [
+              2
+            ],
+            "status": null
+          }
+        },
+        {
+          "name": "slow-down-past-the-deadline-sleeps-only-to-it",
+          "clientId": "internetdata-cli",
+          "device": {
+            "device_code": "mo_dc_poll",
+            "user_code": "BCDF-GHJK",
+            "verification_uri": "https://app.internetdata.io/device",
+            "verification_uri_complete": "https://app.internetdata.io/device?user_code=BCDF-GHJK",
+            "expires_in": 8,
+            "interval": 1
+          },
+          "why": "The cut applies to every sleep, a widened one included: 1, then 6 after the first slow_down, then only the 1 s left of the 8 rather than 11.",
+          "responses": [
+            {
+              "status": 400,
+              "body": {
+                "error": "slow_down"
+              }
+            },
+            {
+              "status": 400,
+              "body": {
+                "error": "slow_down"
+              }
+            }
+          ],
+          "expect": {
+            "outcome": "expiredToken",
+            "requests": 2,
+            "waits": [
+              1,
+              6,
+              1
+            ],
+            "status": null
+          }
         }
       ]
     },

{internetdata-2.6.0 → internetdata-2.6.1}/tests/test_client.py

@@ -357,6 +357,34 @@ def test_a_rate_limit_is_retried_and_honors_retry_after(make_client: ClientFacto
     assert len(stub.requests) == 3
 
 
+@pytest.mark.parametrize(
+    "retry_after", ["2147484", "9223372036854775807", "1e400", "Fri, 31 Dec 9999 23:59:59 GMT"]
+)
+def test_a_retry_after_past_the_ceiling_waits_the_backoff_and_stays_a_throttle(
+    make_client: ClientFactory, monkeypatch: pytest.MonkeyPatch, retry_after: str
+) -> None:
+    """As given, 2147484 held the call for 24.8 days, and the rest raised a raw
+    OverflowError from the sync client's sleep."""
+    monkeypatch.setattr(_core, "_BACKOFF_BASE", 0.0)
+    headers = {"Retry-After": retry_after}
+    stub = Stub({LIST_PATH: {"status": 429, "body": {"rc": "RATE_LIMITED"}, "headers": headers}})
+    client = make_client(transport=stub.transport, retries=1)
+
+    outcome = settle(client.database.list, within=5.0)
+
+    assert isinstance(outcome, InternetDataError), f"settled with {outcome!r}"
+    assert outcome.kind == "rate_limited"
+    assert len(stub.requests) == 2
+
+
+def test_a_retry_after_is_waited_as_given_up_to_the_ceiling() -> None:
+    def throttled(seconds: float) -> InternetDataError:
+        return InternetDataError("rate_limited", "RATE_LIMITED", 429, seconds)
+
+    assert _core.retry_delay(throttled(2147483.647), 0, 1) == 2147483.647
+    assert _core.retry_delay(throttled(2147483.648), 0, 1) == _core._BACKOFF_BASE
+
+
 def test_a_transport_failure_surfaces_as_a_network_error() -> None:
     def refuse(request: httpx.Request) -> httpx.Response:
         raise httpx.ConnectError("connection refused", request=request)
@@ -441,7 +469,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"), "30", True])
+@pytest.mark.parametrize("timeout", [0, -1, float("nan"), float("inf"), 1e300, "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
@@ -494,7 +522,9 @@ 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"), "30", True])
+@pytest.mark.parametrize(
+    "timeout", [0, -1, 0.0, float("nan"), float("inf"), 9223372037, 1e300, "30", True]
+)
 def test_a_timeout_no_attempt_can_meet_is_refused_when_the_client_is_built(
     client: type[InternetData | AsyncInternetData], timeout: Any
 ) -> None:
@@ -503,7 +533,7 @@ def test_a_timeout_no_attempt_can_meet_is_refused_when_the_client_is_built(
         client(API_KEY, timeout=timeout)
 
 
-@pytest.mark.parametrize("timeout", [None, 0.25, 1, 30])
+@pytest.mark.parametrize("timeout", [None, 0.25, 1, 30, 9223372036])
 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())

{internetdata-2.6.0 → internetdata-2.6.1}/tests/test_download.py

@@ -326,6 +326,32 @@ def test_a_storage_5xx_before_the_body_is_retried(
     assert outcome == SMALL
 
 
+@pytest.mark.parametrize("retry_after", ["2147484", "9223372036854775807"])
+def test_a_storage_retry_after_past_the_ceiling_waits_the_backoff(
+    make_client: ClientFactory, monkeypatch: pytest.MonkeyPatch, retry_after: str
+) -> None:
+    """Object storage's 429 is bounded like the API's: as given, one held the transfer for
+    24.8 days, and the other raised a raw OverflowError from the sync client's sleep."""
+    monkeypatch.setattr(_core, "_BACKOFF_BASE", 0.0)
+    requests: list[httpx.Request] = []
+
+    def handle(request: httpx.Request) -> httpx.Response:
+        requests.append(request)
+        if request.url.path == DOWNLOAD_PATH:
+            return httpx.Response(302, headers={"Location": BLOB})
+        return httpx.Response(429, headers={"Retry-After": retry_after})
+
+    client = make_client(
+        api_key=API_KEY, base_url=API, transport=httpx.MockTransport(handle), retries=1
+    )
+
+    outcome = settle(lambda: client.database.download_bytes("bogon_ip_v1", "csvgz"), within=5.0)
+
+    assert [r.url.path for r in requests].count("/blob") == 2, "storage's 429 and its retry"
+    assert isinstance(outcome, InternetDataError), f"settled with {outcome!r}"
+    assert outcome.kind == "rate_limited"
+
+
 @pytest.mark.parametrize("method", ["download", "download_bytes"])
 def test_a_transfer_that_dies_part_way_is_not_fetched_again(
     make_client: ClientFactory, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, method: str

{internetdata-2.6.0 → internetdata-2.6.1}/tests/test_oauth.py

@@ -305,6 +305,92 @@ def test_poll_device_token_waits_widens_and_ends_as_the_corpus_says(
     _assert_outcome(outcome, {**expect, "type": expect["outcome"]}, case["name"])
 
 
+def test_the_poll_sleeps_the_fraction_left_before_its_deadline(make_client: ClientFactory) -> None:
+    """On the real clock, which the corpus's seam replaces. The second wait is the ~0.99 s
+    left, so the deadline passes with one request sent; a sleep that dropped the fraction
+    would poll again at once, and this stub approves that second poll."""
+    bound = LoopBound()
+    replies = [
+        {"status": 400, "body": {"error": "authorization_pending"}},
+        {"status": 200, "body": EVERY_REQUIRED_MEMBER},
+    ]
+    stub = OauthStub(replies, bound, limit=2)
+    client = make_client(base_url=BASE_URL, transport=stub.transport)
+    device = DeviceAuthorization(
+        device_code="mo_dc_x",
+        user_code="BCDF-GHJK",
+        verification_uri="https://app.example.test/device",
+        expires_in=2,
+        interval=1,
+    )
+
+    outcome = settle(lambda: client.oauth.poll_device_token("internetdata-cli", device), bound)
+
+    assert isinstance(outcome, OauthExpiredTokenError), f"settled with {outcome!r}"
+    assert outcome.status is None, "the local deadline, not the server's"
+    assert len(stub.requests) == 1
+
+
+def test_the_real_clock_sleeps_past_what_time_sleep_can_count_in_parts(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """`time.sleep` raises OverflowError past WAIT_CEILING, and a poll's wait is the server's
+    `interval` or `expires_in`, of any size."""
+    waits: list[float] = []
+    monkeypatch.setattr(time, "sleep", waits.append)
+
+    _core.Clock().sleep(_core.WAIT_CEILING * 2.5)
+
+    assert waits == [_core.WAIT_CEILING, _core.WAIT_CEILING, _core.WAIT_CEILING / 2]
+
+
+def test_a_poll_whose_request_outlives_the_deadline_waits_nothing_more(
+    make_client: ClientFactory,
+) -> None:
+    """The request itself takes the clock 10 s past the deadline, so the time left is
+    negative, and `time.sleep` raises ValueError for a negative wait."""
+    bound = LoopBound()
+    clock = FakeClock(bound)
+    stub = OauthStub([{"status": 400, "body": {"error": "authorization_pending"}}], bound, limit=1)
+
+    def slow(request: httpx.Request) -> httpx.Response:
+        clock._elapsed += 10
+        return stub._handle(request)
+
+    client = make_client(base_url=BASE_URL, transport=httpx.MockTransport(slow))
+    client.oauth.use_clock(clock)
+    device = DeviceAuthorization(**{**_device_fields(), "expires_in": 5, "interval": 1})
+
+    outcome = settle(lambda: client.oauth.poll_device_token("internetdata-cli", device), bound)
+
+    assert isinstance(outcome, OauthExpiredTokenError), f"settled with {outcome!r}"
+    assert clock.waits == [1, 0]
+
+
+def test_an_expires_in_past_any_float_still_polls(make_client: ClientFactory) -> None:
+    """The server's integer, of any size: added to the clock whole, 10**400 raised a raw
+    OverflowError before the first wait."""
+    bound = LoopBound()
+    stub = OauthStub([{"status": 200, "body": EVERY_REQUIRED_MEMBER}], bound, limit=1)
+    client = make_client(base_url=BASE_URL, transport=stub.transport)
+    clock = FakeClock(bound)
+    client.oauth.use_clock(clock)
+    device = DeviceAuthorization(**{**_device_fields(), "expires_in": 10**400, "interval": 1})
+
+    outcome = settle(lambda: client.oauth.poll_device_token("internetdata-cli", device), bound)
+
+    assert isinstance(outcome, TokenResponse), f"settled with {outcome!r}"
+    assert clock.waits == [1]
+
+
+def _device_fields() -> dict[str, Any]:
+    return {
+        "device_code": "mo_dc_x",
+        "user_code": "BCDF-GHJK",
+        "verification_uri": "https://app.example.test/device",
+    }
+
+
 def test_cancelling_a_poll_during_its_first_wait_ends_it_at_once() -> None:
     bound = LoopBound()
     stub = OauthStub([{"status": 400, "body": {"error": "authorization_pending"}}], bound, limit=1)