xdataapi 0.3.0__py3-none-any.whl

xdataapi/models/create_checkout_response_200.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CreateCheckoutResponse200")
+
+
+@_attrs_define
+class CreateCheckoutResponse200:
+    """
+    Attributes:
+        url (str | Unset):
+        pack (str | Unset):
+        usd (int | Unset):
+        credits_ (int | Unset):
+        request_id (str | Unset):
+    """
+
+    url: str | Unset = UNSET
+    pack: str | Unset = UNSET
+    usd: int | Unset = UNSET
+    credits_: int | Unset = UNSET
+    request_id: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        url = self.url
+
+        pack = self.pack
+
+        usd = self.usd
+
+        credits_ = self.credits_
+
+        request_id = self.request_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if url is not UNSET:
+            field_dict["url"] = url
+        if pack is not UNSET:
+            field_dict["pack"] = pack
+        if usd is not UNSET:
+            field_dict["usd"] = usd
+        if credits_ is not UNSET:
+            field_dict["credits"] = credits_
+        if request_id is not UNSET:
+            field_dict["request_id"] = request_id
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        url = d.pop("url", UNSET)
+
+        pack = d.pop("pack", UNSET)
+
+        usd = d.pop("usd", UNSET)
+
+        credits_ = d.pop("credits", UNSET)
+
+        request_id = d.pop("request_id", UNSET)
+
+        create_checkout_response_200 = cls(
+            url=url,
+            pack=pack,
+            usd=usd,
+            credits_=credits_,
+            request_id=request_id,
+        )
+
+        create_checkout_response_200.additional_properties = d
+        return create_checkout_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

xdataapi/models/error.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.error_body import ErrorBody
+
+
+T = TypeVar("T", bound="Error")
+
+
+@_attrs_define
+class Error:
+    """Every failure from this API, in one shape. Charged nothing, always carries a
+    `request_id`. The same failure is available as RFC 9457 `application/problem+json`
+    to callers that ask for it.
+
+        Attributes:
+            error (ErrorBody): The failure itself. `code` is stable; match on it, never on `message`.
+            request_id (str):
+    """
+
+    error: ErrorBody
+    request_id: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        error = self.error.to_dict()
+
+        request_id = self.request_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "error": error,
+                "request_id": request_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.error_body import ErrorBody  # noqa: PLC0415
+
+        d = dict(src_dict)
+        error = ErrorBody.from_dict(d.pop("error"))
+
+        request_id = d.pop("request_id")
+
+        error = cls(
+            error=error,
+            request_id=request_id,
+        )
+
+        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

xdataapi/models/error_body.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.error_body_code import ErrorBodyCode
+
+T = TypeVar("T", bound="ErrorBody")
+
+
+@_attrs_define
+class ErrorBody:
+    """The failure itself. `code` is stable; match on it, never on `message`.
+
+    Attributes:
+        code (ErrorBodyCode):
+        message (str):
+    """
+
+    code: ErrorBodyCode
+    message: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        code = self.code.value
+
+        message = self.message
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "code": code,
+                "message": message,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        code = ErrorBodyCode(d.pop("code"))
+
+        message = d.pop("message")
+
+        error_body = cls(
+            code=code,
+            message=message,
+        )
+
+        error_body.additional_properties = d
+        return error_body
+
+    @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

xdataapi/models/error_body_code.py

@@ -0,0 +1,22 @@
+from enum import StrEnum
+
+
+class ErrorBodyCode(StrEnum):
+    ACCESS_DENIED = "access_denied"
+    BAD_REQUEST = "bad_request"
+    BILLING_DISABLED = "billing_disabled"
+    INTERNAL = "internal"
+    INVALID_KEY = "invalid_key"
+    MISSING_KEY = "missing_key"
+    NOT_FOUND = "not_found"
+    NO_ACCOUNT = "no_account"
+    NO_CREDITS = "no_credits"
+    PRODUCT_UNAVAILABLE = "product_unavailable"
+    QUERY_ID_STALE = "query_id_stale"
+    RATE_LIMITED = "rate_limited"
+    REQUEST_REJECTED = "request_rejected"
+    UPSTREAM_ERROR = "upstream_error"
+    UPSTREAM_RATE_LIMITED = "upstream_rate_limited"
+
+    def __str__(self) -> str:
+        return str(self.value)

xdataapi/models/get_me_response_200.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="GetMeResponse200")
+
+
+@_attrs_define
+class GetMeResponse200:
+    """
+    Attributes:
+        customer_id (str | Unset):
+        key_prefix (str | Unset):
+        balance (float | Unset):
+        rate_limit_qps (int | Unset):
+    """
+
+    customer_id: str | Unset = UNSET
+    key_prefix: str | Unset = UNSET
+    balance: float | Unset = UNSET
+    rate_limit_qps: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        customer_id = self.customer_id
+
+        key_prefix = self.key_prefix
+
+        balance = self.balance
+
+        rate_limit_qps = self.rate_limit_qps
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if customer_id is not UNSET:
+            field_dict["customer_id"] = customer_id
+        if key_prefix is not UNSET:
+            field_dict["key_prefix"] = key_prefix
+        if balance is not UNSET:
+            field_dict["balance"] = balance
+        if rate_limit_qps is not UNSET:
+            field_dict["rate_limit_qps"] = rate_limit_qps
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        customer_id = d.pop("customer_id", UNSET)
+
+        key_prefix = d.pop("key_prefix", UNSET)
+
+        balance = d.pop("balance", UNSET)
+
+        rate_limit_qps = d.pop("rate_limit_qps", UNSET)
+
+        get_me_response_200 = cls(
+            customer_id=customer_id,
+            key_prefix=key_prefix,
+            balance=balance,
+            rate_limit_qps=rate_limit_qps,
+        )
+
+        get_me_response_200.additional_properties = d
+        return get_me_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

xdataapi/models/get_tweets_body.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="GetTweetsBody")
+
+
+@_attrs_define
+class GetTweetsBody:
+    """
+    Attributes:
+        ids (list[str]):  Example: ['20', '1968000000000000000'].
+    """
+
+    ids: list[str]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        ids = self.ids
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "ids": ids,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        ids = cast(list[str], d.pop("ids"))
+
+        get_tweets_body = cls(
+            ids=ids,
+        )
+
+        get_tweets_body.additional_properties = d
+        return get_tweets_body
+
+    @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

xdataapi/models/get_users_body.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="GetUsersBody")
+
+
+@_attrs_define
+class GetUsersBody:
+    """
+    Attributes:
+        handles (list[str]):  Example: ['x', 'github', 'vercel'].
+    """
+
+    handles: list[str]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        handles = self.handles
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "handles": handles,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        handles = cast(list[str], d.pop("handles"))
+
+        get_users_body = cls(
+            handles=handles,
+        )
+
+        get_users_body.additional_properties = d
+        return get_users_body
+
+    @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

xdataapi/models/id_page.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.meta_cache import MetaCache
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="IdPage")
+
+
+@_attrs_define
+class IdPage:
+    """
+    Attributes:
+        items (int): Objects returned.
+        credits_charged (float):  Example: 20.
+        balance_remaining (float):  Example: 79980.
+        cache (MetaCache):
+        request_id (UUID):
+        next_cursor (str | Unset):
+        data (list[str] | Unset): Numeric user ids as strings.
+    """
+
+    items: int
+    credits_charged: float
+    balance_remaining: float
+    cache: MetaCache
+    request_id: UUID
+    next_cursor: str | Unset = UNSET
+    data: list[str] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        items = self.items
+
+        credits_charged = self.credits_charged
+
+        balance_remaining = self.balance_remaining
+
+        cache = self.cache.value
+
+        request_id = str(self.request_id)
+
+        next_cursor = self.next_cursor
+
+        data: list[str] | Unset = UNSET
+        if not isinstance(self.data, Unset):
+            data = self.data
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "items": items,
+                "credits_charged": credits_charged,
+                "balance_remaining": balance_remaining,
+                "cache": cache,
+                "request_id": request_id,
+            }
+        )
+        if next_cursor is not UNSET:
+            field_dict["next_cursor"] = next_cursor
+        if data is not UNSET:
+            field_dict["data"] = data
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        items = d.pop("items")
+
+        credits_charged = d.pop("credits_charged")
+
+        balance_remaining = d.pop("balance_remaining")
+
+        cache = MetaCache(d.pop("cache"))
+
+        request_id = UUID(d.pop("request_id"))
+
+        next_cursor = d.pop("next_cursor", UNSET)
+
+        data = cast(list[str], d.pop("data", UNSET))
+
+        id_page = cls(
+            items=items,
+            credits_charged=credits_charged,
+            balance_remaining=balance_remaining,
+            cache=cache,
+            request_id=request_id,
+            next_cursor=next_cursor,
+            data=data,
+        )
+
+        id_page.additional_properties = d
+        return id_page
+
+    @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

xdataapi/models/list_packs_response_200.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, 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.list_packs_response_200_data_item import ListPacksResponse200DataItem
+    from ..models.list_packs_response_200_rate_limits_item import ListPacksResponse200RateLimitsItem
+
+
+T = TypeVar("T", bound="ListPacksResponse200")
+
+
+@_attrs_define
+class ListPacksResponse200:
+    """
+    Attributes:
+        data (list[ListPacksResponse200DataItem] | Unset):
+        rate_limits (list[ListPacksResponse200RateLimitsItem] | Unset): Requests per second by the total paid over the
+            account's life. The limit only goes up.
+    """
+
+    data: list[ListPacksResponse200DataItem] | Unset = UNSET
+    rate_limits: list[ListPacksResponse200RateLimitsItem] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        data: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.data, Unset):
+            data = []
+            for data_item_data in self.data:
+                data_item = data_item_data.to_dict()
+                data.append(data_item)
+
+        rate_limits: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.rate_limits, Unset):
+            rate_limits = []
+            for rate_limits_item_data in self.rate_limits:
+                rate_limits_item = rate_limits_item_data.to_dict()
+                rate_limits.append(rate_limits_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if data is not UNSET:
+            field_dict["data"] = data
+        if rate_limits is not UNSET:
+            field_dict["rate_limits"] = rate_limits
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.list_packs_response_200_data_item import ListPacksResponse200DataItem  # noqa: PLC0415
+        from ..models.list_packs_response_200_rate_limits_item import (
+            ListPacksResponse200RateLimitsItem,  # noqa: PLC0415
+        )
+
+        d = dict(src_dict)
+        _data = d.pop("data", UNSET)
+        data: list[ListPacksResponse200DataItem] | Unset = UNSET
+        if _data is not UNSET:
+            data = []
+            for data_item_data in _data:
+                data_item = ListPacksResponse200DataItem.from_dict(data_item_data)
+
+                data.append(data_item)
+
+        _rate_limits = d.pop("rate_limits", UNSET)
+        rate_limits: list[ListPacksResponse200RateLimitsItem] | Unset = UNSET
+        if _rate_limits is not UNSET:
+            rate_limits = []
+            for rate_limits_item_data in _rate_limits:
+                rate_limits_item = ListPacksResponse200RateLimitsItem.from_dict(rate_limits_item_data)
+
+                rate_limits.append(rate_limits_item)
+
+        list_packs_response_200 = cls(
+            data=data,
+            rate_limits=rate_limits,
+        )
+
+        list_packs_response_200.additional_properties = d
+        return list_packs_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