twitter-openapi-python 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

twitter_openapi_python/api/__init__.py

@@ -2,6 +2,8 @@
 
 # flake8: noqa
 
+from twitter_openapi_python.api.birdwatch_api import BirdwatchApiUtils
+from twitter_openapi_python.api.community_api import CommunityApiUtils
 from twitter_openapi_python.api.default_api import DefaultApiUtils
 from twitter_openapi_python.api.initial_state_api import InitialStateApiUtils
 from twitter_openapi_python.api.post_api import PostApiUtils

twitter_openapi_python/api/birdwatch_api.py

@@ -0,0 +1,116 @@
+from typing import Any, Optional
+
+import twitter_openapi_python_generated as twitter
+import twitter_openapi_python_generated.models as models
+from x_client_transaction import ClientTransaction
+
+from twitter_openapi_python.models import (
+    TimelineApiUtilsResponse,
+    TweetApiUtilsData,
+    TwitterApiUtilsResponse,
+)
+from twitter_openapi_python.utils import (
+    data_request,
+    error_check,
+    timeline_request,
+    tweet_entries_converter,
+)
+
+ResponseType = TwitterApiUtilsResponse[TimelineApiUtilsResponse[TweetApiUtilsData]]
+ParamType = dict[str, Any]
+
+
+class BirdwatchApiUtils:
+    """Community Notes."""
+
+    api: twitter.BirdwatchApi
+    flag: ParamType
+
+    def __init__(self, api: twitter.BirdwatchApi, flag: ParamType, ct: ClientTransaction):
+        self.api = api
+        self.flag = flag
+        self.ct = ct
+
+    def get_birdwatch_fetch_alias_self_select_status(
+        self,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.BirdwatchAliasSelfSelectStatus]:
+        param: ParamType = {}
+        if extra_param is not None:
+            param.update(extra_param)
+        return data_request(
+            self.api.get_birdwatch_fetch_alias_self_select_status_with_http_info,
+            self.flag["BirdwatchFetchAliasSelfSelectStatus"],
+            self.ct,
+            lambda e: error_check(e.data, e.errors).authenticated_user_birdwatch_alias_self_select_status,
+            param,
+        )
+
+    def get_birdwatch_fetch_authenticated_user_profile(
+        self,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.BirdwatchProfile]:
+        param: ParamType = {}
+        if extra_param is not None:
+            param.update(extra_param)
+        return data_request(
+            self.api.get_birdwatch_fetch_authenticated_user_profile_with_http_info,
+            self.flag["BirdwatchFetchAuthenticatedUserProfile"],
+            self.ct,
+            lambda e: error_check(e.data, e.errors).authenticated_user_birdwatch_profile,
+            param,
+        )
+
+    def get_birdwatch_fetch_birdwatch_profile(
+        self,
+        alias: str,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.BirdwatchProfile]:
+        param: ParamType = {"alias": alias}
+        if extra_param is not None:
+            param.update(extra_param)
+        return data_request(
+            self.api.get_birdwatch_fetch_birdwatch_profile_with_http_info,
+            self.flag["BirdwatchFetchBirdwatchProfile"],
+            self.ct,
+            lambda e: error_check(e.data, e.errors).birdwatch_profile_by_alias,
+            param,
+        )
+
+    def get_birdwatch_fetch_global_timeline(
+        self,
+        cursor: Optional[str] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        """Posts with notes on the Community Notes home page (first tab)."""
+        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_birdwatch_fetch_global_timeline_with_http_info,
+            self.flag["BirdwatchFetchGlobalTimeline"],
+            self.ct,
+            lambda e: error_check(
+                e.data.viewer.birdwatch_home_page.body.initial_timeline.timeline.timeline, e.errors
+            ).instructions,
+            param,
+            tweet_entries_converter,
+        )
+
+    def get_birdwatch_fetch_public_data(
+        self,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.BirdwatchPublicDataFileBundle]:
+        """Download urls of the latest public data files."""
+        param: ParamType = {}
+        if extra_param is not None:
+            param.update(extra_param)
+        return data_request(
+            self.api.get_birdwatch_fetch_public_data_with_http_info,
+            self.flag["BirdwatchFetchPublicData"],
+            self.ct,
+            lambda e: error_check(e.data, e.errors).birdwatch_latest_public_data_file_bundle,
+            param,
+        )

twitter_openapi_python/api/community_api.py

@@ -0,0 +1,149 @@
+from typing import Any, List, Optional
+
+import twitter_openapi_python_generated as twitter
+import twitter_openapi_python_generated.models as models
+from x_client_transaction import ClientTransaction
+
+from twitter_openapi_python.models import (
+    TimelineApiUtilsResponse,
+    TweetApiUtilsData,
+    TwitterApiUtilsResponse,
+)
+from twitter_openapi_python.utils import (
+    data_request,
+    error_check,
+    timeline_request,
+    tweet_entries_converter,
+)
+
+ResponseType = TwitterApiUtilsResponse[TimelineApiUtilsResponse[TweetApiUtilsData]]
+ParamType = dict[str, Any]
+
+
+class CommunityApiUtils:
+    api: twitter.CommunityApi
+    flag: ParamType
+
+    def __init__(self, api: twitter.CommunityApi, flag: ParamType, ct: ClientTransaction):
+        self.api = api
+        self.flag = flag
+        self.ct = ct
+
+    def get_communities_fetch_one_query(
+        self,
+        community_id: str,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.CommunityPageCommunity]:
+        """The community page (full members and moderators)."""
+        param: ParamType = {"communityId": community_id}
+        if extra_param is not None:
+            param.update(extra_param)
+        return data_request(
+            self.api.get_communities_fetch_one_query_with_http_info,
+            self.flag["CommunitiesFetchOneQuery"],
+            self.ct,
+            lambda e: error_check(e.data, e.errors).community_results.result,
+            param,
+        )
+
+    def get_community_query(
+        self,
+        community_id: str,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.CommunitySettingsCommunity]:
+        """The community settings / moderation pages (partial users, trending hashtags)."""
+        param: ParamType = {"communityId": community_id}
+        if extra_param is not None:
+            param.update(extra_param)
+        return data_request(
+            self.api.get_community_query_with_http_info,
+            self.flag["CommunityQuery"],
+            self.ct,
+            lambda e: error_check(e.data, e.errors).community_results.result,
+            param,
+        )
+
+    def get_communities_search_query(
+        self,
+        query: str,
+        cursor: Optional[str] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.CommunitiesSearchSlice]:
+        """Community cards for a query; the next page is slice_info.next_cursor."""
+        param: ParamType = {"query": query}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if extra_param is not None:
+            param.update(extra_param)
+        return data_request(
+            self.api.get_communities_search_query_with_http_info,
+            self.flag["CommunitiesSearchQuery"],
+            self.ct,
+            lambda e: error_check(e.data, e.errors).communities_search_slice,
+            param,
+        )
+
+    def get_topic_carousel_query(
+        self,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[List[models.CommunityTopic]]:
+        param: ParamType = {}
+        if extra_param is not None:
+            param.update(extra_param)
+        return data_request(
+            self.api.get_topic_carousel_query_with_http_info,
+            self.flag["TopicCarouselQuery"],
+            self.ct,
+            lambda e: error_check(e.data, e.errors).community_topic_results.community_topics,
+            param,
+        )
+
+    def get_global_communities_post_search_timeline(
+        self,
+        raw_query: str,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        """Posts across communities (Top)."""
+        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_global_communities_post_search_timeline_with_http_info,
+            self.flag["GlobalCommunitiesPostSearchTimeline"],
+            self.ct,
+            lambda e: error_check(e.data.search_by_raw_query.communities_posts_search_page.timeline, e.errors).instructions,
+            param,
+            tweet_entries_converter,
+        )
+
+    def get_global_communities_latest_post_search_timeline(
+        self,
+        raw_query: str,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        """Posts across communities (Latest)."""
+        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_global_communities_latest_post_search_timeline_with_http_info,
+            self.flag["GlobalCommunitiesLatestPostSearchTimeline"],
+            self.ct,
+            lambda e: error_check(
+                e.data.search_by_raw_query.communities_latest_posts_search_page.timeline, e.errors
+            ).instructions,
+            param,
+            tweet_entries_converter,
+        )

twitter_openapi_python/api/default_api.py

@@ -78,3 +78,144 @@ class DefaultApiUtils:
         if response.data is None:
             raise Exception("No tweet")
         return response  # type: ignore
+
+    def get_authenticate_periscope(
+        self,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[str]:
+        """A Periscope (live video) token for the account."""
+        param: ParamType = {}
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_authenticate_periscope_with_http_info,
+            convertFn=lambda x: error_check(x.data, x.errors).authenticate_periscope,
+            key="AuthenticatePeriscope",
+            param=param,
+        )
+
+    def get_creator_studio_tab_bar_item_query(
+        self,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.CreatorStudioTabBarItemQueryResponseData]:
+        param: ParamType = {}
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_creator_studio_tab_bar_item_query_with_http_info,
+            convertFn=lambda x: error_check(x.data, x.errors),
+            key="CreatorStudioTabBarItemQuery",
+            param=param,
+        )
+
+    def get_data_saver_mode(
+        self,
+        device_id: Optional[str] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.DataSaverModeResponseData]:
+        param: ParamType = {}
+        if device_id is not None:
+            param["device_id"] = device_id
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_data_saver_mode_with_http_info,
+            convertFn=lambda x: error_check(x.data, x.errors),
+            key="DataSaverMode",
+            param=param,
+        )
+
+    def get_grok_home(
+        self,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.GrokHome]:
+        """Grok model options, prompts and eligibility."""
+        param: ParamType = {}
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_grok_home_with_http_info,
+            convertFn=lambda x: error_check(x.data, x.errors).grok_home,
+            key="GrokHome",
+            param=param,
+        )
+
+    def get_pinned_timelines(
+        self,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.PinnedTimelines]:
+        param: ParamType = {}
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_pinned_timelines_with_http_info,
+            convertFn=lambda x: error_check(x.data, x.errors).pinned_timelines,
+            key="PinnedTimelines",
+            param=param,
+        )
+
+    def get_broadcast_query(
+        self,
+        id: str,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.Broadcast]:
+        """A live video broadcast by id."""
+        param: ParamType = {"id": id}
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_broadcast_query_with_http_info,
+            convertFn=lambda x: error_check(x.data, x.errors).broadcast,
+            key="BroadcastQuery",
+            param=param,
+        )
+
+    def get_audio_space_by_id(
+        self,
+        id: str,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.AudioSpace]:
+        """A Space by id: metadata, participants and the announcing post."""
+        param: ParamType = {"id": id}
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_audio_space_by_id_with_http_info,
+            convertFn=lambda x: error_check(x.data, x.errors).audio_space,
+            key="AudioSpaceById",
+            param=param,
+        )
+
+    def get_use_story_topic_query(
+        self,
+        rest_id: str = "For You",
+        limit: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.StoryTopic]:
+        """AI-written stories of an explore topic."""
+        param: ParamType = {"rest_id": rest_id}
+        if limit is not None:
+            param["limit"] = limit
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_use_story_topic_query_with_http_info,
+            convertFn=lambda x: error_check(x.data, x.errors).story_topic,
+            key="useStoryTopicQuery",
+            param=param,
+        )
+
+    def get_grok_account_jwt_query(
+        self,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.GrokAccountJwt]:
+        """Whether the account is linked to a Grok account."""
+        param: ParamType = {}
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_grok_account_jwt_query_with_http_info,
+            convertFn=lambda x: error_check(x.data, x.errors).grok_account_jwt,
+            key="grokAccountJwtQuery",
+            param=param,
+        )

twitter_openapi_python/api/tweet_api.py

@@ -93,9 +93,11 @@ class TweetApiUtils:
 
         response = self.request(
             apiFn=self.api.get_search_timeline_with_http_info,
-            convertFn=lambda e: error_check(
-                error_check(e.data.search_by_raw_query, e.errors).search_timeline.timeline, e.errors
-            ).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,
         )
@@ -162,9 +164,9 @@ class TweetApiUtils:
 
         response = self.request(
             apiFn=self.api.get_list_latest_tweets_timeline_with_http_info,
-            convertFn=lambda e: error_check(
-                error_check(e.data.list, e.errors).tweets_timeline.timeline, e.errors
-            ).instructions,
+            convertFn=lambda e: (
+                error_check(error_check(e.data.list, e.errors).tweets_timeline.timeline, e.errors).instructions
+            ),
             key="ListLatestTweetsTimeline",
             param=param,
         )
@@ -187,9 +189,11 @@ class TweetApiUtils:
 
         response = self.request(
             apiFn=self.api.get_user_tweets_with_http_info,
-            convertFn=lambda e: error_check(
-                error_check(e.data.user, e.errors).result.timeline.timeline, e.errors
-            ).instructions,
+            convertFn=lambda e: (
+                error_check(
+                    error_check(error_check(e.data.user, e.errors).result.timeline, e.errors).timeline, e.errors
+                ).instructions
+            ),
             key="UserTweets",
             param=param,
         )
@@ -212,9 +216,11 @@ class TweetApiUtils:
 
         response = self.request(
             apiFn=self.api.get_user_originals_timeline_with_http_info,
-            convertFn=lambda e: error_check(
-                error_check(e.data.user, e.errors).result.timeline.timeline, e.errors
-            ).instructions,
+            convertFn=lambda e: (
+                error_check(
+                    error_check(error_check(e.data.user, e.errors).result.timeline, e.errors).timeline, e.errors
+                ).instructions
+            ),
             key="UserOriginalsTimeline",
             param=param,
         )
@@ -237,9 +243,11 @@ class TweetApiUtils:
 
         response = self.request(
             apiFn=self.api.get_user_replies_timeline_with_http_info,
-            convertFn=lambda e: error_check(
-                error_check(e.data.user, e.errors).result.timeline.timeline, e.errors
-            ).instructions,
+            convertFn=lambda e: (
+                error_check(
+                    error_check(error_check(e.data.user, e.errors).result.timeline, e.errors).timeline, e.errors
+                ).instructions
+            ),
             key="UserRepliesTimeline",
             param=param,
         )
@@ -262,9 +270,11 @@ class TweetApiUtils:
 
         response = self.request(
             apiFn=self.api.get_user_video_timeline_with_http_info,
-            convertFn=lambda e: error_check(
-                error_check(e.data.user, e.errors).result.timeline.timeline, e.errors
-            ).instructions,
+            convertFn=lambda e: (
+                error_check(
+                    error_check(error_check(e.data.user, e.errors).result.timeline, e.errors).timeline, e.errors
+                ).instructions
+            ),
             key="UserVideoTimeline",
             param=param,
         )
@@ -287,9 +297,11 @@ class TweetApiUtils:
 
         response = self.request(
             apiFn=self.api.get_user_tweets_and_replies_with_http_info,
-            convertFn=lambda e: error_check(
-                error_check(e.data.user, e.errors).result.timeline.timeline, e.errors
-            ).instructions,
+            convertFn=lambda e: (
+                error_check(
+                    error_check(error_check(e.data.user, e.errors).result.timeline, e.errors).timeline, e.errors
+                ).instructions
+            ),
             key="UserTweetsAndReplies",
             param=param,
         )
@@ -312,9 +324,11 @@ class TweetApiUtils:
 
         response = self.request(
             apiFn=self.api.get_user_media_with_http_info,
-            convertFn=lambda e: error_check(
-                error_check(e.data.user, e.errors).result.timeline.timeline, e.errors
-            ).instructions,
+            convertFn=lambda e: (
+                error_check(
+                    error_check(error_check(e.data.user, e.errors).result.timeline, e.errors).timeline, e.errors
+                ).instructions
+            ),
             key="UserMedia",
             param=param,
         )
@@ -337,9 +351,11 @@ class TweetApiUtils:
 
         response = self.request(
             apiFn=self.api.get_likes_with_http_info,
-            convertFn=lambda e: error_check(
-                error_check(e.data.user, e.errors).result.timeline.timeline, e.errors
-            ).instructions,
+            convertFn=lambda e: (
+                error_check(
+                    error_check(error_check(e.data.user, e.errors).result.timeline, e.errors).timeline, e.errors
+                ).instructions
+            ),
             key="Likes",
             param=param,
         )
@@ -361,9 +377,9 @@ class TweetApiUtils:
 
         response = self.request(
             apiFn=self.api.get_bookmarks_with_http_info,
-            convertFn=lambda e: error_check(
-                error_check(e.data, e.errors).bookmark_timeline_v2.timeline, e.errors
-            ).instructions,
+            convertFn=lambda e: (
+                error_check(error_check(e.data, e.errors).bookmark_timeline_v2.timeline, e.errors).instructions
+            ),
             key="Bookmarks",
             param=param,
         )
@@ -389,9 +405,11 @@ class TweetApiUtils:
 
         response = self.request(
             apiFn=self.api.get_community_tweets_timeline_with_http_info,
-            convertFn=lambda e: error_check(
-                error_check(e.data, e.errors).community_results.result.ranked_community_timeline.timeline, e.errors
-            ).instructions,
+            convertFn=lambda e: (
+                error_check(
+                    error_check(e.data, e.errors).community_results.result.ranked_community_timeline.timeline, e.errors
+                ).instructions
+            ),
             key="CommunityTweetsTimeline",
             param=param,
         )
@@ -414,9 +432,11 @@ class TweetApiUtils:
 
         response = self.request(
             apiFn=self.api.get_community_media_timeline_with_http_info,
-            convertFn=lambda e: error_check(
-                error_check(e.data, e.errors).community_results.result.community_media_timeline.timeline, e.errors
-            ).instructions,
+            convertFn=lambda e: (
+                error_check(
+                    error_check(e.data, e.errors).community_results.result.community_media_timeline.timeline, e.errors
+                ).instructions
+            ),
             key="CommunityMediaTimeline",
             param=param,
         )
@@ -439,7 +459,9 @@ class TweetApiUtils:
 
         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,
+            convertFn=lambda e: (
+                error_check(error_check(e.data.user, e.errors).result.timeline, e.errors).timeline.instructions
+            ),
             key="UserHighlightsTweets",
             param=param,
         )
@@ -462,9 +484,11 @@ class TweetApiUtils:
 
         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,
+            convertFn=lambda e: (
+                error_check(
+                    error_check(error_check(e.data.user, e.errors).result.timeline, e.errors).timeline, e.errors
+                ).instructions
+            ),
             key="UserRepostsTimeline",
             param=param,
         )
@@ -488,9 +512,11 @@ class TweetApiUtils:
 
         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,
+            convertFn=lambda e: (
+                error_check(
+                    error_check(error_check(e.data.user, e.errors).result.timeline, e.errors).timeline, e.errors
+                ).instructions
+            ),
             key="UserSuperFollowTweets",
             param=param,
         )
@@ -564,9 +590,9 @@ class TweetApiUtils:
             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,
+            lambda e: (
+                error_check(e.data.viewer_v2.user_results.result.notification_timeline.timeline, e.errors).instructions
+            ),
             param,
             notification_entries_converter,
         )
@@ -636,3 +662,47 @@ class TweetApiUtils:
             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

@@ -80,6 +80,23 @@ class UserApiUtils:
             param=param,
         )
 
+    def get_about_account_query(
+        self,
+        screen_name: str,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.AboutAccountUser]:
+        """The "About this account" panel: join date, where the account is based, username changes, verification."""
+        param: ParamType = {"screenName": screen_name}
+        if extra_param is not None:
+            param.update(extra_param)
+        return data_request(
+            self.api.get_about_account_query_with_http_info,
+            self.flag["AboutAccountQuery"],
+            self.ct,
+            lambda e: error_check(e.data, e.errors).user_result_by_screen_name.result,
+            param,
+        )
+
     def get_viewer_badge_counts(
         self,
         extra_param: Optional[ParamType] = None,

twitter_openapi_python/api/user_list_api.py

@@ -66,7 +66,9 @@ class UserListApiUtils:
             param.update(extra_param)
         return self.request(
             apiFn=self.api.get_followers_with_http_info,
-            convertFn=lambda e: error_check(e.data.user, e.errors).result.timeline.timeline.instructions,
+            convertFn=lambda e: (
+                error_check(error_check(e.data.user, e.errors).result.timeline, e.errors).timeline.instructions
+            ),
             key="Followers",
             param=param,
         )
@@ -87,7 +89,9 @@ class UserListApiUtils:
             param.update(extra_param)
         return self.request(
             apiFn=self.api.get_following_with_http_info,
-            convertFn=lambda e: error_check(e.data.user, e.errors).result.timeline.timeline.instructions,
+            convertFn=lambda e: (
+                error_check(error_check(e.data.user, e.errors).result.timeline, e.errors).timeline.instructions
+            ),
             key="Following",
             param=param,
         )
@@ -108,7 +112,9 @@ class UserListApiUtils:
             param.update(extra_param)
         return self.request(
             apiFn=self.api.get_followers_you_know_with_http_info,
-            convertFn=lambda e: error_check(e.data.user, e.errors).result.timeline.timeline.instructions,
+            convertFn=lambda e: (
+                error_check(error_check(e.data.user, e.errors).result.timeline, e.errors).timeline.instructions
+            ),
             key="FollowersYouKnow",
             param=param,
         )
@@ -129,9 +135,9 @@ class UserListApiUtils:
             param.update(extra_param)
         return self.request(
             apiFn=self.api.get_favoriters_with_http_info,
-            convertFn=lambda e: error_check(
-                error_check(e.data.favoriters_timeline, e.errors).timeline, e.errors
-            ).instructions,
+            convertFn=lambda e: (
+                error_check(error_check(e.data.favoriters_timeline, e.errors).timeline, e.errors).instructions
+            ),
             key="Favoriters",
             param=param,
         )
@@ -152,9 +158,9 @@ class UserListApiUtils:
             param.update(extra_param)
         return self.request(
             apiFn=self.api.get_retweeters_with_http_info,
-            convertFn=lambda e: error_check(
-                error_check(e.data.retweeters_timeline, e.errors).timeline, e.errors
-            ).instructions,
+            convertFn=lambda e: (
+                error_check(error_check(e.data.retweeters_timeline, e.errors).timeline, e.errors).instructions
+            ),
             key="Retweeters",
             param=param,
         )
@@ -175,7 +181,9 @@ class UserListApiUtils:
             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,
+            convertFn=lambda e: (
+                error_check(error_check(e.data.user, e.errors).result.timeline, e.errors).timeline.instructions
+            ),
             key="BlueVerifiedFollowers",
             param=param,
         )
@@ -282,7 +290,11 @@ class UserListApiUtils:
             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,
+            lambda e: (
+                error_check(
+                    error_check(error_check(e.data.user, e.errors).result.timeline, e.errors).timeline, e.errors
+                ).instructions
+            ),
             param,
             list_entries_converter,
         )
@@ -302,3 +314,77 @@ class UserListApiUtils:
             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(error_check(e.data.user, e.errors).result.timeline, e.errors).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,
+        )

twitter_openapi_python/api/users_api.py

@@ -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_result_converter,
@@ -54,3 +55,37 @@ class UsersApiUtils:
             key="UsersByRestIds",
             param=param,
         )
+
+    def get_users_verified_avatars(
+        self,
+        user_ids: list[str],
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[list[models.VerifiedAvatarUser]]:
+        """Partial users (avatar shape, verification) for the given ids."""
+        param: ParamType = {"userIds": user_ids}
+        if extra_param is not None:
+            param.update(extra_param)
+        return data_request(
+            self.api.get_users_verified_avatars_with_http_info,
+            self.flag["UsersVerifiedAvatars"],
+            self.ct,
+            lambda e: [x.result for x in error_check(e.data, e.errors).users_results],
+            param,
+        )
+
+    def get_sidebar_user_recommendations(
+        self,
+        profile_user_id: str,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[list[models.SidebarUserRecommendation]]:
+        """Who to follow, shown in the sidebar of a profile, each with its recommendation token."""
+        param: ParamType = {"profileUserId": profile_user_id}
+        if extra_param is not None:
+            param.update(extra_param)
+        return data_request(
+            self.api.get_sidebar_user_recommendations_with_http_info,
+            self.flag["SidebarUserRecommendations"],
+            self.ct,
+            lambda e: error_check(e.data, e.errors).sidebar_user_recommendations,
+            param,
+        )

twitter_openapi_python/client.py

@@ -8,6 +8,8 @@ import urllib3
 from x_client_transaction import ClientTransaction
 
 from twitter_openapi_python.api import (
+    BirdwatchApiUtils,
+    CommunityApiUtils,
     DefaultApiUtils,
     InitialStateApiUtils,
     PostApiUtils,
@@ -32,6 +34,12 @@ class TwitterOpenapiPythonClient:
         self.placeholder = placeholder
         self.ct = ct
 
+    def get_birdwatch_api(self) -> BirdwatchApiUtils:
+        return BirdwatchApiUtils(twitter.BirdwatchApi(self.api), self.placeholder, self.ct)
+
+    def get_community_api(self) -> CommunityApiUtils:
+        return CommunityApiUtils(twitter.CommunityApi(self.api), self.placeholder, self.ct)
+
     def get_default_api(self) -> DefaultApiUtils:
         return DefaultApiUtils(twitter.DefaultApi(self.api), self.placeholder, self.ct)
 
@@ -61,7 +69,7 @@ class TwitterOpenapiPythonClient:
 
 
 class TwitterOpenapiPython:
-    hash: str = "ec7d907e12cfaca5b93dde55522dcc6045457570"
+    hash: str = "82d12f1e93e93cd283534f6abb4102bf7dc31c74"
     placeholder_url = "https://raw.githubusercontent.com/fa0311/twitter-openapi/{hash}/src/config/placeholder.json"
     header = "https://raw.githubusercontent.com/fa0311/latest-user-agent/refs/heads/main/header.json"
     access_token: str = (

{twitter_openapi_python-0.1.1.dist-info → twitter_openapi_python-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: twitter_openapi_python
-Version: 0.1.1
+Version: 0.1.3
 Summary: Twitter OpenAPI
 Keywords: twitter,api,python,scraper
 Author: fa0311
@@ -8,7 +8,7 @@ Author-email: fa0311 <yuki@yuki0311.com>
 License-Expression: LicenseRef-Custom OR AGPL-3.0-or-later
 License-File: LICENSE
 License-File: LICENSE.AGPL
-Requires-Dist: twitter-openapi-python-generated==0.1.1
+Requires-Dist: twitter-openapi-python-generated==0.1.3
 Requires-Dist: pydantic>=2.6
 Requires-Dist: requests>=2.31.0,<3.0.0
 Requires-Dist: urllib3>=2.1.0,<3.0.0

{twitter_openapi_python-0.1.1.dist-info → twitter_openapi_python-0.1.3.dist-info}/RECORD

@@ -1,15 +1,17 @@
 twitter_openapi_python/__init__.py,sha256=IyCanHNVJtKPGaYEMBqF37VXfMtZNUJlPhSOZMvO5jg,324
-twitter_openapi_python/api/__init__.py,sha256=m9S_EoojMhead7EToafmdHKUxpyYHm9-qaKN_auWhSM,630
-twitter_openapi_python/api/default_api.py,sha256=34l_jG5Mq1u0StPRX-QfGYHoGVYP8EEY_-5vFG_Xz7o,2586
+twitter_openapi_python/api/__init__.py,sha256=1YPsr8wnqlrBFAViXCwYwDdk2kNwA6PMC8DAnsWC62U,772
+twitter_openapi_python/api/birdwatch_api.py,sha256=_SpT0-RU3GhEvYa9Sqf7JpC62kxnE-u0CbUnCHNTrBM,4121
+twitter_openapi_python/api/community_api.py,sha256=hht31A83v3BfqcYa1-H9LyNIKd7UJMUWM9kzMUEJCus,5379
+twitter_openapi_python/api/default_api.py,sha256=Ca8OYS6TiYYVWo64QG-HUcmgog8FXwo5Xe8_-PUI6Js,7765
 twitter_openapi_python/api/initial_state_api.py,sha256=nAkb25-btWdMoSyyncxS_VrBQ9uKDgzmG7jBubfETYo,2269
 twitter_openapi_python/api/post_api.py,sha256=YSiGjV95AxxxSukZZESVRJ34D8hde6YRjd0Q6ElQ8fE,13166
-twitter_openapi_python/api/tweet_api.py,sha256=VktFxYf8XLIZjIUaON_rVzuImJIrCe5s7HYKpbqTSE0,22000
-twitter_openapi_python/api/user_api.py,sha256=CF9ST6jNI54H_ShBZLT-O1uu1h-xkaKKJmcQ0Au0H7g,4477
-twitter_openapi_python/api/user_list_api.py,sha256=EzBHlLNsbqTiXgZJoRR8SNru8Adr5F47SoAY6SxCrgM,10539
-twitter_openapi_python/api/users_api.py,sha256=8bcRi-kYZ9MtsgTxYDU1SnVqKtcyQ1b7QqWEVXVafqk,1750
+twitter_openapi_python/api/tweet_api.py,sha256=qaFin2czb9SObvEz_ObMG6NOf7e_Da90m7Pkckon7rM,24226
+twitter_openapi_python/api/user_api.py,sha256=zZFczuDwm7izp_WGFEgNTL4RQyN1aRPSijFTa8hZ_OI,5176
+twitter_openapi_python/api/user_list_api.py,sha256=dCp_K0bIC0CBn_kI5B8hpKy0TVhZgET4zpfadc_TrZ0,13471
+twitter_openapi_python/api/users_api.py,sha256=_vLDKAu5RfvPVwBeOcFpuSUd47fAgLjTLVK40dJuLMQ,3170
 twitter_openapi_python/api/v11_get_api.py,sha256=UXe34f6IBYExqWCJ8HCld_8d_ChQb92je0G5VtLxmyM,1978
 twitter_openapi_python/api/v11_post_api.py,sha256=eErGBOo-y4E1AAMIHgeWnc0rAFmc5KgIoipJI-8V0Y8,1781
-twitter_openapi_python/client.py,sha256=FSIArYbykUREGLISz9pcwYsux3xgDRgH_vkbM6zc2Ps,6786
+twitter_openapi_python/client.py,sha256=Ra44Oxc-DfU_Jar93nXndVF_xjbPkYlCtT3JxAy5L_M,7126
 twitter_openapi_python/models/__init__.py,sha256=pHISZJrEPBlXS25kMydl1SxXuCct-CUpnPDfL7kEEBo,588
 twitter_openapi_python/models/base.py,sha256=3sw6wdQn9i8FoujFxhEFVWIB26-qjI6JTDuXKuebM0Y,189
 twitter_openapi_python/models/header.py,sha256=EKujtBRZOJmeh2SD1QOCsLWaE9gdGY4wsNUgwCnbTCU,644
@@ -20,8 +22,8 @@ twitter_openapi_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 twitter_openapi_python/tid.py,sha256=xjqJMyPOp62nw2MQjMGHaB4L6G6OZHuWkMR-WKJo7aU,1120
 twitter_openapi_python/utils/__init__.py,sha256=lIEPoDqtgCvUk0A8cWqdTlTWMhkEp_NbVxL7sJ0uiu8,612
 twitter_openapi_python/utils/api.py,sha256=ytdYSv08LYGCe8gof4DptzhjCkgIBV1uJmJXC9htQnU,12623
-twitter_openapi_python-0.1.1.dist-info/licenses/LICENSE,sha256=sLv8EMhrPCMG_LeweYvYKS_B-cDMBwBSKZel7LSMGAs,1493
-twitter_openapi_python-0.1.1.dist-info/licenses/LICENSE.AGPL,sha256=TfPDBt3ar0uv_f9cqCDMZ5rIzW3CY8anRRd4PkL6ejs,34522
-twitter_openapi_python-0.1.1.dist-info/WHEEL,sha256=9IUYslYuG_asT4WlWvfk_K76nveuLvSTKDoLeL0cV-Q,80
-twitter_openapi_python-0.1.1.dist-info/METADATA,sha256=KwMg1oNCnWMvRFro3Bh-Qi7Q88-ebem6u8b4vfoatUo,3232
-twitter_openapi_python-0.1.1.dist-info/RECORD,,
+twitter_openapi_python-0.1.3.dist-info/licenses/LICENSE,sha256=sLv8EMhrPCMG_LeweYvYKS_B-cDMBwBSKZel7LSMGAs,1493
+twitter_openapi_python-0.1.3.dist-info/licenses/LICENSE.AGPL,sha256=TfPDBt3ar0uv_f9cqCDMZ5rIzW3CY8anRRd4PkL6ejs,34522
+twitter_openapi_python-0.1.3.dist-info/WHEEL,sha256=9IUYslYuG_asT4WlWvfk_K76nveuLvSTKDoLeL0cV-Q,80
+twitter_openapi_python-0.1.3.dist-info/METADATA,sha256=yjdR3DLGE3SoEu6yuHgaoAgweBEwicaBYLfIi3-PaFk,3232
+twitter_openapi_python-0.1.3.dist-info/RECORD,,