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

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)

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,218 @@ 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)),
+        )

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,24 +41,14 @@ 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,
+        return timeline_request(
+            apiFn,
+            self.flag[key],
+            self.ct,
+            convertFn,
+            param,
+            lambda entry: user_result_converter(user_entries_converter(entry)),
         )
-        data = TimelineApiUtilsResponse[UserApiUtilsData](
-            raw=raw,
-            cursor=entries_cursor(entry),
-            data=user,
-        )
-
-        return build_response(response=res, data=data)
 
     def get_followers(
         self,
@@ -169,3 +158,147 @@ 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,
+        )

twitter_openapi_python/client.py

@@ -61,7 +61,7 @@ class TwitterOpenapiPythonClient:
 
 
 class TwitterOpenapiPython:
-    hash: str = "103dca20cc540be8dc8291e6f573c3d48ba7af3e"
+    hash: str = "ec7d907e12cfaca5b93dde55522dcc6045457570"
     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/models/__init__.py

@@ -15,6 +15,7 @@ from twitter_openapi_python.models.response import (
 )
 from twitter_openapi_python.models.timeline import (
     ApiUtilsRaw,
+    CommunityApiUtilsData,
     CursorApiUtilsResponse,
     TimelineApiUtilsResponse,
     TweetApiUtilsData,

twitter_openapi_python/models/timeline.py

@@ -34,6 +34,11 @@ class UserApiUtilsData(BaseModel):
     user: models.User = Field()
 
 
+class CommunityApiUtilsData(BaseModel):
+    raw: models.TimelineCommunity = Field()
+    community: models.Community = Field()
+
+
 class TimelineApiUtilsResponse(BaseModel, Generic[T]):
     raw: ApiUtilsRaw = Field()
     cursor: CursorApiUtilsResponse = Field()

twitter_openapi_python/utils/__init__.py

@@ -8,11 +8,18 @@ from twitter_openapi_python.utils.api import (
     build_header,
     build_response,
     build_tweet_api_utils,
+    community_entries_converter,
+    data_request,
     error_check,
     entries_cursor,
     get_kwargs,
     get_legacy_kwargs,
     instruction_to_entry,
+    item_contents,
+    list_entries_converter,
+    notification_entries_converter,
+    timeline_request,
+    trend_entries_converter,
     tweet_entries_converter,
     tweet_results_converter,
     user_entries_converter,

twitter_openapi_python/utils/api.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Dict, List, Mapping, Optional, TypeGuard, TypeVar
+from typing import Any, Callable, Dict, List, Mapping, Optional, TypeGuard, TypeVar
 
 import twitter_openapi_python_generated as twitter
 import twitter_openapi_python_generated.models as models
@@ -7,7 +7,10 @@ from x_client_transaction import ClientTransaction
 
 from twitter_openapi_python.models import (
     ApiUtilsHeader,
+    ApiUtilsRaw,
+    CommunityApiUtilsData,
     CursorApiUtilsResponse,
+    TimelineApiUtilsResponse,
     TweetApiUtilsData,
     TwitterApiUtilsRaw,
     TwitterApiUtilsResponse,
@@ -198,17 +201,45 @@ def tweet_results_converter(tweetResults: models.ItemResult) -> Optional[models.
     raise Exception()
 
 
+def item_contents(item: List[models.TimelineAddEntry]) -> List[Any]:
+    """Every item of the entries, module items included (TimelineTweet, TimelineUser, TimelineTrend, ...)."""
+
+    def map_fn(x: models.TimelineAddEntry) -> List[Any]:
+        one_of = x.content.actual_instance
+        if isinstance(one_of, models.TimelineTimelineItem):
+            return [one_of.item_content.actual_instance]
+        elif isinstance(one_of, models.TimelineTimelineModule):
+            return [y.item.item_content.actual_instance for y in one_of.items or []]
+        return []
+
+    return flat(list(map(map_fn, item)))
+
+
 def user_entries_converter(
     item: list[models.TimelineAddEntry],
 ) -> list[models.UserResults]:
-    def map_fn(x: models.TimelineAddEntry) -> Optional[models.UserResults]:
-        one_of = x.content.actual_instance
-        if isinstance(one_of, models.TimelineTimelineItem):
-            item = one_of.item_content.actual_instance
-            if isinstance(item, models.TimelineUser):
-                return item.user_results
+    return [x.user_results for x in item_contents(item) if isinstance(x, models.TimelineUser)]
 
-    return non_nullable_list(list(map(map_fn, item)))
+
+def trend_entries_converter(item: List[models.TimelineAddEntry]) -> List[models.TimelineTrend]:
+    return [x for x in item_contents(item) if isinstance(x, models.TimelineTrend)]
+
+
+def notification_entries_converter(item: List[models.TimelineAddEntry]) -> List[models.TimelineNotification]:
+    return [x for x in item_contents(item) if isinstance(x, models.TimelineNotification)]
+
+
+def list_entries_converter(item: List[models.TimelineAddEntry]) -> List[models.TwitterList]:
+    return [x.list for x in item_contents(item) if isinstance(x, models.TimelineTwitterList)]
+
+
+def community_entries_converter(item: List[models.TimelineAddEntry]) -> List[CommunityApiUtilsData]:
+    def map_fn(x: models.TimelineCommunity) -> Optional[CommunityApiUtilsData]:
+        community = x.community_results.result.actual_instance
+        if isinstance(community, models.Community):
+            return CommunityApiUtilsData(raw=x, community=community)
+
+    return non_nullable_list([map_fn(x) for x in item_contents(item) if isinstance(x, models.TimelineCommunity)])
 
 
 def user_result_converter(item: list[models.UserResults]) -> List[UserApiUtilsData]:
@@ -270,6 +301,36 @@ def build_header(headers: Dict[str, str]) -> ApiUtilsHeader:
     )
 
 
+def timeline_request(
+    api_fn: Callable[..., twitter.ApiResponse[T1]],
+    flag: ParamType,
+    ct: ClientTransaction,
+    convert_fn: Callable[[T1], List[models.InstructionUnion]],
+    param: ParamType,
+    items_fn: Callable[[List[models.TimelineAddEntry]], List[T2]],
+) -> TwitterApiUtilsResponse[TimelineApiUtilsResponse[T2]]:
+    res = api_fn(**get_kwargs(flag=flag, additional=param, ct=ct))
+    instruction = convert_fn(res.data)
+    entry = instruction_to_entry(instruction)
+    data = TimelineApiUtilsResponse[T2](
+        raw=ApiUtilsRaw(instruction=instruction, entry=entry),
+        cursor=entries_cursor(entry),
+        data=items_fn(entry),
+    )
+    return build_response(res, data)
+
+
+def data_request(
+    api_fn: Callable[..., twitter.ApiResponse[T1]],
+    flag: ParamType,
+    ct: ClientTransaction,
+    convert_fn: Callable[[T1], T2],
+    param: ParamType,
+) -> TwitterApiUtilsResponse[T2]:
+    res = api_fn(**get_kwargs(flag=flag, additional=param, ct=ct))
+    return build_response(res, convert_fn(res.data))
+
+
 def build_response(response: twitter.ApiResponse, data: T1) -> TwitterApiUtilsResponse[T1]:
     if response.headers is None:
         raise Exception("headers is None")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: twitter_openapi_python
-Version: 0.1.0
+Version: 0.1.1
 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.1
 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.dist-info → twitter_openapi_python-0.1.1.dist-info}/RECORD

@@ -2,26 +2,26 @@ twitter_openapi_python/__init__.py,sha256=IyCanHNVJtKPGaYEMBqF37VXfMtZNUJlPhSOZM
 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/initial_state_api.py,sha256=nAkb25-btWdMoSyyncxS_VrBQ9uKDgzmG7jBubfETYo,2269
-twitter_openapi_python/api/post_api.py,sha256=uM-TzRKJQo5mFLXk8h8eu0zfYRXAvIZ0uRWA1eCnyuU,6526
-twitter_openapi_python/api/tweet_api.py,sha256=F-oa2FJk4ySkUPkALp3cRindjsisbkCdyZh9XTLrRnQ,14178
-twitter_openapi_python/api/user_api.py,sha256=AmGhdLrIidDwNn9eOmA3O0kYKbyustv3ZlrZdxTcvwc,2457
-twitter_openapi_python/api/user_list_api.py,sha256=KYNYZfBFuvvZQERJcVjj5ZYc93tuCLNNOMv7r3dknOo,5502
+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/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=LUGEgRmCgnqNJJwQu1WO3ssJfQjVUzhvnf7vchF1UuM,6786
-twitter_openapi_python/models/__init__.py,sha256=Mt28XGFXzAauvwrjFhKyKpo2ZoN7uP_TMq-d9JuM9qk,561
+twitter_openapi_python/client.py,sha256=FSIArYbykUREGLISz9pcwYsux3xgDRgH_vkbM6zc2Ps,6786
+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
 twitter_openapi_python/models/initial_state.py,sha256=XULKiYznCIG5TsLfV5RGPD_xOiE2bmKt1C8EtL-tQKM,513
 twitter_openapi_python/models/response.py,sha256=ziBYbwdGSeCN3zfu5mFTTd8613zaZetzkZf8y_roTaI,461
-twitter_openapi_python/models/timeline.py,sha256=5oyOUgCtrfuY8hDPVgAL2-s7Ma4jOdzWtV8kiCR1V98,1356
+twitter_openapi_python/models/timeline.py,sha256=dRMoc7zqyW_E2iehs4F6HfX8Iy_1b-e3Uo_c2b6Apbg,1484
 twitter_openapi_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 twitter_openapi_python/tid.py,sha256=xjqJMyPOp62nw2MQjMGHaB4L6G6OZHuWkMR-WKJo7aU,1120
-twitter_openapi_python/utils/__init__.py,sha256=dCcm68kn5uv5rCRMLRd0rpeN6hAKulIz9khp0HLgx1c,427
-twitter_openapi_python/utils/api.py,sha256=k51VenadKXzLeoA_fS9YyAb_Ufx6Hz7p_l3WnITdUBs,10131
-twitter_openapi_python-0.1.0.dist-info/licenses/LICENSE,sha256=sLv8EMhrPCMG_LeweYvYKS_B-cDMBwBSKZel7LSMGAs,1493
-twitter_openapi_python-0.1.0.dist-info/licenses/LICENSE.AGPL,sha256=TfPDBt3ar0uv_f9cqCDMZ5rIzW3CY8anRRd4PkL6ejs,34522
-twitter_openapi_python-0.1.0.dist-info/WHEEL,sha256=9IUYslYuG_asT4WlWvfk_K76nveuLvSTKDoLeL0cV-Q,80
-twitter_openapi_python-0.1.0.dist-info/METADATA,sha256=c1EtDT83hxNtKvGdwrrHX77NyF-k1LEtR69Kohl-hkw,3232
-twitter_openapi_python-0.1.0.dist-info/RECORD,,
+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,,