xdataapi 0.3.0__py3-none-any.whl

xdataapi/models/list_packs_response_200_data_item.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="ListPacksResponse200DataItem")
+
+
+@_attrs_define
+class ListPacksResponse200DataItem:
+    """
+    Attributes:
+        name (str | Unset):  Example: starter.
+        usd (int | Unset):  Example: 10.
+        credits_ (int | Unset):  Example: 80000.
+        buyable (bool | Unset):
+    """
+
+    name: str | Unset = UNSET
+    usd: int | Unset = UNSET
+    credits_: int | Unset = UNSET
+    buyable: bool | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        usd = self.usd
+
+        credits_ = self.credits_
+
+        buyable = self.buyable
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if name is not UNSET:
+            field_dict["name"] = name
+        if usd is not UNSET:
+            field_dict["usd"] = usd
+        if credits_ is not UNSET:
+            field_dict["credits"] = credits_
+        if buyable is not UNSET:
+            field_dict["buyable"] = buyable
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name", UNSET)
+
+        usd = d.pop("usd", UNSET)
+
+        credits_ = d.pop("credits", UNSET)
+
+        buyable = d.pop("buyable", UNSET)
+
+        list_packs_response_200_data_item = cls(
+            name=name,
+            usd=usd,
+            credits_=credits_,
+            buyable=buyable,
+        )
+
+        list_packs_response_200_data_item.additional_properties = d
+        return list_packs_response_200_data_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

xdataapi/models/list_packs_response_200_rate_limits_item.py

@@ -0,0 +1,70 @@
+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="ListPacksResponse200RateLimitsItem")
+
+
+@_attrs_define
+class ListPacksResponse200RateLimitsItem:
+    """
+    Attributes:
+        paid_usd (int | Unset):  Example: 10.
+        requests_per_second (int | Unset):  Example: 20.
+    """
+
+    paid_usd: int | Unset = UNSET
+    requests_per_second: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        paid_usd = self.paid_usd
+
+        requests_per_second = self.requests_per_second
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if paid_usd is not UNSET:
+            field_dict["paid_usd"] = paid_usd
+        if requests_per_second is not UNSET:
+            field_dict["requests_per_second"] = requests_per_second
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        paid_usd = d.pop("paid_usd", UNSET)
+
+        requests_per_second = d.pop("requests_per_second", UNSET)
+
+        list_packs_response_200_rate_limits_item = cls(
+            paid_usd=paid_usd,
+            requests_per_second=requests_per_second,
+        )
+
+        list_packs_response_200_rate_limits_item.additional_properties = d
+        return list_packs_response_200_rate_limits_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

xdataapi/models/media.py

@@ -0,0 +1,96 @@
+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.media_type import MediaType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="Media")
+
+
+@_attrs_define
+class Media:
+    """
+    Attributes:
+        type_ (MediaType | Unset):
+        url (str | Unset):
+        width (int | Unset):
+        height (int | Unset):
+    """
+
+    type_: MediaType | Unset = UNSET
+    url: str | Unset = UNSET
+    width: int | Unset = UNSET
+    height: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_: str | Unset = UNSET
+        if not isinstance(self.type_, Unset):
+            type_ = self.type_.value
+
+        url = self.url
+
+        width = self.width
+
+        height = self.height
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if url is not UNSET:
+            field_dict["url"] = url
+        if width is not UNSET:
+            field_dict["width"] = width
+        if height is not UNSET:
+            field_dict["height"] = height
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        _type_ = d.pop("type", UNSET)
+        type_: MediaType | Unset
+        if isinstance(_type_, Unset):
+            type_ = UNSET
+        else:
+            type_ = MediaType(_type_)
+
+        url = d.pop("url", UNSET)
+
+        width = d.pop("width", UNSET)
+
+        height = d.pop("height", UNSET)
+
+        media = cls(
+            type_=type_,
+            url=url,
+            width=width,
+            height=height,
+        )
+
+        media.additional_properties = d
+        return media
+
+    @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/media_type.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+
+class MediaType(StrEnum):
+    ANIMATED_GIF = "animated_gif"
+    PHOTO = "photo"
+    VIDEO = "video"
+
+    def __str__(self) -> str:
+        return str(self.value)

xdataapi/models/meta.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+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="Meta")
+
+
+@_attrs_define
+class Meta:
+    """
+    Attributes:
+        items (int): Objects returned.
+        credits_charged (float):  Example: 20.
+        balance_remaining (float):  Example: 79980.
+        cache (MetaCache):
+        request_id (UUID):
+        next_cursor (str | Unset):
+    """
+
+    items: int
+    credits_charged: float
+    balance_remaining: float
+    cache: MetaCache
+    request_id: UUID
+    next_cursor: 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
+
+        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
+
+        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)
+
+        meta = cls(
+            items=items,
+            credits_charged=credits_charged,
+            balance_remaining=balance_remaining,
+            cache=cache,
+            request_id=request_id,
+            next_cursor=next_cursor,
+        )
+
+        meta.additional_properties = d
+        return meta
+
+    @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/meta_cache.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+
+class MetaCache(StrEnum):
+    BYPASS = "bypass"
+    HIT = "hit"
+    MISS = "miss"
+
+    def __str__(self) -> str:
+        return str(self.value)

xdataapi/models/problem.py

@@ -0,0 +1,131 @@
+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.error_body import ErrorBody
+
+
+T = TypeVar("T", bound="Problem")
+
+
+@_attrs_define
+class Problem:
+    """RFC 9457 view of the same failure, served when the caller sends
+    `Accept: application/problem+json`. Nothing new is reported — `type`, `title`,
+    `status` and `detail` are the registered names for what `error.code` and
+    `error.message` already said, so a generic client can read a failure it has no
+    specific handling for.
+
+        Attributes:
+            type_ (str): A page describing this error code. Example: https://xdataapi.io/docs/errors#no_credits.
+            title (str):  Example: Balance is zero.
+            status (int):  Example: 402.
+            code (str): The same value as `error.code`. Stable; match on this, not on the text.
+            request_id (str):
+            detail (str | Unset): The same text as `error.message`.
+            error (ErrorBody | Unset): The failure itself. `code` is stable; match on it, never on `message`.
+    """
+
+    type_: str
+    title: str
+    status: int
+    code: str
+    request_id: str
+    detail: str | Unset = UNSET
+    error: ErrorBody | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_
+
+        title = self.title
+
+        status = self.status
+
+        code = self.code
+
+        request_id = self.request_id
+
+        detail = self.detail
+
+        error: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.error, Unset):
+            error = self.error.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+                "title": title,
+                "status": status,
+                "code": code,
+                "request_id": request_id,
+            }
+        )
+        if detail is not UNSET:
+            field_dict["detail"] = detail
+        if error is not UNSET:
+            field_dict["error"] = error
+
+        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)
+        type_ = d.pop("type")
+
+        title = d.pop("title")
+
+        status = d.pop("status")
+
+        code = d.pop("code")
+
+        request_id = d.pop("request_id")
+
+        detail = d.pop("detail", UNSET)
+
+        _error = d.pop("error", UNSET)
+        error: ErrorBody | Unset
+        if isinstance(_error, Unset):
+            error = UNSET
+        else:
+            error = ErrorBody.from_dict(_error)
+
+        problem = cls(
+            type_=type_,
+            title=title,
+            status=status,
+            code=code,
+            request_id=request_id,
+            detail=detail,
+            error=error,
+        )
+
+        problem.additional_properties = d
+        return problem
+
+    @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/search_tweets_product.py

@@ -0,0 +1,12 @@
+from enum import StrEnum
+
+
+class SearchTweetsProduct(StrEnum):
+    LATEST = "Latest"
+    PEOPLE = "People"
+    PHOTOS = "Photos"
+    TOP = "Top"
+    VIDEOS = "Videos"
+
+    def __str__(self) -> str:
+        return str(self.value)