def filter(self, *, follow=None, track=None, locations=None, filter_level=None, languages=None, stall_warnings=False, threaded=False): if self.running: raise TweepyException("Stream is already connected") method = "POST" endpoint = "statuses/filter" headers = {"Content-Type": "application/x-www-form-urlencoded"} body = {} if follow: body["follow"] = ','.join(map(str, follow)) if track: body["track"] = ','.join(map(str, track)) if locations and len(locations) > 0: if len(locations) % 4: raise TweepyException( "Number of location coordinates should be a multiple of 4" ) body["locations"] = ','.join(f"{l:.4f}" for l in locations) if filter_level: body["filter_level"] = filter_level if languages: body["language"] = ','.join(map(str, languages)) if stall_warnings: body["stall_warnings"] = stall_warnings if threaded: return self._threaded_connect(method, endpoint, headers=headers, body=body) else: self._connect(method, endpoint, headers=headers, body=body)
def parse(self, payload, *, api=None, payload_list=False, payload_type=None, return_cursors=False): try: if payload_type is None: return model = getattr(self.model_factory, payload_type) except AttributeError: raise TweepyException( f'No model for this payload type: {payload_type}' ) json = JSONParser.parse(self, payload, return_cursors=return_cursors) if isinstance(json, tuple): json, cursors = json else: cursors = None try: if payload_list: result = model.parse_list(api, json) else: result = model.parse(api, json) except KeyError: raise TweepyException( f"Unable to parse response payload: {json}" ) from None if cursors: return result, cursors else: return result
def prev(self): if self.current_page is None: raise TweepyException('Can not go back more, at first page') if self.page_index == 0: # At the beginning of the current page, move to next... self.current_page = self.page_iterator.prev() self.page_index = len(self.current_page) if self.page_index == 0: raise TweepyException('No more items') self.page_index -= 1 self.num_tweets -= 1 return self.current_page[self.page_index]
def prev(self): if self.prev_cursor == 0: raise TweepyException('Can not page back more, at first page') data, self.next_cursor, self.prev_cursor = self.method( cursor=self.prev_cursor, *self.args, **self.kwargs) self.num_tweets -= 1 return data
def __init__(self, method, *args, **kwargs): if hasattr(method, 'pagination_mode'): if method.pagination_mode == 'cursor': self.iterator = CursorIterator(method, *args, **kwargs) elif method.pagination_mode == 'dm_cursor': self.iterator = DMCursorIterator(method, *args, **kwargs) elif method.pagination_mode == 'id': self.iterator = IdIterator(method, *args, **kwargs) elif method.pagination_mode == "next": self.iterator = NextIterator(method, *args, **kwargs) elif method.pagination_mode == 'page': self.iterator = PageIterator(method, *args, **kwargs) else: raise TweepyException('Invalid pagination mode.') else: raise TweepyException('This method does not perform pagination')
def _get_request_token(self, access_type=None): try: url = self._get_oauth_url('request_token') if access_type: url += f'?x_auth_access_type={access_type}' return self.oauth.fetch_request_token(url) except Exception as e: raise TweepyException(e)
def sample(self, *, languages=None, stall_warnings=False, threaded=False): """Sample realtime Tweets .. deprecated:: 4.9 `The Twitter API v1.1 endpoint this method uses is now deprecated and will be retired on October 29, 2022.`_ Twitter API v2 can be used instead with :meth:`StreamingClient.sample`. Parameters ---------- languages : list[str] | None Setting this parameter to a comma-separated list of `BCP 47`_ language identifiers corresponding to any of the languages listed on Twitter’s `advanced search`_ page will only return Tweets that have been detected as being written in the specified languages. For example, connecting with language=en will only stream Tweets detected to be in the English language. stall_warnings : bool Specifies whether stall warnings should be delivered threaded : bool Whether or not to use a thread to run the stream Raises ------ TweepyException When the stream is already connected Returns ------- threading.Thread | None The thread if ``threaded`` is set to ``True``, else ``None`` References ---------- https://developer.twitter.com/en/docs/twitter-api/v1/tweets/sample-realtime/api-reference/get-statuses-sample .. _BCP 47: https://tools.ietf.org/html/bcp47 .. _advanced search: https://twitter.com/search-advanced .. _The Twitter API v1.1 endpoint this method uses is now deprecated and will be retired on October 29, 2022.: https://twittercommunity.com/t/deprecation-announcement-removing-compliance-messages-from-statuses-filter-and-retiring-statuses-sample-from-the-twitter-api-v1-1/170500 """ if self.running: raise TweepyException("Stream is already connected") method = "GET" endpoint = "statuses/sample" params = {} if languages: params["language"] = ','.join(map(str, languages)) if stall_warnings: params["stall_warnings"] = "true" if threaded: return self._threaded_connect(method, endpoint, params=params) else: self._connect(method, endpoint, params=params)
def sample(self, *, languages=None, stall_warnings=False): """Sample realtime Tweets .. deprecated:: 4.10 `The Twitter API v1.1 endpoint this method uses is now deprecated and will be retired on October 29, 2022.`_ Twitter API v2 can be used instead with :meth:`AsyncStreamingClient.sample`. Parameters ---------- languages : list[str] | None Setting this parameter to a comma-separated list of `BCP 47`_ language identifiers corresponding to any of the languages listed on Twitter’s `advanced search`_ page will only return Tweets that have been detected as being written in the specified languages. For example, connecting with language=en will only stream Tweets detected to be in the English language. stall_warnings: bool | None Specifies whether stall warnings should be delivered. See https://developer.twitter.com/en/docs/tweets/filter-realtime/guides/basic-stream-parameters for more information. Raises ------ TweepyException When the stream is already connected Returns ------- asyncio.Task The task running the stream References ---------- https://developer.twitter.com/en/docs/twitter-api/v1/tweets/sample-realtime/api-reference/get-statuses-sample .. _BCP 47: https://tools.ietf.org/html/bcp47 .. _advanced search: https://twitter.com/search-advanced .. _The Twitter API v1.1 endpoint this method uses is now deprecated and will be retired on October 29, 2022.: https://twittercommunity.com/t/deprecation-announcement-removing-compliance-messages-from-statuses-filter-and-retiring-statuses-sample-from-the-twitter-api-v1-1/170500 """ if self.task is not None and not self.task.done(): raise TweepyException("Stream is already connected") endpoint = "statuses/sample" params = {} if languages is not None: params["language"] = ','.join(map(str, languages)) if stall_warnings: params["stall_warnings"] = "true" self.task = asyncio.create_task( self._connect("GET", endpoint, params=params) ) # Use name parameter when support for Python 3.7 is dropped return self.task
def get_username(self): if self.username is None: api = API(self) user = api.verify_credentials() if user: self.username = user.screen_name else: raise TweepyException('Unable to get username,' ' invalid oauth token!') return self.username
def sample(self, *, languages=None, stall_warnings=False): """Sample realtime Tweets Parameters ---------- languages : Optional[List[str]] Setting this parameter to a comma-separated list of `BCP 47`_ language identifiers corresponding to any of the languages listed on Twitter’s `advanced search`_ page will only return Tweets that have been detected as being written in the specified languages. For example, connecting with language=en will only stream Tweets detected to be in the English language. stall_warnings: Optional[bool] Specifies whether stall warnings should be delivered. See https://developer.twitter.com/en/docs/tweets/filter-realtime/guides/basic-stream-parameters for more information. Raises ------ TweepyException When the stream is already connected Returns ------- asyncio.Task The task running the stream References ---------- https://developer.twitter.com/en/docs/twitter-api/v1/tweets/sample-realtime/api-reference/get-statuses-sample .. _BCP 47: https://tools.ietf.org/html/bcp47 .. _advanced search: https://twitter.com/search-advanced """ if self.task is not None and not self.task.done(): raise TweepyException("Stream is already connected") endpoint = "statuses/sample" params = {} if languages is not None: params["language"] = ','.join(map(str, languages)) if stall_warnings: params["stall_warnings"] = "true" self.task = asyncio.ensure_future( self._connect("GET", endpoint, params=params) ) # Use create_task when support for Python 3.6 is dropped return self.task
def __init__(self, consumer_key, consumer_secret): self.consumer_key = consumer_key self.consumer_secret = consumer_secret self._bearer_token = '' resp = requests.post(self._get_oauth_url('token'), auth=(self.consumer_key, self.consumer_secret), data={'grant_type': 'client_credentials'}) data = resp.json() if data.get('token_type') != 'bearer': raise TweepyException('Expected token_type to equal "bearer", ' f'but got {data.get("token_type")} instead') self._bearer_token = data['access_token']
def get_authorization_url(self, signin_with_twitter=False, access_type=None): """Get the authorization URL to redirect the user""" try: if signin_with_twitter: url = self._get_oauth_url('authenticate') if access_type: log.warning(WARNING_MESSAGE) else: url = self._get_oauth_url('authorize') self.request_token = self._get_request_token(access_type=access_type) return self.oauth.authorization_url(url) except Exception as e: raise TweepyException(e)
def parse(self, payload, *, return_cursors=False, **kwargs): try: json = json_lib.loads(payload) except Exception as e: raise TweepyException(f'Failed to parse JSON payload: {e}') if return_cursors and isinstance(json, dict): if 'next' in json: return json, json['next'] elif 'next_cursor' in json: if 'previous_cursor' in json: cursors = json['previous_cursor'], json['next_cursor'] return json, cursors else: return json, json['next_cursor'] return json
def sample(self, *, languages=None, stall_warnings=False, threaded=False): if self.running: raise TweepyException("Stream is already connected") method = "GET" endpoint = "statuses/sample" params = {} if languages: params["language"] = ','.join(map(str, languages)) if stall_warnings: params["stall_warnings"] = "true" if threaded: return self._threaded_connect(method, endpoint, params=params) else: self._connect(method, endpoint, params=params)
def sample(self, *, languages=None, stall_warnings=False, threaded=False): """Sample realtime Tweets Parameters ---------- languages : list[str] | None Setting this parameter to a comma-separated list of `BCP 47`_ language identifiers corresponding to any of the languages listed on Twitter’s `advanced search`_ page will only return Tweets that have been detected as being written in the specified languages. For example, connecting with language=en will only stream Tweets detected to be in the English language. stall_warnings : bool Specifies whether stall warnings should be delivered threaded : bool Whether or not to use a thread to run the stream Returns ------- threading.Thread | None The thread if ``threaded`` is set to ``True``, else ``None`` References ---------- https://developer.twitter.com/en/docs/twitter-api/v1/tweets/sample-realtime/api-reference/get-statuses-sample .. _BCP 47: https://tools.ietf.org/html/bcp47 .. _advanced search: https://twitter.com/search-advanced """ if self.running: raise TweepyException("Stream is already connected") method = "GET" endpoint = "statuses/sample" params = {} if languages: params["language"] = ','.join(map(str, languages)) if stall_warnings: params["stall_warnings"] = "true" if threaded: return self._threaded_connect(method, endpoint, params=params) else: self._connect(method, endpoint, params=params)
def get_access_token(self, verifier=None): """ After user has authorized the request token, get access token with user supplied verifier. """ try: url = self._get_oauth_url('access_token') self.oauth = OAuth1Session(self.consumer_key, client_secret=self.consumer_secret, resource_owner_key=self.request_token['oauth_token'], resource_owner_secret=self.request_token['oauth_token_secret'], verifier=verifier, callback_uri=self.callback) resp = self.oauth.fetch_access_token(url) self.access_token = resp['oauth_token'] self.access_token_secret = resp['oauth_token_secret'] return self.access_token, self.access_token_secret except Exception as e: raise TweepyException(e)
def get_xauth_access_token(self, username, password): """ Get an access token from an username and password combination. In order to get this working you need to create an app at http://twitter.com/apps, after that send a mail to [email protected] and request activation of xAuth for it. """ try: url = self._get_oauth_url('access_token') oauth = OAuth1(self.consumer_key, client_secret=self.consumer_secret) r = requests.post(url=url, auth=oauth, headers={'x_auth_mode': 'client_auth', 'x_auth_username': username, 'x_auth_password': password}) credentials = parse_qs(r.content) return credentials.get('oauth_token')[0], credentials.get('oauth_token_secret')[0] except Exception as e: raise TweepyException(e)
def sample(self, *, threaded=False, **params): """sample( \ *, backfill_minutes=None, expansions=None, media_fields=None, \ place_fields=None, poll_fields=None, tweet_fields=None, \ user_fields=None, threaded=False \ ) Streams about 1% of all Tweets in real-time. If you are using the academic research product track, you can connect up to two `redundant connections <sample redundant connections_>`_ to maximize your streaming up-time. Parameters ---------- backfill_minutes : int | None By passing this parameter, you can request up to five (5) minutes worth of streaming data that you might have missed during a disconnection to be delivered to you upon reconnection. The backfilled Tweets will automatically flow through the reconnected stream, with older Tweets generally being delivered before any newly matching Tweets. You must include a whole number between 1 and 5 as the value to this parameter. This feature will deliver duplicate Tweets, meaning that if you were disconnected for 90 seconds, and you requested two minutes of backfill, you will receive 30 seconds worth of duplicate Tweets. Due to this, you should make sure your system is tolerant of duplicate data. This feature is currently only available to the Academic Research product track. expansions : list[str] | str :ref:`expansions_parameter` media_fields : list[str] | str :ref:`media_fields_parameter` place_fields : list[str] | str :ref:`place_fields_parameter` poll_fields : list[str] | str :ref:`poll_fields_parameter` tweet_fields : list[str] | str :ref:`tweet_fields_parameter` user_fields : list[str] | str :ref:`user_fields_parameter` threaded : bool Whether or not to use a thread to run the stream Raises ------ TweepyException When the stream is already connected Returns ------- threading.Thread | None The thread if ``threaded`` is set to ``True``, else ``None`` References ---------- https://developer.twitter.com/en/docs/twitter-api/tweets/volume-streams/api-reference/get-tweets-sample-stream .. _sample redundant connections: https://developer.twitter.com/en/docs/twitter-api/tweets/volume-streams/integrate/recovery-and-redundancy-features """ if self.running: raise TweepyException("Stream is already connected") method = "GET" endpoint = "sample" params = self._process_params( params, endpoint_parameters=( "backfill_minutes", "expansions", "media.fields", "place.fields", "poll.fields", "tweet.fields", "user.fields" ) ) if threaded: return self._threaded_connect(method, endpoint, params=params) else: self._connect(method, endpoint, params=params)
def filter(self, *, follow=None, track=None, locations=None, filter_level=None, languages=None, stall_warnings=False, threaded=False): """Filter realtime Tweets .. deprecated:: 4.9 `The delivery of compliance messages through the Twitter API v1.1 endpoint this method uses has been deprecated, and they will stop being delivered beginning October 29, 2022.`_ Twitter API v2 can be used instead with :meth:`StreamingClient.filter` and/or :class:`Client` :ref:`batch compliance <Batch compliance>` methods. Parameters ---------- follow : list[int | str] | None User IDs, indicating the users to return statuses for in the stream track : list[str] | None Keywords to track locations : list[float] | None Specifies a set of bounding boxes to track filter_level : str | None Setting this parameter to one of none, low, or medium will set the minimum value of the filter_level Tweet attribute required to be included in the stream. The default value is none, which includes all available Tweets. When displaying a stream of Tweets to end users (dashboards or live feeds at a presentation or conference, for example) it is suggested that you set this value to medium. languages : list[str] | None Setting this parameter to a comma-separated list of `BCP 47`_ language identifiers corresponding to any of the languages listed on Twitter’s `advanced search`_ page will only return Tweets that have been detected as being written in the specified languages. For example, connecting with language=en will only stream Tweets detected to be in the English language. stall_warnings : bool Specifies whether stall warnings should be delivered threaded : bool Whether or not to use a thread to run the stream Raises ------ TweepyException When the stream is already connected or when the number of location coordinates is not a multiple of 4 Returns ------- threading.Thread | None The thread if ``threaded`` is set to ``True``, else ``None`` References ---------- https://developer.twitter.com/en/docs/twitter-api/v1/tweets/filter-realtime/api-reference/post-statuses-filter .. _BCP 47: https://tools.ietf.org/html/bcp47 .. _advanced search: https://twitter.com/search-advanced .. _The delivery of compliance messages through the Twitter API v1.1 endpoint this method uses has been deprecated, and they will stop being delivered beginning October 29, 2022.: https://twittercommunity.com/t/deprecation-announcement-removing-compliance-messages-from-statuses-filter-and-retiring-statuses-sample-from-the-twitter-api-v1-1/170500 """ if self.running: raise TweepyException("Stream is already connected") method = "POST" endpoint = "statuses/filter" headers = {"Content-Type": "application/x-www-form-urlencoded"} body = {} if follow: body["follow"] = ','.join(map(str, follow)) if track: body["track"] = ','.join(map(str, track)) if locations and len(locations) > 0: if len(locations) % 4: raise TweepyException( "Number of location coordinates should be a multiple of 4" ) body["locations"] = ','.join(f"{l:.4f}" for l in locations) if filter_level: body["filter_level"] = filter_level if languages: body["language"] = ','.join(map(str, languages)) if stall_warnings: body["stall_warnings"] = stall_warnings if threaded: return self._threaded_connect(method, endpoint, headers=headers, body=body) else: self._connect(method, endpoint, headers=headers, body=body)
# Tweepy # Copyright 2009-2022 Joshua Roesslein # See LICENSE for details. """ Tweepy.asynchronoous Asynchronous interfaces with the Twitter API """ try: import aiohttp import oauthlib except ModuleNotFoundError: from tweepy.errors import TweepyException raise TweepyException( "tweepy.asynchronous requires aiohttp and oauthlib to be installed" ) from tweepy.asynchronous.streaming import AsyncStream
def prev(self): raise TweepyException( 'This method does not allow backwards pagination')
def prev(self): if self.current_page == 1: raise TweepyException('Can not page back more, at first page') self.current_page -= 1 return self.method(page=self.current_page, *self.args, **self.kwargs)
def filter(self, *, follow=None, track=None, locations=None, filter_level=None, languages=None, stall_warnings=False, threaded=False): """Filter realtime Tweets Parameters ---------- follow : Optional[List[Union[int, str]]] User IDs, indicating the users to return statuses for in the stream track : Optional[List[str]] Keywords to track locations : Optional[List[float]] Specifies a set of bounding boxes to track filter_level : Optional[str] Setting this parameter to one of none, low, or medium will set the minimum value of the filter_level Tweet attribute required to be included in the stream. The default value is none, which includes all available Tweets. When displaying a stream of Tweets to end users (dashboards or live feeds at a presentation or conference, for example) it is suggested that you set this value to medium. languages : Optional[List[str]] Setting this parameter to a comma-separated list of `BCP 47`_ language identifiers corresponding to any of the languages listed on Twitter’s `advanced search`_ page will only return Tweets that have been detected as being written in the specified languages. For example, connecting with language=en will only stream Tweets detected to be in the English language. stall_warnings : bool Specifies whether stall warnings should be delivered threaded : bool Whether or not to use a thread to run the stream Raises ------ TweepyException When number of location coordinates is not a multiple of 4 Returns ------- Optional[threading.Thread] The thread if ``threaded`` is set to ``True``, else ``None`` References ---------- https://developer.twitter.com/en/docs/twitter-api/v1/tweets/filter-realtime/api-reference/post-statuses-filter .. _BCP 47: https://tools.ietf.org/html/bcp47 .. _advanced search: https://twitter.com/search-advanced """ if self.running: raise TweepyException("Stream is already connected") method = "POST" endpoint = "statuses/filter" headers = {"Content-Type": "application/x-www-form-urlencoded"} body = {} if follow: body["follow"] = ','.join(map(str, follow)) if track: body["track"] = ','.join(map(str, track)) if locations and len(locations) > 0: if len(locations) % 4: raise TweepyException( "Number of location coordinates should be a multiple of 4" ) body["locations"] = ','.join(f"{l:.4f}" for l in locations) if filter_level: body["filter_level"] = filter_level if languages: body["language"] = ','.join(map(str, languages)) if stall_warnings: body["stall_warnings"] = stall_warnings if threaded: return self._threaded_connect(method, endpoint, headers=headers, body=body) else: self._connect(method, endpoint, headers=headers, body=body)
def filter(self, *, follow=None, track=None, locations=None, filter_level=None, languages=None, stall_warnings=False): """Filter realtime Tweets Parameters ---------- follow: list[int | str] | None A list of user IDs, indicating the users to return statuses for in the stream. See https://developer.twitter.com/en/docs/twitter-api/v1/tweets/filter-realtime/guides/basic-stream-parameters for more information. track: list[str] | None Keywords to track. Phrases of keywords are specified by a list. See https://developer.twitter.com/en/docs/tweets/filter-realtime/guides/basic-stream-parameters for more information. locations: list[float] | None Specifies a set of bounding boxes to track. See https://developer.twitter.com/en/docs/tweets/filter-realtime/guides/basic-stream-parameters for more information. filter_level : str | None Setting this parameter to one of none, low, or medium will set the minimum value of the filter_level Tweet attribute required to be included in the stream. The default value is none, which includes all available Tweets. When displaying a stream of Tweets to end users (dashboards or live feeds at a presentation or conference, for example) it is suggested that you set this value to medium. languages : list[str] | None Setting this parameter to a comma-separated list of `BCP 47`_ language identifiers corresponding to any of the languages listed on Twitter’s `advanced search`_ page will only return Tweets that have been detected as being written in the specified languages. For example, connecting with language=en will only stream Tweets detected to be in the English language. stall_warnings: bool | None Specifies whether stall warnings should be delivered. See https://developer.twitter.com/en/docs/tweets/filter-realtime/guides/basic-stream-parameters for more information. Raises ------ TweepyException When the stream is already connected or when the number of location coordinates is not a multiple of 4 Returns ------- asyncio.Task The task running the stream References ---------- https://developer.twitter.com/en/docs/twitter-api/v1/tweets/filter-realtime/api-reference/post-statuses-filter .. _BCP 47: https://tools.ietf.org/html/bcp47 .. _advanced search: https://twitter.com/search-advanced """ if self.task is not None and not self.task.done(): raise TweepyException("Stream is already connected") endpoint = "statuses/filter" headers = {"Content-Type": "application/x-www-form-urlencoded"} body = {} if follow is not None: body["follow"] = ','.join(map(str, follow)) if track is not None: body["track"] = ','.join(map(str, track)) if locations is not None: if len(locations) % 4: raise TweepyException( "Number of location coordinates should be a multiple of 4") body["locations"] = ','.join(f"{location:.4f}" for location in locations) if filter_level is not None: body["filter_level"] = filter_level if languages is not None: body["language"] = ','.join(map(str, languages)) if stall_warnings: body["stall_warnings"] = "true" self.task = asyncio.create_task( self._connect("POST", endpoint, headers=headers, body=body or None)) # Use name parameter when support for Python 3.7 is dropped return self.task
def filter(self, **params): """filter( \ *, backfill_minutes=None, expansions=None, media_fields=None, \ place_fields=None, poll_fields=None, tweet_fields=None, \ user_fields=None \ ) Streams Tweets in real-time based on a specific set of filter rules. If you are using the academic research product track, you can connect up to two `redundant connections <filter redundant connections_>`_ to maximize your streaming up-time. The Tweets returned by this endpoint count towards the Project-level `Tweet cap`_. Parameters ---------- backfill_minutes : int | None By passing this parameter, you can request up to five (5) minutes worth of streaming data that you might have missed during a disconnection to be delivered to you upon reconnection. The backfilled Tweets will automatically flow through the reconnected stream, with older Tweets generally being delivered before any newly matching Tweets. You must include a whole number between 1 and 5 as the value to this parameter. This feature will deliver duplicate Tweets, meaning that if you were disconnected for 90 seconds, and you requested two minutes of backfill, you will receive 30 seconds worth of duplicate Tweets. Due to this, you should make sure your system is tolerant of duplicate data. This feature is currently only available to the Academic Research product track. expansions : list[str] | str :ref:`expansions_parameter` media_fields : list[str] | str :ref:`media_fields_parameter` place_fields : list[str] | str :ref:`place_fields_parameter` poll_fields : list[str] | str :ref:`poll_fields_parameter` tweet_fields : list[str] | str :ref:`tweet_fields_parameter` user_fields : list[str] | str :ref:`user_fields_parameter` Raises ------ TweepyException When the stream is already connected Returns ------- asyncio.Task The task running the stream References ---------- https://developer.twitter.com/en/docs/twitter-api/tweets/filtered-stream/api-reference/get-tweets-search-stream .. _filter redundant connections: https://developer.twitter.com/en/docs/twitter-api/tweets/filtered-stream/integrate/recovery-and-redundancy-features .. _Tweet cap: https://developer.twitter.com/en/docs/twitter-api/tweet-caps """ if self.task is not None and not self.task.done(): raise TweepyException("Stream is already connected") endpoint = "search" params = self._process_params( params, endpoint_parameters=( "backfill_minutes", "expansions", "media.fields", "place.fields", "poll.fields", "tweet.fields", "user.fields" ) ) self.task = asyncio.create_task( self._connect("GET", endpoint, params=params) ) # Use name parameter when support for Python 3.7 is dropped return self.task