tweetapi 1.1.0__py3-none-any.whl

tweetapi/resources/list_.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import Any, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..client import TweetAPI
+    from ..types import (
+        ListResponse,
+        TweetsPaginatedResponse,
+        UserPaginatedResponse,
+    )
+
+
+class ListResource:
+    def __init__(self, client: TweetAPI) -> None:
+        self._client = client
+
+    def get_details(self, *, list_id: str) -> ListResponse:
+        """Get list details."""
+        return self._client._get("/tw-v2/list/details", {"listId": list_id})
+
+    def get_tweets(self, *, list_id: str, cursor: Optional[str] = None) -> TweetsPaginatedResponse:
+        """Get tweets in a list."""
+        return self._client._get("/tw-v2/list/tweets", {"listId": list_id, "cursor": cursor})
+
+    def get_members(self, *, list_id: str, cursor: Optional[str] = None) -> UserPaginatedResponse:
+        """Get members of a list."""
+        return self._client._get("/tw-v2/list/members", {"listId": list_id, "cursor": cursor})
+
+    def get_followers(self, *, list_id: str, cursor: Optional[str] = None) -> UserPaginatedResponse:
+        """Get followers of a list."""
+        return self._client._get("/tw-v2/list/followers", {"listId": list_id, "cursor": cursor})

tweetapi/resources/post.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import Any, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..client import TweetAPI
+    from ..types import ActionResponse
+
+
+class PostResource:
+    def __init__(self, client: TweetAPI) -> None:
+        self._client = client
+
+    def create_post(self, *, auth_token: str, text: str, proxy: str, disable_link_preview: Optional[bool] = None) -> ActionResponse:
+        """Create a new tweet."""
+        return self._client._post("/tw-v2/interaction/create-post", {
+            "authToken": auth_token, "text": text, "proxy": proxy,
+            "disableLinkPreview": disable_link_preview,
+        })
+
+    def create_post_quote(self, *, auth_token: str, text: str, attachment_url: str, proxy: str, disable_link_preview: Optional[bool] = None) -> ActionResponse:
+        """Create a quote tweet."""
+        return self._client._post("/tw-v2/interaction/create-post-quote", {
+            "authToken": auth_token, "text": text, "attachmentUrl": attachment_url,
+            "proxy": proxy, "disableLinkPreview": disable_link_preview,
+        })
+
+    def create_post_with_media(self, *, auth_token: str, text: str, media: list[Any], proxy: str, disable_link_preview: Optional[bool] = None) -> ActionResponse:
+        """Create a tweet with media attachments."""
+        return self._client._post("/tw-v2/interaction/create-post-with-media", {
+            "authToken": auth_token, "text": text, "media": media,
+            "proxy": proxy, "disableLinkPreview": disable_link_preview,
+        })
+
+    def reply_post(self, *, auth_token: str, text: str, tweet_id: str, proxy: str, disable_link_preview: Optional[bool] = None) -> ActionResponse:
+        """Reply to a tweet."""
+        return self._client._post("/tw-v2/interaction/reply-post", {
+            "authToken": auth_token, "text": text, "tweetId": tweet_id,
+            "proxy": proxy, "disableLinkPreview": disable_link_preview,
+        })
+
+    def reply_post_with_media(self, *, auth_token: str, text: str, tweet_id: str, media: list[Any], proxy: str, disable_link_preview: Optional[bool] = None) -> ActionResponse:
+        """Reply to a tweet with media attachments."""
+        return self._client._post("/tw-v2/interaction/reply-post-with-media", {
+            "authToken": auth_token, "text": text, "tweetId": tweet_id,
+            "media": media, "proxy": proxy, "disableLinkPreview": disable_link_preview,
+        })
+
+    def delete_post(self, *, auth_token: str, tweet_id: str, proxy: Optional[str] = None) -> ActionResponse:
+        """Delete a tweet."""
+        return self._client._post("/tw-v2/interaction/delete-post", {
+            "authToken": auth_token, "tweetId": tweet_id, "proxy": proxy,
+        })

tweetapi/resources/space.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..client import TweetAPI
+    from ..types import SpaceResponse, SpaceStreamResponse
+
+
+class SpaceResource:
+    def __init__(self, client: TweetAPI) -> None:
+        self._client = client
+
+    def get_by_id(self, *, space_id: str) -> SpaceResponse:
+        """Get Space details by ID."""
+        return self._client._get("/tw-v2/space/by-id", {"spaceId": space_id})
+
+    def get_stream_url(self, *, media_key: str) -> SpaceStreamResponse:
+        """Get the HLS stream URL for a Space."""
+        return self._client._get("/tw-v2/space/stream-url", {"mediaKey": media_key})

tweetapi/resources/tweet.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import Any, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..client import TweetAPI
+    from ..types import (
+        TweetResponse,
+        TweetsPaginatedResponse,
+        TweetTranslationResponse,
+        UserPaginatedResponse,
+    )
+
+
+class TweetResource:
+    def __init__(self, client: TweetAPI) -> None:
+        self._client = client
+
+    def get_details_and_conversation(self, *, tweet_id: str, cursor: Optional[str] = None, sort_by: Optional[str] = None) -> TweetsPaginatedResponse:
+        """Get tweet details and conversation thread."""
+        return self._client._get("/tw-v2/tweet/details", {"tweetId": tweet_id, "cursor": cursor, "sortBy": sort_by})
+
+    def get_details_by_ids(self, *, ids: str) -> dict[str, Any]:
+        """Get details for multiple tweets by IDs (comma-separated, max 200)."""
+        return self._client._get("/tw-v2/tweet/details-by-ids", {"ids": ids})
+
+    def get_retweets(self, *, tweet_id: str, cursor: Optional[str] = None) -> UserPaginatedResponse:
+        """Get users who retweeted a tweet."""
+        return self._client._get("/tw-v2/tweet/retweets", {"tweetId": tweet_id, "cursor": cursor})
+
+    def get_quotes(self, *, tweet_id: str, cursor: Optional[str] = None) -> TweetsPaginatedResponse:
+        """Get quote tweets for a tweet."""
+        return self._client._get("/tw-v2/tweet/quotes", {"tweetId": tweet_id, "cursor": cursor})
+
+    def translate(self, *, tweet_id: str, dst_lang: str) -> TweetTranslationResponse:
+        """Translate a tweet to a different language."""
+        return self._client._post("/tw-v2/tweet/translate", {"tweetId": tweet_id, "dstLang": dst_lang})

tweetapi/resources/unencrypted_dm.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Any, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..client import TweetAPI
+    from ..types import ActionResponse, ApiResponse, PaginatedResponse
+
+
+class UnencryptedDMResource:
+    def __init__(self, client: TweetAPI) -> None:
+        self._client = client
+
+    def send_dm(self, *, auth_token: str, conversation_id: str, text: str, proxy: str, request_id: Optional[str] = None, media: Optional[list[Any]] = None) -> ActionResponse:
+        """Send an unencrypted direct message."""
+        return self._client._post("/tw-v2/interaction/send-dm", {
+            "authToken": auth_token, "conversationId": conversation_id,
+            "text": text, "proxy": proxy, "requestId": request_id, "media": media,
+        })
+
+    def get_dm_permissions(self, *, auth_token: str, recipient_ids: str, proxy: Optional[str] = None) -> ApiResponse:
+        """Check DM permissions for recipients."""
+        return self._client._get("/tw-v2/interaction/dm-permissions", {
+            "authToken": auth_token, "recipientIds": recipient_ids, "proxy": proxy,
+        })
+
+    def get_inbox_initial_state(self, *, auth_token: str, proxy: Optional[str] = None) -> ApiResponse:
+        """Get initial inbox state."""
+        return self._client._get("/tw-v2/interaction/inbox-initial-state", {
+            "authToken": auth_token, "proxy": proxy,
+        })
+
+    def get_inbox_trusted(self, *, auth_token: str, cursor: str, filter_low_quality: Optional[bool] = None, proxy: Optional[str] = None) -> PaginatedResponse:
+        """Get trusted inbox conversations."""
+        return self._client._get("/tw-v2/interaction/inbox-timeline-trusted", {
+            "authToken": auth_token, "cursor": cursor,
+            "filterLowQuality": filter_low_quality, "proxy": proxy,
+        })
+
+    def get_inbox_untrusted(self, *, auth_token: str, cursor: str, filter_low_quality: Optional[bool] = None, proxy: Optional[str] = None) -> PaginatedResponse:
+        """Get untrusted (message requests) inbox conversations."""
+        return self._client._get("/tw-v2/interaction/inbox-timeline-untrusted", {
+            "authToken": auth_token, "cursor": cursor,
+            "filterLowQuality": filter_low_quality, "proxy": proxy,
+        })
+
+    def get_conversation(self, *, auth_token: str, conversation_id: str, cursor: Optional[str] = None, proxy: Optional[str] = None) -> PaginatedResponse:
+        """Get messages in a conversation."""
+        return self._client._get("/tw-v2/interaction/conversation", {
+            "authToken": auth_token, "conversationId": conversation_id,
+            "cursor": cursor, "proxy": proxy,
+        })
+
+    def get_dm_user_updates(self, *, auth_token: str, cursor: str, proxy: Optional[str] = None) -> PaginatedResponse:
+        """Get DM user updates."""
+        return self._client._get("/tw-v2/interaction/dm-user-updates", {
+            "authToken": auth_token, "cursor": cursor, "proxy": proxy,
+        })
+
+    def accept_conversation(self, *, auth_token: str, conversation_id: str, proxy: Optional[str] = None) -> ActionResponse:
+        """Accept a conversation request."""
+        return self._client._post("/tw-v2/interaction/accept-conversation", {
+            "authToken": auth_token, "conversationId": conversation_id, "proxy": proxy,
+        })

tweetapi/resources/user.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from typing import Any, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..client import TweetAPI
+    from ..types import (
+        UserResponse,
+        UsersResponse,
+        UserPaginatedResponse,
+        UserRelationshipResponse,
+        TweetsPaginatedResponse,
+        PaginatedResponse,
+        ApiResponse,
+    )
+
+
+class UserResource:
+    def __init__(self, client: TweetAPI) -> None:
+        self._client = client
+
+    def get_by_username(self, *, username: str) -> UserResponse:
+        """Get a user profile by username."""
+        return self._client._get("/tw-v2/user/by-username", {"username": username})
+
+    def get_by_usernames(self, *, usernames: str) -> UsersResponse:
+        """Get multiple user profiles by usernames (comma-separated)."""
+        return self._client._get("/tw-v2/user/by-usernames", {"usernames": usernames})
+
+    def get_by_user_id(self, *, user_id: str) -> UserResponse:
+        """Get a user profile by user ID."""
+        return self._client._get("/tw-v2/user/by-id", {"userId": user_id})
+
+    def get_by_user_ids(self, *, user_ids: list[str]) -> UsersResponse:
+        """Get multiple user profiles by user IDs (list of ID strings, max 50)."""
+        return self._client._get("/tw-v2/user/by-ids", {"userIds": user_ids})
+
+    def get_tweets(self, *, user_id: str, cursor: Optional[str] = None) -> TweetsPaginatedResponse:
+        """Get a user's tweets."""
+        return self._client._get("/tw-v2/user/tweets", {"userId": user_id, "cursor": cursor})
+
+    def get_tweets_and_replies(self, *, user_id: str, cursor: Optional[str] = None) -> TweetsPaginatedResponse:
+        """Get a user's tweets and replies."""
+        return self._client._get("/tw-v2/user/tweets-and-replies", {"userId": user_id, "cursor": cursor})
+
+    def get_following(self, *, user_id: str, cursor: Optional[str] = None) -> UserPaginatedResponse:
+        """Get who a user follows (v2 — full user objects)."""
+        return self._client._get("/tw-v2/user/following", {"userId": user_id, "cursor": cursor})
+
+    def get_followers(self, *, user_id: str, cursor: Optional[str] = None) -> UserPaginatedResponse:
+        """Get a user's followers (v2 — full user objects)."""
+        return self._client._get("/tw-v2/user/followers", {"userId": user_id, "cursor": cursor})
+
+    def get_verified_followers(self, *, user_id: str, cursor: Optional[str] = None) -> UserPaginatedResponse:
+        """Get a user's verified followers."""
+        return self._client._get("/tw-v2/user/verified-followers", {"userId": user_id, "cursor": cursor})
+
+    def get_subscriptions(self, *, user_id: str, cursor: Optional[str] = None) -> UserPaginatedResponse:
+        """Get a user's subscriptions."""
+        return self._client._get("/tw-v2/user/subscriptions", {"userId": user_id, "cursor": cursor})
+
+    def get_following_v1(self, *, user_id: str, count: Optional[str] = None, cursor: Optional[str] = None) -> UserPaginatedResponse:
+        """Get who a user follows (v1 — supports count)."""
+        return self._client._get("/tw-v2/user/following-list", {"userId": user_id, "count": count, "cursor": cursor})
+
+    def get_followers_v1(self, *, user_id: str, count: Optional[str] = None, cursor: Optional[str] = None) -> UserPaginatedResponse:
+        """Get a user's followers (v1 — supports count)."""
+        return self._client._get("/tw-v2/user/followers-list", {"userId": user_id, "count": count, "cursor": cursor})
+
+    def get_following_ids(self, *, user_id: str, count: Optional[str] = None, cursor: Optional[str] = None) -> PaginatedResponse:
+        """Get IDs of accounts a user is following."""
+        return self._client._get("/tw-v2/user/following-ids", {"userId": user_id, "count": count, "cursor": cursor})
+
+    def get_followers_ids(self, *, user_id: str, count: Optional[str] = None, cursor: Optional[str] = None) -> PaginatedResponse:
+        """Get IDs of a user's followers."""
+        return self._client._get("/tw-v2/user/followers-ids", {"userId": user_id, "count": count, "cursor": cursor})
+
+    def check_follow(self, *, subject_id: str, target_id: str) -> UserRelationshipResponse:
+        """Check the follow relationship between two users."""
+        return self._client._get("/tw-v2/user/friendship", {"subjectId": subject_id, "targetId": target_id})
+
+    def about_account(self, *, username: str) -> ApiResponse:
+        """Get account creation details and transparency information."""
+        return self._client._get("/tw-v2/user/about-account", {"username": username})

tweetapi/resources/xchat.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import Any, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..client import TweetAPI
+    from ..types import ActionResponse, ApiResponse, PaginatedResponse
+
+
+class XChatResource:
+    def __init__(self, client: TweetAPI) -> None:
+        self._client = client
+
+    def setup(self, *, auth_token: str, user_id: str, pin: str, proxy: Optional[str] = None) -> ActionResponse:
+        """Initialize X Chat (encrypted DMs) for your account."""
+        return self._client._post("/tw-v2/xchat/setup", {
+            "authToken": auth_token, "userId": user_id, "pin": pin, "proxy": proxy,
+        })
+
+    def get_conversations(self, *, auth_token: str, cursor: Optional[str] = None, graph_snapshot_id: Optional[str] = None, limit: Optional[int] = None, proxy: Optional[str] = None) -> PaginatedResponse:
+        """List encrypted DM conversations."""
+        return self._client._post("/tw-v2/xchat/conversations", {
+            "authToken": auth_token, "cursor": cursor,
+            "graphSnapshotId": graph_snapshot_id, "limit": limit, "proxy": proxy,
+        })
+
+    def send(self, *, auth_token: str, recipient_id: str, message: str, proxy: Optional[str] = None) -> ActionResponse:
+        """Send an encrypted message."""
+        return self._client._post("/tw-v2/xchat/send", {
+            "authToken": auth_token, "recipientId": recipient_id,
+            "message": message, "proxy": proxy,
+        })
+
+    def get_history(self, *, auth_token: str, conversation_id: str, cursor: Optional[str] = None, limit: Optional[int] = None, proxy: Optional[str] = None) -> PaginatedResponse:
+        """Get encrypted conversation history."""
+        return self._client._post("/tw-v2/xchat/history", {
+            "authToken": auth_token, "conversationId": conversation_id,
+            "cursor": cursor, "limit": limit, "proxy": proxy,
+        })
+
+    def can_dm(self, *, auth_token: str, user_ids: list[str], proxy: Optional[str] = None) -> ApiResponse:
+        """Check if you can send encrypted DMs to users."""
+        return self._client._post("/tw-v2/xchat/can-dm", {
+            "authToken": auth_token, "userIds": user_ids, "proxy": proxy,
+        })