twitter-openapi-python 0.1.0__py3-none-any.whl → 0.1.2__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,78 @@ 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,
+        )

twitter_openapi_python/api/post_api.py

@@ -164,3 +164,164 @@ class PostApiUtils:
             _headers=get_headers(self.flag["UnfavoriteTweet"], self.ct),
         )
         return build_response(res, res.data)
+
+    def post_create_bookmark(
+        self,
+        tweet_id: str,
+    ) -> ResponseType[models.CreateBookmarkResponse]:
+        variables = non_nullable(
+            twitter.PostCreateBookmarkRequestVariables.from_dict(self.flag["CreateBookmark"]["variables"])
+        )
+        variables.tweet_id = tweet_id
+
+        res = self.api.post_create_bookmark_with_http_info(
+            path_query_id=self.flag["CreateBookmark"]["queryId"],
+            post_create_bookmark_request=twitter.PostCreateBookmarkRequest(
+                queryId=self.flag["CreateBookmark"]["queryId"],
+                variables=variables,
+            ),
+            _headers=get_headers(self.flag["CreateBookmark"], self.ct),
+        )
+        return build_response(res, res.data)
+
+    def post_delete_bookmark(
+        self,
+        tweet_id: str,
+    ) -> ResponseType[models.DeleteBookmarkResponse]:
+        variables = non_nullable(
+            twitter.PostCreateBookmarkRequestVariables.from_dict(self.flag["DeleteBookmark"]["variables"])
+        )
+        variables.tweet_id = tweet_id
+
+        res = self.api.post_delete_bookmark_with_http_info(
+            path_query_id=self.flag["DeleteBookmark"]["queryId"],
+            post_delete_bookmark_request=twitter.PostDeleteBookmarkRequest(
+                queryId=self.flag["DeleteBookmark"]["queryId"],
+                variables=variables,
+            ),
+            _headers=get_headers(self.flag["DeleteBookmark"], self.ct),
+        )
+        return build_response(res, res.data)
+
+    def post_create_list(
+        self,
+        name: str,
+        description: str = "",
+        is_private: bool = False,
+    ) -> ResponseType[models.ListResponse]:
+        variables = non_nullable(twitter.PostCreateListRequestVariables.from_dict(self.flag["CreateList"]["variables"]))
+        features = non_nullable(twitter.PostCreateListRequestFeatures.from_dict(self.flag["CreateList"]["features"]))
+        variables.name = name
+        variables.description = description
+        variables.is_private = is_private
+
+        res = self.api.post_create_list_with_http_info(
+            path_query_id=self.flag["CreateList"]["queryId"],
+            post_create_list_request=twitter.PostCreateListRequest(
+                queryId=self.flag["CreateList"]["queryId"],
+                variables=variables,
+                features=features,
+            ),
+            _headers=get_headers(self.flag["CreateList"], self.ct),
+        )
+        return build_response(res, res.data)
+
+    def post_delete_list(
+        self,
+        list_id: str,
+    ) -> ResponseType[models.DeleteListResponse]:
+        variables = non_nullable(twitter.PostDeleteListRequestVariables.from_dict(self.flag["DeleteList"]["variables"]))
+        variables.list_id = list_id
+
+        res = self.api.post_delete_list_with_http_info(
+            path_query_id=self.flag["DeleteList"]["queryId"],
+            post_delete_list_request=twitter.PostDeleteListRequest(
+                queryId=self.flag["DeleteList"]["queryId"],
+                variables=variables,
+            ),
+            _headers=get_headers(self.flag["DeleteList"], self.ct),
+        )
+        return build_response(res, res.data)
+
+    def post_list_add_member(
+        self,
+        list_id: str,
+        user_id: str,
+    ) -> ResponseType[models.ListResponse]:
+        variables = non_nullable(
+            twitter.PostListAddMemberRequestVariables.from_dict(self.flag["ListAddMember"]["variables"])
+        )
+        features = non_nullable(twitter.PostCreateListRequestFeatures.from_dict(self.flag["ListAddMember"]["features"]))
+        variables.list_id = list_id
+        variables.user_id = user_id
+
+        res = self.api.post_list_add_member_with_http_info(
+            path_query_id=self.flag["ListAddMember"]["queryId"],
+            post_list_add_member_request=twitter.PostListAddMemberRequest(
+                queryId=self.flag["ListAddMember"]["queryId"],
+                variables=variables,
+                features=features,
+            ),
+            _headers=get_headers(self.flag["ListAddMember"], self.ct),
+        )
+        return build_response(res, res.data)
+
+    def post_list_remove_member(
+        self,
+        list_id: str,
+        user_id: str,
+    ) -> ResponseType[models.ListResponse]:
+        variables = non_nullable(
+            twitter.PostListAddMemberRequestVariables.from_dict(self.flag["ListRemoveMember"]["variables"])
+        )
+        features = non_nullable(
+            twitter.PostCreateListRequestFeatures.from_dict(self.flag["ListRemoveMember"]["features"])
+        )
+        variables.list_id = list_id
+        variables.user_id = user_id
+
+        res = self.api.post_list_remove_member_with_http_info(
+            path_query_id=self.flag["ListRemoveMember"]["queryId"],
+            post_list_remove_member_request=twitter.PostListRemoveMemberRequest(
+                queryId=self.flag["ListRemoveMember"]["queryId"],
+                variables=variables,
+                features=features,
+            ),
+            _headers=get_headers(self.flag["ListRemoveMember"], self.ct),
+        )
+        return build_response(res, res.data)
+
+    def post_create_draft_tweet(
+        self,
+        status: str,
+    ) -> ResponseType[models.CreateDraftTweetResponse]:
+        variables = non_nullable(
+            twitter.PostCreateDraftTweetRequestVariables.from_dict(self.flag["CreateDraftTweet"]["variables"])
+        )
+        variables.post_tweet_request.status = status
+
+        res = self.api.post_create_draft_tweet_with_http_info(
+            path_query_id=self.flag["CreateDraftTweet"]["queryId"],
+            post_create_draft_tweet_request=twitter.PostCreateDraftTweetRequest(
+                queryId=self.flag["CreateDraftTweet"]["queryId"],
+                variables=variables,
+            ),
+            _headers=get_headers(self.flag["CreateDraftTweet"], self.ct),
+        )
+        return build_response(res, res.data)
+
+    def post_delete_draft_tweets(
+        self,
+        draft_tweet_ids: list[str],
+    ) -> ResponseType[models.DeleteDraftTweetsResponse]:
+        variables = twitter.PostDeleteDraftTweetsRequestVariables(draft_tweet_ids=draft_tweet_ids)
+
+        res = self.api.post_delete_draft_tweets_with_http_info(
+            path_query_id=self.flag["DeleteDraftTweets"]["queryId"],
+            post_delete_draft_tweets_request=twitter.PostDeleteDraftTweetsRequest(
+                queryId=self.flag["DeleteDraftTweets"]["queryId"],
+                variables=variables,
+            ),
+            _headers=get_headers(self.flag["DeleteDraftTweets"], self.ct),
+        )
+        return build_response(res, res.data)