twitter-openapi-python 0.0.45__tar.gz → 0.1.1__tar.gz

{twitter_openapi_python-0.0.45 → twitter_openapi_python-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: twitter_openapi_python
-Version: 0.0.45
+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.0.35
+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.0.45 → twitter_openapi_python-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "twitter_openapi_python"
-version = "0.0.45"
+version = "0.1.1"
 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.0.35",
+    "twitter_openapi_python_generated==0.1.1",
     "pydantic>=2.6",
     "requests>=2.31.0,<3.0.0",
     "urllib3>=2.1.0,<3.0.0",

{twitter_openapi_python-0.0.45 → twitter_openapi_python-0.1.1}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "twitter_openapi_python"
-version = "0.0.45"
+version = "0.1.1"
 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.0.35",
+    "twitter_openapi_python_generated==0.1.1",
     "pydantic>=2.6",
     "requests>=2.31.0,<3.0.0",
     "urllib3>=2.1.0,<3.0.0",

twitter_openapi_python-0.1.1/twitter_openapi_python/api/post_api.py

@@ -0,0 +1,327 @@
+from typing import Any, 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 TwitterApiUtilsResponse
+from twitter_openapi_python.utils import build_response, non_nullable
+from twitter_openapi_python.utils.api import get_headers
+
+T = TypeVar("T")
+ResponseType = TwitterApiUtilsResponse[T]
+ParamType = dict[str, Any]
+
+
+class PostApiUtils:
+    api: twitter.PostApi
+    flag: ParamType
+
+    def __init__(self, api: twitter.PostApi, flag: ParamType, ct: ClientTransaction):
+        self.api = api
+        self.flag = flag
+        self.ct = ct
+
+    def post_create_tweet(
+        self,
+        tweet_text: str,
+        media_ids: Optional[list[str]] = None,
+        tagged_users: Optional[list[list[str]]] = None,
+        in_reply_to_tweet_id: Optional[str] = None,
+        attachment_url: Optional[str] = None,
+        conversation_control: Optional[str] = None,
+    ) -> ResponseType[models.CreateTweetResponse]:
+        variables = non_nullable(
+            twitter.PostCreateTweetRequestVariables.from_dict(self.flag["CreateTweet"]["variables"])
+        )
+        features = non_nullable(twitter.PostCreateTweetRequestFeatures.from_dict(self.flag["CreateTweet"]["features"]))
+        variables.tweet_text = tweet_text
+        if media_ids:
+            tagged_or = tagged_users or []
+            variables.media.media_entities = [
+                twitter.PostCreateTweetRequestVariablesMediaMediaEntitiesInner(
+                    media_id=media_id,
+                    tagged_users=tagged_or[idx] if len(tagged_or) > idx else [],
+                )
+                for idx, media_id in enumerate(media_ids)
+            ]
+        variables.attachment_url = attachment_url
+        if conversation_control:
+            variables.conversation_control = twitter.PostCreateTweetRequestVariablesConversationControl(
+                mode=conversation_control
+            )
+
+        if in_reply_to_tweet_id:
+            variables.reply = twitter.PostCreateTweetRequestVariablesReply(
+                exclude_reply_user_ids=[],
+                in_reply_to_tweet_id=in_reply_to_tweet_id,
+            )
+
+        res = self.api.post_create_tweet_with_http_info(
+            path_query_id=self.flag["CreateTweet"]["queryId"],
+            post_create_tweet_request=twitter.PostCreateTweetRequest(
+                queryId=self.flag["CreateTweet"]["queryId"],
+                variables=variables,
+                features=features,
+            ),
+            _headers=get_headers(self.flag["CreateTweet"], self.ct),
+        )
+        return build_response(res, res.data)
+
+    def post_delete_tweet(
+        self,
+        tweet_id: str,
+    ) -> ResponseType[models.DeleteTweetResponse]:
+        variables = non_nullable(
+            twitter.PostCreateRetweetRequestVariables.from_dict(self.flag["DeleteTweet"]["variables"])
+        )
+        variables.tweet_id = tweet_id
+
+        res = self.api.post_delete_tweet_with_http_info(
+            path_query_id=self.flag["DeleteTweet"]["queryId"],
+            post_delete_tweet_request=twitter.PostDeleteTweetRequest(
+                queryId=self.flag["DeleteTweet"]["queryId"],
+                variables=variables,
+            ),
+            _headers=get_headers(self.flag["DeleteTweet"], self.ct),
+        )
+        return build_response(res, res.data)
+
+    def post_create_retweet(
+        self,
+        tweet_id: str,
+    ) -> ResponseType[models.CreateRetweetResponse]:
+        variables = non_nullable(
+            twitter.PostCreateRetweetRequestVariables.from_dict(self.flag["CreateRetweet"]["variables"])
+        )
+        variables.tweet_id = tweet_id
+
+        res = self.api.post_create_retweet_with_http_info(
+            path_query_id=self.flag["CreateRetweet"]["queryId"],
+            post_create_retweet_request=twitter.PostCreateRetweetRequest(
+                queryId=self.flag["CreateRetweet"]["queryId"],
+                variables=variables,
+            ),
+            _headers=get_headers(self.flag["CreateRetweet"], self.ct),
+        )
+        return build_response(res, res.data)
+
+    def post_delete_retweet(
+        self,
+        source_tweet_id: str,
+    ) -> ResponseType[models.DeleteRetweetResponse]:
+        variables = non_nullable(
+            twitter.PostDeleteRetweetRequestVariables.from_dict(self.flag["DeleteRetweet"]["variables"])
+        )
+        variables.source_tweet_id = source_tweet_id
+
+        res = self.api.post_delete_retweet_with_http_info(
+            path_query_id=self.flag["DeleteRetweet"]["queryId"],
+            post_delete_retweet_request=twitter.PostDeleteRetweetRequest(
+                queryId=self.flag["DeleteRetweet"]["queryId"],
+                variables=variables,
+            ),
+            _headers=get_headers(self.flag["DeleteRetweet"], self.ct),
+        )
+        return build_response(res, res.data)
+
+    # postFavoriteTweet
+    def post_favorite_tweet(
+        self,
+        tweet_id: str,
+    ) -> ResponseType[models.FavoriteTweetResponse]:
+        variables = non_nullable(
+            twitter.PostCreateBookmarkRequestVariables.from_dict(self.flag["FavoriteTweet"]["variables"])
+        )
+        variables.tweet_id = tweet_id
+
+        res = self.api.post_favorite_tweet_with_http_info(
+            path_query_id=self.flag["FavoriteTweet"]["queryId"],
+            post_favorite_tweet_request=twitter.PostFavoriteTweetRequest(
+                queryId=self.flag["FavoriteTweet"]["queryId"],
+                variables=variables,
+            ),
+            _headers=get_headers(self.flag["FavoriteTweet"], self.ct),
+        )
+        return build_response(res, res.data)
+
+    # postUnfavoriteTweet
+    def post_unfavorite_tweet(
+        self,
+        tweet_id: str,
+    ) -> ResponseType[models.UnfavoriteTweetResponse]:
+        variables = non_nullable(
+            twitter.PostCreateRetweetRequestVariables.from_dict(self.flag["UnfavoriteTweet"]["variables"])
+        )
+        variables.tweet_id = tweet_id
+
+        res = self.api.post_unfavorite_tweet_with_http_info(
+            path_query_id=self.flag["UnfavoriteTweet"]["queryId"],
+            post_unfavorite_tweet_request=twitter.PostUnfavoriteTweetRequest(
+                queryId=self.flag["UnfavoriteTweet"]["queryId"],
+                variables=variables,
+            ),
+            _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-0.0.45 → twitter_openapi_python-0.1.1}/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)),
+        )