twitter-openapi-python 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

twitter_openapi_python/api/tweet_api.py

@@ -5,22 +5,29 @@ import twitter_openapi_python_generated.models as models
 from x_client_transaction import ClientTransaction
 
 from twitter_openapi_python.models import (
-    ApiUtilsRaw,
+    CommunityApiUtilsData,
     TimelineApiUtilsResponse,
     TweetApiUtilsData,
     TwitterApiUtilsResponse,
+    UserApiUtilsData,
 )
 from twitter_openapi_python.utils import (
-    build_response,
-    entries_cursor,
+    community_entries_converter,
     error_check,
-    get_kwargs,
-    instruction_to_entry,
+    notification_entries_converter,
+    timeline_request,
+    trend_entries_converter,
     tweet_entries_converter,
+    user_entries_converter,
+    user_result_converter,
 )
 
 T = TypeVar("T")
 ResponseType = TwitterApiUtilsResponse[TimelineApiUtilsResponse[TweetApiUtilsData]]
+UserResponseType = TwitterApiUtilsResponse[TimelineApiUtilsResponse[UserApiUtilsData]]
+TrendResponseType = TwitterApiUtilsResponse[TimelineApiUtilsResponse[models.TimelineTrend]]
+NotificationResponseType = TwitterApiUtilsResponse[TimelineApiUtilsResponse[models.TimelineNotification]]
+CommunityResponseType = TwitterApiUtilsResponse[TimelineApiUtilsResponse[CommunityApiUtilsData]]
 ApiFnType = Callable[..., twitter.ApiResponse[T]]
 ParamType = dict[str, Any]
 
@@ -41,21 +48,7 @@ class TweetApiUtils:
         key: str,
         param: ParamType,
     ) -> ResponseType:
-        args = get_kwargs(flag=self.flag[key], additional=param, ct=self.ct)
-        res = apiFn(**args)
-        instruction = convertFn(res.data)
-        entry = instruction_to_entry(instruction)
-        tweet_list = tweet_entries_converter(entry)
-        raw = ApiUtilsRaw(
-            instruction=instruction,
-            entry=entry,
-        )
-        data = TimelineApiUtilsResponse[TweetApiUtilsData](
-            raw=raw,
-            cursor=entries_cursor(entry),
-            data=tweet_list,
-        )
-        return build_response(res, data)
+        return timeline_request(apiFn, self.flag[key], self.ct, convertFn, param, tweet_entries_converter)
 
     def get_tweet_detail(
         self,
@@ -100,7 +93,9 @@ class TweetApiUtils:
 
         response = self.request(
             apiFn=self.api.get_search_timeline_with_http_info,
-            convertFn=lambda e: error_check(e.data.search_by_raw_query, e.errors).search_timeline.timeline.instructions,
+            convertFn=lambda e: error_check(
+                error_check(e.data.search_by_raw_query, e.errors).search_timeline.timeline, e.errors
+            ).instructions,
             key="SearchTimeline",
             param=param,
         )
@@ -426,3 +421,262 @@ class TweetApiUtils:
             param=param,
         )
         return response
+
+    def get_user_highlights_tweets(
+        self,
+        user_id: str,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        param: ParamType = {"userId": user_id}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+
+        response = self.request(
+            apiFn=self.api.get_user_highlights_tweets_with_http_info,
+            convertFn=lambda e: error_check(e.data.user, e.errors).result.timeline.timeline.instructions,
+            key="UserHighlightsTweets",
+            param=param,
+        )
+        return response
+
+    def get_user_reposts_timeline(
+        self,
+        user_id: str,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        param: ParamType = {"userId": user_id}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+
+        response = self.request(
+            apiFn=self.api.get_user_reposts_timeline_with_http_info,
+            convertFn=lambda e: error_check(
+                error_check(e.data.user, e.errors).result.timeline.timeline, e.errors
+            ).instructions,
+            key="UserRepostsTimeline",
+            param=param,
+        )
+        return response
+
+    def get_user_super_follow_tweets(
+        self,
+        user_id: str,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        """Subscriber-only posts; without a subscription the timeline only carries a TimelineMessagePrompt."""
+        param: ParamType = {"userId": user_id}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+
+        response = self.request(
+            apiFn=self.api.get_user_super_follow_tweets_with_http_info,
+            convertFn=lambda e: error_check(
+                error_check(e.data.user, e.errors).result.timeline.timeline, e.errors
+            ).instructions,
+            key="UserSuperFollowTweets",
+            param=param,
+        )
+        return response
+
+    def get_explore_page(
+        self,
+        cursor: Optional[str] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> TrendResponseType:
+        """Trends of the first explore tab; the other tabs are GenericTimelineById timelines."""
+        param: ParamType = {}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if extra_param is not None:
+            param.update(extra_param)
+
+        return timeline_request(
+            self.api.get_explore_page_with_http_info,
+            self.flag["ExplorePage"],
+            self.ct,
+            lambda e: error_check(e.data.explore_page.body.initial_timeline.timeline.timeline, e.errors).instructions,
+            param,
+            trend_entries_converter,
+        )
+
+    def get_generic_timeline_by_id(
+        self,
+        timeline_id: str,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> TrendResponseType:
+        """Explore tab timelines (trending, news, sports, ...)."""
+        param: ParamType = {"timelineId": timeline_id}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+
+        return timeline_request(
+            self.api.get_generic_timeline_by_id_with_http_info,
+            self.flag["GenericTimelineById"],
+            self.ct,
+            lambda e: error_check(e.data.timeline.timeline, e.errors).instructions,
+            param,
+            trend_entries_converter,
+        )
+
+    def get_notifications_timeline(
+        self,
+        timeline_type: Optional[Literal["All", "Verified", "Mentions"]] = None,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> NotificationResponseType:
+        """Notification items only; the tweets of the Mentions tab are in data.raw.entry (tweet_entries_converter)."""
+        param: ParamType = {}
+        if timeline_type is not None:
+            param["timeline_type"] = timeline_type
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+
+        return timeline_request(
+            self.api.get_notifications_timeline_with_http_info,
+            self.flag["NotificationsTimeline"],
+            self.ct,
+            lambda e: error_check(
+                e.data.viewer_v2.user_results.result.notification_timeline.timeline, e.errors
+            ).instructions,
+            param,
+            notification_entries_converter,
+        )
+
+    def get_community_discovery_timeline(
+        self,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> CommunityResponseType:
+        param: ParamType = {}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+
+        return timeline_request(
+            self.api.get_community_discovery_timeline_with_http_info,
+            self.flag["CommunityDiscoveryTimeline"],
+            self.ct,
+            lambda e: error_check(e.data.viewer.community_discovery_timeline.timeline, e.errors).instructions,
+            param,
+            community_entries_converter,
+        )
+
+    def get_community_about_timeline(
+        self,
+        community_id: str,
+        extra_param: Optional[ParamType] = None,
+    ) -> UserResponseType:
+        """Moderators and members of a community."""
+        param: ParamType = {"communityId": community_id}
+        if extra_param is not None:
+            param.update(extra_param)
+
+        return timeline_request(
+            self.api.get_community_about_timeline_with_http_info,
+            self.flag["CommunityAboutTimeline"],
+            self.ct,
+            lambda e: error_check(e.data.community_results.result.about_timeline.timeline, e.errors).instructions,
+            param,
+            lambda entry: user_result_converter(user_entries_converter(entry)),
+        )
+
+    def get_connect_tab_timeline(
+        self,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> UserResponseType:
+        """Who to follow."""
+        param: ParamType = {}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+
+        return timeline_request(
+            self.api.get_connect_tab_timeline_with_http_info,
+            self.flag["ConnectTabTimeline"],
+            self.ct,
+            lambda e: error_check(e.data.connect_tab_timeline.timeline, e.errors).instructions,
+            param,
+            lambda entry: user_result_converter(user_entries_converter(entry)),
+        )
+
+    def get_bookmark_search_timeline(
+        self,
+        raw_query: str,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        """Search the account's bookmarks."""
+        param: ParamType = {"rawQuery": raw_query}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+
+        response = self.request(
+            apiFn=self.api.get_bookmark_search_timeline_with_http_info,
+            convertFn=lambda e: error_check(
+                e.data.search_by_raw_query.bookmarks_search_timeline.timeline, e.errors
+            ).instructions,
+            key="BookmarkSearchTimeline",
+            param=param,
+        )
+        return response
+
+    def get_explore_sidebar(
+        self,
+        extra_param: Optional[ParamType] = None,
+    ) -> TrendResponseType:
+        """Trends of the explore sidebar."""
+        param: ParamType = {}
+        if extra_param is not None:
+            param.update(extra_param)
+
+        return timeline_request(
+            self.api.get_explore_sidebar_with_http_info,
+            self.flag["ExploreSidebar"],
+            self.ct,
+            lambda e: error_check(e.data.explore_sidebar.timeline, e.errors).instructions,
+            param,
+            trend_entries_converter,
+        )

twitter_openapi_python/api/user_api.py

@@ -1,4 +1,4 @@
-from typing import Any, Callable, Optional, TypeVar
+from typing import Any, Callable, Dict, List, Optional, TypeVar
 
 import twitter_openapi_python_generated as twitter
 import twitter_openapi_python_generated.models as models
@@ -7,6 +7,7 @@ from x_client_transaction import ClientTransaction
 from twitter_openapi_python.models import TwitterApiUtilsResponse, UserApiUtilsData
 from twitter_openapi_python.utils import (
     build_response,
+    data_request,
     error_check,
     get_kwargs,
     user_or_null_converter,
@@ -78,3 +79,56 @@ class UserApiUtils:
             key="UserByRestId",
             param=param,
         )
+
+    def get_viewer_badge_counts(
+        self,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.BadgeCounts]:
+        """Unread counts (notifications, DMs, XChat) of the authenticated account."""
+        param: ParamType = {}
+        if extra_param is not None:
+            param.update(extra_param)
+        return data_request(
+            self.api.get_viewer_badge_counts_with_http_info,
+            self.flag["ViewerBadgeCounts"],
+            self.ct,
+            lambda e: error_check(e.data, e.errors).viewer_v2.user_results.result.badge_counts,
+            param,
+        )
+
+    def get_fetch_draft_tweets(
+        self,
+        ascending: Optional[bool] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[List[models.DraftTweet]]:
+        param: ParamType = {}
+        if ascending is not None:
+            param["ascending"] = ascending
+        if extra_param is not None:
+            param.update(extra_param)
+        return data_request(
+            self.api.get_fetch_draft_tweets_with_http_info,
+            self.flag["FetchDraftTweets"],
+            self.ct,
+            lambda e: error_check(e.data, e.errors).viewer.draft_list.response_data,
+            param,
+        )
+
+    def get_fetch_scheduled_tweets(
+        self,
+        ascending: Optional[bool] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[List[Dict[str, Any]]]:
+        """Items are untyped: no scheduled post has been recorded yet."""
+        param: ParamType = {}
+        if ascending is not None:
+            param["ascending"] = ascending
+        if extra_param is not None:
+            param.update(extra_param)
+        return data_request(
+            self.api.get_fetch_scheduled_tweets_with_http_info,
+            self.flag["FetchScheduledTweets"],
+            self.ct,
+            lambda e: error_check(e.data, e.errors).viewer.scheduled_tweet_list,
+            param,
+        )

twitter_openapi_python/api/user_list_api.py

@@ -5,23 +5,22 @@ import twitter_openapi_python_generated.models as models
 from x_client_transaction import ClientTransaction
 
 from twitter_openapi_python.models import (
-    ApiUtilsRaw,
     TimelineApiUtilsResponse,
     TwitterApiUtilsResponse,
     UserApiUtilsData,
 )
 from twitter_openapi_python.utils import (
-    build_response,
-    entries_cursor,
+    data_request,
     error_check,
-    get_kwargs,
-    instruction_to_entry,
+    list_entries_converter,
+    timeline_request,
     user_entries_converter,
     user_result_converter,
 )
 
 T = TypeVar("T")
 ResponseType = TwitterApiUtilsResponse[TimelineApiUtilsResponse[UserApiUtilsData]]
+ListResponseType = TwitterApiUtilsResponse[TimelineApiUtilsResponse[models.TwitterList]]
 ApiFnType = Callable[..., twitter.ApiResponse[T]]
 ParamType = dict[str, Any]
 
@@ -42,25 +41,15 @@ class UserListApiUtils:
         key: str,
         param: ParamType,
     ) -> ResponseType:
-        args = get_kwargs(flag=self.flag[key], additional=param, ct=self.ct)
-        res = apiFn(**args)
-        instruction = convertFn(res.data)
-        entry = instruction_to_entry(instruction)
-        user_list = user_entries_converter(entry)
-        user = user_result_converter(user_list)
-
-        raw = ApiUtilsRaw(
-            instruction=instruction,
-            entry=entry,
-        )
-        data = TimelineApiUtilsResponse[UserApiUtilsData](
-            raw=raw,
-            cursor=entries_cursor(entry),
-            data=user,
+        return timeline_request(
+            apiFn,
+            self.flag[key],
+            self.ct,
+            convertFn,
+            param,
+            lambda entry: user_result_converter(user_entries_converter(entry)),
         )
 
-        return build_response(response=res, data=data)
-
     def get_followers(
         self,
         user_id: str,
@@ -169,3 +158,217 @@ class UserListApiUtils:
             key="Retweeters",
             param=param,
         )
+
+    def get_blue_verified_followers(
+        self,
+        user_id: str,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        param: ParamType = {"userId": user_id}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_blue_verified_followers_with_http_info,
+            convertFn=lambda e: error_check(e.data.user, e.errors).result.timeline.timeline.instructions,
+            key="BlueVerifiedFollowers",
+            param=param,
+        )
+
+    def get_list_members(
+        self,
+        list_id: str,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        param: ParamType = {"listId": list_id}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_list_members_with_http_info,
+            convertFn=lambda e: error_check(e.data.list.members_timeline.timeline, e.errors).instructions,
+            key="ListMembers",
+            param=param,
+        )
+
+    def get_list_subscribers(
+        self,
+        list_id: str,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        param: ParamType = {"listId": list_id}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_list_subscribers_with_http_info,
+            convertFn=lambda e: error_check(e.data.list.subscribers_timeline.timeline, e.errors).instructions,
+            key="ListSubscribers",
+            param=param,
+        )
+
+    def get_list_creation_recommended_users(
+        self,
+        list_id: str,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        """Empty unless list_id is one of the authenticated account's lists."""
+        param: ParamType = {"listId": list_id}
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_list_creation_recommended_users_with_http_info,
+            convertFn=lambda e: t.instructions if (t := e.data.list.recommended_users.timeline) else [],
+            key="ListCreationRecommendedUsers",
+            param=param,
+        )
+
+    def get_list_edit_recommended_users(
+        self,
+        list_id: str,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        """Empty unless list_id is one of the authenticated account's lists."""
+        param: ParamType = {"listId": list_id}
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_list_edit_recommended_users_with_http_info,
+            convertFn=lambda e: t.instructions if (t := e.data.list.recommended_users.timeline) else [],
+            key="ListEditRecommendedUsers",
+            param=param,
+        )
+
+    def get_list_ownerships(
+        self,
+        user_id: str,
+        is_list_member_target_user_id: Optional[str] = None,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ListResponseType:
+        """Lists owned by user_id; is_list_member_target_user_id marks the lists that user is a member of."""
+        param: ParamType = {"userId": user_id}
+        if is_list_member_target_user_id is not None:
+            param["isListMemberTargetUserId"] = is_list_member_target_user_id
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+        return timeline_request(
+            self.api.get_list_ownerships_with_http_info,
+            self.flag["ListOwnerships"],
+            self.ct,
+            lambda e: error_check(error_check(e.data.user, e.errors).result.timeline.timeline, e.errors).instructions,
+            param,
+            list_entries_converter,
+        )
+
+    def get_list_by_rest_id(
+        self,
+        list_id: str,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.TwitterList]:
+        param: ParamType = {"listId": list_id}
+        if extra_param is not None:
+            param.update(extra_param)
+        return data_request(
+            self.api.get_list_by_rest_id_with_http_info,
+            self.flag["ListByRestId"],
+            self.ct,
+            lambda e: error_check(e.data, e.errors).list,
+            param,
+        )
+
+    def get_list_search_timeline(
+        self,
+        raw_query: str,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ListResponseType:
+        param: ParamType = {"rawQuery": raw_query}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+        return timeline_request(
+            self.api.get_list_search_timeline_with_http_info,
+            self.flag["ListSearchTimeline"],
+            self.ct,
+            lambda e: error_check(e.data.search_by_raw_query.list_search_timeline.timeline, e.errors).instructions,
+            param,
+            list_entries_converter,
+        )
+
+    def get_combined_lists(
+        self,
+        user_id: str,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ListResponseType:
+        """Lists a user owns or follows."""
+        param: ParamType = {"userId": user_id}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+        return timeline_request(
+            self.api.get_combined_lists_with_http_info,
+            self.flag["CombinedLists"],
+            self.ct,
+            lambda e: error_check(error_check(e.data.user, e.errors).result.timeline.timeline, e.errors).instructions,
+            param,
+            list_entries_converter,
+        )
+
+    def get_lists_management_page_timeline(
+        self,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ListResponseType:
+        """The account's lists management page."""
+        param: ParamType = {}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+        return timeline_request(
+            self.api.get_lists_management_page_timeline_with_http_info,
+            self.flag["ListsManagementPageTimeline"],
+            self.ct,
+            lambda e: error_check(e.data.viewer.list_management_timeline.timeline, e.errors).instructions,
+            param,
+            list_entries_converter,
+        )