internetdata 1.0.0__py3-none-any.whl

internetdata/_generated/models/database_metadata_schema.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.database_metadata_column import DatabaseMetadataColumn
+
+
+T = TypeVar("T", bound="DatabaseMetadataSchema")
+
+
+@_attrs_define
+class DatabaseMetadataSchema:
+    """Columns, keyed by format."""
+
+    additional_properties: dict[str, list[DatabaseMetadataColumn]] = _attrs_field(
+        init=False, factory=dict
+    )
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = []
+            for additional_property_item_data in prop:
+                additional_property_item = additional_property_item_data.to_dict()
+                field_dict[prop_name].append(additional_property_item)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.database_metadata_column import DatabaseMetadataColumn
+
+        d = dict(src_dict)
+        database_metadata_schema = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = []
+            _additional_property = prop_dict
+            for additional_property_item_data in _additional_property:
+                additional_property_item = DatabaseMetadataColumn.from_dict(
+                    additional_property_item_data
+                )
+
+                additional_property.append(additional_property_item)
+
+            additional_properties[prop_name] = additional_property
+
+        database_metadata_schema.additional_properties = additional_properties
+        return database_metadata_schema
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> list[DatabaseMetadataColumn]:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: list[DatabaseMetadataColumn]) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

internetdata/_generated/models/database_metadata_size.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="DatabaseMetadataSize")
+
+
+@_attrs_define
+class DatabaseMetadataSize:
+    """Bytes per format."""
+
+    additional_properties: dict[str, int] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        database_metadata_size = cls()
+
+        database_metadata_size.additional_properties = d
+        return database_metadata_size
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> int:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: int) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

internetdata/_generated/models/database_redistribution_type_1.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+
+class DatabaseRedistributionType1(StrEnum):
+    EVALUATION = "evaluation"
+    INTERNAL = "internal"
+    REDISTRIBUTE = "redistribute"
+
+    def __str__(self) -> str:
+        return str(self.value)

internetdata/_generated/models/database_redistribution_type_2_type_1.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+
+class DatabaseRedistributionType2Type1(StrEnum):
+    EVALUATION = "evaluation"
+    INTERNAL = "internal"
+    REDISTRIBUTE = "redistribute"
+
+    def __str__(self) -> str:
+        return str(self.value)

internetdata/_generated/models/database_redistribution_type_3_type_1.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+
+class DatabaseRedistributionType3Type1(StrEnum):
+    EVALUATION = "evaluation"
+    INTERNAL = "internal"
+    REDISTRIBUTE = "redistribute"
+
+    def __str__(self) -> str:
+        return str(self.value)

internetdata/_generated/models/database_standing.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+
+class DatabaseStanding(StrEnum):
+    EXPIRED = "expired"
+    LICENSED = "licensed"
+    UNLICENSED = "unlicensed"
+
+    def __str__(self) -> str:
+        return str(self.value)

internetdata/_generated/models/database_version.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.database_version_formats_item import DatabaseVersionFormatsItem
+
+T = TypeVar("T", bound="DatabaseVersion")
+
+
+@_attrs_define
+class DatabaseVersion:
+    """
+    Attributes:
+        id (str): The versioned id. Pass this to `download`, `checksum` and `metadata`. Example: vpn_ip_v1.
+        version (int):  Example: 1.
+        summary (str):
+        formats (list[DatabaseVersionFormatsItem]): The formats this version is BUILT in. Asking for another is a 400,
+            not a gap - the `_provider` catalogs are keyed by provider id, so no
+            MMDB exists for them.
+    """
+
+    id: str
+    version: int
+    summary: str
+    formats: list[DatabaseVersionFormatsItem]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        version = self.version
+
+        summary = self.summary
+
+        formats = []
+        for formats_item_data in self.formats:
+            formats_item = formats_item_data.value
+            formats.append(formats_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "version": version,
+                "summary": summary,
+                "formats": formats,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        version = d.pop("version")
+
+        summary = d.pop("summary")
+
+        formats = []
+        _formats = d.pop("formats")
+        for formats_item_data in _formats:
+            formats_item = DatabaseVersionFormatsItem(formats_item_data)
+
+            formats.append(formats_item)
+
+        database_version = cls(
+            id=id,
+            version=version,
+            summary=summary,
+            formats=formats,
+        )
+
+        database_version.additional_properties = d
+        return database_version
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

internetdata/_generated/models/database_version_formats_item.py

@@ -0,0 +1,9 @@
+from enum import StrEnum
+
+
+class DatabaseVersionFormatsItem(StrEnum):
+    CSVGZ = "csvgz"
+    MMDB = "mmdb"
+
+    def __str__(self) -> str:
+        return str(self.value)

internetdata/_generated/models/db_checksums.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="DbChecksums")
+
+
+@_attrs_define
+class DbChecksums:
+    """
+    Attributes:
+        md5 (str): Hex-encoded MD5 digest.
+        sha1 (str): Hex-encoded SHA-1 digest.
+        sha256 (str): Hex-encoded SHA-256 digest.
+        sha512 (str): Hex-encoded SHA-512 digest.
+    """
+
+    md5: str
+    sha1: str
+    sha256: str
+    sha512: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        md5 = self.md5
+
+        sha1 = self.sha1
+
+        sha256 = self.sha256
+
+        sha512 = self.sha512
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "md5": md5,
+                "sha1": sha1,
+                "sha256": sha256,
+                "sha512": sha512,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        md5 = d.pop("md5")
+
+        sha1 = d.pop("sha1")
+
+        sha256 = d.pop("sha256")
+
+        sha512 = d.pop("sha512")
+
+        db_checksums = cls(
+            md5=md5,
+            sha1=sha1,
+            sha256=sha256,
+            sha512=sha512,
+        )
+
+        db_checksums.additional_properties = d
+        return db_checksums
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

internetdata/_generated/models/download.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.download_outcome import DownloadOutcome
+
+T = TypeVar("T", bound="Download")
+
+
+@_attrs_define
+class Download:
+    """One download ATTEMPT, refusals included.
+
+    Attributes:
+        dataset_id (str):
+        format_ (str):
+        outcome (DownloadOutcome):
+        bytes_ (int | None): Object size at redirect time, NOT bytes delivered: the transfer is a
+            presigned redirect straight to object storage, so we never observe
+            how much of it was taken.
+        http_status (int | None):
+        apikey_id (None | str): The key that made the request. Null when it could not be resolved.
+        client_ip (None | str):
+        user_agent (None | str):
+        created (datetime.datetime):
+    """
+
+    dataset_id: str
+    format_: str
+    outcome: DownloadOutcome
+    bytes_: int | None
+    http_status: int | None
+    apikey_id: None | str
+    client_ip: None | str
+    user_agent: None | str
+    created: datetime.datetime
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        dataset_id = self.dataset_id
+
+        format_ = self.format_
+
+        outcome = self.outcome.value
+
+        bytes_: int | None
+        bytes_ = self.bytes_
+
+        http_status: int | None
+        http_status = self.http_status
+
+        apikey_id: None | str
+        apikey_id = self.apikey_id
+
+        client_ip: None | str
+        client_ip = self.client_ip
+
+        user_agent: None | str
+        user_agent = self.user_agent
+
+        created = self.created.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "dataset_id": dataset_id,
+                "format": format_,
+                "outcome": outcome,
+                "bytes": bytes_,
+                "http_status": http_status,
+                "apikey_id": apikey_id,
+                "client_ip": client_ip,
+                "user_agent": user_agent,
+                "created": created,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        dataset_id = d.pop("dataset_id")
+
+        format_ = d.pop("format")
+
+        outcome = DownloadOutcome(d.pop("outcome"))
+
+        def _parse_bytes_(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        bytes_ = _parse_bytes_(d.pop("bytes"))
+
+        def _parse_http_status(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        http_status = _parse_http_status(d.pop("http_status"))
+
+        def _parse_apikey_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        apikey_id = _parse_apikey_id(d.pop("apikey_id"))
+
+        def _parse_client_ip(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        client_ip = _parse_client_ip(d.pop("client_ip"))
+
+        def _parse_user_agent(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        user_agent = _parse_user_agent(d.pop("user_agent"))
+
+        created = datetime.datetime.fromisoformat(d.pop("created"))
+
+        download = cls(
+            dataset_id=dataset_id,
+            format_=format_,
+            outcome=outcome,
+            bytes_=bytes_,
+            http_status=http_status,
+            apikey_id=apikey_id,
+            client_ip=client_ip,
+            user_agent=user_agent,
+            created=created,
+        )
+
+        download.additional_properties = d
+        return download
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

internetdata/_generated/models/download_database_v2_format.py

@@ -0,0 +1,9 @@
+from enum import StrEnum
+
+
+class DownloadDatabaseV2Format(StrEnum):
+    CSVGZ = "csvgz"
+    MMDB = "mmdb"
+
+    def __str__(self) -> str:
+        return str(self.value)

internetdata/_generated/models/download_outcome.py

@@ -0,0 +1,13 @@
+from enum import StrEnum
+
+
+class DownloadOutcome(StrEnum):
+    DENIED = "denied"
+    EXPIRED = "expired"
+    OK = "ok"
+    UNAUTHORIZED = "unauthorized"
+    UNAVAILABLE = "unavailable"
+    UNKNOWN = "unknown"
+
+    def __str__(self) -> str:
+        return str(self.value)

internetdata/_generated/models/error.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="Error")
+
+
+@_attrs_define
+class Error:
+    """
+    Attributes:
+        rc (str): A machine-readable result code. Deliberately not an enum: a code
+            added later must stay parseable by a client generated today.
+    """
+
+    rc: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        rc = self.rc
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "rc": rc,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        rc = d.pop("rc")
+
+        error = cls(
+            rc=rc,
+        )
+
+        error.additional_properties = d
+        return error
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

internetdata/_generated/models/list_databases_response_200.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.database import Database
+
+
+T = TypeVar("T", bound="ListDatabasesResponse200")
+
+
+@_attrs_define
+class ListDatabasesResponse200:
+    """
+    Attributes:
+        databases (list[Database]):
+    """
+
+    databases: list[Database]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        databases = []
+        for databases_item_data in self.databases:
+            databases_item = databases_item_data.to_dict()
+            databases.append(databases_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "databases": databases,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.database import Database
+
+        d = dict(src_dict)
+        databases = []
+        _databases = d.pop("databases")
+        for databases_item_data in _databases:
+            databases_item = Database.from_dict(databases_item_data)
+
+            databases.append(databases_item)
+
+        list_databases_response_200 = cls(
+            databases=databases,
+        )
+
+        list_databases_response_200.additional_properties = d
+        return list_databases_response_200
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties