xdataapi 0.3.0__py3-none-any.whl

xdataapi/models/tweet_response.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, 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
+
+if TYPE_CHECKING:
+    from ..models.tweet import Tweet
+
+
+T = TypeVar("T", bound="TweetResponse")
+
+
+@_attrs_define
+class TweetResponse:
+    """
+    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 (Tweet | Unset):
+    """
+
+    items: int
+    credits_charged: float
+    balance_remaining: float
+    cache: MetaCache
+    request_id: UUID
+    next_cursor: str | Unset = UNSET
+    data: Tweet | 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: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.data, Unset):
+            data = self.data.to_dict()
+
+        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:
+        from ..models.tweet import Tweet  # noqa: PLC0415
+
+        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 = d.pop("data", UNSET)
+        data: Tweet | Unset
+        if isinstance(_data, Unset):
+            data = UNSET
+        else:
+            data = Tweet.from_dict(_data)
+
+        tweet_response = cls(
+            items=items,
+            credits_charged=credits_charged,
+            balance_remaining=balance_remaining,
+            cache=cache,
+            request_id=request_id,
+            next_cursor=next_cursor,
+            data=data,
+        )
+
+        tweet_response.additional_properties = d
+        return tweet_response
+
+    @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/user.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+import datetime
+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
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="User")
+
+
+@_attrs_define
+class User:
+    """
+    Attributes:
+        id (str):  Example: 783214.
+        handle (str):  Example: X.
+        name (str):
+        followers (int):
+        following (int):
+        tweets (int):
+        created_at (datetime.datetime):
+        bio (str | Unset):
+        location (str | Unset):
+        url (str | Unset):
+        avatar_url (str | Unset):
+        banner_url (str | Unset):
+        verified (bool | Unset):
+        protected (bool | Unset):
+        likes (int | Unset):
+        listed (int | Unset):
+        pinned_tweet_ids (list[str] | Unset):
+    """
+
+    id: str
+    handle: str
+    name: str
+    followers: int
+    following: int
+    tweets: int
+    created_at: datetime.datetime
+    bio: str | Unset = UNSET
+    location: str | Unset = UNSET
+    url: str | Unset = UNSET
+    avatar_url: str | Unset = UNSET
+    banner_url: str | Unset = UNSET
+    verified: bool | Unset = UNSET
+    protected: bool | Unset = UNSET
+    likes: int | Unset = UNSET
+    listed: int | Unset = UNSET
+    pinned_tweet_ids: list[str] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        handle = self.handle
+
+        name = self.name
+
+        followers = self.followers
+
+        following = self.following
+
+        tweets = self.tweets
+
+        created_at = self.created_at.isoformat()
+
+        bio = self.bio
+
+        location = self.location
+
+        url = self.url
+
+        avatar_url = self.avatar_url
+
+        banner_url = self.banner_url
+
+        verified = self.verified
+
+        protected = self.protected
+
+        likes = self.likes
+
+        listed = self.listed
+
+        pinned_tweet_ids: list[str] | Unset = UNSET
+        if not isinstance(self.pinned_tweet_ids, Unset):
+            pinned_tweet_ids = self.pinned_tweet_ids
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "handle": handle,
+                "name": name,
+                "followers": followers,
+                "following": following,
+                "tweets": tweets,
+                "created_at": created_at,
+            }
+        )
+        if bio is not UNSET:
+            field_dict["bio"] = bio
+        if location is not UNSET:
+            field_dict["location"] = location
+        if url is not UNSET:
+            field_dict["url"] = url
+        if avatar_url is not UNSET:
+            field_dict["avatar_url"] = avatar_url
+        if banner_url is not UNSET:
+            field_dict["banner_url"] = banner_url
+        if verified is not UNSET:
+            field_dict["verified"] = verified
+        if protected is not UNSET:
+            field_dict["protected"] = protected
+        if likes is not UNSET:
+            field_dict["likes"] = likes
+        if listed is not UNSET:
+            field_dict["listed"] = listed
+        if pinned_tweet_ids is not UNSET:
+            field_dict["pinned_tweet_ids"] = pinned_tweet_ids
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        handle = d.pop("handle")
+
+        name = d.pop("name")
+
+        followers = d.pop("followers")
+
+        following = d.pop("following")
+
+        tweets = d.pop("tweets")
+
+        created_at = datetime.datetime.fromisoformat(d.pop("created_at"))
+
+        bio = d.pop("bio", UNSET)
+
+        location = d.pop("location", UNSET)
+
+        url = d.pop("url", UNSET)
+
+        avatar_url = d.pop("avatar_url", UNSET)
+
+        banner_url = d.pop("banner_url", UNSET)
+
+        verified = d.pop("verified", UNSET)
+
+        protected = d.pop("protected", UNSET)
+
+        likes = d.pop("likes", UNSET)
+
+        listed = d.pop("listed", UNSET)
+
+        pinned_tweet_ids = cast(list[str], d.pop("pinned_tweet_ids", UNSET))
+
+        user = cls(
+            id=id,
+            handle=handle,
+            name=name,
+            followers=followers,
+            following=following,
+            tweets=tweets,
+            created_at=created_at,
+            bio=bio,
+            location=location,
+            url=url,
+            avatar_url=avatar_url,
+            banner_url=banner_url,
+            verified=verified,
+            protected=protected,
+            likes=likes,
+            listed=listed,
+            pinned_tweet_ids=pinned_tweet_ids,
+        )
+
+        user.additional_properties = d
+        return user
+
+    @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/user_batch.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.batch_meta_cache import BatchMetaCache
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.batch_error import BatchError
+    from ..models.user import User
+
+
+T = TypeVar("T", bound="UserBatch")
+
+
+@_attrs_define
+class UserBatch:
+    """
+    Attributes:
+        errors (list[BatchError]): Inputs that returned nothing, with the reason. Never charged.
+        items (int): Objects returned.
+        credits_charged (float):
+        balance_remaining (float):
+        cache (BatchMetaCache):
+        cache_hits (int): Objects served from cache
+        request_id (UUID):
+        data (list[User] | Unset): Found profiles
+    """
+
+    errors: list[BatchError]
+    items: int
+    credits_charged: float
+    balance_remaining: float
+    cache: BatchMetaCache
+    cache_hits: int
+    request_id: UUID
+    data: list[User] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        errors = []
+        for errors_item_data in self.errors:
+            errors_item = errors_item_data.to_dict()
+            errors.append(errors_item)
+
+        items = self.items
+
+        credits_charged = self.credits_charged
+
+        balance_remaining = self.balance_remaining
+
+        cache = self.cache.value
+
+        cache_hits = self.cache_hits
+
+        request_id = str(self.request_id)
+
+        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)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "errors": errors,
+                "items": items,
+                "credits_charged": credits_charged,
+                "balance_remaining": balance_remaining,
+                "cache": cache,
+                "cache_hits": cache_hits,
+                "request_id": request_id,
+            }
+        )
+        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:
+        from ..models.batch_error import BatchError  # noqa: PLC0415
+        from ..models.user import User  # noqa: PLC0415
+
+        d = dict(src_dict)
+        errors = []
+        _errors = d.pop("errors")
+        for errors_item_data in _errors:
+            errors_item = BatchError.from_dict(errors_item_data)
+
+            errors.append(errors_item)
+
+        items = d.pop("items")
+
+        credits_charged = d.pop("credits_charged")
+
+        balance_remaining = d.pop("balance_remaining")
+
+        cache = BatchMetaCache(d.pop("cache"))
+
+        cache_hits = d.pop("cache_hits")
+
+        request_id = UUID(d.pop("request_id"))
+
+        _data = d.pop("data", UNSET)
+        data: list[User] | Unset = UNSET
+        if _data is not UNSET:
+            data = []
+            for data_item_data in _data:
+                data_item = User.from_dict(data_item_data)
+
+                data.append(data_item)
+
+        user_batch = cls(
+            errors=errors,
+            items=items,
+            credits_charged=credits_charged,
+            balance_remaining=balance_remaining,
+            cache=cache,
+            cache_hits=cache_hits,
+            request_id=request_id,
+            data=data,
+        )
+
+        user_batch.additional_properties = d
+        return user_batch
+
+    @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/user_page.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, 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
+
+if TYPE_CHECKING:
+    from ..models.user import User
+
+
+T = TypeVar("T", bound="UserPage")
+
+
+@_attrs_define
+class UserPage:
+    """
+    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[User] | Unset):
+    """
+
+    items: int
+    credits_charged: float
+    balance_remaining: float
+    cache: MetaCache
+    request_id: UUID
+    next_cursor: str | Unset = UNSET
+    data: list[User] | 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[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)
+
+        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:
+        from ..models.user import User  # noqa: PLC0415
+
+        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 = d.pop("data", UNSET)
+        data: list[User] | Unset = UNSET
+        if _data is not UNSET:
+            data = []
+            for data_item_data in _data:
+                data_item = User.from_dict(data_item_data)
+
+                data.append(data_item)
+
+        user_page = cls(
+            items=items,
+            credits_charged=credits_charged,
+            balance_remaining=balance_remaining,
+            cache=cache,
+            request_id=request_id,
+            next_cursor=next_cursor,
+            data=data,
+        )
+
+        user_page.additional_properties = d
+        return user_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