universal-mcp-applications 0.1.13__py3-none-any.whl → 0.1.14__py3-none-any.whl

universal_mcp/applications/twitter/api_segments/tweets_api.py

@@ -18,9 +18,8 @@ class TweetsApi(APISegmentBase):
         place_fields=None,
     ) -> dict[str, Any]:
         """
-
-        Retrieves one or more Tweets by their IDs and returns associated details, supporting optional parameters for specifying additional fields and expansions.
-
+        Fetches detailed information for multiple tweets, specified by a list of their IDs. Optional parameters allow response customization by including specific fields (e.g., media, user, polls) and expansions. This function handles batch lookups, distinguishing it from `find_tweet_by_id` which retrieves a single tweet.
+        
         Args:
             ids (array): An array of IDs for the tweets to retrieve, required for the operation.
             tweet_fields (array): A comma separated list of Tweet fields to display. Example: "['article', 'attachments', 'author_id', 'card_uri', 'context_annotations', 'conversation_id', 'created_at', 'edit_controls', 'edit_history_tweet_ids', 'entities', 'geo', 'id', 'in_reply_to_user_id', 'lang', 'non_public_metrics', 'note_tweet', 'organic_metrics', 'possibly_sensitive', 'promoted_metrics', 'public_metrics', 'referenced_tweets', 'reply_settings', 'scopes', 'source', 'text', 'username', 'withheld']".
@@ -29,14 +28,14 @@ class TweetsApi(APISegmentBase):
             poll_fields (array): A comma separated list of Poll fields to display. Example: "['duration_minutes', 'end_datetime', 'id', 'options', 'voting_status']".
             user_fields (array): A comma separated list of User fields to display. Example: "['affiliation', 'connection_status', 'created_at', 'description', 'entities', 'id', 'location', 'most_recent_tweet_id', 'name', 'pinned_tweet_id', 'profile_banner_url', 'profile_image_url', 'protected', 'public_metrics', 'receives_your_dm', 'subscription_type', 'url', 'username', 'verified', 'verified_type', 'withheld']".
             place_fields (array): A comma separated list of Place fields to display. Example: "['contained_within', 'country', 'country_code', 'full_name', 'geo', 'id', 'name', 'place_type']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -73,9 +72,8 @@ class TweetsApi(APISegmentBase):
         text=None,
     ) -> dict[str, Any]:
         """
-
-        Creates a new tweet using the Twitter API v2, requiring an application/json payload and OAuth2 user token for authentication, and returns a 201 status upon successful creation.
-
+        Posts a new tweet for an authenticated user, supporting optional parameters like text, media, polls, replies, and quote tweets. This function constructs a POST request to the `/2/tweets` endpoint, enabling the creation of diverse tweet formats with specific visibility and reply settings.
+        
         Args:
             card_uri (string): Card Uri Parameter. This is mutually exclusive from Quote Tweet Id, Poll, Media, and Direct Message Deep Link.
             direct_message_deep_link (string): Link to take the conversation from the public timeline to a private Direct Message.
@@ -87,15 +85,15 @@ class TweetsApi(APISegmentBase):
             quote_tweet_id (string): Unique identifier of this Tweet. This is returned as a string in order to avoid complications with languages and tools that cannot handle large integers. Example: '1346889436626259968'.
             reply (object): Tweet information of the Tweet being replied to.
             reply_settings (string): Settings to indicate who can reply to the Tweet.
-            text (string): The content of the Tweet. Example: 'Learn how to use the user Tweet timeline and user mention timeline endpoints in the X API v2 to explore Tweet\\u2026 https:\\/\\/t.co\\/56a0vZUx7i'.
-
+            text (string): The content of the Tweet. Example: 'Learn how to use the user Tweet timeline and user mention timeline endpoints in the X API v2 to explore Tweet\u2026 https:\/\/t.co\/56a0vZUx7i'.
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -131,22 +129,21 @@ class TweetsApi(APISegmentBase):
         self, partition, backfill_minutes=None, start_time=None, end_time=None
     ) -> Any:
         """
-
-        Streams compliance events for tweets in real-time, allowing for the retrieval of events such as post deletions, edits, and withholdings, as well as user account changes, using parameters like partition, backfill_minutes, start_time, and end_time.
-
+        Streams real-time compliance events for tweets, such as deletions and user updates, from a specified partition. Unlike other stream functions that return tweet content, this provides metadata about content and user status changes, supporting optional time-based filtering and backfilling.
+        
         Args:
             partition (integer): Specifies the partition number from which to retrieve compliance stream events, with a required integer value between 1 and 4.
             backfill_minutes (integer): Optional integer parameter to specify the number of minutes of data to recover from a stream disconnection, allowing retrieval of missed tweets.
             start_time (string): Optional string parameter specifying the earliest UTC timestamp from which compliance events will be provided, formatted as YYYY-MM-DDTHH:mm:ssZ. Example: '2021-02-01T18:40:40.000Z'.
             end_time (string): The `end_time` parameter specifies the latest UTC timestamp (in ISO 8601 format) until which compliance events will be streamed. Example: '2021-02-14T18:40:40.000Z'.
-
+        
         Returns:
             Any: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Compliance
         """
@@ -178,9 +175,8 @@ class TweetsApi(APISegmentBase):
         search_count_fields=None,
     ) -> dict[str, Any]:
         """
-
-        Retrieves the full-archive count of tweets for a specified query using the "/2/tweets/counts/all" endpoint, allowing optional filtering by start and end times, granularity, and pagination.
-
+        Calculates the number of tweets from the entire historical archive that match a given search query. Results can be aggregated by minute, hour, or day over a specific time range to analyze historical tweet volume trends.
+        
         Args:
             query (string): The "query" parameter is a required string used to filter tweets by specifying keywords or phrases, allowing users to retrieve counts for specific topics or hashtags. Example: '(from:TwitterDev OR from:TwitterAPI) has:media -is:retweet'.
             start_time (string): The start_time parameter sets the earliest timestamp from which to begin counting Tweets in the full-archive matching the query, formatted as an ISO 8601 string.
@@ -191,14 +187,14 @@ class TweetsApi(APISegmentBase):
             pagination_token (string): Used to request the next page of results, providing the value of `next_token` from the previous response to paginate through data.
             granularity (string): The **granularity** parameter specifies the time unit for retrieving tweet counts, allowing options of "minute", "hour", or "day", with "hour" as the default.
             search_count_fields (array): A comma separated list of SearchCount fields to display. Example: "['end', 'start', 'tweet_count']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -235,9 +231,8 @@ class TweetsApi(APISegmentBase):
         search_count_fields=None,
     ) -> dict[str, Any]:
         """
-
-        Retrieves the count of recent Tweets that match a search query over the last seven days, using the "GET" method with optional parameters for specifying start and end times, granularity, and pagination.
-
+        Retrieves the total count of tweets from the last seven days matching a specified query. Results can be aggregated by minute, hour, or day and filtered by time range or tweet ID. This function contrasts with `tweet_counts_full_archive_search`, which queries the entire tweet history.
+        
         Args:
             query (string): The search query to filter recent tweets for counting matching tweets. Example: '(from:TwitterDev OR from:TwitterAPI) has:media -is:retweet'.
             start_time (string): Optional start time for the recent Tweet counts query, specified in ISO 8601 format, which determines the beginning of the time window for which Tweet counts are returned.
@@ -248,14 +243,14 @@ class TweetsApi(APISegmentBase):
             pagination_token (string): Optional parameter to paginate through the results, used by passing the `next_token` value from the previous response to retrieve the next page of tweet count data.
             granularity (string): The granularity parameter specifies the time interval for aggregating Tweet counts in the response, with possible values of "minute," "hour" (default), or "day".
             search_count_fields (array): A comma separated list of SearchCount fields to display. Example: "['end', 'start', 'tweet_count']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -293,9 +288,8 @@ class TweetsApi(APISegmentBase):
         place_fields=None,
     ) -> dict[str, Any]:
         """
-
-        Streams all tweets in real-time using the Firehose API, allowing parameters such as partition, backfill minutes, start and end time, and various field expansions to customize the data retrieved, which requires authentication via a Bearer Token.
-
+        Streams all public tweets in real-time from the Firehose API for a specified partition. This unfiltered feed can be customized with optional parameters to backfill data, define a time window, and specify desired tweet, user, and media fields.
+        
         Args:
             partition (integer): A required integer parameter that specifies the partition from which to retrieve the firehose stream data.
             backfill_minutes (integer): The backfill_minutes parameter allows requesting up to five minutes of missed streaming data to be delivered upon reconnection, helping recover Tweets lost during short disconnections; it accepts an integer value from 1 to 5 and is available only with Academic Research access.
@@ -307,14 +301,14 @@ class TweetsApi(APISegmentBase):
             poll_fields (array): A comma separated list of Poll fields to display. Example: "['duration_minutes', 'end_datetime', 'id', 'options', 'voting_status']".
             user_fields (array): A comma separated list of User fields to display. Example: "['affiliation', 'connection_status', 'created_at', 'description', 'entities', 'id', 'location', 'most_recent_tweet_id', 'name', 'pinned_tweet_id', 'profile_banner_url', 'profile_image_url', 'protected', 'public_metrics', 'receives_your_dm', 'subscription_type', 'url', 'username', 'verified', 'verified_type', 'withheld']".
             place_fields (array): A comma separated list of Place fields to display. Example: "['contained_within', 'country', 'country_code', 'full_name', 'geo', 'id', 'name', 'place_type']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -339,7 +333,7 @@ class TweetsApi(APISegmentBase):
         response.raise_for_status()
         return response.json()
 
-    def get_tweets_firehose_stream_lang_en(
+    def stream_english_tweets_firehose(
         self,
         partition,
         backfill_minutes=None,
@@ -353,9 +347,8 @@ class TweetsApi(APISegmentBase):
         place_fields=None,
     ) -> dict[str, Any]:
         """
-
-        Connects to the Twitter Firehose streaming API to receive a real-time stream of English-language tweets with optional filtering and data field expansions.
-
+        Streams real-time public tweets from the Firehose API, specifically filtered for the English language. Requires a partition number and supports optional parameters to customize the data payload. It is distinct from other language-specific (`_ja`, `_ko`, `_pt`) or the unfiltered `get_tweets_firehose_stream` functions.
+        
         Args:
             partition (integer): The `partition` parameter is an integer value required in the query for the GET operation at path "/2/tweets/firehose/stream/lang/en", specifying the partition number for the stream.
             backfill_minutes (integer): Requests up to five minutes of missed streaming data to be delivered upon reconnection, useful for recovering data lost during brief disconnections.
@@ -367,14 +360,14 @@ class TweetsApi(APISegmentBase):
             poll_fields (array): A comma separated list of Poll fields to display. Example: "['duration_minutes', 'end_datetime', 'id', 'options', 'voting_status']".
             user_fields (array): A comma separated list of User fields to display. Example: "['affiliation', 'connection_status', 'created_at', 'description', 'entities', 'id', 'location', 'most_recent_tweet_id', 'name', 'pinned_tweet_id', 'profile_banner_url', 'profile_image_url', 'protected', 'public_metrics', 'receives_your_dm', 'subscription_type', 'url', 'username', 'verified', 'verified_type', 'withheld']".
             place_fields (array): A comma separated list of Place fields to display. Example: "['contained_within', 'country', 'country_code', 'full_name', 'geo', 'id', 'name', 'place_type']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -413,9 +406,8 @@ class TweetsApi(APISegmentBase):
         place_fields=None,
     ) -> dict[str, Any]:
         """
-
-        Retrieves a stream of Tweets in Japanese using the Firehose API, allowing for real-time access to a high-volume stream of Tweets based on specified parameters such as partitions and optional backfill minutes, start and end times, and customizable fields for Tweets, users, and media.
-
+        Streams real-time tweets specifically in Japanese from the Twitter Firehose API, requiring a partition number. It supports optional parameters for time ranges, backfill, and customizable fields. This method is distinct from other `get_tweets_firehose_stream` variants, which target different languages or the entire stream.
+        
         Args:
             partition (integer): The partition number used to identify and organize the data stream, which is required for this operation.
             backfill_minutes (integer): The number of minutes (1 to 5) of missed streaming data to backfill and recover upon reconnection, available only with Academic Research access.
@@ -427,14 +419,14 @@ class TweetsApi(APISegmentBase):
             poll_fields (array): A comma separated list of Poll fields to display. Example: "['duration_minutes', 'end_datetime', 'id', 'options', 'voting_status']".
             user_fields (array): A comma separated list of User fields to display. Example: "['affiliation', 'connection_status', 'created_at', 'description', 'entities', 'id', 'location', 'most_recent_tweet_id', 'name', 'pinned_tweet_id', 'profile_banner_url', 'profile_image_url', 'protected', 'public_metrics', 'receives_your_dm', 'subscription_type', 'url', 'username', 'verified', 'verified_type', 'withheld']".
             place_fields (array): A comma separated list of Place fields to display. Example: "['contained_within', 'country', 'country_code', 'full_name', 'geo', 'id', 'name', 'place_type']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -459,7 +451,7 @@ class TweetsApi(APISegmentBase):
         response.raise_for_status()
         return response.json()
 
-    def get_tweets_firehose_stream_lang_ko(
+    def stream_korean_firehose_tweets(
         self,
         partition,
         backfill_minutes=None,
@@ -473,9 +465,8 @@ class TweetsApi(APISegmentBase):
         place_fields=None,
     ) -> dict[str, Any]:
         """
-
-        Streams real-time tweets in Korean from the Twitter firehose, allowing for optional backfill, specific partitions, and customizable start and end times, with support for various tweet, media, poll, user, and place fields.
-
+        Streams real-time tweets filtered for the Korean language from the Firehose API. This function allows customization via parameters for partitions, time range, backfill, and specific data fields for tweets, users, and media, distinguishing it from other language-specific stream functions.
+        
         Args:
             partition (integer): The partition parameter specifies the integer partition number to use for streaming tweets.
             backfill_minutes (integer): The number of minutes (1 to 5) of previously missed Tweets to backfill and deliver upon reconnection, allowing recovery of up to five minutes of data missed during a disconnection; duplicates may occur and this feature requires Academic Research access.
@@ -487,14 +478,14 @@ class TweetsApi(APISegmentBase):
             poll_fields (array): A comma separated list of Poll fields to display. Example: "['duration_minutes', 'end_datetime', 'id', 'options', 'voting_status']".
             user_fields (array): A comma separated list of User fields to display. Example: "['affiliation', 'connection_status', 'created_at', 'description', 'entities', 'id', 'location', 'most_recent_tweet_id', 'name', 'pinned_tweet_id', 'profile_banner_url', 'profile_image_url', 'protected', 'public_metrics', 'receives_your_dm', 'subscription_type', 'url', 'username', 'verified', 'verified_type', 'withheld']".
             place_fields (array): A comma separated list of Place fields to display. Example: "['contained_within', 'country', 'country_code', 'full_name', 'geo', 'id', 'name', 'place_type']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -533,9 +524,8 @@ class TweetsApi(APISegmentBase):
         place_fields=None,
     ) -> dict[str, Any]:
         """
-
-        Streams real-time Tweets in Portuguese using the Firehose API, allowing for filtering by specific parameters such as tweet fields, expansions, media, polls, users, and places, and requires a partition number for the stream.
-
+        Streams real-time tweets in Portuguese from the Firehose API, requiring a partition number. It allows data customization via optional parameters for time ranges and fields, specifically targeting the Portuguese language stream, unlike other general or language-specific firehose functions.
+        
         Args:
             partition (integer): The **partition** parameter is a required integer that specifies the partition number for the GET operation at the "/2/tweets/firehose/stream/lang/pt" path, used to distribute the stream of tweets across multiple partitions for efficient processing.
             backfill_minutes (integer): The number of minutes (1-5) of missed streaming data to recover and deliver upon reconnection, available only for Academic Research access.
@@ -547,14 +537,14 @@ class TweetsApi(APISegmentBase):
             poll_fields (array): A comma separated list of Poll fields to display. Example: "['duration_minutes', 'end_datetime', 'id', 'options', 'voting_status']".
             user_fields (array): A comma separated list of User fields to display. Example: "['affiliation', 'connection_status', 'created_at', 'description', 'entities', 'id', 'location', 'most_recent_tweet_id', 'name', 'pinned_tweet_id', 'profile_banner_url', 'profile_image_url', 'protected', 'public_metrics', 'receives_your_dm', 'subscription_type', 'url', 'username', 'verified', 'verified_type', 'withheld']".
             place_fields (array): A comma separated list of Place fields to display. Example: "['contained_within', 'country', 'country_code', 'full_name', 'geo', 'id', 'name', 'place_type']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -579,25 +569,24 @@ class TweetsApi(APISegmentBase):
         response.raise_for_status()
         return response.json()
 
-    def get_tweets_label_stream(
+    def stream_labeled_tweets(
         self, backfill_minutes=None, start_time=None, end_time=None
     ) -> Any:
         """
-
-        Streams tweets labeled with a specific identifier in real-time using the Twitter API, allowing for optional parameters to specify backfill minutes, start time, and end time, and requires authentication via a Bearer Token.
-
+        Streams real-time Tweet objects labeled for compliance reasons, such as withheld content. Unlike `get_tweets_compliance_stream`, which provides events, this returns the actual tweets. Supports filtering by a time window and backfilling missed data upon reconnection.
+        
         Args:
             backfill_minutes (integer): The number of minutes (up to five) of missed tweet data to recover and backfill after a disconnection, available for Academic Research access.
             start_time (string): Optional parameter specifying the earliest UTC timestamp (in ISO 8601/RFC 3339 format) from which to retrieve tweets, allowing filtering by creation time. Example: '2021-02-01T18:40:40.000Z'.
             end_time (string): Optional parameter specifying the end time in ISO 8601 format for retrieving tweets from a label stream, used to filter tweets created before this time. Example: '2021-02-01T18:40:40.000Z'.
-
+        
         Returns:
             Any: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Compliance
         """
@@ -626,9 +615,8 @@ class TweetsApi(APISegmentBase):
         place_fields=None,
     ) -> dict[str, Any]:
         """
-
-        Retrieves a real-time sampled stream of public Tweets with optional parameters to specify Tweet, user, media, poll, and place fields, supporting backfill for missed data.
-
+        Streams a real-time, random sample of public tweets from the API. It allows data customization through optional field and expansion parameters. This function targets the standard (~1%) sample stream, distinct from `get_tweets_sample_stream` which accesses the partitioned 10% stream.
+        
         Args:
             backfill_minutes (integer): The number of minutes (1 to 5) of missed streaming Tweets to backfill and receive upon reconnection, available for Academic Research access.
             tweet_fields (array): A comma separated list of Tweet fields to display. Example: "['article', 'attachments', 'author_id', 'card_uri', 'context_annotations', 'conversation_id', 'created_at', 'edit_controls', 'edit_history_tweet_ids', 'entities', 'geo', 'id', 'in_reply_to_user_id', 'lang', 'non_public_metrics', 'note_tweet', 'organic_metrics', 'possibly_sensitive', 'promoted_metrics', 'public_metrics', 'referenced_tweets', 'reply_settings', 'scopes', 'source', 'text', 'username', 'withheld']".
@@ -637,14 +625,14 @@ class TweetsApi(APISegmentBase):
             poll_fields (array): A comma separated list of Poll fields to display. Example: "['duration_minutes', 'end_datetime', 'id', 'options', 'voting_status']".
             user_fields (array): A comma separated list of User fields to display. Example: "['affiliation', 'connection_status', 'created_at', 'description', 'entities', 'id', 'location', 'most_recent_tweet_id', 'name', 'pinned_tweet_id', 'profile_banner_url', 'profile_image_url', 'protected', 'public_metrics', 'receives_your_dm', 'subscription_type', 'url', 'username', 'verified', 'verified_type', 'withheld']".
             place_fields (array): A comma separated list of Place fields to display. Example: "['contained_within', 'country', 'country_code', 'full_name', 'geo', 'id', 'name', 'place_type']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -666,7 +654,7 @@ class TweetsApi(APISegmentBase):
         response.raise_for_status()
         return response.json()
 
-    def get_tweets_sample_stream(
+    def get_tweets_sample10_stream(
         self,
         partition,
         backfill_minutes=None,
@@ -680,9 +668,8 @@ class TweetsApi(APISegmentBase):
         place_fields=None,
     ) -> dict[str, Any]:
         """
-
-        Streams a random sample of 10% of all Tweets in real-time, allowing optional filtering by specifying additional parameters such as backfill minutes, partition, start and end times, and various field expansions for tweets, media, polls, users, and places.
-
+        Streams a 10% random sample of real-time tweets from a specified partition, offering a larger volume than `sample_stream`. It supports optional time-based filtering and customization of returned data for tweets, media, users, and places using field selectors and expansions.
+        
         Args:
             partition (integer): The "partition" parameter specifies the partition number for the stream, which is required for the GET operation at path "/2/tweets/sample10/stream".
             backfill_minutes (integer): The `backfill_minutes` parameter allows you to request up to five minutes of missed streaming data to be delivered upon reconnection, helping recover data lost during disconnections; it is only available for Academic Research access.
@@ -694,14 +681,14 @@ class TweetsApi(APISegmentBase):
             poll_fields (array): A comma separated list of Poll fields to display. Example: "['duration_minutes', 'end_datetime', 'id', 'options', 'voting_status']".
             user_fields (array): A comma separated list of User fields to display. Example: "['affiliation', 'connection_status', 'created_at', 'description', 'entities', 'id', 'location', 'most_recent_tweet_id', 'name', 'pinned_tweet_id', 'profile_banner_url', 'profile_image_url', 'protected', 'public_metrics', 'receives_your_dm', 'subscription_type', 'url', 'username', 'verified', 'verified_type', 'withheld']".
             place_fields (array): A comma separated list of Place fields to display. Example: "['contained_within', 'country', 'country_code', 'full_name', 'geo', 'id', 'name', 'place_type']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -745,9 +732,8 @@ class TweetsApi(APISegmentBase):
         place_fields=None,
     ) -> dict[str, Any]:
         """
-
-        Retrieves and returns a list of historical Tweets matching a specified query, allowing for filtering by time range, tweet ID, and other parameters.
-
+        Searches the entire historical archive of public Tweets using a specific query. It supports filtering by time range and pagination, allowing customization of returned fields. This differs from `tweets_recent_search`, which only covers the last seven days, and `tweet_counts_full_archive_search`, which returns counts instead of tweet data.
+        
         Args:
             query (string): The "query" parameter is a required string input used to specify the search criteria for retrieving tweets. Example: '(from:TwitterDev OR from:TwitterAPI) has:media -is:retweet'.
             start_time (string): Optional timestamp specifying the earliest date and time from which to retrieve Tweets, formatted as YYYY-MM-DDTHH:mm:ssZ in ISO 8601/RFC 3339 format; if not specified and end_time is provided, it defaults to 30 days before end_time.
@@ -764,14 +750,14 @@ class TweetsApi(APISegmentBase):
             poll_fields (array): A comma separated list of Poll fields to display. Example: "['duration_minutes', 'end_datetime', 'id', 'options', 'voting_status']".
             user_fields (array): A comma separated list of User fields to display. Example: "['affiliation', 'connection_status', 'created_at', 'description', 'entities', 'id', 'location', 'most_recent_tweet_id', 'name', 'pinned_tweet_id', 'profile_banner_url', 'profile_image_url', 'protected', 'public_metrics', 'receives_your_dm', 'subscription_type', 'url', 'username', 'verified', 'verified_type', 'withheld']".
             place_fields (array): A comma separated list of Place fields to display. Example: "['contained_within', 'country', 'country_code', 'full_name', 'geo', 'id', 'name', 'place_type']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -820,9 +806,8 @@ class TweetsApi(APISegmentBase):
         place_fields=None,
     ) -> dict[str, Any]:
         """
-
-        Retrieves recent tweets based on a specified search query, allowing for optional filtering by time range and additional parameters such as tweet fields, expansions, and user details.
-
+        Searches for tweets from the past seven days matching a specific query. Allows advanced filtering, pagination, and data expansions to customize results. Unlike `tweet_counts_recent_search`, it returns full tweet objects instead of just a count.
+        
         Args:
             query (string): A string parameter used to specify the search query for retrieving recent tweets. Example: '(from:TwitterDev OR from:TwitterAPI) has:media -is:retweet'.
             start_time (string): Optional parameter to specify the earliest time to search for tweets, formatted as ISO8601/RFC3339 (e.g., 2023-05-12T00:00:00Z).
@@ -839,14 +824,14 @@ class TweetsApi(APISegmentBase):
             poll_fields (array): A comma separated list of Poll fields to display. Example: "['duration_minutes', 'end_datetime', 'id', 'options', 'voting_status']".
             user_fields (array): A comma separated list of User fields to display. Example: "['affiliation', 'connection_status', 'created_at', 'description', 'entities', 'id', 'location', 'most_recent_tweet_id', 'name', 'pinned_tweet_id', 'profile_banner_url', 'profile_image_url', 'protected', 'public_metrics', 'receives_your_dm', 'subscription_type', 'url', 'username', 'verified', 'verified_type', 'withheld']".
             place_fields (array): A comma separated list of Place fields to display. Example: "['contained_within', 'country', 'country_code', 'full_name', 'geo', 'id', 'name', 'place_type']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -876,7 +861,7 @@ class TweetsApi(APISegmentBase):
         response.raise_for_status()
         return response.json()
 
-    def search_stream(
+    def get_filtered_stream(
         self,
         backfill_minutes=None,
         start_time=None,
@@ -889,9 +874,8 @@ class TweetsApi(APISegmentBase):
         place_fields=None,
     ) -> dict[str, Any]:
         """
-
-        Streams tweets based on predefined rules using the Twitter API v2, allowing for real-time filtering and retrieval of tweets with optional parameters for backfill minutes, start and end times, and various tweet, media, poll, user, and place fields.
-
+        Streams real-time tweets matching a user's pre-configured filtering rules from the Twitter API. Unlike `sample_stream` or `get_tweets_firehose_stream`, this provides a targeted feed. Optional parameters can customize returned data fields and specify a time window.
+        
         Args:
             backfill_minutes (integer): The "backfill_minutes" parameter allows clients to request up to five minutes of missed data upon reconnection, helping to recover Tweets that were missed due to a disconnection.
             start_time (string): The "start_time" parameter specifies the earliest UTC timestamp (in ISO 8601 format) from which to include Tweets in the search results. Example: '2021-02-01T18:40:40.000Z'.
@@ -902,14 +886,14 @@ class TweetsApi(APISegmentBase):
             poll_fields (array): A comma separated list of Poll fields to display. Example: "['duration_minutes', 'end_datetime', 'id', 'options', 'voting_status']".
             user_fields (array): A comma separated list of User fields to display. Example: "['affiliation', 'connection_status', 'created_at', 'description', 'entities', 'id', 'location', 'most_recent_tweet_id', 'name', 'pinned_tweet_id', 'profile_banner_url', 'profile_image_url', 'protected', 'public_metrics', 'receives_your_dm', 'subscription_type', 'url', 'username', 'verified', 'verified_type', 'withheld']".
             place_fields (array): A comma separated list of Place fields to display. Example: "['contained_within', 'country', 'country_code', 'full_name', 'geo', 'id', 'name', 'place_type']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -933,25 +917,24 @@ class TweetsApi(APISegmentBase):
         response.raise_for_status()
         return response.json()
 
-    def get_rules(
+    def get_filtered_stream_rules(
         self, ids=None, max_results=None, pagination_token=None
     ) -> dict[str, Any]:
         """
-
-        Retrieves the active stream filtering rules for a user's Twitter API v2 filtered stream, optionally filtered by rule IDs, with support for pagination and maximum results.
-
+        Retrieves the active filtering rules for a Twitter API v2 filtered stream. It can fetch all rules or a subset specified by rule IDs, with support for pagination to manage large rule sets, complementing the `add_or_delete_rules` and `search_stream` functions.
+        
         Args:
             ids (array): Optional array of rule IDs to fetch a subset of rules from the user's active rule set.
             max_results (integer): The maximum number of stream filtering rules to return per response, up to 1000; defaults to 1000 if not specified.
             pagination_token (string): The `pagination_token` parameter is a string used to request the next page of results in a paginated response, typically obtained from the `next_token` value in the previous response.
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -969,26 +952,25 @@ class TweetsApi(APISegmentBase):
         response.raise_for_status()
         return response.json()
 
-    def add_or_delete_rules(
+    def update_stream_rules(
         self, dry_run=None, delete_all=None, add=None, delete=None
     ) -> dict[str, Any]:
         """
-
-        Adds or removes rules from a Twitter API v2 filtered stream using a POST request, allowing for optional dry-run or delete-all parameters.
-
+        Adds or removes filtering rules for a tweet stream. Supports a dry-run mode to validate rule syntax without application and an option to delete all existing rules. This function directly modifies the active rule set used by the `search_stream` function.
+        
         Args:
             dry_run (boolean): Indicates whether to test the syntax of the rule without applying it to the stream, allowing validation of rule changes without taking effect.
             delete_all (boolean): Indicates whether to delete all existing rules for the user before applying new rules; if true, all existing rules will be deleted.
             add (array): add
             delete (object): IDs and values of all deleted user-specified stream filtering rules.
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -1012,21 +994,20 @@ class TweetsApi(APISegmentBase):
         response.raise_for_status()
         return response.json()
 
-    def get_rule_count(self, rules_count_fields=None) -> dict[str, Any]:
+    def get_stream_rule_usage(self, rules_count_fields=None) -> dict[str, Any]:
         """
-
-        Retrieves the counts of Tweets matching specific search rules using the "GET" method, providing a way to analyze the volume of Tweets based on predefined criteria.
-
+        Retrieves the number of active filtered stream rules for the user's project and app. This helps manage usage against API limits by providing metadata about rule counts, not the number of tweets matching those rules.
+        
         Args:
             rules_count_fields (array): A comma separated list of RulesCount fields to display. Example: "['all_project_client_apps', 'cap_per_client_app', 'cap_per_project', 'client_app_rules_count', 'project_rules_count']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             General
         """
@@ -1042,19 +1023,18 @@ class TweetsApi(APISegmentBase):
 
     def delete_tweet_by_id(self, id) -> dict[str, Any]:
         """
-
-        Deletes a specified Tweet by its ID on behalf of an authenticated user.
-
+        Deletes a specific Tweet, identified by its unique ID, on behalf of the authenticated user. This function permanently removes the targeted Tweet by sending a DELETE request to the API's corresponding endpoint.
+        
         Args:
             id (string): id
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -1066,7 +1046,7 @@ class TweetsApi(APISegmentBase):
         response.raise_for_status()
         return response.json()
 
-    def find_tweet_by_id(
+    def get_tweet_by_id(
         self,
         id,
         tweet_fields=None,
@@ -1077,9 +1057,8 @@ class TweetsApi(APISegmentBase):
         place_fields=None,
     ) -> dict[str, Any]:
         """
-
-        Retrieves detailed information about a single Tweet specified by its unique ID, with optional expansions for fields related to the Tweet, user, media, polls, and places.
-
+        Retrieves detailed information for a single Tweet by its unique ID. It supports optional parameters to customize the response by specifying fields for the tweet, user, and media. Unlike `find_tweets_by_id`, which retrieves a batch of tweets, this function fetches exactly one.
+        
         Args:
             id (string): id
             tweet_fields (array): A comma separated list of Tweet fields to display. Example: "['article', 'attachments', 'author_id', 'card_uri', 'context_annotations', 'conversation_id', 'created_at', 'edit_controls', 'edit_history_tweet_ids', 'entities', 'geo', 'id', 'in_reply_to_user_id', 'lang', 'non_public_metrics', 'note_tweet', 'organic_metrics', 'possibly_sensitive', 'promoted_metrics', 'public_metrics', 'referenced_tweets', 'reply_settings', 'scopes', 'source', 'text', 'username', 'withheld']".
@@ -1088,14 +1067,14 @@ class TweetsApi(APISegmentBase):
             poll_fields (array): A comma separated list of Poll fields to display. Example: "['duration_minutes', 'end_datetime', 'id', 'options', 'voting_status']".
             user_fields (array): A comma separated list of User fields to display. Example: "['affiliation', 'connection_status', 'created_at', 'description', 'entities', 'id', 'location', 'most_recent_tweet_id', 'name', 'pinned_tweet_id', 'profile_banner_url', 'profile_image_url', 'protected', 'public_metrics', 'receives_your_dm', 'subscription_type', 'url', 'username', 'verified', 'verified_type', 'withheld']".
             place_fields (array): A comma separated list of Place fields to display. Example: "['contained_within', 'country', 'country_code', 'full_name', 'geo', 'id', 'name', 'place_type']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -1118,7 +1097,7 @@ class TweetsApi(APISegmentBase):
         response.raise_for_status()
         return response.json()
 
-    def tweets_id_liking_users(
+    def get_tweet_liking_users(
         self,
         id,
         max_results=None,
@@ -1128,9 +1107,8 @@ class TweetsApi(APISegmentBase):
         tweet_fields=None,
     ) -> dict[str, Any]:
         """
-
-        Retrieves a list of users who have liked a specified tweet using the provided tweet ID.
-
+        Retrieves a list of users who have liked a specific tweet, identified by its ID. Supports pagination and allows for customization of the returned data fields for users and tweets, including expansions for related objects.
+        
         Args:
             id (string): id
             max_results (integer): Specifies the maximum number of liking users to return in a response, with a default value of 100 and a maximum allowed value of 100.
@@ -1138,14 +1116,14 @@ class TweetsApi(APISegmentBase):
             user_fields (array): A comma separated list of User fields to display. Example: "['affiliation', 'connection_status', 'created_at', 'description', 'entities', 'id', 'location', 'most_recent_tweet_id', 'name', 'pinned_tweet_id', 'profile_banner_url', 'profile_image_url', 'protected', 'public_metrics', 'receives_your_dm', 'subscription_type', 'url', 'username', 'verified', 'verified_type', 'withheld']".
             expansions (array): A comma separated list of fields to expand. Example: "['affiliation.user_id', 'most_recent_tweet_id', 'pinned_tweet_id']".
             tweet_fields (array): A comma separated list of Tweet fields to display. Example: "['article', 'attachments', 'author_id', 'card_uri', 'context_annotations', 'conversation_id', 'created_at', 'edit_controls', 'edit_history_tweet_ids', 'entities', 'geo', 'id', 'in_reply_to_user_id', 'lang', 'non_public_metrics', 'note_tweet', 'organic_metrics', 'possibly_sensitive', 'promoted_metrics', 'public_metrics', 'referenced_tweets', 'reply_settings', 'scopes', 'source', 'text', 'username', 'withheld']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Users
         """
@@ -1167,7 +1145,7 @@ class TweetsApi(APISegmentBase):
         response.raise_for_status()
         return response.json()
 
-    def find_tweets_that_quote_atweet(
+    def get_quote_tweets_by_id(
         self,
         id,
         max_results=None,
@@ -1181,9 +1159,8 @@ class TweetsApi(APISegmentBase):
         place_fields=None,
     ) -> dict[str, Any]:
         """
-
-        Retrieves a list of quote Tweets for a specified Tweet ID, allowing for optional parameters to customize the results with fields like tweet fields, media fields, and user expansions, and supports pagination for handling large responses.
-
+        Retrieves a list of tweets that have quoted a specified tweet ID. Supports pagination and allows for response customization by specifying additional data fields for tweets, media, users, polls, and places through various expansion parameters.
+        
         Args:
             id (string): id
             max_results (integer): Specifies the maximum number of quote Tweets to return in the response, ranging from 1 to 100, with a default of 10.
@@ -1195,14 +1172,14 @@ class TweetsApi(APISegmentBase):
             poll_fields (array): A comma separated list of Poll fields to display. Example: "['duration_minutes', 'end_datetime', 'id', 'options', 'voting_status']".
             user_fields (array): A comma separated list of User fields to display. Example: "['affiliation', 'connection_status', 'created_at', 'description', 'entities', 'id', 'location', 'most_recent_tweet_id', 'name', 'pinned_tweet_id', 'profile_banner_url', 'profile_image_url', 'protected', 'public_metrics', 'receives_your_dm', 'subscription_type', 'url', 'username', 'verified', 'verified_type', 'withheld']".
             place_fields (array): A comma separated list of Place fields to display. Example: "['contained_within', 'country', 'country_code', 'full_name', 'geo', 'id', 'name', 'place_type']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -1228,7 +1205,7 @@ class TweetsApi(APISegmentBase):
         response.raise_for_status()
         return response.json()
 
-    def tweets_id_retweeting_users(
+    def get_retweeting_users_by_tweet_id(
         self,
         id,
         max_results=None,
@@ -1238,9 +1215,8 @@ class TweetsApi(APISegmentBase):
         tweet_fields=None,
     ) -> dict[str, Any]:
         """
-
-        Retrieves a list of User objects representing users who have retweeted the Tweet specified by the given Tweet ID.
-
+        Retrieves a list of users who retweeted a specific tweet, identified by its ID. Supports pagination and allows customizing the response with optional fields. This function returns user objects, unlike `find_tweets_that_retweet_atweet` which returns the actual retweet objects.
+        
         Args:
             id (string): id
             max_results (integer): The `max_results` parameter specifies the maximum number of users to return who have retweeted the specified Tweet, with a default value of 100 and a required range of 1 to 100.
@@ -1248,14 +1224,14 @@ class TweetsApi(APISegmentBase):
             user_fields (array): A comma separated list of User fields to display. Example: "['affiliation', 'connection_status', 'created_at', 'description', 'entities', 'id', 'location', 'most_recent_tweet_id', 'name', 'pinned_tweet_id', 'profile_banner_url', 'profile_image_url', 'protected', 'public_metrics', 'receives_your_dm', 'subscription_type', 'url', 'username', 'verified', 'verified_type', 'withheld']".
             expansions (array): A comma separated list of fields to expand. Example: "['affiliation.user_id', 'most_recent_tweet_id', 'pinned_tweet_id']".
             tweet_fields (array): A comma separated list of Tweet fields to display. Example: "['article', 'attachments', 'author_id', 'card_uri', 'context_annotations', 'conversation_id', 'created_at', 'edit_controls', 'edit_history_tweet_ids', 'entities', 'geo', 'id', 'in_reply_to_user_id', 'lang', 'non_public_metrics', 'note_tweet', 'organic_metrics', 'possibly_sensitive', 'promoted_metrics', 'public_metrics', 'referenced_tweets', 'reply_settings', 'scopes', 'source', 'text', 'username', 'withheld']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Users
         """
@@ -1277,7 +1253,7 @@ class TweetsApi(APISegmentBase):
         response.raise_for_status()
         return response.json()
 
-    def find_tweets_that_retweet_atweet(
+    def get_retweets_by_id(
         self,
         id,
         max_results=None,
@@ -1290,9 +1266,8 @@ class TweetsApi(APISegmentBase):
         place_fields=None,
     ) -> dict[str, Any]:
         """
-
-        Retrieves a list of retweets for a specified Tweet ID, optionally allowing for pagination and customization of returned fields via query parameters.
-
+        Retrieves Tweet objects that are retweets of a specified tweet ID, supporting pagination and data customization. This function returns the actual retweets, distinguishing it from `tweets_id_retweeting_users` which returns the users who retweeted.
+        
         Args:
             id (string): id
             max_results (integer): Specifies the maximum number of retweets to return per request, with a default of 100 and a maximum value of 100.
@@ -1303,14 +1278,14 @@ class TweetsApi(APISegmentBase):
             poll_fields (array): A comma separated list of Poll fields to display. Example: "['duration_minutes', 'end_datetime', 'id', 'options', 'voting_status']".
             user_fields (array): A comma separated list of User fields to display. Example: "['affiliation', 'connection_status', 'created_at', 'description', 'entities', 'id', 'location', 'most_recent_tweet_id', 'name', 'pinned_tweet_id', 'profile_banner_url', 'profile_image_url', 'protected', 'public_metrics', 'receives_your_dm', 'subscription_type', 'url', 'username', 'verified', 'verified_type', 'withheld']".
             place_fields (array): A comma separated list of Place fields to display. Example: "['contained_within', 'country', 'country_code', 'full_name', 'geo', 'id', 'name', 'place_type']".
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -1335,22 +1310,21 @@ class TweetsApi(APISegmentBase):
         response.raise_for_status()
         return response.json()
 
-    def hide_reply_by_id(self, tweet_id, hidden=None) -> dict[str, Any]:
+    def set_reply_visibility(self, tweet_id, hidden=None) -> dict[str, Any]:
         """
-
-        Hides or unhides a reply to a specified Tweet by its tweet_id.
-
+        Updates the visibility of a specific reply tweet. This function sends a PUT request to hide or unhide a reply, identified by its `tweet_id`, based on the provided boolean `hidden` parameter, thus managing its state within a conversation.
+        
         Args:
             tweet_id (string): tweet_id
             hidden (boolean): hidden
-
+        
         Returns:
             dict[str, Any]: The request has succeeded.
-
+        
         Raises:
             HTTPError: Raised when the API request fails (e.g., non-2XX status code).
             JSONDecodeError: Raised if the response body cannot be parsed as JSON.
-
+        
         Tags:
             Tweets
         """
@@ -1380,24 +1354,24 @@ class TweetsApi(APISegmentBase):
             self.tweet_counts_full_archive_search,
             self.tweet_counts_recent_search,
             self.get_tweets_firehose_stream,
-            self.get_tweets_firehose_stream_lang_en,
+            self.stream_english_tweets_firehose,
             self.get_tweets_firehose_stream_lang_ja,
-            self.get_tweets_firehose_stream_lang_ko,
+            self.stream_korean_firehose_tweets,
             self.get_tweets_firehose_stream_lang_pt,
-            self.get_tweets_label_stream,
+            self.stream_labeled_tweets,
             self.sample_stream,
-            self.get_tweets_sample_stream,
+            self.get_tweets_sample10_stream,
             self.tweets_fullarchive_search,
             self.tweets_recent_search,
-            self.search_stream,
-            self.get_rules,
-            self.add_or_delete_rules,
-            self.get_rule_count,
+            self.get_filtered_stream,
+            self.get_filtered_stream_rules,
+            self.update_stream_rules,
+            self.get_stream_rule_usage,
             self.delete_tweet_by_id,
-            self.find_tweet_by_id,
-            self.tweets_id_liking_users,
-            self.find_tweets_that_quote_atweet,
-            self.tweets_id_retweeting_users,
-            self.find_tweets_that_retweet_atweet,
-            self.hide_reply_by_id,
+            self.get_tweet_by_id,
+            self.get_tweet_liking_users,
+            self.get_quote_tweets_by_id,
+            self.get_retweeting_users_by_tweet_id,
+            self.get_retweets_by_id,
+            self.set_reply_visibility,
         ]