internetdata 2.9.5__tar.gz → 2.9.6__tar.gz

{internetdata-2.9.5 → internetdata-2.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: internetdata
-Version: 2.9.5
+Version: 2.9.6
 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.9.5 → internetdata-2.9.6}/src/internetdata/__init__.py

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

{internetdata-2.9.5 → internetdata-2.9.6}/src/internetdata/aio.py

@@ -478,9 +478,17 @@ class AsyncOauthApi:
         while True:
             # 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:
+            # 2147483647 held a poll with 2 s left for 68 years (2.6.0). A remainder not
+            # above 0 is none left: a hand-built `expires_in` of NaN, which compares false
+            # with everything, polled every interval for good (2.9.5). `max(0, ...)` is 0
+            # for NaN only in that order; `max(nan, 0)` is NaN.
+            left = max(0, deadline - self._clock.now())
+            to_deadline = left <= interval
+            await self._clock.sleep(left if to_deadline else interval)
+            # A wait that ran to the deadline ends the poll without reading the clock again:
+            # a timer may wake before the clock has moved the whole wait, and the deadline
+            # would then read as not yet reached, so one more request would go out at it.
+            if to_deadline or self._clock.now() >= deadline:
                 raise OauthExpiredTokenError()
             try:
                 return await self.exchange_device_code(

{internetdata-2.9.5 → internetdata-2.9.6}/src/internetdata/client.py

@@ -537,9 +537,17 @@ class OauthApi:
         while True:
             # 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:
+            # 2147483647 held a poll with 2 s left for 68 years (2.6.0). A remainder not
+            # above 0 is none left: a hand-built `expires_in` of NaN, which compares false
+            # with everything, polled every interval for good (2.9.5). `max(0, ...)` is 0
+            # for NaN only in that order; `max(nan, 0)` is NaN.
+            left = max(0, deadline - self._clock.now())
+            to_deadline = left <= interval
+            self._clock.sleep(left if to_deadline else interval)
+            # A wait that ran to the deadline ends the poll without reading the clock again:
+            # a timer may wake before the clock has moved the whole wait, and the deadline
+            # would then read as not yet reached, so one more request would go out at it.
+            if to_deadline or self._clock.now() >= deadline:
                 raise OauthExpiredTokenError()
             try:
                 return self.exchange_device_code(client_id, device.device_code, timeout=timeout)

{internetdata-2.9.5 → internetdata-2.9.6}/tests/helpers.py

@@ -222,11 +222,14 @@ class FakeClock(Clock):
     """A poll's sleep and monotonic clock, replaced together, recording every wait in
     seconds. Past LOOP_BOUND waits, or twice that many clock reads, it trips `bound`."""
 
-    def __init__(self, bound: LoopBound) -> None:
+    def __init__(self, bound: LoopBound, short: float = 0.0) -> None:
         self.waits: list[float] = []
         self._elapsed = 0.0
         self._reads = 0
         self._bound = bound
+        # Each wait of at least 1 ms wakes this many seconds before the clock has moved
+        # its delay, as a runtime timer may.
+        self._short = short
 
     def now(self) -> float:
         self._reads += 1
@@ -238,7 +241,7 @@ class FakeClock(Clock):
         if len(self.waits) == LOOP_BOUND:
             self._bound.trip(f"waited more than {LOOP_BOUND} times")
         self.waits.append(seconds)
-        self._elapsed += seconds
+        self._elapsed += seconds - self._short if seconds >= 0.001 else seconds
 
 
 class AsyncFakeClock(AsyncClock):

{internetdata-2.9.5 → internetdata-2.9.6}/tests/test_oauth.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 import asyncio
 import json
+import math
 import re
 import time
 import urllib.parse
@@ -389,6 +390,49 @@ def test_an_expires_in_past_any_float_still_polls(make_client: ClientFactory) ->
     assert clock.waits == [1]
 
 
+@pytest.mark.parametrize("interval", [5, 3])
+def test_a_wait_that_ran_to_the_deadline_ends_the_poll_however_early_the_timer_woke(
+    make_client: ClientFactory, interval: int
+) -> None:
+    """A timer that wakes before the clock has moved its delay leaves the deadline reading as
+    not yet reached, so a poll that read the clock again would ask once more at it. A wait
+    cut to the deadline, or ending at it, ends the poll."""
+    bound = LoopBound()
+    stub = OauthStub([{"status": 400, "body": {"error": "authorization_pending"}}], bound)
+    client = make_client(base_url=BASE_URL, transport=stub.transport)
+    clock = FakeClock(bound, short=0.0005)
+    client.oauth.use_clock(clock)
+    device = DeviceAuthorization(**{**_device_fields(), "expires_in": 3, "interval": interval})
+
+    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 stub.requests == []
+    assert clock.waits == [3]
+
+
+@pytest.mark.parametrize("expires_in", [math.nan, -math.nan, math.inf - math.inf])
+def test_a_lifetime_that_is_not_a_number_ends_the_poll_at_once(
+    make_client: ClientFactory, expires_in: float
+) -> None:
+    """A hand-built device can carry NaN, which compares false with everything, so the
+    deadline was never reached and the poll asked every interval for good."""
+    bound = LoopBound()
+    stub = OauthStub([{"status": 400, "body": {"error": "authorization_pending"}}], bound)
+    client = make_client(base_url=BASE_URL, transport=stub.transport)
+    clock = FakeClock(bound)
+    client.oauth.use_clock(clock)
+    device = DeviceAuthorization(**{**_device_fields(), "expires_in": expires_in, "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 stub.requests == []
+    assert clock.waits == [0]
+
+
 def _device_fields() -> dict[str, Any]:
     return {
         "device_code": "mo_dc_x",