tweepy-self 1.6.3__py3-none-any.whl → 1.10.0b1__py3-none-any.whl

twitter/client.py

@@ -1,13 +1,15 @@
-from typing import Any, Literal
+from typing import Any, Literal, Iterable
 from time import time
 import asyncio
 import base64
+import json
 import re
 
+from loguru import logger
 from curl_cffi import requests
 from yarl import URL
 
-from python3_capsolver.fun_captcha import FunCaptcha, FunCaptchaTypeEnm
+from ._capsolver.fun_captcha import FunCaptcha, FunCaptchaTypeEnm
 
 from .errors import (
     TwitterException,
@@ -25,20 +27,24 @@ from .errors import (
     ConsentLocked,
     Suspended,
 )
-from .utils import to_json, tweet_url as create_tweet_url
-from .base import BaseClient
+from .utils import to_json
+from .base import BaseHTTPClient
 from .account import Account, AccountStatus
-from .models import UserData, Tweet
-from .utils import remove_at_sign, parse_oauth_html, parse_unlock_html
+from .models import User, Tweet, Media
+from .utils import (
+    remove_at_sign,
+    parse_oauth_html,
+    parse_unlock_html,
+    tweets_data_from_instructions,
+)
 
 
-class Client(BaseClient):
-    _BEARER_TOKEN = "Bearer AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA"
+class Client(BaseHTTPClient):
+    _BEARER_TOKEN = "AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA"
     _DEFAULT_HEADERS = {
         "authority": "twitter.com",
         "origin": "https://twitter.com",
         "x-twitter-active-user": "yes",
-        # 'x-twitter-auth-type': 'OAuth2Session',
         "x-twitter-client-language": "en",
     }
     _GRAPHQL_URL = "https://twitter.com/i/api/graphql"
@@ -56,6 +62,7 @@ class Client(BaseClient):
         "Following": "t-BPOrMIduGUJWO_LxcvNQ",
         "Followers": "3yX7xr2hKjcZYnXt6cU6lQ",
         "UserByScreenName": "G3KGOASz96M-Qu0nwmGXNg",
+        "UsersByRestIds": "itEhGywpgX9b3GJCzOtSrA",
         "Viewer": "W62NnYgkgziw9bwyoVht0g",
     }
     _CAPTCHA_URL = "https://twitter.com/account/access"
@@ -76,7 +83,9 @@ class Client(BaseClient):
         *,
         wait_on_rate_limit: bool = True,
         capsolver_api_key: str = None,
-        max_unlock_attempts: int = 4,
+        max_unlock_attempts: int = 5,
+        auto_relogin: bool = True,
+        request_self_on_startup: bool = True,
         **session_kwargs,
     ):
         super().__init__(**session_kwargs)
@@ -84,20 +93,29 @@ class Client(BaseClient):
         self.wait_on_rate_limit = wait_on_rate_limit
         self.capsolver_api_key = capsolver_api_key
         self.max_unlock_attempts = max_unlock_attempts
+        self.auto_relogin = auto_relogin
+        self.request_self_on_startup = request_self_on_startup
 
-    async def request(
+    async def __aenter__(self):
+        await self.on_startup()
+        return await super().__aenter__()
+
+    async def _request(
         self,
         method,
         url,
+        *,
         auth: bool = True,
         bearer: bool = True,
+        wait_on_rate_limit: bool = None,
         **kwargs,
     ) -> tuple[requests.Response, Any]:
         cookies = kwargs["cookies"] = kwargs.get("cookies") or {}
         headers = kwargs["headers"] = kwargs.get("headers") or {}
 
         if bearer:
-            headers["authorization"] = self._BEARER_TOKEN
+            headers["authorization"] = f"Bearer {self._BEARER_TOKEN}"
+            # headers["x-twitter-auth-type"] = "OAuth2Session"
 
         if auth:
             if not self.account.auth_token:
@@ -108,6 +126,14 @@ class Client(BaseClient):
                 cookies["ct0"] = self.account.ct0
                 headers["x-csrf-token"] = self.account.ct0
 
+        # fmt: off
+        log_message = (f"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+                       f" ==> Request {method} {url}")
+        if kwargs.get('data'): log_message += f"\nRequest data: {kwargs.get('data')}"
+        if kwargs.get('json'): log_message += f"\nRequest data: {kwargs.get('json')}"
+        logger.debug(log_message)
+        # fmt: on
+
         try:
             response = await self._session.request(method, url, **kwargs)
         except requests.errors.RequestsError as exc:
@@ -120,17 +146,53 @@ class Client(BaseClient):
             raise
 
         data = response.text
-        if response.headers["content-type"].startswith("application/json"):
+        # fmt: off
+        logger.debug(f"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+                     f" <== Response {method} {url}"
+                     f"\nStatus code: {response.status_code}"
+                     f"\nResponse data: {data}")
+        # fmt: on
+
+        if ct0 := self._session.cookies.get("ct0", domain=".twitter.com"):
+            self.account.ct0 = ct0
+
+        auth_token = self._session.cookies.get("auth_token")
+        if auth_token and auth_token != self.account.auth_token:
+            self.account.auth_token = auth_token
+            logger.info(
+                f"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+                f" Requested new auth_token!"
+            )
+
+        try:
             data = response.json()
+        except json.decoder.JSONDecodeError:
+            pass
 
-        if response.status_code == 429:
-            if self.wait_on_rate_limit:
-                reset_time = int(response.headers["x-rate-limit-reset"])
-                sleep_time = reset_time - int(time()) + 1
-                if sleep_time > 0:
-                    await asyncio.sleep(sleep_time)
-                return await self.request(method, url, auth, bearer, **kwargs)
-            raise RateLimited(response, data)
+        if 300 > response.status_code >= 200:
+            if isinstance(data, dict) and "errors" in data:
+                exc = HTTPException(response, data)
+
+                if 141 in exc.api_codes:
+                    self.account.status = AccountStatus.SUSPENDED
+                    raise Suspended(exc, self.account)
+
+                if 326 in exc.api_codes:
+                    for error_data in exc.api_errors:
+                        if (
+                            error_data.get("code") == 326
+                            and error_data.get("bounce_location")
+                            == "/i/flow/consent_flow"
+                        ):
+                            self.account.status = AccountStatus.CONSENT_LOCKED
+                            raise ConsentLocked(exc, self.account)
+
+                    self.account.status = AccountStatus.LOCKED
+                    raise Locked(exc, self.account)
+                raise exc
+
+            self.account.status = AccountStatus.GOOD
+            return response, data
 
         if response.status_code == 400:
             raise BadRequest(response, data)
@@ -147,10 +209,6 @@ class Client(BaseClient):
         if response.status_code == 403:
             exc = Forbidden(response, data)
 
-            if 353 in exc.api_codes and "ct0" in response.cookies:
-                self.account.ct0 = response.cookies["ct0"]
-                return await self.request(method, url, auth, bearer, **kwargs)
-
             if 64 in exc.api_codes:
                 self.account.status = AccountStatus.SUSPENDED
                 raise Suspended(exc, self.account)
@@ -165,52 +223,82 @@ class Client(BaseClient):
                         raise ConsentLocked(exc, self.account)
 
                 self.account.status = AccountStatus.LOCKED
-                if not self.capsolver_api_key:
-                    raise Locked(exc, self.account)
-
-                await self.unlock()
-                return await self.request(method, url, auth, bearer, **kwargs)
+                raise Locked(exc, self.account)
 
             raise exc
 
         if response.status_code == 404:
             raise NotFound(response, data)
 
+        if response.status_code == 429:
+            if wait_on_rate_limit is None:
+                wait_on_rate_limit = self.wait_on_rate_limit
+            if not wait_on_rate_limit:
+                raise RateLimited(response, data)
+
+            reset_time = int(response.headers["x-rate-limit-reset"])
+            sleep_time = reset_time - int(time()) + 1
+            if sleep_time > 0:
+                logger.info(
+                    f"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+                    f"Rate limited! Sleep time: {sleep_time} sec."
+                )
+                await asyncio.sleep(sleep_time)
+            return await self._request(
+                method,
+                url,
+                auth=auth,
+                bearer=bearer,
+                wait_on_rate_limit=wait_on_rate_limit,
+                **kwargs,
+            )
+
         if response.status_code >= 500:
             raise ServerError(response, data)
 
-        if not 200 <= response.status_code < 300:
-            raise HTTPException(response, data)
-
-        if isinstance(data, dict) and "errors" in data:
-            exc = HTTPException(response, data)
+    async def request(
+        self,
+        method,
+        url,
+        *,
+        auto_unlock: bool = True,
+        auto_relogin: bool = None,
+        **kwargs,
+    ) -> tuple[requests.Response, Any]:
+        try:
+            return await self._request(method, url, **kwargs)
 
-            if 141 in exc.api_codes:
-                self.account.status = AccountStatus.SUSPENDED
-                raise Suspended(exc, self.account)
+        except Locked:
+            if not self.capsolver_api_key or not auto_unlock:
+                raise
 
-            if 326 in exc.api_codes:
-                for error_data in exc.api_errors:
-                    if (
-                        error_data.get("code") == 326
-                        and error_data.get("bounce_location") == "/i/flow/consent_flow"
-                    ):
-                        self.account.status = AccountStatus.CONSENT_LOCKED
-                        raise ConsentLocked(exc, self.account)
+            await self.unlock()
+            return await self._request(method, url, **kwargs)
 
-                self.account.status = AccountStatus.LOCKED
-                if not self.capsolver_api_key:
-                    raise Locked(exc, self.account)
+        except BadToken:
+            if auto_relogin is None:
+                auto_relogin = self.auto_relogin
+            if (
+                not auto_relogin
+                or not self.account.password
+                or not (self.account.email or self.account.username)
+            ):
+                raise
 
-                await self.unlock()
-                return await self.request(method, url, auth, bearer, **kwargs)
+            await self.relogin()
+            return await self._request(method, url, **kwargs)
 
-            raise exc
+        except Forbidden as exc:
+            if 353 in exc.api_codes and "ct0" in exc.response.cookies:
+                return await self._request(method, url, **kwargs)
+            else:
+                raise
 
-        self.account.status = AccountStatus.GOOD
-        return response, data
+    async def on_startup(self):
+        if self.request_self_on_startup:
+            await self.request_user()
 
-    async def _request_oauth_2_auth_code(
+    async def _request_oauth2_auth_code(
         self,
         client_id: str,
         code_challenge: str,
@@ -234,7 +322,7 @@ class Client(BaseClient):
         auth_code = response_json["auth_code"]
         return auth_code
 
-    async def _confirm_oauth_2(self, auth_code: str):
+    async def _confirm_oauth2(self, auth_code: str):
         data = {
             "approval": "true",
             "code": auth_code,
@@ -247,7 +335,7 @@ class Client(BaseClient):
             data=data,
         )
 
-    async def oauth_2(
+    async def oauth2(
         self,
         client_id: str,
         code_challenge: str,
@@ -263,15 +351,13 @@ class Client(BaseClient):
         Привязка (бинд, линк) приложения.
 
         :param client_id: Идентификатор клиента, используемый для OAuth.
-        :param code_challenge: Код-вызов, используемый для PKCE (Proof Key for Code Exchange).
         :param state: Уникальная строка состояния для предотвращения CSRF-атак.
         :param redirect_uri: URI перенаправления, на который будет отправлен ответ.
-        :param code_challenge_method: Метод, используемый для преобразования code_verifier в code_challenge.
         :param scope: Строка областей доступа, запрашиваемых у пользователя.
         :param response_type: Тип ответа, который ожидается от сервера авторизации.
         :return: Код авторизации (привязки).
         """
-        auth_code = await self._request_oauth_2_auth_code(
+        auth_code = await self._request_oauth2_auth_code(
             client_id,
             code_challenge,
             state,
@@ -280,7 +366,7 @@ class Client(BaseClient):
             scope,
             response_type,
         )
-        await self._confirm_oauth_2(auth_code)
+        await self._confirm_oauth2(auth_code)
         return auth_code
 
     async def _oauth(self, oauth_token: str, **oauth_params) -> requests.Response:
@@ -335,12 +421,12 @@ class Client(BaseClient):
 
         return authenticity_token, redirect_url
 
-    async def request_username(self):
+    async def request_and_set_username(self):
         url = "https://twitter.com/i/api/1.1/account/settings.json"
         response, response_json = await self.request("POST", url)
         self.account.username = response_json["screen_name"]
 
-    async def _request_user_data(self, username: str) -> UserData:
+    async def _request_user(self, username: str) -> User:
         url, query_id = self._action_to_url("UserByScreenName")
         username = remove_at_sign(username)
         variables = {
@@ -367,48 +453,56 @@ class Client(BaseClient):
             "features": to_json(features),
             "fieldToggles": to_json(field_toggles),
         }
-        response, response_json = await self.request("GET", url, params=params)
-        user_data = UserData.from_raw_user_data(response_json["data"]["user"]["result"])
+        response, data = await self.request("GET", url, params=params)
+        return User.from_raw_data(data["data"]["user"]["result"])
 
-        if self.account.username == user_data.username:
-            self.account.id = user_data.id
-            self.account.name = user_data.name
+    async def request_user(
+        self, *, username: str = None, user_id: int | str = None
+    ) -> User | Account:
+        if username and user_id:
+            raise ValueError("Specify username or user_id, not both.")
 
-        return user_data
-
-    async def request_user_data(self, username: str = None) -> UserData:
-        if username:
-            return await self._request_user_data(username)
+        if user_id:
+            users = await self.request_users((user_id,))
+            user = users[user_id]
         else:
-            if not self.account.username:
-                await self.request_username()
-            return await self._request_user_data(self.account.username)
+            if not username:
+                if not self.account.username:
+                    await self.request_and_set_username()
+                username = self.account.username
+
+            user = await self._request_user(username)
+
+        if self.account.username == user.username:
+            self.account.update(**user.model_dump())
+            user = self.account
+
+        return user
 
     async def upload_image(
         self,
         image: bytes,
         attempts: int = 3,
         timeout: float | tuple[float, float] = 10,
-    ) -> int:
+    ) -> Media:
         """
         Upload image as bytes.
 
         Иногда при первой попытке загрузки изображения возвращает 408,
         после чего повторная попытка загрузки изображения проходит успешно
 
-        :return: Media ID
+        :return: Media
         """
         url = "https://upload.twitter.com/1.1/media/upload.json"
 
-        data = {"media_data": base64.b64encode(image)}
+        payload = {"media_data": base64.b64encode(image)}
 
         for attempt in range(attempts):
             try:
-                response, response_json = await self.request(
-                    "POST", url, data=data, timeout=timeout
+                response, data = await self.request(
+                    "POST", url, data=payload, timeout=timeout
                 )
-                media_id = response_json["media_id"]
-                return media_id
+                return Media(**data)
             except (HTTPException, requests.errors.RequestsError) as exc:
                 if (
                     attempt < attempts - 1
@@ -425,9 +519,6 @@ class Client(BaseClient):
                 else:
                     raise
 
-        media_id = response_json["media_id"]
-        return media_id
-
     async def _follow_action(self, action: str, user_id: int | str) -> bool:
         url = f"https://twitter.com/i/api/1.1/friendships/{action}.json"
         params = {
@@ -466,22 +557,60 @@ class Client(BaseClient):
             "variables": {"tweet_id": tweet_id, "dark_request": False},
             "queryId": query_id,
         }
-        response, response_json = await self.request("POST", url, json=json_payload)
-        return response_json
+        response, data = await self.request("POST", url, json=json_payload)
+        return data
 
-    async def repost(self, tweet_id: int) -> int:
+    async def _repost(self, tweet_id: int | str) -> Tweet:
+        data = await self._interact_with_tweet("CreateRetweet", tweet_id)
+        tweet_id = data["data"]["create_retweet"]["retweet_results"]["result"]["rest_id"]  # type: ignore
+        return await self.request_tweet(tweet_id)
+
+    async def _repost_or_search_duplicate(
+        self,
+        tweet_id: int,
+        *,
+        search_duplicate: bool = True,
+    ) -> Tweet:
+        try:
+            tweet = await self._repost(tweet_id)
+        except HTTPException as exc:
+            if (
+                search_duplicate
+                and 327
+                in exc.api_codes  # duplicate retweet (You have already retweeted this Tweet)
+            ):
+                tweets = await self.request_tweets(self.account.id)
+                duplicate_tweet = None
+                for tweet_ in tweets:  # type: Tweet
+                    if tweet_.retweeted_tweet and tweet_.retweeted_tweet.id == tweet_id:
+                        duplicate_tweet = tweet_
+
+                if not duplicate_tweet:
+                    raise FailedToFindDuplicatePost(
+                        f"Couldn't find a post duplicate in the next 20 posts"
+                    )
+
+                tweet = duplicate_tweet
+
+            else:
+                raise
+
+        return tweet
+
+    async def repost(
+        self,
+        tweet_id: int,
+        *,
+        search_duplicate: bool = True,
+    ) -> Tweet:
         """
         Repost (retweet)
 
-        :return: Tweet ID
+        :return: Tweet
         """
-        response_json = await self._interact_with_tweet("CreateRetweet", tweet_id)
-        retweet_id = int(
-            response_json["data"]["create_retweet"]["retweet_results"]["result"][
-                "rest_id"
-            ]
+        return await self._repost_or_search_duplicate(
+            tweet_id, search_duplicate=search_duplicate
         )
-        return retweet_id
 
     async def like(self, tweet_id: int) -> bool:
         response_json = await self._interact_with_tweet("FavoriteTweet", tweet_id)
@@ -588,7 +717,6 @@ class Client(BaseClient):
         tweet_id_to_reply: str | int = None,
         attachment_url: str = None,
         search_duplicate: bool = True,
-        with_tweet_url: bool = True,
     ) -> Tweet:
         try:
             tweet = await self._tweet(
@@ -602,10 +730,10 @@ class Client(BaseClient):
                 search_duplicate
                 and 187 in exc.api_codes  # duplicate tweet (Status is a duplicate)
             ):
-                tweets = await self.request_tweets(self.account.id)
+                tweets = await self.request_tweets()
                 duplicate_tweet = None
                 for tweet_ in tweets:
-                    if tweet_.full_text.startswith(text.strip()):
+                    if tweet_.text.startswith(text.strip()):
                         duplicate_tweet = tweet_
 
                 if not duplicate_tweet:
@@ -617,11 +745,6 @@ class Client(BaseClient):
             else:
                 raise
 
-        if with_tweet_url:
-            if not self.account.username:
-                await self.request_user_data()
-            tweet.url = create_tweet_url(self.account.username, tweet.id)
-
         return tweet
 
     async def tweet(
@@ -630,13 +753,11 @@ class Client(BaseClient):
         *,
         media_id: int | str = None,
         search_duplicate: bool = True,
-        with_tweet_url: bool = True,
     ) -> Tweet:
         return await self._tweet_or_search_duplicate(
             text,
             media_id=media_id,
             search_duplicate=search_duplicate,
-            with_tweet_url=with_tweet_url,
         )
 
     async def reply(
@@ -646,14 +767,12 @@ class Client(BaseClient):
         *,
         media_id: int | str = None,
         search_duplicate: bool = True,
-        with_tweet_url: bool = True,
     ) -> Tweet:
         return await self._tweet_or_search_duplicate(
             text,
             media_id=media_id,
             tweet_id_to_reply=tweet_id,
             search_duplicate=search_duplicate,
-            with_tweet_url=with_tweet_url,
         )
 
     async def quote(
@@ -663,14 +782,12 @@ class Client(BaseClient):
         *,
         media_id: int | str = None,
         search_duplicate: bool = True,
-        with_tweet_url: bool = True,
     ) -> Tweet:
         return await self._tweet_or_search_duplicate(
             text,
             media_id=media_id,
             attachment_url=tweet_url,
             search_duplicate=search_duplicate,
-            with_tweet_url=with_tweet_url,
         )
 
     async def vote(
@@ -692,7 +809,7 @@ class Client(BaseClient):
 
     async def _request_users(
         self, action: str, user_id: int | str, count: int
-    ) -> list[UserData]:
+    ) -> list[User]:
         url, query_id = self._action_to_url(action)
         variables = {
             "userId": str(user_id),
@@ -737,12 +854,12 @@ class Client(BaseClient):
                     user_data_dict = entry["content"]["itemContent"]["user_results"][
                         "result"
                     ]
-                    users.append(UserData.from_raw_user_data(user_data_dict))
+                    users.append(User.from_raw_data(user_data_dict))
         return users
 
     async def request_followers(
         self, user_id: int | str = None, count: int = 10
-    ) -> list[UserData]:
+    ) -> list[User]:
         """
         :param user_id: Текущий пользователь, если не передан ID иного пользователя.
         :param count: Количество подписчиков.
@@ -751,12 +868,12 @@ class Client(BaseClient):
             return await self._request_users("Followers", user_id, count)
         else:
             if not self.account.id:
-                await self.request_user_data()
+                await self.request_user()
             return await self._request_users("Followers", self.account.id, count)
 
     async def request_followings(
         self, user_id: int | str = None, count: int = 10
-    ) -> list[UserData]:
+    ) -> list[User]:
         """
         :param user_id: Текущий пользователь, если не передан ID иного пользователя.
         :param count: Количество подписчиков.
@@ -765,12 +882,32 @@ class Client(BaseClient):
             return await self._request_users("Following", user_id, count)
         else:
             if not self.account.id:
-                await self.request_user_data()
+                await self.request_user()
             return await self._request_users("Following", self.account.id, count)
 
-    async def _request_tweet_data(self, tweet_id: int) -> dict:
-        action = "TweetDetail"
-        url, query_id = self._action_to_url(action)
+    async def request_users(
+        self, user_ids: Iterable[str | int]
+    ) -> dict[int : User | Account]:
+        url, query_id = self._action_to_url("UsersByRestIds")
+        variables = {"userIds": list({str(user_id) for user_id in user_ids})}
+        features = {
+            "responsive_web_graphql_exclude_directive_enabled": True,
+            "responsive_web_graphql_skip_user_profile_image_extensions_enabled": False,
+            "responsive_web_graphql_timeline_navigation_enabled": True,
+            "verified_phone_label_enabled": False,
+        }
+        query = {"variables": variables, "features": features}
+        response, data = await self.request("GET", url, params=query)
+
+        users = {}
+        for user_data in data["data"]["users"]:
+            user_data = user_data["result"]
+            user = User.from_raw_data(user_data)
+            users[user.id] = user
+        return users
+
+    async def _request_tweet(self, tweet_id: int | str) -> Tweet:
+        url, query_id = self._action_to_url("TweetDetail")
         variables = {
             "focalTweetId": str(tweet_id),
             "with_rux_injections": False,
@@ -801,12 +938,71 @@ class Client(BaseClient):
             "longform_notetweets_inline_media_enabled": True,
             "responsive_web_enhance_cards_enabled": False,
         }
-        params = {
+        query = {
             "variables": to_json(variables),
             "features": to_json(features),
         }
-        response, response_json = await self.request("GET", url, params=params)
-        return response_json
+        response, data = await self.request("GET", url, params=query)
+        instructions = data["data"]["threaded_conversation_with_injections_v2"]["instructions"]  # type: ignore
+        tweet_data = tweets_data_from_instructions(instructions)[0]
+        return Tweet.from_raw_data(tweet_data)
+
+    async def _request_tweets(self, user_id: int | str, count: int = 20) -> list[Tweet]:
+        url, query_id = self._action_to_url("UserTweets")
+        variables = {
+            "userId": str(user_id),
+            "count": count,
+            "includePromotedContent": True,
+            "withQuickPromoteEligibilityTweetFields": True,
+            "withVoice": True,
+            "withV2Timeline": True,
+        }
+        features = {
+            "responsive_web_graphql_exclude_directive_enabled": True,
+            "verified_phone_label_enabled": False,
+            "creator_subscriptions_tweet_preview_api_enabled": True,
+            "responsive_web_graphql_timeline_navigation_enabled": True,
+            "responsive_web_graphql_skip_user_profile_image_extensions_enabled": False,
+            "c9s_tweet_anatomy_moderator_badge_enabled": True,
+            "tweetypie_unmention_optimization_enabled": True,
+            "responsive_web_edit_tweet_api_enabled": True,
+            "graphql_is_translatable_rweb_tweet_is_translatable_enabled": True,
+            "view_counts_everywhere_api_enabled": True,
+            "longform_notetweets_consumption_enabled": True,
+            "responsive_web_twitter_article_tweet_consumption_enabled": False,
+            "tweet_awards_web_tipping_enabled": False,
+            "freedom_of_speech_not_reach_fetch_enabled": True,
+            "standardized_nudges_misinfo": True,
+            "tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled": True,
+            "rweb_video_timestamps_enabled": True,
+            "longform_notetweets_rich_text_read_enabled": True,
+            "longform_notetweets_inline_media_enabled": True,
+            "responsive_web_media_download_video_enabled": False,
+            "responsive_web_enhance_cards_enabled": False,
+        }
+        params = {"variables": to_json(variables), "features": to_json(features)}
+        response, data = await self.request("GET", url, params=params)
+
+        instructions = data["data"]["user"]["result"]["timeline_v2"]["timeline"][
+            "instructions"
+        ]
+        tweets_data = tweets_data_from_instructions(instructions)
+        return [Tweet.from_raw_data(tweet_data) for tweet_data in tweets_data]
+
+    async def request_tweet(self, tweet_id: int | str) -> Tweet:
+        return await self._request_tweet(tweet_id)
+
+    async def request_tweets(
+        self,
+        user_id: int | str = None,
+        count: int = 20,
+    ) -> list[Tweet]:
+        if not user_id:
+            if not self.account.id:
+                await self.request_user()
+            user_id = self.account.id
+
+        return await self._request_tweets(user_id, count)
 
     async def _update_profile_image(
         self, type: Literal["banner", "image"], media_id: str | int
@@ -832,8 +1028,8 @@ class Client(BaseClient):
             "skip_status": "1",
             "return_user": "true",
         }
-        response, response_json = await self.request("POST", url, params=params)
-        image_url = response_json[f"profile_{type}_url"]
+        response, data = await self.request("POST", url, params=params)
+        image_url = data[f"profile_{type}_url"]
         return image_url
 
     async def update_profile_avatar(self, media_id: int | str) -> str:
@@ -850,12 +1046,12 @@ class Client(BaseClient):
 
     async def change_username(self, username: str) -> bool:
         url = "https://twitter.com/i/api/1.1/account/settings.json"
-        data = {"screen_name": username}
-        response, response_json = await self.request("POST", url, data=data)
-        new_username = response_json["screen_name"]
-        is_changed = new_username == username
+        payload = {"screen_name": username}
+        response, data = await self.request("POST", url, data=payload)
+        new_username = data["screen_name"]
+        changed = new_username == username
         self.account.username = new_username
-        return is_changed
+        return changed
 
     async def change_password(self, password: str) -> bool:
         """
@@ -865,17 +1061,18 @@ class Client(BaseClient):
             raise ValueError(f"Specify the current password before changing it")
 
         url = "https://twitter.com/i/api/i/account/change_password.json"
-        data = {
+        payload = {
             "current_password": self.account.password,
             "password": password,
             "password_confirmation": password,
         }
-        response, response_json = await self.request("POST", url, data=data)
-        is_changed = response_json["status"] == "ok"
+        response, data = await self.request("POST", url, data=payload)
+        changed = data["status"] == "ok"
+        # TODO Делать это автоматически в методе request
         auth_token = response.cookies.get("auth_token", domain=".twitter.com")
         self.account.auth_token = auth_token
         self.account.password = password
-        return is_changed
+        return changed
 
     async def update_profile(
         self,
@@ -891,9 +1088,9 @@ class Client(BaseClient):
             raise ValueError("Specify at least one param")
 
         url = "https://twitter.com/i/api/1.1/account/update_profile.json"
-        headers = {"content-type": "application/x-www-form-urlencoded"}
+        # headers = {"content-type": "application/x-www-form-urlencoded"}
         # Создаем словарь data, включая в него только те ключи, для которых значения не равны None
-        data = {
+        payload = {
             k: v
             for k, v in [
                 ("name", name),
@@ -903,26 +1100,23 @@ class Client(BaseClient):
             ]
             if v is not None
         }
-        response, response_json = await self.request(
-            "POST", url, headers=headers, data=data
-        )
+        # response, response_json = await self.request("POST", url, headers=headers, data=payload)
+        response, data = await self.request("POST", url, data=payload)
         # Проверяем, что все переданные параметры соответствуют полученным
-        is_updated = all(
-            response_json.get(key) == value
-            for key, value in data.items()
-            if key != "url"
+        updated = all(
+            data.get(key) == value for key, value in payload.items() if key != "url"
         )
         if website:
-            is_updated &= URL(website) == URL(
-                response_json["entities"]["url"]["urls"][0]["expanded_url"]
+            updated &= URL(website) == URL(
+                data["entities"]["url"]["urls"][0]["expanded_url"]
             )
-        await self.request_user_data()
-        return is_updated
+        await self.request_user()
+        return updated
 
     async def establish_status(self):
         url = "https://twitter.com/i/api/1.1/account/update_profile.json"
         try:
-            await self.request("POST", url)
+            await self.request("POST", url, auto_unlock=False, auto_relogin=False)
         except BadAccount:
             pass
 
@@ -947,7 +1141,7 @@ class Client(BaseClient):
             "POST", url, headers=headers, data=data
         )
         birthdate_data = response_json["extended_profile"]["birthdate"]
-        is_updated = all(
+        updated = all(
             (
                 birthdate_data["day"] == day,
                 birthdate_data["month"] == month,
@@ -956,7 +1150,7 @@ class Client(BaseClient):
                 birthdate_data["year_visibility"] == year_visibility,
             )
         )
-        return is_updated
+        return updated
 
     async def send_message(self, user_id: int | str, text: str) -> dict:
         """
@@ -972,6 +1166,20 @@ class Client(BaseClient):
                 },
             }
         }
+        response, data = await self.request("POST", url, json=payload)
+        event_data = data["event"]
+        return event_data  # TODO Возвращать модель, а не словарь
+
+    async def send_message_to_conversation(
+        self, conversation_id: int | str, text: str
+    ) -> dict:
+        """
+        requires OAuth1 or OAuth2
+
+        :return: Event data
+        """
+        url = f"https://api.twitter.com/2/dm_conversations/{conversation_id}/messages"
+        payload = {"text": text}
         response, response_json = await self.request("POST", url, json=payload)
         event_data = response_json["event"]
         return event_data
@@ -1023,56 +1231,7 @@ class Client(BaseClient):
             for entry in response_json["inbox_initial_state"]["entries"]
             if "message" in entry
         ]
-        return messages
-
-    async def request_tweets(self, user_id: str | int, count: int = 20) -> list[Tweet]:
-        url, query_id = self._action_to_url("UserTweets")
-        variables = {
-            "userId": str(user_id),
-            "count": count,
-            "includePromotedContent": True,
-            "withQuickPromoteEligibilityTweetFields": True,
-            "withVoice": True,
-            "withV2Timeline": True,
-        }
-        features = {
-            "responsive_web_graphql_exclude_directive_enabled": True,
-            "verified_phone_label_enabled": False,
-            "creator_subscriptions_tweet_preview_api_enabled": True,
-            "responsive_web_graphql_timeline_navigation_enabled": True,
-            "responsive_web_graphql_skip_user_profile_image_extensions_enabled": False,
-            "c9s_tweet_anatomy_moderator_badge_enabled": True,
-            "tweetypie_unmention_optimization_enabled": True,
-            "responsive_web_edit_tweet_api_enabled": True,
-            "graphql_is_translatable_rweb_tweet_is_translatable_enabled": True,
-            "view_counts_everywhere_api_enabled": True,
-            "longform_notetweets_consumption_enabled": True,
-            "responsive_web_twitter_article_tweet_consumption_enabled": False,
-            "tweet_awards_web_tipping_enabled": False,
-            "freedom_of_speech_not_reach_fetch_enabled": True,
-            "standardized_nudges_misinfo": True,
-            "tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled": True,
-            "rweb_video_timestamps_enabled": True,
-            "longform_notetweets_rich_text_read_enabled": True,
-            "longform_notetweets_inline_media_enabled": True,
-            "responsive_web_media_download_video_enabled": False,
-            "responsive_web_enhance_cards_enabled": False,
-        }
-        params = {"variables": to_json(variables), "features": to_json(features)}
-        response, response_json = await self.request("GET", url, params=params)
-
-        tweets = []
-        for instruction in response_json["data"]["user"]["result"]["timeline_v2"][
-            "timeline"
-        ]["instructions"]:
-            if instruction["type"] == "TimelineAddEntries":
-                for entry in instruction["entries"]:
-                    if entry["entryId"].startswith("tweet"):
-                        tweet_data = entry["content"]["itemContent"]["tweet_results"][
-                            "result"
-                        ]
-                        tweets.append(Tweet.from_raw_data(tweet_data))
-        return tweets
+        return messages  # TODO Возвращать модели, а не словари
 
     async def _confirm_unlock(
         self,
@@ -1133,8 +1292,19 @@ class Client(BaseClient):
         else:
             funcaptcha["captcha_type"] = FunCaptchaTypeEnm.FunCaptchaTaskProxyLess
 
-        while needs_unlock:
+        while needs_unlock and attempt <= self.max_unlock_attempts:
             solution = await FunCaptcha(**funcaptcha).aio_captcha_handler()
+            if solution.errorId:
+                logger.warning(
+                    f"{self.account} Failed to solve funcaptcha:"
+                    f"\n\tUnlock attempt: {attempt}/{self.max_unlock_attempts}"
+                    f"\n\tError ID: {solution.errorId}"
+                    f"\n\tError code: {solution.errorCode}"
+                    f"\n\tError description: {solution.errorDescription}"
+                )
+                attempt += 1
+                continue
+
             token = solution.solution["token"]
             response, html = await self._confirm_unlock(
                 authenticity_token,
@@ -1142,12 +1312,8 @@ class Client(BaseClient):
                 verification_string=token,
             )
 
-            if (
-                attempt > self.max_unlock_attempts
-                or response.url == "https://twitter.com/?lang=en"
-            ):
-                await self.establish_status()
-                return
+            if response.url == "https://twitter.com/?lang=en":
+                break
 
             (
                 authenticity_token,
@@ -1171,6 +1337,8 @@ class Client(BaseClient):
 
             attempt += 1
 
+        await self.establish_status()
+
     async def _task(self, **kwargs):
         """
         :return: flow_token, subtasks
@@ -1335,7 +1503,7 @@ class Client(BaseClient):
             "fieldToggles": to_json(field_toggles),
             "variables": to_json(variables),
         }
-        return self.request("GET", url, params=params)
+        return await self.request("GET", url, params=params)
 
     async def _request_guest_token(self) -> str:
         """
@@ -1374,18 +1542,9 @@ class Client(BaseClient):
                 flow_token
             )
 
-        # TODO Возможно, стоит добавить отслеживание этих параметров прямо в request
-        self.account.auth_token = self._session.cookies["auth_token"]
-        self.account.ct0 = self._session.cookies["ct0"]
-
         await self._finish_task(flow_token)
 
-    async def login(self):
-        if self.account.auth_token:
-            await self.establish_status()
-            if self.account.status != "BAD_TOKEN":
-                return
-
+    async def relogin(self):
         if not self.account.email and not self.account.username:
             raise ValueError("No email or username")
 
@@ -1393,11 +1552,20 @@ class Client(BaseClient):
             raise ValueError("No password")
 
         await self._login()
+        await self._viewer()
         await self.establish_status()
 
+    async def login(self):
+        if self.account.auth_token:
+            await self.establish_status()
+            if self.account.status not in ("BAD_TOKEN", "CONSENT_LOCKED"):
+                return
+
+        await self.relogin()
+
     async def totp_is_enabled(self):
         if not self.account.id:
-            await self.request_user_data()
+            await self.request_user()
 
         url = f"https://twitter.com/i/api/1.1/strato/column/User/{self.account.id}/account-security/twoFactorAuthSettings2"
         response, data = await self.request("GET", url)
@@ -1409,7 +1577,7 @@ class Client(BaseClient):
         """
         :return: flow_token, subtask_ids
         """
-        params = {
+        query = {
             "flow_name": "two-factor-auth-app-enrollment",
         }
         payload = {
@@ -1463,7 +1631,7 @@ class Client(BaseClient):
                 "web_modal": 1,
             },
         }
-        return await self._task(params=params, json=payload)
+        return await self._task(params=query, json=payload)
 
     async def _two_factor_enrollment_verify_password_subtask(self, flow_token: str):
         subtask_inputs = [
@@ -1561,6 +1729,4 @@ class Client(BaseClient):
         if await self.totp_is_enabled():
             return
 
-        # TODO Осторожно, костыль! Перед началом работы вызываем request_user_data, чтоб убедиться что нет других ошибок
-        await self.request_user_data()
         await self._enable_totp()