tweepy-self 1.6.3__py3-none-any.whl → 1.10.0b9__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,23 @@ 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, Subtask
+from .utils import (
+    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"
@@ -46,7 +51,7 @@ class Client(BaseClient):
         "CreateRetweet": "ojPdsZsimiJrUGLR1sjUtA",
         "FavoriteTweet": "lI07N6Otwv1PhnEgXILM7A",
         "UnfavoriteTweet": "ZYKSe-w7KEslx3JhSIk5LA",
-        "CreateTweet": "SoVnbfCycZ7fERGCwpZkYA",
+        "CreateTweet": "v0en1yVV-Ybeek8ClmXwYw",
         "TweetResultByRestId": "V3vfsYzNEyD9tsf4xoFRgw",
         "ModerateTweet": "p'jF:GVqCjTcZol0xcBJjw",
         "DeleteTweet": "VaenaVgh5q5ih7kvyVjgtg",
@@ -56,6 +61,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 +82,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,
+        update_account_info_on_startup: bool = True,
         **session_kwargs,
     ):
         super().__init__(**session_kwargs)
@@ -84,20 +92,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._update_account_info_on_startup = update_account_info_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 +125,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 +145,52 @@ 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.warning(
+                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
+
+            return response, data
 
         if response.status_code == 400:
             raise BadRequest(response, data)
@@ -147,10 +207,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 +221,83 @@ 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.warning(
+                    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._update_account_info_on_startup:
+            await self.update_account_info()
+            await self.establish_status()
 
-    async def _request_oauth_2_auth_code(
+    async def _request_oauth2_auth_code(
         self,
         client_id: str,
         code_challenge: str,
@@ -234,7 +321,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 +334,7 @@ class Client(BaseClient):
             data=data,
         )
 
-    async def oauth_2(
+    async def oauth2(
         self,
         client_id: str,
         code_challenge: str,
@@ -263,15 +350,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 +365,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,14 +420,13 @@ class Client(BaseClient):
 
         return authenticity_token, redirect_url
 
-    async def request_username(self):
+    async def _update_account_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_by_username(self, username: str) -> User | None:
         url, query_id = self._action_to_url("UserByScreenName")
-        username = remove_at_sign(username)
         variables = {
             "screen_name": username,
             "withSafetyModeUserFields": True,
@@ -367,48 +451,99 @@ 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)
+        if not data["data"]:
+            return None
+        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_by_username(self, username: str) -> User | Account | None:
+        """
+        :param username: Имя пользователя без знака `@`
+        :return: Пользователь, если существует, иначе None. Или собственный аккаунт, если совпадает имя пользователя.
+        """
+        if not self.account.username:
+            await self.update_account_info()
 
-        return user_data
+        user = await self._request_user_by_username(username)
 
-    async def request_user_data(self, username: str = None) -> UserData:
-        if username:
-            return await self._request_user_data(username)
-        else:
-            if not self.account.username:
-                await self.request_username()
-            return await self._request_user_data(self.account.username)
+        if user and user.username == self.account.username:
+            self.account.update(**user.model_dump())
+            return self.account
+
+        return user
+
+    async def _request_users_by_ids(
+        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
+            if user.id == self.account.id:
+                users[self.account.id] = self.account
+        return users
+
+    async def request_user_by_id(self, user_id: int | str) -> User | Account | None:
+        """
+        :param user_id: ID пользователя
+        :return: Пользователь, если существует, иначе None. Или собственный аккаунт, если совпадает ID.
+        """
+        if not self.account.id:
+            await self.update_account_info()
+
+        users = await self._request_users_by_ids((user_id,))
+        user = users[user_id]
+        return user
+
+    async def request_users_by_ids(
+        self, user_ids: Iterable[str | int]
+    ) -> dict[int : User | Account]:
+        """
+        :param user_ids: ID пользователей
+        :return: Пользователи, если существует, иначе None. Или собственный аккаунт, если совпадает ID.
+        """
+        return await self._request_users_by_ids(user_ids)
+
+    async def update_account_info(self):
+        if not self.account.username:
+            await self._update_account_username()
+
+        await self.request_user_by_username(self.account.username)
 
     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 +560,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,27 +598,76 @@ 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 | 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
 
-    async def repost(self, tweet_id: int) -> int:
+            else:
+                raise
+
+        return tweet
+
+    async def repost(
+        self,
+        tweet_id: int,
+        *,
+        search_duplicate: bool = True,
+    ) -> Tweet:
         """
         Repost (retweet)
 
-        :return: Tweet ID
+        Иногда может вернуть ошибку 404 (Not Found), если плохой прокси или по другим неизвестным причинам
+
+        :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)
-        is_liked = response_json["data"]["favorite_tweet"] == "Done"
-        return is_liked
+        """
+        :return: Liked or not
+        """
+        try:
+            response_json = await self._interact_with_tweet("FavoriteTweet", tweet_id)
+        except HTTPException as exc:
+            if 139 in exc.api_codes:
+                # Already liked
+                return True
+            else:
+                raise
+        return response_json["data"]["favorite_tweet"] == "Done"
 
     async def unlike(self, tweet_id: int) -> dict:
         response_json = await self._interact_with_tweet("UnfavoriteTweet", tweet_id)
@@ -533,47 +714,50 @@ class Client(BaseClient):
         attachment_url: str = None,
     ) -> Tweet:
         url, query_id = self._action_to_url("CreateTweet")
-        payload = {
-            "variables": {
-                "tweet_text": text if text is not None else "",
-                "dark_request": False,
-                "media": {"media_entities": [], "possibly_sensitive": False},
-                "semantic_annotation_ids": [],
-            },
-            "features": {
-                "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,
-                "tweet_awards_web_tipping_enabled": False,
-                "longform_notetweets_rich_text_read_enabled": True,
-                "longform_notetweets_inline_media_enabled": True,
-                "responsive_web_graphql_exclude_directive_enabled": True,
-                "verified_phone_label_enabled": False,
-                "freedom_of_speech_not_reach_fetch_enabled": True,
-                "standardized_nudges_misinfo": True,
-                "tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled": False,
-                "responsive_web_graphql_skip_user_profile_image_extensions_enabled": False,
-                "responsive_web_graphql_timeline_navigation_enabled": True,
-                "responsive_web_enhance_cards_enabled": False,
-                "responsive_web_twitter_article_tweet_consumption_enabled": False,
-                "responsive_web_media_download_video_enabled": False,
-            },
-            "queryId": query_id,
+        variables = {
+            "tweet_text": text if text is not None else "",
+            "dark_request": False,
+            "media": {"media_entities": [], "possibly_sensitive": False},
+            "semantic_annotation_ids": [],
         }
         if attachment_url:
-            payload["variables"]["attachment_url"] = attachment_url
+            variables["attachment_url"] = attachment_url
         if tweet_id_to_reply:
-            payload["variables"]["reply"] = {
+            variables["reply"] = {
                 "in_reply_to_tweet_id": str(tweet_id_to_reply),
                 "exclude_reply_user_ids": [],
             }
         if media_id:
-            payload["variables"]["media"]["media_entities"].append(
+            variables["media"]["media_entities"].append(
                 {"media_id": str(media_id), "tagged_users": []}
             )
-
+        features = {
+            "communities_web_enable_tweet_community_results_fetch": True,
+            "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": True,
+            "tweet_awards_web_tipping_enabled": False,
+            "longform_notetweets_rich_text_read_enabled": True,
+            "longform_notetweets_inline_media_enabled": True,
+            "rweb_video_timestamps_enabled": True,
+            "responsive_web_graphql_exclude_directive_enabled": True,
+            "verified_phone_label_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,
+            "responsive_web_graphql_skip_user_profile_image_extensions_enabled": False,
+            "responsive_web_graphql_timeline_navigation_enabled": True,
+            "responsive_web_enhance_cards_enabled": False,
+        }
+        payload = {
+            "variables": variables,
+            "features": features,
+            "queryId": query_id,
+        }
         response, response_json = await self.request("POST", url, json=payload)
         tweet = Tweet.from_raw_data(
             response_json["data"]["create_tweet"]["tweet_results"]["result"]
@@ -588,7 +772,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 +785,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 +800,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 +808,16 @@ class Client(BaseClient):
         *,
         media_id: int | str = None,
         search_duplicate: bool = True,
-        with_tweet_url: bool = True,
     ) -> Tweet:
+        """
+        Иногда может вернуть ошибку 404 (Not Found), если плохой прокси или по другим неизвестным причинам
+
+        :return: 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 +827,17 @@ class Client(BaseClient):
         *,
         media_id: int | str = None,
         search_duplicate: bool = True,
-        with_tweet_url: bool = True,
     ) -> Tweet:
+        """
+        Иногда может вернуть ошибку 404 (Not Found), если плохой прокси или по другим неизвестным причинам
+
+        :return: 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 +847,17 @@ class Client(BaseClient):
         *,
         media_id: int | str = None,
         search_duplicate: bool = True,
-        with_tweet_url: bool = True,
     ) -> Tweet:
+        """
+        Иногда может вернуть ошибку 404 (Not Found), если плохой прокси или по другим неизвестным причинам
+
+        :return: 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(
@@ -690,15 +877,21 @@ class Client(BaseClient):
         response, response_json = await self.request("POST", url, params=params)
         return response_json
 
-    async def _request_users(
-        self, action: str, user_id: int | str, count: int
-    ) -> list[UserData]:
+    async def _request_users_by_action(
+        self,
+        action: str,
+        user_id: int | str,
+        count: int,
+        cursor: str = None,
+    ) -> list[User]:
         url, query_id = self._action_to_url(action)
         variables = {
             "userId": str(user_id),
             "count": count,
             "includePromotedContent": False,
         }
+        if cursor:
+            variables["cursor"] = cursor
         features = {
             "rweb_lists_timeline_redesign_enabled": True,
             "responsive_web_graphql_exclude_directive_enabled": True,
@@ -737,40 +930,53 @@ 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]:
+        self,
+        user_id: int | str = None,
+        count: int = 20,
+        cursor: str = None,
+    ) -> list[User]:
         """
         :param user_id: Текущий пользователь, если не передан ID иного пользователя.
         :param count: Количество подписчиков.
         """
         if user_id:
-            return await self._request_users("Followers", user_id, count)
+            return await self._request_users_by_action(
+                "Followers", user_id, count, cursor
+            )
         else:
             if not self.account.id:
-                await self.request_user_data()
-            return await self._request_users("Followers", self.account.id, count)
+                await self.update_account_info()
+            return await self._request_users_by_action(
+                "Followers", self.account.id, count, cursor
+            )
 
     async def request_followings(
-        self, user_id: int | str = None, count: int = 10
-    ) -> list[UserData]:
+        self,
+        user_id: int | str = None,
+        count: int = 20,
+        cursor: str = None,
+    ) -> list[User]:
         """
         :param user_id: Текущий пользователь, если не передан ID иного пользователя.
         :param count: Количество подписчиков.
         """
         if user_id:
-            return await self._request_users("Following", user_id, count)
+            return await self._request_users_by_action(
+                "Following", user_id, count, cursor
+            )
         else:
             if not self.account.id:
-                await self.request_user_data()
-            return await self._request_users("Following", self.account.id, count)
+                await self.update_account_info()
+            return await self._request_users_by_action(
+                "Following", self.account.id, count, cursor
+            )
 
-    async def _request_tweet_data(self, tweet_id: int) -> dict:
-        action = "TweetDetail"
-        url, query_id = self._action_to_url(action)
+    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 +1007,73 @@ 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, cursor: str = None
+    ) -> 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,
+        }
+        if cursor:
+            variables["cursor"] = cursor
+        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, cursor: str = None
+    ) -> list[Tweet]:
+        if not user_id:
+            if not self.account.id:
+                await self.update_account_info()
+            user_id = self.account.id
+
+        return await self._request_tweets(user_id, count, cursor)
 
     async def _update_profile_image(
         self, type: Literal["banner", "image"], media_id: str | int
@@ -832,8 +1099,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 +1117,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 +1132,15 @@ 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"
-        auth_token = response.cookies.get("auth_token", domain=".twitter.com")
-        self.account.auth_token = auth_token
+        response, data = await self.request("POST", url, data=payload)
+        changed = data["status"] == "ok"
         self.account.password = password
-        return is_changed
+        return changed
 
     async def update_profile(
         self,
@@ -891,9 +1156,8 @@ 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"}
         # Создаем словарь data, включая в него только те ключи, для которых значения не равны None
-        data = {
+        payload = {
             k: v
             for k, v in [
                 ("name", name),
@@ -903,26 +1167,23 @@ class Client(BaseClient):
             ]
             if v is not None
         }
-        response, response_json = await self.request(
-            "POST", url, headers=headers, data=data
-        )
+        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.update_account_info()
+        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)
+            self.account.status = AccountStatus.GOOD
         except BadAccount:
             pass
 
@@ -935,19 +1196,16 @@ class Client(BaseClient):
         year_visibility: Literal["self"] = "self",
     ) -> bool:
         url = "https://twitter.com/i/api/1.1/account/update_profile.json"
-        headers = {"content-type": "application/x-www-form-urlencoded"}
-        data = {
+        payload = {
             "birthdate_day": day,
             "birthdate_month": month,
             "birthdate_year": year,
             "birthdate_visibility": visibility,
             "birthdate_year_visibility": year_visibility,
         }
-        response, response_json = await self.request(
-            "POST", url, headers=headers, data=data
-        )
+        response, response_json = await self.request("POST", url, json=payload)
         birthdate_data = response_json["extended_profile"]["birthdate"]
-        is_updated = all(
+        updated = all(
             (
                 birthdate_data["day"] == day,
                 birthdate_data["month"] == month,
@@ -956,7 +1214,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 +1230,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 +1295,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,
@@ -1090,6 +1313,8 @@ class Client(BaseClient):
             payload["verification_string"] = verification_string
             payload["language_code"] = "en"
 
+        # TODO ui_metrics
+
         return await self.request("POST", self._CAPTCHA_URL, data=payload, bearer=False)
 
     async def unlock(self):
@@ -1103,9 +1328,23 @@ class Client(BaseClient):
             needs_unlock,
             start_button,
             finish_button,
+            delete_button,
         ) = parse_unlock_html(html)
         attempt = 1
 
+        if delete_button:
+            response, html = await self._confirm_unlock(
+                authenticity_token, assignment_token
+            )
+            (
+                authenticity_token,
+                assignment_token,
+                needs_unlock,
+                start_button,
+                finish_button,
+                delete_button,
+            ) = parse_unlock_html(html)
+
         if start_button or finish_button:
             response, html = await self._confirm_unlock(
                 authenticity_token, assignment_token
@@ -1116,6 +1355,7 @@ class Client(BaseClient):
                 needs_unlock,
                 start_button,
                 finish_button,
+                delete_button,
             ) = parse_unlock_html(html)
 
         funcaptcha = {
@@ -1133,8 +1373,20 @@ 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"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+                    f"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 +1394,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,
@@ -1155,6 +1403,7 @@ class Client(BaseClient):
                 needs_unlock,
                 start_button,
                 finish_button,
+                delete_button,
             ) = parse_unlock_html(html)
 
             if finish_button:
@@ -1167,22 +1416,58 @@ class Client(BaseClient):
                     needs_unlock,
                     start_button,
                     finish_button,
+                    delete_button,
                 ) = parse_unlock_html(html)
 
             attempt += 1
 
-    async def _task(self, **kwargs):
+        await self.establish_status()
+
+    async def update_backup_code(self):
+        url = "https://api.twitter.com/1.1/account/backup_code.json"
+        response, response_json = await self.request("GET", url)
+        self.account.backup_code = response_json["codes"][0]
+
+    async def _send_raw_subtask(self, **request_kwargs) -> tuple[str, list[Subtask]]:
         """
-        :return: flow_token, subtasks
+        :return: flow_token and subtasks
         """
         url = "https://api.twitter.com/1.1/onboarding/task.json"
-        response, response_json = await self.request("POST", url, **kwargs)
-        return response_json["flow_token"], response_json["subtasks"]
+        response, data = await self.request("POST", url, **request_kwargs)
+        subtasks = [
+            Subtask.from_raw_data(subtask_data) for subtask_data in data["subtasks"]
+        ]
+        log_message = (
+            f"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+            f" Requested subtasks:"
+        )
+        for subtask in subtasks:
+            log_message += f"\n\t{subtask.id}"
+            if subtask.primary_text:
+                log_message += f"\n\tPrimary text: {subtask.primary_text}"
+            if subtask.secondary_text:
+                log_message += f"\n\tSecondary text: {subtask.secondary_text}"
+            if subtask.detail_text:
+                log_message += f"\n\tDetail text: {subtask.detail_text}"
+        logger.debug(log_message)
+        return data["flow_token"], subtasks
+
+    async def _complete_subtask(
+        self,
+        flow_token: str,
+        inputs: list[dict],
+        **request_kwargs,
+    ) -> tuple[str, list[Subtask]]:
+        payload = request_kwargs["json"] = request_kwargs.get("json") or {}
+        payload.update(
+            {
+                "flow_token": flow_token,
+                "subtask_inputs": inputs,
+            }
+        )
+        return await self._send_raw_subtask(**request_kwargs)
 
-    async def _request_login_tasks(self):
-        """
-        :return: flow_token, subtask_ids
-        """
+    async def _request_login_tasks(self) -> tuple[str, list[Subtask]]:
         params = {
             "flow_name": "login",
         }
@@ -1237,84 +1522,89 @@ class Client(BaseClient):
                 "web_modal": 1,
             },
         }
-        return await self._task(params=params, json=payload, auth=False)
+        return await self._send_raw_subtask(params=params, json=payload, auth=False)
 
-    async def _send_task(self, flow_token: str, subtask_inputs: list[dict], **kwargs):
-        payload = kwargs["json"] = kwargs.get("json") or {}
-        payload.update(
-            {
-                "flow_token": flow_token,
-                "subtask_inputs": subtask_inputs,
-            }
-        )
-        return await self._task(**kwargs)
-
-    async def _finish_task(self, flow_token):
-        payload = {
-            "flow_token": flow_token,
-            "subtask_inputs": [],
-        }
-        return await self._task(json=payload)
-
-    async def _login_enter_user_identifier(self, flow_token):
-        subtask_inputs = [
+    async def _login_enter_user_identifier(self, flow_token: str):
+        inputs = [
             {
                 "subtask_id": "LoginEnterUserIdentifierSSO",
                 "settings_list": {
+                    "link": "next_link",
                     "setting_responses": [
                         {
                             "key": "user_identifier",
                             "response_data": {
                                 "text_data": {
-                                    "result": self.account.email
-                                    or self.account.username
+                                    "result": self.account.username
+                                    or self.account.email
                                 }
                             },
                         }
                     ],
-                    "link": "next_link",
                 },
             }
         ]
-        return await self._send_task(flow_token, subtask_inputs, auth=False)
+        return await self._complete_subtask(flow_token, inputs, auth=False)
 
-    async def _login_enter_password(self, flow_token):
-        subtask_inputs = [
+    async def _login_enter_password(self, flow_token: str):
+        inputs = [
             {
                 "subtask_id": "LoginEnterPassword",
                 "enter_password": {
-                    "password": self.account.password,
                     "link": "next_link",
+                    "password": self.account.password,
                 },
             }
         ]
-        return await self._send_task(flow_token, subtask_inputs, auth=False)
+        return await self._complete_subtask(flow_token, inputs, auth=False)
 
     async def _account_duplication_check(self, flow_token):
-        subtask_inputs = [
+        inputs = [
             {
                 "subtask_id": "AccountDuplicationCheck",
                 "check_logged_in_account": {"link": "AccountDuplicationCheck_false"},
             }
         ]
-        return await self._send_task(flow_token, subtask_inputs, auth=False)
-
-    async def _login_two_factor_auth_challenge(self, flow_token):
-        if not self.account.totp_secret:
-            raise TwitterException(
-                f"Failed to login. Task id: LoginTwoFactorAuthChallenge"
-            )
+        return await self._complete_subtask(flow_token, inputs, auth=False)
 
-        subtask_inputs = [
+    async def _login_two_factor_auth_challenge(self, flow_token, value: str):
+        inputs = [
             {
                 "subtask_id": "LoginTwoFactorAuthChallenge",
                 "enter_text": {
-                    "text": self.account.get_totp_code(),
                     "link": "next_link",
+                    "text": value,
                 },
             }
         ]
-        return await self._send_task(flow_token, subtask_inputs, auth=False)
+        return await self._complete_subtask(flow_token, inputs, auth=False)
+
+    async def _login_two_factor_auth_choose_method(
+        self, flow_token: str, choices: Iterable[int] = (0,)
+    ):
+        inputs = [
+            {
+                "subtask_id": "LoginTwoFactorAuthChooseMethod",
+                "choice_selection": {
+                    "link": "next_link",
+                    "selected_choices": [str(choice) for choice in choices],
+                },
+            }
+        ]
+        return await self._complete_subtask(flow_token, inputs, auth=False)
+
+    async def _login_acid(
+        self,
+        flow_token: str,
+        value: str,
+    ):
+        inputs = [
+            {
+                "subtask_id": "LoginAcid",
+                "enter_text": {"text": value, "link": "next_link"},
+            }
+        ]
+        return await self._complete_subtask(flow_token, inputs, auth=False)
 
     async def _viewer(self):
         url, query_id = self._action_to_url("Viewer")
@@ -1331,11 +1621,11 @@ class Client(BaseClient):
         }
         variables = {"withCommunitiesMemberships": True}
         params = {
-            "features": to_json(features),
-            "fieldToggles": to_json(field_toggles),
-            "variables": to_json(variables),
+            "features": features,
+            "fieldToggles": field_toggles,
+            "variables": variables,
         }
-        return self.request("GET", url, params=params)
+        return await self.request("GET", url, params=params)
 
     async def _request_guest_token(self) -> str:
         """
@@ -1350,66 +1640,151 @@ class Client(BaseClient):
         guest_token = re.search(r"gt\s?=\s?\d+", response.text)[0].split("=")[1]
         return guest_token
 
-    async def _login(self):
+    async def _login(self) -> bool:
+        update_backup_code = False
+
         guest_token = await self._request_guest_token()
         self._session.headers["X-Guest-Token"] = guest_token
 
-        # Можно не устанавливать, так как твиттер сам вернет этот токен
-        # self._session.cookies["gt"] = guest_token
-
         flow_token, subtasks = await self._request_login_tasks()
         for _ in range(2):
             flow_token, subtasks = await self._login_enter_user_identifier(flow_token)
+
+        subtask_ids = {subtask.id for subtask in subtasks}
+        if "LoginEnterAlternateIdentifierSubtask" in subtask_ids:
+            if not self.account.username:
+                raise TwitterException("Failed to login: no username to relogin")
+
         flow_token, subtasks = await self._login_enter_password(flow_token)
         flow_token, subtasks = await self._account_duplication_check(flow_token)
 
-        subtask_ids = [subtask["subtask_id"] for subtask in subtasks]
+        for subtask in subtasks:
+            if subtask.id == "LoginAcid":
+                if not self.account.email:
+                    raise TwitterException(
+                        f"Failed to login. Task id: LoginAcid." f" No email!"
+                    )
 
-        # TODO IMAP Обработчик
-        if "LoginAcid" in subtask_ids:
-            raise TwitterException(f"Failed to login: email verification!")
+                if subtask.primary_text == "Check your email":
+                    raise TwitterException(
+                        f"Failed to login. Task id: LoginAcid."
+                        f" Email verification required!"
+                        f" No IMAP handler for this version of library :<"
+                    )
 
-        if "LoginTwoFactorAuthChallenge" in subtask_ids:
-            flow_token, subtasks = await self._login_two_factor_auth_challenge(
-                flow_token
-            )
+                try:
+                    # fmt: off
+                    flow_token, subtasks = await self._login_acid(flow_token, self.account.email)
+                    # fmt: on
+                except HTTPException as exc:
+                    if 399 in exc.api_codes:
+                        logger.warning(
+                            f"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+                            f" Bad email!"
+                        )
+                        raise TwitterException(
+                            f"Failed to login. Task id: LoginAcid. Bad email!"
+                        )
+                    else:
+                        raise
+
+        subtask_ids = {subtask.id for subtask in subtasks}
 
-        # TODO Возможно, стоит добавить отслеживание этих параметров прямо в request
-        self.account.auth_token = self._session.cookies["auth_token"]
-        self.account.ct0 = self._session.cookies["ct0"]
+        if "LoginTwoFactorAuthChallenge" in subtask_ids:
+            if not self.account.totp_secret:
+                raise TwitterException(
+                    f"Failed to login. Task id: LoginTwoFactorAuthChallenge. No totp_secret!"
+                )
 
-        await self._finish_task(flow_token)
+            try:
+                # fmt: off
+                flow_token, subtasks = await self._login_two_factor_auth_challenge(flow_token, self.account.get_totp_code())
+                # fmt: on
+            except HTTPException as exc:
+                if 399 in exc.api_codes:
+                    logger.warning(
+                        f"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+                        f" Bad TOTP secret!"
+                    )
+                    if not self.account.backup_code:
+                        raise TwitterException(
+                            f"Failed to login. Task id: LoginTwoFactorAuthChallenge. No backup code!"
+                        )
+
+                    # Enter backup code
+                    # fmt: off
+                    flow_token, subtasks = await self._login_two_factor_auth_choose_method(flow_token)
+                    try:
+                        flow_token, subtasks = await self._login_two_factor_auth_challenge(flow_token, self.account.backup_code)
+                    except HTTPException as exc:
+                        if 399 in exc.api_codes:
+                            logger.warning(
+                                f"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+                                f" Bad backup code!"
+                            )
+                            raise TwitterException(
+                                f"Failed to login. Task id: LoginTwoFactorAuthChallenge. Bad backup_code!"
+                            )
+                        else:
+                            raise
+
+                    update_backup_code = True
+                    # fmt: on
+                else:
+                    raise
 
-    async def login(self):
-        if self.account.auth_token:
-            await self.establish_status()
-            if self.account.status != "BAD_TOKEN":
-                return
+        await self._complete_subtask(flow_token, [])
+        return update_backup_code
 
+    async def relogin(self):
+        """
+        Может вызвать следующую ошибку:
+            twitter.errors.BadRequest: (response status: 400)
+            (code 398) Can't complete your signup right now.
+        Причина возникновения ошибки неизвестна. Не забудьте обработать ее.
+        """
         if not self.account.email and not self.account.username:
             raise ValueError("No email or username")
 
         if not self.account.password:
             raise ValueError("No password")
 
-        await self._login()
+        update_backup_code = await self._login()
+        await self._viewer()
+
+        if update_backup_code:
+            await self.update_backup_code()
+            logger.warning(
+                f"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+                f" Requested new backup code!"
+            )
+            # TODO Также обновлять totp_secret
+
         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.update_account_info()
 
         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)
-        return "Totp" in [
-            method_data["twoFactorType"] for method_data in data["methods"]
-        ]
+        # fmt: off
+        return "Totp" in [method_data["twoFactorType"] for method_data in data["methods"]]
+        # fmt: on
 
-    async def _request_2fa_tasks(self):
+    async def _request_2fa_tasks(self) -> tuple[str, list[Subtask]]:
         """
-        :return: flow_token, subtask_ids
+        :return: flow_token, tasks
         """
-        params = {
+        query = {
             "flow_name": "two-factor-auth-app-enrollment",
         }
         payload = {
@@ -1463,34 +1838,37 @@ class Client(BaseClient):
                 "web_modal": 1,
             },
         }
-        return await self._task(params=params, json=payload)
+        return await self._send_raw_subtask(params=query, json=payload)
 
-    async def _two_factor_enrollment_verify_password_subtask(self, flow_token: str):
-        subtask_inputs = [
+    async def _two_factor_enrollment_verify_password_subtask(
+        self, flow_token: str
+    ) -> tuple[str, list[Subtask]]:
+        inputs = [
             {
                 "subtask_id": "TwoFactorEnrollmentVerifyPasswordSubtask",
                 "enter_password": {
-                    "password": self.account.password,
                     "link": "next_link",
+                    "password": self.account.password,
                 },
             }
         ]
-        return await self._send_task(flow_token, subtask_inputs)
+        return await self._complete_subtask(flow_token, inputs)
 
     async def _two_factor_enrollment_authentication_app_begin_subtask(
         self, flow_token: str
-    ):
-        subtask_inputs = [
+    ) -> tuple[str, list[Subtask]]:
+        inputs = [
             {
                 "subtask_id": "TwoFactorEnrollmentAuthenticationAppBeginSubtask",
                 "action_list": {"link": "next_link"},
             }
         ]
-        return await self._send_task(flow_token, subtask_inputs)
+        return await self._complete_subtask(flow_token, inputs)
 
     async def _two_factor_enrollment_authentication_app_plain_code_subtask(
-        self, flow_token: str
-    ):
+        self,
+        flow_token: str,
+    ) -> tuple[str, list[Subtask]]:
         subtask_inputs = [
             {
                 "subtask_id": "TwoFactorEnrollmentAuthenticationAppPlainCodeSubtask",
@@ -1499,12 +1877,12 @@ class Client(BaseClient):
             {
                 "subtask_id": "TwoFactorEnrollmentAuthenticationAppEnterCodeSubtask",
                 "enter_text": {
-                    "text": self.account.get_totp_code(),
                     "link": "next_link",
+                    "text": self.account.get_totp_code(),
                 },
             },
         ]
-        return await self._send_task(flow_token, subtask_inputs)
+        return await self._complete_subtask(flow_token, subtask_inputs)
 
     async def _finish_2fa_task(self, flow_token: str):
         subtask_inputs = [
@@ -1513,54 +1891,38 @@ class Client(BaseClient):
                 "cta": {"link": "finish_link"},
             }
         ]
-        return await self._send_task(flow_token, subtask_inputs)
+        await self._complete_subtask(flow_token, subtask_inputs)
 
     async def _enable_totp(self):
+        # fmt: off
         flow_token, subtasks = await self._request_2fa_tasks()
-        flow_token, subtasks = (
-            await self._two_factor_enrollment_verify_password_subtask(flow_token)
-        )
-        flow_token, subtasks = (
-            await self._two_factor_enrollment_authentication_app_begin_subtask(
-                flow_token
-            )
+        flow_token, subtasks = await self._two_factor_enrollment_verify_password_subtask(
+            flow_token
         )
+        flow_token, subtasks = (await self._two_factor_enrollment_authentication_app_begin_subtask(flow_token))
 
         for subtask in subtasks:
-            if (
-                subtask["subtask_id"]
-                == "TwoFactorEnrollmentAuthenticationAppPlainCodeSubtask"
-            ):
-                self.account.totp_secret = subtask["show_code"]["code"]
+            if subtask.id == "TwoFactorEnrollmentAuthenticationAppPlainCodeSubtask":
+                self.account.totp_secret = subtask.raw_data["show_code"]["code"]
                 break
 
-        flow_token, subtasks = (
-            await self._two_factor_enrollment_authentication_app_plain_code_subtask(
-                flow_token
-            )
-        )
+        flow_token, subtasks = await self._two_factor_enrollment_authentication_app_plain_code_subtask(flow_token)
 
         for subtask in subtasks:
-            if (
-                subtask["subtask_id"]
-                == "TwoFactorEnrollmentAuthenticationAppCompleteSubtask"
-            ):
-                result = re.search(
-                    r"\n[a-z0-9]{12}\n", subtask["cta"]["secondary_text"]["text"]
-                )
+            if subtask.id == "TwoFactorEnrollmentAuthenticationAppCompleteSubtask":
+                result = re.search(r"\n[a-z0-9]{12}\n", subtask.raw_data["cta"]["secondary_text"]["text"])
                 backup_code = result[0].strip() if result else None
                 self.account.backup_code = backup_code
                 break
 
+        # fmt: on
         await self._finish_2fa_task(flow_token)
 
     async def enable_totp(self):
-        if not self.account.password:
-            raise ValueError("Password is required for this action")
-
         if await self.totp_is_enabled():
             return
 
-        # TODO Осторожно, костыль! Перед началом работы вызываем request_user_data, чтоб убедиться что нет других ошибок
-        await self.request_user_data()
+        if not self.account.password:
+            raise ValueError("Password required to enable TOTP")
+
         await self._enable_totp()