internetdata 1.0.0__py3-none-any.whl

internetdata/errors.py

@@ -0,0 +1,128 @@
+"""The one exception this library raises, and how a response becomes one."""
+
+from __future__ import annotations
+
+import datetime
+import email.utils
+import math
+from typing import Any, Literal
+
+import httpx
+
+__all__ = ["ErrorKind", "InternetDataError"]
+
+ErrorKind = Literal[
+    "bad_request",
+    "unauthorized",
+    "forbidden",
+    "rate_limited",
+    "quota_exceeded",
+    "server_error",
+    "network",
+]
+"""Why a request failed.
+
+`rate_limited` and `quota_exceeded` both arrive as HTTP 429 and are NOT the same thing.
+A rate limit is the API protecting itself and carries `Retry-After`; retrying works. A
+spent quota carries no such header and retrying will not help until the window rolls
+over or the limit is raised. The header is the only thing that distinguishes them.
+"""
+
+_RETRYABLE: frozenset[str] = frozenset({"rate_limited", "server_error", "network"})
+
+
+class InternetDataError(Exception):
+    """Every failure this library reports, discriminated by `kind`."""
+
+    kind: ErrorKind
+    status: int | None
+    retry_after_seconds: float | None
+
+    def __init__(
+        self,
+        kind: ErrorKind,
+        message: str,
+        status: int | None = None,
+        retry_after_seconds: float | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.kind = kind
+        self.status = status
+        self.retry_after_seconds = retry_after_seconds
+
+    @property
+    def message(self) -> str:
+        return str(self)
+
+    @property
+    def retryable(self) -> bool:
+        """Whether retrying this exact request could succeed."""
+        return self.kind in _RETRYABLE
+
+    def __repr__(self) -> str:
+        return (
+            f"InternetDataError(kind={self.kind!r}, status={self.status!r}, message={str(self)!r})"
+        )
+
+
+def error_from_response(status: int, headers: httpx.Headers, body: Any) -> InternetDataError:
+    """Classify a failed response.
+
+    Everything outside the four named statuses is decided by its RANGE rather than by an
+    enumerated list, which is the whole point: a 404 from a database id that does not
+    exist has to land on a client error, and mapping 400/401/403/429 and letting the rest
+    fall through to `server_error` retries it twice before failing. Three of the four
+    first SDKs shipped exactly that bug, so the shared corpus pins both 404 shapes.
+    """
+    message = _message_of(body) or f"request failed with status {status}"
+    retry_after = _parse_retry_after(headers.get("retry-after"))
+
+    if status == 429:
+        # Present means transient, absent means an allowance is spent. Nothing else in
+        # the response separates the two.
+        if retry_after is None:
+            return InternetDataError("quota_exceeded", message, status)
+        return InternetDataError("rate_limited", message, status, retry_after)
+    if status == 401:
+        return InternetDataError("unauthorized", message, status)
+    if status == 403:
+        return InternetDataError("forbidden", message, status)
+    if 400 <= status < 500:
+        return InternetDataError("bad_request", message, status)
+    return InternetDataError("server_error", message, status)
+
+
+def _message_of(body: Any) -> str | None:
+    """The API's own result code, which is the whole error envelope.
+
+    `rc` is deliberately not an enum in the spec, so a code added later stays readable by
+    a client generated today. Passing it through verbatim is what keeps that promise: a
+    caller switching on `NOT_LICENSED` versus `LICENSE_EXPIRED` needs the string, not a
+    status.
+    """
+    if not isinstance(body, dict):
+        return None
+    code = body.get("rc")
+    if isinstance(code, str) and code != "":
+        return code
+    return None
+
+
+def _parse_retry_after(value: str | None) -> float | None:
+    if value is None or value.strip() == "":
+        return None
+    try:
+        seconds = float(value)
+    except ValueError:
+        pass
+    else:
+        return seconds if seconds >= 0 else None
+    # The header also permits an HTTP date.
+    try:
+        when = email.utils.parsedate_to_datetime(value)
+    except (TypeError, ValueError):
+        return None
+    if when.tzinfo is None:
+        when = when.replace(tzinfo=datetime.UTC)
+    delta = (when - datetime.datetime.now(datetime.UTC)).total_seconds()
+    return max(0.0, math.ceil(delta))

internetdata/models.py

@@ -0,0 +1,197 @@
+"""What the API answers, and the one place the wire shape becomes an idiomatic one.
+
+The generated models are a wire contract rather than an API: the spec spells
+`redistribution` as a nullable enum, which the generator renders as a union of three
+single-member enum classes, and nobody should have to read that. These are frozen
+dataclasses of plain values, built straight from the served JSON, with `raw` kept beside
+them so a field this pinned spec predates is still reachable.
+"""
+
+from __future__ import annotations
+
+import datetime
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+__all__ = [
+    "Database",
+    "DatabaseMetadata",
+    "DatabaseVersion",
+    "Download",
+    "Format",
+    "MetadataColumn",
+    "Outcome",
+    "Redistribution",
+    "Standing",
+]
+
+Format = Literal["csvgz", "mmdb"]
+"""The file formats a database version can be built in.
+
+Which of them a given version HAS is `DatabaseVersion.formats`; asking for another is a
+`bad_request` rather than a gap, because the `_provider` catalogs are keyed by provider
+id and no MMDB exists for them.
+"""
+
+Standing = Literal["licensed", "expired", "unlicensed"]
+"""Where your organization stands with one database family."""
+
+Redistribution = Literal["evaluation", "internal", "redistribute"]
+"""What a licence permits you to do with the data. `None` when there is no licence."""
+
+Outcome = Literal["ok", "unauthorized", "denied", "expired", "unknown", "unavailable"]
+"""How one download attempt ended, refusals included."""
+
+
+@dataclass(frozen=True, slots=True)
+class DatabaseVersion:
+    """One published version of a family.
+
+    Old versions are frozen rather than migrated, so several stay downloadable at once.
+    `id` is what `download`, `checksums` and `metadata` take; the family `base` is what a
+    licence is held against.
+    """
+
+    id: str
+    version: int
+    summary: str
+    formats: tuple[Format, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class Database:
+    """One database FAMILY, with your organization's licence beside it.
+
+    A family your organization has never licensed is still listed, with `standing` set to
+    `unlicensed`, so you can see what else exists. A family commissioned for a single
+    customer is a different matter: it is absent from this listing entirely for everyone
+    who does not license it. Absence here means "not yours to see", never "does not
+    exist", so the catalog is not the same document for every key.
+    """
+
+    base: str
+    name: str
+    summary: str
+    standing: Standing
+    redistribution: Redistribution | None
+    starts: datetime.datetime | None
+    expires: datetime.datetime | None
+    versions: tuple[DatabaseVersion, ...]
+    raw: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class MetadataColumn:
+    """One column of a published file. `description` is absent on older builds."""
+
+    name: str
+    type: str
+    description: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class DatabaseMetadata:
+    """What is inside one database: freshness, row count, columns, samples and sizes.
+
+    Poll this to decide whether today's build is worth fetching. `size` is keyed by
+    format and is in bytes, which is what a caller should budget a transfer against
+    before starting one.
+    """
+
+    id: str
+    updated: datetime.date
+    entries: int
+    schema: dict[str, tuple[MetadataColumn, ...]]
+    size: dict[str, int]
+    update_freq: str | None = None
+    sample: dict[str, tuple[dict[str, Any], ...]] = field(default_factory=dict)
+    raw: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class Download:
+    """One download ATTEMPT by your organization, refusals included.
+
+    `bytes` is the object size when the link was minted rather than bytes delivered: the
+    transfer is a presigned redirect straight to object storage, so the API never
+    observes how much of it was taken.
+    """
+
+    dataset_id: str
+    format: str
+    outcome: Outcome
+    created: datetime.datetime
+    bytes: int | None = None
+    http_status: int | None = None
+    apikey_id: str | None = None
+    client_ip: str | None = None
+    user_agent: str | None = None
+
+
+def to_database(body: dict[str, Any]) -> Database:
+    return Database(
+        base=body["base"],
+        name=body["name"],
+        summary=body["summary"],
+        standing=body["standing"],
+        redistribution=body["redistribution"],
+        starts=_datetime(body["starts"]),
+        expires=_datetime(body["expires"]),
+        versions=tuple(to_version(v) for v in body["versions"]),
+        raw=body,
+    )
+
+
+def to_version(body: dict[str, Any]) -> DatabaseVersion:
+    return DatabaseVersion(
+        id=body["id"],
+        version=body["version"],
+        summary=body["summary"],
+        formats=tuple(body["formats"]),
+    )
+
+
+def to_metadata(body: dict[str, Any]) -> DatabaseMetadata:
+    return DatabaseMetadata(
+        id=body["id"],
+        updated=datetime.date.fromisoformat(body["updated"]),
+        entries=body["entries"],
+        schema={
+            fmt: tuple(to_column(c) for c in columns) for fmt, columns in body["schema"].items()
+        },
+        size=dict(body["size"]),
+        update_freq=body.get("update_freq"),
+        sample={fmt: tuple(rows) for fmt, rows in body.get("sample", {}).items()},
+        raw=body,
+    )
+
+
+def to_column(body: dict[str, Any]) -> MetadataColumn:
+    return MetadataColumn(name=body["name"], type=body["type"], description=body.get("description"))
+
+
+def to_download(body: dict[str, Any]) -> Download:
+    return Download(
+        dataset_id=body["dataset_id"],
+        format=body["format"],
+        outcome=body["outcome"],
+        created=datetime.datetime.fromisoformat(body["created"]),
+        bytes=body["bytes"],
+        http_status=body["http_status"],
+        apikey_id=body["apikey_id"],
+        client_ip=body["client_ip"],
+        user_agent=body["user_agent"],
+    )
+
+
+def _datetime(value: Any) -> datetime.datetime | None:
+    """A NULLABLE wire timestamp. A licence 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".
+    """
+    if value is None:
+        return None
+    return datetime.datetime.fromisoformat(value)

internetdata-1.0.0.dist-info/METADATA

@@ -0,0 +1,184 @@
+Metadata-Version: 2.5
+Name: internetdata
+Version: 1.0.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
+Project-URL: Source, https://github.com/internetdata/sdk-python
+Project-URL: Issues, https://github.com/internetdata/sdk-python/issues
+Author-email: Mslm Dev <support@internetdata.io>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: asn,bogon,dataset,geolocation,hosting,internetdata,ip-database,ip-intelligence,mmdb,proxy,vpn
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Internet
+Classifier: Topic :: Security
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: attrs>=22.2.0
+Requires-Dist: httpx<1,>=0.27
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: openapi-python-client<0.30,>=0.29; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# [<img src="https://s3.internetdata.io/internetdata-public/brand/mark.svg" alt="InternetData" width="24"/>](https://internetdata.io/) InternetData Python Client Library
+
+[![PyPI](https://img.shields.io/pypi/v/internetdata.svg)](https://pypi.org/project/internetdata/)
+[![license](https://img.shields.io/pypi/l/internetdata.svg)](LICENSE)
+
+The official Python client library for the [InternetData](https://internetdata.io) API.
+
+The library helps you browse the databases your organization is licensed for, check what is in each build before you fetch it, and download and verify the files.
+
+## Getting Started
+
+```bash
+pip install internetdata
+```
+
+Requires Python 3.11 or newer. Type hints are included, and the package ships `py.typed`.
+
+## Usage
+
+Every call needs an API key carrying the `db.download` scope. Create one in the console, then:
+
+```python
+import os
+from internetdata import InternetData
+
+client = InternetData(os.environ["INTERNETDATA_API_KEY"])
+
+for family in client.database.list():
+    print(family.base, family.standing, [v.id for v in family.versions])
+```
+
+The client holds an HTTP connection pool, so use it as a context manager, or call `client.close()` when you are done with it:
+
+```python
+with InternetData(api_key) as client:
+    print(len(client.database.list()))
+```
+
+### The catalog
+
+`list` answers database FAMILIES. A licence is held against a family, while a download names a specific version, so the ids the other calls take come from each family's `versions`:
+
+```python
+for family in client.database.list():
+    if family.standing != "licensed":
+        continue
+    for version in family.versions:
+        print(version.id, version.formats)   # 'bogon_ip_v1' ('csvgz', 'mmdb')
+```
+
+`standing` is `licensed`, `expired` or `unlicensed`, and `redistribution` is what your licence lets you do with the data (`evaluation`, `internal`, `redistribute`, or `None` when there is no licence). A family you have never bought is still listed, as `unlicensed`, so you can see what else exists.
+
+**The catalog is not the same document for every key.** Databases commissioned for a single customer are absent from the listing entirely for everyone else, rather than shown as `unlicensed`. The server decides that per key, so treat what you get back as the answer for the key you asked with: this library never caches a listing, never reuses one across clients, and has no built-in list of database ids to fall back on.
+
+### What is inside a build
+
+`metadata` is cheap enough to poll. It answers when the build was generated, how many rows it has, its columns and a few real rows, and the size of each format in bytes, all without moving the file:
+
+```python
+meta = client.database.metadata("bogon_ip_v1")
+
+print(meta.updated)                  # datetime.date(2026, 9, 4)
+print(meta.entries)                  # 1234
+print(meta.size["csvgz"])            # 760
+print([c.name for c in meta.schema["csvgz"]])
+```
+
+Checking `size` before a download is worth the round trip: the catalog spans a few hundred bytes to several gigabytes.
+
+### Downloading
+
+Three ways, depending on what you want to do with the bytes:
+
+```python
+url = client.database.download_url("bogon_ip_v1", "csvgz")
+raw = client.database.download_bytes("bogon_ip_v1", "csvgz")
+written = client.database.download("bogon_ip_v1", "mmdb", "./bogon_ip_v1.mmdb")
+```
+
+`download_url` hands back a time-limited link straight to object storage. It carries its own signature and none of your API key, so you can pass it to `curl`, a job runner or anything else that speaks HTTP. The link authorizes the START of a transfer, so one already running is not cut off when it lapses.
+
+`download` streams to a file, so nothing larger than a chunk is ever held in memory. The bytes land in a neighboring `.part` file that is moved into place only once the whole transfer has arrived, so a failed refresh leaves the copy you already had untouched. `download_bytes` holds the whole file in memory, so reach for it only at the small end of the catalog.
+
+Either way a short transfer fails rather than handing you a truncated file, and the key is never sent to object storage.
+
+Verify what you fetched against the published digests:
+
+```python
+import hashlib
+
+digests = client.database.checksums("bogon_ip_v1", "csvgz")
+assert hashlib.sha256(raw).hexdigest() == digests["sha256"]
+```
+
+### Download history
+
+`downloads` answers your organization's recent attempts, newest first, refusals included. A denial is what answers "it stopped working", and its absence answers nothing:
+
+```python
+for attempt in client.database.downloads(limit=20):
+    print(attempt.created, attempt.dataset_id, attempt.outcome, attempt.http_status)
+```
+
+### Async
+
+Everything above works the same way under asyncio, with `AsyncInternetData`:
+
+```python
+import asyncio
+from internetdata import AsyncInternetData
+
+async def main():
+    async with AsyncInternetData(api_key) as client:
+        meta = await client.database.metadata("bogon_ip_v1")
+        await client.database.download("bogon_ip_v1", "csvgz", "./bogon_ip_v1.csv.gz")
+        print(meta.entries)
+
+asyncio.run(main())
+```
+
+### Errors
+
+Failures raise an `InternetDataError` carrying a `kind` and a `retryable` flag:
+
+```python
+from internetdata import InternetDataError
+
+try:
+    client.database.download_url("vpn_ip_v1", "mmdb")
+except InternetDataError as err:
+    print(err.kind, err.retryable, err.message)   # forbidden False NOT_LICENSED
+```
+
+`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.
+
+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.
+
+## 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.
+
+## About InternetData
+
+InternetData: IP and network intelligence databases, published as CSV and MMDB, licensed by contract and downloadable on demand.
+
+[<img src="https://s3.internetdata.io/internetdata-public/brand/mark.svg" alt="InternetData" width="96"/>](https://internetdata.io/)
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).

internetdata-1.0.0.dist-info/RECORD

@@ -0,0 +1,46 @@
+internetdata/__init__.py,sha256=RxzMbXKap5PrHulNUwHJSLGkrIM1mMcD88CR1ShEWiY,1105
+internetdata/_core.py,sha256=3waAQnkS_0KYaSl-7bHmBDjwOiR-R0A0z6G0oi8jnKU,11064
+internetdata/aio.py,sha256=KF-8PX7MQYIDFupvzyI7LUkP4vHl9AljdHAFDFzyVww,10311
+internetdata/client.py,sha256=42dL-9pyLetDFpkDbOypWkUBjsS4TjRn2zd-uwMMlOc,10379
+internetdata/errors.py,sha256=dYmFTImvgNqNPgIrcPCw2fGTZf8c_Ws7Clu8otiDLxw,4316
+internetdata/models.py,sha256=M-w6AyqV7l1uM9FsRHkGsc_bXN2TGxE5Me6ylp2nNdY,6495
+internetdata/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+internetdata/_generated/__init__.py,sha256=wqKoc5J-jEpNI_y90nHagEpn2sTWbwTYnMmCgqDEBq0,159
+internetdata/_generated/client.py,sha256=MHk8TC1YjyaLkvQ3tF0HBP561cJZmQY8Ih6seOCcOMI,12382
+internetdata/_generated/errors.py,sha256=gO8GBmKqmSNgAg-E5oT-oOyxztvp7V_6XG7OUTT15q0,546
+internetdata/_generated/types.py,sha256=0We4NPvhIYASRpQ3le41nmJeEAVm42-2VKdzlJ4Ogok,1343
+internetdata/_generated/api/__init__.py,sha256=zTSiG_ujSjAqWPyc435YXaX9XTlpMjiJWBbV-f-YtdA,45
+internetdata/_generated/api/database_v_2/__init__.py,sha256=5vd9uJWAjRqa9xzxzYkLD1yoZ12Ld_bAaNB5WX4fbE8,56
+internetdata/_generated/api/database_v_2/database_checksum_v2.py,sha256=MI-zxBNO8y-_ZGJ8zNbnv_eIrMgrGyHxeIoZ18w3Ir0,5448
+internetdata/_generated/api/database_v_2/database_metadata_v2.py,sha256=WVv8-Qe_rGtkvLxyOb50_HcrwixB3z6PqlzOaPX0rFI,5446
+internetdata/_generated/api/database_v_2/download_database_v2.py,sha256=Qf_PDFwAn1rHxsI3P9Db2KhUoekIN6ik_Vn1t5uCPlk,5554
+internetdata/_generated/api/database_v_2/list_databases.py,sha256=u8hDrKC2BEdKuh-a9p4jKxVBKfzlQD7ufAGf5j52uJ8,4958
+internetdata/_generated/api/database_v_2/list_downloads.py,sha256=-2WV7ghS4e5On8xPRzAuHAHBmhkl83rWYZEVyJy5SaI,4820
+internetdata/_generated/models/__init__.py,sha256=KyWrvMFBzQIxvajNAth3TEIQXOTPhtOKgmRNbmOwo1g,2170
+internetdata/_generated/models/database.py,sha256=v_zZZ_9EUbNXRoJNstk8H_uX8VTIPJr__uQElLCVqG4,7983
+internetdata/_generated/models/database_checksum_v2_format.py,sha256=nof7_Q3xI2VhEN3GzhqUc-nGqEp5UiyUQSVGKqOqDSo,168
+internetdata/_generated/models/database_checksum_v2_response_200.py,sha256=bw21224pDJtt28sQNuddVCv4gA57DmqzBjU6-5O9mow,2311
+internetdata/_generated/models/database_checksum_v2_response_200_format.py,sha256=PIn4sLd4drgU1Y90enf3NC39Z4acdH8WRZ85ohdPOS0,179
+internetdata/_generated/models/database_metadata.py,sha256=yMjTI9YHiQ61E4F9tzAFciRjcANy494mVf-yaFrOA4k,4039
+internetdata/_generated/models/database_metadata_column.py,sha256=7EaGGmKkeFTSdUvsNKGuVJRx_gwQQZ63dapiJNhpm3A,2005
+internetdata/_generated/models/database_metadata_sample.py,sha256=LaS_rGlKTljIItUN9giTM-HXUAG3mnjV1iat51BtQUM,2642
+internetdata/_generated/models/database_metadata_sample_additional_property_item.py,sha256=fapR9XWubK3WS07JfgKrnbQbLQN1OOagR7pnTt8TM_Q,1401
+internetdata/_generated/models/database_metadata_schema.py,sha256=DiWZkwkbJr3KqseZbq0837GuLsn9QzZe6in74M0Uhqk,2394
+internetdata/_generated/models/database_metadata_size.py,sha256=yZ9lYIK2fM3npNC6Cz10l8Gw1CfvF12rSA_GWRFH8SU,1301
+internetdata/_generated/models/database_redistribution_type_1.py,sha256=4XI7wpGnmbQ52EGB-bTlOXD1_G5ubbq0kXkGSRBXIJo,223
+internetdata/_generated/models/database_redistribution_type_2_type_1.py,sha256=3eHBM6r-0F8epfzr14yq8hpncuqY1NjA9wWaRl4mAIw,228
+internetdata/_generated/models/database_redistribution_type_3_type_1.py,sha256=h3eqMgSTEEM47Q-ATEqueDLcsAtzKRJGy1l18XKwfZI,228
+internetdata/_generated/models/database_standing.py,sha256=fOhY--mUbtkr188IySudfuyub5XpjnNjudrQ93MRUvU,202
+internetdata/_generated/models/database_version.py,sha256=cqkfPCiY4BBQIiC5sAtFZp75RSkTctlFS1dbWqeki_Y,2723
+internetdata/_generated/models/database_version_formats_item.py,sha256=IGjztCYren6snoX0zb-m0KTtwzNKGBmfBA4EZ3aJ_jc,170
+internetdata/_generated/models/db_checksums.py,sha256=4hB_YuDm7gVqhyJB2h-YuYjRqxyI9Jq3Dw2RJEP-NFo,2038
+internetdata/_generated/models/download.py,sha256=REGcSs5HF3atMI-vocxd2cY6-y-aoEExnYJhnc6BFdk,4586
+internetdata/_generated/models/download_database_v2_format.py,sha256=XRhb_e2-eJwtQ6mJJ0qzqi3T2kYBFgpbWCAh8fF8Egc,168
+internetdata/_generated/models/download_outcome.py,sha256=C_xdtqtpFbgg3M2WdT2nE48NPhErO4WMbqAx7_ZPJUA,271
+internetdata/_generated/models/error.py,sha256=n6JO5D33IFfQ7UoB5LANoJzKdVGfdO0nhwra1uNJFaY,1558
+internetdata/_generated/models/list_databases_response_200.py,sha256=c_qDy3Nq0Ymr2o8J6wsifvm_lWlnwtcZxGEJ86Q3Dhs,2071
+internetdata/_generated/models/list_downloads_response_200.py,sha256=HWd_62XgkIAnNbnJ8Kft-D2Et6qaZWe64QCHkS7tMuU,2071
+internetdata-1.0.0.dist-info/METADATA,sha256=bCspIg9ZfRhKtueBjhnxmBAzN-qBWpbYen71ljeZQGU,8224
+internetdata-1.0.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+internetdata-1.0.0.dist-info/licenses/LICENSE,sha256=wglb3Uww0HrX4-4rYO9Xe4j8Sn9STPtK2M9Tt5NKTrQ,1065
+internetdata-1.0.0.dist-info/RECORD,,

internetdata-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

internetdata-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mslm Dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.