internetdata 1.0.0__py3-none-any.whl

internetdata/_generated/models/database.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.database_redistribution_type_1 import DatabaseRedistributionType1
+from ..models.database_redistribution_type_2_type_1 import DatabaseRedistributionType2Type1
+from ..models.database_redistribution_type_3_type_1 import DatabaseRedistributionType3Type1
+from ..models.database_standing import DatabaseStanding
+
+if TYPE_CHECKING:
+    from ..models.database_version import DatabaseVersion
+
+
+T = TypeVar("T", bound="Database")
+
+
+@_attrs_define
+class Database:
+    """One database FAMILY, with your organization's licence beside it. A
+    licence covers the family, while a download names a specific version,
+    so the ids passed to `download` and `checksum` come from `versions`.
+
+        Attributes:
+            base (str): The family, e.g. `vpn_ip`. What a licence is held against. Example: vpn_ip.
+            name (str):  Example: VPN IP.
+            summary (str): One line on what the newest version contains.
+            standing (DatabaseStanding): `licensed` is a live grant, `expired` one whose term has ended, and
+                `unlicensed` a database published but never bought.
+            redistribution (DatabaseRedistributionType1 | DatabaseRedistributionType2Type1 |
+                DatabaseRedistributionType3Type1 | None): What your licence permits you to do with the data. Null when there
+                is no licence.
+            starts (datetime.datetime | None):
+            expires (datetime.datetime | None): Null when the licence has no end date, or when there is none.
+            versions (list[DatabaseVersion]): Every published version of this family, oldest first. Old versions
+                are frozen rather than migrated, so both stay downloadable.
+    """
+
+    base: str
+    name: str
+    summary: str
+    standing: DatabaseStanding
+    redistribution: (
+        DatabaseRedistributionType1
+        | DatabaseRedistributionType2Type1
+        | DatabaseRedistributionType3Type1
+        | None
+    )
+    starts: datetime.datetime | None
+    expires: datetime.datetime | None
+    versions: list[DatabaseVersion]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        base = self.base
+
+        name = self.name
+
+        summary = self.summary
+
+        standing = self.standing.value
+
+        redistribution: None | str
+        if (
+            isinstance(self.redistribution, DatabaseRedistributionType1)
+            or isinstance(self.redistribution, DatabaseRedistributionType2Type1)
+            or isinstance(self.redistribution, DatabaseRedistributionType3Type1)
+        ):
+            redistribution = self.redistribution.value
+        else:
+            redistribution = self.redistribution
+
+        starts: None | str
+        if isinstance(self.starts, datetime.datetime):
+            starts = self.starts.isoformat()
+        else:
+            starts = self.starts
+
+        expires: None | str
+        if isinstance(self.expires, datetime.datetime):
+            expires = self.expires.isoformat()
+        else:
+            expires = self.expires
+
+        versions = []
+        for versions_item_data in self.versions:
+            versions_item = versions_item_data.to_dict()
+            versions.append(versions_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "base": base,
+                "name": name,
+                "summary": summary,
+                "standing": standing,
+                "redistribution": redistribution,
+                "starts": starts,
+                "expires": expires,
+                "versions": versions,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.database_version import DatabaseVersion
+
+        d = dict(src_dict)
+        base = d.pop("base")
+
+        name = d.pop("name")
+
+        summary = d.pop("summary")
+
+        standing = DatabaseStanding(d.pop("standing"))
+
+        def _parse_redistribution(
+            data: object,
+        ) -> (
+            DatabaseRedistributionType1
+            | DatabaseRedistributionType2Type1
+            | DatabaseRedistributionType3Type1
+            | None
+        ):
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                redistribution_type_1 = DatabaseRedistributionType1(data)
+
+                return redistribution_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                redistribution_type_2_type_1 = DatabaseRedistributionType2Type1(data)
+
+                return redistribution_type_2_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                redistribution_type_3_type_1 = DatabaseRedistributionType3Type1(data)
+
+                return redistribution_type_3_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(
+                DatabaseRedistributionType1
+                | DatabaseRedistributionType2Type1
+                | DatabaseRedistributionType3Type1
+                | None,
+                data,
+            )
+
+        redistribution = _parse_redistribution(d.pop("redistribution"))
+
+        def _parse_starts(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                starts_type_0 = datetime.datetime.fromisoformat(data)
+
+                return starts_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        starts = _parse_starts(d.pop("starts"))
+
+        def _parse_expires(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                expires_type_0 = datetime.datetime.fromisoformat(data)
+
+                return expires_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        expires = _parse_expires(d.pop("expires"))
+
+        versions = []
+        _versions = d.pop("versions")
+        for versions_item_data in _versions:
+            versions_item = DatabaseVersion.from_dict(versions_item_data)
+
+            versions.append(versions_item)
+
+        database = cls(
+            base=base,
+            name=name,
+            summary=summary,
+            standing=standing,
+            redistribution=redistribution,
+            starts=starts,
+            expires=expires,
+            versions=versions,
+        )
+
+        database.additional_properties = d
+        return database
+
+    @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_checksum_v2_format.py

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

internetdata/_generated/models/database_checksum_v2_response_200.py

@@ -0,0 +1,85 @@
+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
+
+from ..models.database_checksum_v2_response_200_format import DatabaseChecksumV2Response200Format
+
+if TYPE_CHECKING:
+    from ..models.db_checksums import DbChecksums
+
+
+T = TypeVar("T", bound="DatabaseChecksumV2Response200")
+
+
+@_attrs_define
+class DatabaseChecksumV2Response200:
+    """
+    Attributes:
+        id (str):
+        format_ (DatabaseChecksumV2Response200Format):
+        checksums (DbChecksums):
+    """
+
+    id: str
+    format_: DatabaseChecksumV2Response200Format
+    checksums: DbChecksums
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        format_ = self.format_.value
+
+        checksums = self.checksums.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "format": format_,
+                "checksums": checksums,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.db_checksums import DbChecksums
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        format_ = DatabaseChecksumV2Response200Format(d.pop("format"))
+
+        checksums = DbChecksums.from_dict(d.pop("checksums"))
+
+        database_checksum_v2_response_200 = cls(
+            id=id,
+            format_=format_,
+            checksums=checksums,
+        )
+
+        database_checksum_v2_response_200.additional_properties = d
+        return database_checksum_v2_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

internetdata/_generated/models/database_checksum_v2_response_200_format.py

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

internetdata/_generated/models/database_metadata.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import datetime
+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
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.database_metadata_sample import DatabaseMetadataSample
+    from ..models.database_metadata_schema import DatabaseMetadataSchema
+    from ..models.database_metadata_size import DatabaseMetadataSize
+
+
+T = TypeVar("T", bound="DatabaseMetadata")
+
+
+@_attrs_define
+class DatabaseMetadata:
+    """The build document written by the exporter, served through unchanged.
+
+    Attributes:
+        id (str):
+        updated (datetime.date): ISO-8601 date (YYYY-MM-DD) the published build was generated on. Example: 2026-09-04.
+        entries (int): Row count in the current build.
+        schema (DatabaseMetadataSchema): Columns, keyed by format.
+        size (DatabaseMetadataSize): Bytes per format.
+        update_freq (str | Unset): How often a new build is published.
+        sample (DatabaseMetadataSample | Unset): A few real rows, keyed by format.
+    """
+
+    id: str
+    updated: datetime.date
+    entries: int
+    schema: DatabaseMetadataSchema
+    size: DatabaseMetadataSize
+    update_freq: str | Unset = UNSET
+    sample: DatabaseMetadataSample | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        updated = self.updated.isoformat()
+
+        entries = self.entries
+
+        schema = self.schema.to_dict()
+
+        size = self.size.to_dict()
+
+        update_freq = self.update_freq
+
+        sample: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.sample, Unset):
+            sample = self.sample.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "updated": updated,
+                "entries": entries,
+                "schema": schema,
+                "size": size,
+            }
+        )
+        if update_freq is not UNSET:
+            field_dict["update_freq"] = update_freq
+        if sample is not UNSET:
+            field_dict["sample"] = sample
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.database_metadata_sample import DatabaseMetadataSample
+        from ..models.database_metadata_schema import DatabaseMetadataSchema
+        from ..models.database_metadata_size import DatabaseMetadataSize
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        updated = datetime.date.fromisoformat(d.pop("updated"))
+
+        entries = d.pop("entries")
+
+        schema = DatabaseMetadataSchema.from_dict(d.pop("schema"))
+
+        size = DatabaseMetadataSize.from_dict(d.pop("size"))
+
+        update_freq = d.pop("update_freq", UNSET)
+
+        _sample = d.pop("sample", UNSET)
+        sample: DatabaseMetadataSample | Unset
+        if isinstance(_sample, Unset):
+            sample = UNSET
+        else:
+            sample = DatabaseMetadataSample.from_dict(_sample)
+
+        database_metadata = cls(
+            id=id,
+            updated=updated,
+            entries=entries,
+            schema=schema,
+            size=size,
+            update_freq=update_freq,
+            sample=sample,
+        )
+
+        database_metadata.additional_properties = d
+        return database_metadata
+
+    @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_metadata_column.py

@@ -0,0 +1,80 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="DatabaseMetadataColumn")
+
+
+@_attrs_define
+class DatabaseMetadataColumn:
+    """
+    Attributes:
+        name (str):
+        type_ (str):
+        description (str | Unset):
+    """
+
+    name: str
+    type_: str
+    description: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        type_ = self.type_
+
+        description = self.description
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+                "type": type_,
+            }
+        )
+        if description is not UNSET:
+            field_dict["description"] = description
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        type_ = d.pop("type")
+
+        description = d.pop("description", UNSET)
+
+        database_metadata_column = cls(
+            name=name,
+            type_=type_,
+            description=description,
+        )
+
+        database_metadata_column.additional_properties = d
+        return database_metadata_column
+
+    @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_metadata_sample.py

@@ -0,0 +1,78 @@
+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_sample_additional_property_item import (
+        DatabaseMetadataSampleAdditionalPropertyItem,
+    )
+
+
+T = TypeVar("T", bound="DatabaseMetadataSample")
+
+
+@_attrs_define
+class DatabaseMetadataSample:
+    """A few real rows, keyed by format."""
+
+    additional_properties: dict[str, list[DatabaseMetadataSampleAdditionalPropertyItem]] = (
+        _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_sample_additional_property_item import (
+            DatabaseMetadataSampleAdditionalPropertyItem,
+        )
+
+        d = dict(src_dict)
+        database_metadata_sample = 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 = DatabaseMetadataSampleAdditionalPropertyItem.from_dict(
+                    additional_property_item_data
+                )
+
+                additional_property.append(additional_property_item)
+
+            additional_properties[prop_name] = additional_property
+
+        database_metadata_sample.additional_properties = additional_properties
+        return database_metadata_sample
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> list[DatabaseMetadataSampleAdditionalPropertyItem]:
+        return self.additional_properties[key]
+
+    def __setitem__(
+        self, key: str, value: list[DatabaseMetadataSampleAdditionalPropertyItem]
+    ) -> 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_sample_additional_property_item.py

@@ -0,0 +1,45 @@
+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="DatabaseMetadataSampleAdditionalPropertyItem")
+
+
+@_attrs_define
+class DatabaseMetadataSampleAdditionalPropertyItem:
+    additional_properties: dict[str, Any] = _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_sample_additional_property_item = cls()
+
+        database_metadata_sample_additional_property_item.additional_properties = d
+        return database_metadata_sample_additional_property_item
+
+    @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