twitter-openapi-python 0.1.0__tar.gz → 0.1.2__tar.gz

{twitter_openapi_python-0.1.0 → twitter_openapi_python-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: twitter_openapi_python
-Version: 0.1.0
+Version: 0.1.2
 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.0
+Requires-Dist: twitter-openapi-python-generated==0.1.2
 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.0 → twitter_openapi_python-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "twitter_openapi_python"
-version = "0.1.0"
+version = "0.1.2"
 description = "Twitter OpenAPI"
 readme = "README.md"
 license = "LicenseRef-Custom OR AGPL-3.0-or-later"
@@ -16,7 +16,7 @@ keywords = [
 ]
 requires-python = ">=3.10"
 dependencies = [
-    "twitter_openapi_python_generated==0.1.0",
+    "twitter_openapi_python_generated==0.1.2",
     "pydantic>=2.6",
     "requests>=2.31.0,<3.0.0",
     "urllib3>=2.1.0,<3.0.0",

{twitter_openapi_python-0.1.0 → twitter_openapi_python-0.1.2}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "twitter_openapi_python"
-version = "0.1.0"
+version = "0.1.2"
 description = "Twitter OpenAPI"
 authors = [{ name = "fa0311", email = "yuki@yuki0311.com" }]
 readme = "README.md"
@@ -9,7 +9,7 @@ license-files = ["LICENSE", "LICENSE.AGPL"]
 keywords = ["twitter", "api", "python", "scraper"]
 requires-python = ">=3.10"
 dependencies = [
-    "twitter_openapi_python_generated==0.1.0",
+    "twitter_openapi_python_generated==0.1.2",
     "pydantic>=2.6",
     "requests>=2.31.0,<3.0.0",
     "urllib3>=2.1.0,<3.0.0",

{twitter_openapi_python-0.1.0 → twitter_openapi_python-0.1.2}/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-0.1.2/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-0.1.2/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-0.1.2/twitter_openapi_python/api/default_api.py

@@ -0,0 +1,155 @@
+from typing import Any, Callable, Optional, TypeVar
+
+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 TweetApiUtilsData, TwitterApiUtilsResponse
+from twitter_openapi_python.utils import (
+    build_response,
+    build_tweet_api_utils,
+    get_kwargs,
+)
+from twitter_openapi_python.utils.api import error_check
+
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+ApiFnType = Callable[..., twitter.ApiResponse[T1]]
+ParamType = dict[str, Any]
+
+
+class DefaultApiUtils:
+    api: twitter.DefaultApi
+    flag: ParamType
+
+    def __init__(self, api: twitter.DefaultApi, flag: ParamType, ct: ClientTransaction):
+        self.api = api
+        self.flag = flag
+        self.ct = ct
+
+    def request(
+        self,
+        apiFn: "ApiFnType[T1]",
+        convertFn: Callable[[T1], T2],
+        key: str,
+        param: ParamType,
+    ):
+        args = get_kwargs(flag=self.flag[key], additional=param, ct=self.ct)
+        res = apiFn(**args)
+        data = convertFn(res.data)
+        return build_response(res, data)
+
+    def get_profile_spotlights_query(
+        self,
+        screen_name: Optional[str] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[models.UserResultByScreenName]:
+        param: ParamType = {}
+        if screen_name is not None:
+            param["screen_name"] = screen_name
+        if extra_param is not None:
+            param.update(extra_param)
+
+        response = self.request(
+            apiFn=self.api.get_profile_spotlights_query_with_http_info,
+            convertFn=lambda x: error_check(x.data.user_result_by_screen_name, x.errors),
+            key="ProfileSpotlightsQuery",
+            param=param,
+        )
+        return response
+
+    def get_tweet_result_by_rest_id(
+        self,
+        tweet_id: str,
+        extra_param: Optional[ParamType] = None,
+    ) -> TwitterApiUtilsResponse[TweetApiUtilsData]:
+        param: ParamType = {"tweetId": tweet_id}
+        if extra_param is not None:
+            param.update(extra_param)
+
+        response = self.request(
+            apiFn=self.api.get_tweet_result_by_rest_id_with_http_info,
+            convertFn=lambda x: error_check(
+                build_tweet_api_utils(error_check(x.data.tweet_result, x.errors)), x.errors
+            ),
+            key="TweetResultByRestId",
+            param=param,
+        )
+        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,
+        )