internetdata 2.6.0__tar.gz → 2.6.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: internetdata
-Version: 2.6.0
+Version: 2.6.2
 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
@@ -225,11 +225,11 @@ Check that `state` came back as you sent it before you exchange `code`, which wo
 
 ## Other Libraries
 
-There are official InternetData client libraries available for many languages including PHP, Python, Go, Java, Ruby, and many popular frameworks such as Django, Rails, and Laravel. See our GitHub at https://github.com/internetdata for more.
+There are official InternetData client libraries available for many languages including PHP, Python, Go, Java, and Ruby. See our GitHub at https://github.com/internetdata for more.
 
 ## About InternetData
 
-InternetData: IP and network intelligence databases, published as CSV and MMDB, licensed by contract and downloadable on demand.
+Geolocation, anonymity, ownership and network databases for IP addresses and AS numbers, licensed as files you download and query yourself.
 
 [<img src="https://s3.internetdata.io/internetdata-public/brand/mark.svg" alt="InternetData" height="64"/>](https://internetdata.io/)
 

{internetdata-2.6.0 → internetdata-2.6.2}/README.md

@@ -191,11 +191,11 @@ Check that `state` came back as you sent it before you exchange `code`, which wo
 
 ## Other Libraries
 
-There are official InternetData client libraries available for many languages including PHP, Python, Go, Java, Ruby, and many popular frameworks such as Django, Rails, and Laravel. See our GitHub at https://github.com/internetdata for more.
+There are official InternetData client libraries available for many languages including PHP, Python, Go, Java, and Ruby. See our GitHub at https://github.com/internetdata for more.
 
 ## About InternetData
 
-InternetData: IP and network intelligence databases, published as CSV and MMDB, licensed by contract and downloadable on demand.
+Geolocation, anonymity, ownership and network databases for IP addresses and AS numbers, licensed as files you download and query yourself.
 
 [<img src="https://s3.internetdata.io/internetdata-public/brand/mark.svg" alt="InternetData" height="64"/>](https://internetdata.io/)
 

{internetdata-2.6.0 → internetdata-2.6.2}/spec/openapi.yaml

@@ -12,7 +12,7 @@ info:
     email: support@internetdata.io
     url: https://internetdata.io
   termsOfService: https://internetdata.io/terms
-  version: 2026.09.26
+  version: 2026.10.03
 servers:
   - url: https://internetdata.io
 tags:
@@ -126,7 +126,8 @@ paths:
         `updated` and `entries` without downloading anything.
 
         No `format` parameter - one document describes every format the database
-        is built in.
+        is built in. Needs no license: it answers for every database `list`
+        returns, whatever its `standing`.
       security:
         - ApiKeyQueryAuth: []
         - ApiKeyHeaderAuth: []
@@ -142,8 +143,6 @@ paths:
                 $ref: '#/components/schemas/DatabaseMetadata'
         '401':
           $ref: '#/components/responses/V2Unauthorized'
-        '403':
-          $ref: '#/components/responses/V2NotLicensed'
         '404':
           $ref: '#/components/responses/V2UnknownDatabase'
         '503':
@@ -1641,7 +1640,7 @@ components:
             $ref: '#/components/schemas/Error'
     V2NotAvailable:
       description: |
-        Licensed, but the current build has not been published yet.
+        The current build has not been published yet.
         `rc`: `NOT_AVAILABLE`.
       content:
         application/json:

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

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

{internetdata-2.6.0 → internetdata-2.6.2}/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.2}/src/internetdata/_generated/api/database_v_2/database_metadata_v2.py

@@ -43,11 +43,6 @@ def _parse_response(
 
         return response_401
 
-    if response.status_code == 403:
-        response_403 = Error.from_dict(response.json())
-
-        return response_403
-
     if response.status_code == 404:
         response_404 = Error.from_dict(response.json())
 
@@ -86,7 +81,8 @@ def sync_detailed(
     `updated` and `entries` without downloading anything.
 
     No `format` parameter - one document describes every format the database
-    is built in.
+    is built in. Needs no license: it answers for every database `list`
+    returns, whatever its `standing`.
 
     Args:
         id (str):  Example: vpn_ip_v1.
@@ -121,7 +117,8 @@ def sync(
     `updated` and `entries` without downloading anything.
 
     No `format` parameter - one document describes every format the database
-    is built in.
+    is built in. Needs no license: it answers for every database `list`
+    returns, whatever its `standing`.
 
     Args:
         id (str):  Example: vpn_ip_v1.
@@ -151,7 +148,8 @@ async def asyncio_detailed(
     `updated` and `entries` without downloading anything.
 
     No `format` parameter - one document describes every format the database
-    is built in.
+    is built in. Needs no license: it answers for every database `list`
+    returns, whatever its `standing`.
 
     Args:
         id (str):  Example: vpn_ip_v1.
@@ -184,7 +182,8 @@ async def asyncio(
     `updated` and `entries` without downloading anything.
 
     No `format` parameter - one document describes every format the database
-    is built in.
+    is built in. Needs no license: it answers for every database `list`
+    returns, whatever its `standing`.
 
     Args:
         id (str):  Example: vpn_ip_v1.

{internetdata-2.6.0 → internetdata-2.6.2}/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.2}/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.2}/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.2}/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.2}/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.2}/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)