tweepy-self 1.9.0__py3-none-any.whl → 1.10.0__py3-none-any.whl

twitter/client.py

@@ -2,6 +2,7 @@ from typing import Any, Literal, Iterable
 from time import time
 import asyncio
 import base64
+import json
 import re
 
 from loguru import logger
@@ -29,9 +30,8 @@ from .errors import (
 from .utils import to_json
 from .base import BaseHTTPClient
 from .account import Account, AccountStatus
-from .models import User, Tweet, Media
+from .models import User, Tweet, Media, Subtask
 from .utils import (
-    remove_at_sign,
     parse_oauth_html,
     parse_unlock_html,
     tweets_data_from_instructions,
@@ -44,7 +44,6 @@ class Client(BaseHTTPClient):
         "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"
@@ -52,7 +51,7 @@ class Client(BaseHTTPClient):
         "CreateRetweet": "ojPdsZsimiJrUGLR1sjUtA",
         "FavoriteTweet": "lI07N6Otwv1PhnEgXILM7A",
         "UnfavoriteTweet": "ZYKSe-w7KEslx3JhSIk5LA",
-        "CreateTweet": "SoVnbfCycZ7fERGCwpZkYA",
+        "CreateTweet": "v0en1yVV-Ybeek8ClmXwYw",
         "TweetResultByRestId": "V3vfsYzNEyD9tsf4xoFRgw",
         "ModerateTweet": "p'jF:GVqCjTcZol0xcBJjw",
         "DeleteTweet": "VaenaVgh5q5ih7kvyVjgtg",
@@ -84,6 +83,8 @@ class Client(BaseHTTPClient):
         wait_on_rate_limit: bool = True,
         capsolver_api_key: str = None,
         max_unlock_attempts: int = 5,
+        auto_relogin: bool = True,
+        update_account_info_on_startup: bool = True,
         **session_kwargs,
     ):
         super().__init__(**session_kwargs)
@@ -91,13 +92,21 @@ class Client(BaseHTTPClient):
         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 {}
@@ -105,6 +114,7 @@ class Client(BaseHTTPClient):
 
         if bearer:
             headers["authorization"] = f"Bearer {self._BEARER_TOKEN}"
+            # headers["x-twitter-auth-type"] = "OAuth2Session"
 
         if auth:
             if not self.account.auth_token:
@@ -116,7 +126,8 @@ class Client(BaseHTTPClient):
                 headers["x-csrf-token"] = self.account.ct0
 
         # fmt: off
-        log_message = f"{self.account} Request {method} {url}"
+        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)
@@ -135,23 +146,51 @@ class Client(BaseHTTPClient):
 
         data = response.text
         # fmt: off
-        log_message = (f"{self.account} Response {method} {url}"
-                       f"\nStatus code: {response.status_code}"
-                       f"\nResponse data: {data}")
-        logger.debug(log_message)
+        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 response.headers["content-type"].startswith("application/json"):
+        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)
@@ -168,10 +207,6 @@ class Client(BaseHTTPClient):
         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)
@@ -186,52 +221,83 @@ class Client(BaseHTTPClient):
                         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,
@@ -255,7 +321,7 @@ class Client(BaseHTTPClient):
         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,
@@ -268,7 +334,7 @@ class Client(BaseHTTPClient):
             data=data,
         )
 
-    async def oauth_2(
+    async def oauth2(
         self,
         client_id: str,
         code_challenge: str,
@@ -284,15 +350,13 @@ class Client(BaseHTTPClient):
         Привязка (бинд, линк) приложения.
 
         :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,
@@ -301,7 +365,7 @@ class Client(BaseHTTPClient):
             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:
@@ -356,14 +420,13 @@ class Client(BaseHTTPClient):
 
         return authenticity_token, redirect_url
 
-    async def request_and_set_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(self, username: str) -> User:
+    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,
@@ -389,31 +452,76 @@ class Client(BaseHTTPClient):
             "fieldToggles": to_json(field_toggles),
         }
         response, data = await self.request("GET", url, params=params)
+        if not data["data"]:
+            return None
         return User.from_raw_data(data["data"]["user"]["result"])
 
-    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.")
-
-        if user_id:
-            users = await self.request_users((user_id,))
-            user = users[user_id]
-        else:
-            if not username:
-                if not self.account.username:
-                    await self.request_and_set_username()
-                username = self.account.username
+    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()
 
-            user = await self._request_user(username)
+        user = await self._request_user_by_username(username)
 
-        if self.account.username == user.username:
+        if user and user.username == self.account.username:
             self.account.update(**user.model_dump())
-            user = self.account
+            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,
@@ -429,15 +537,13 @@ class Client(BaseHTTPClient):
         :return: Media
         """
         url = "https://upload.twitter.com/1.1/media/upload.json"
-
         payload = {"media_data": base64.b64encode(image)}
-
         for attempt in range(attempts):
             try:
                 response, data = await self.request(
                     "POST", url, data=payload, timeout=timeout
                 )
-                return Media.from_raw_data(data)
+                return Media(**data)
             except (HTTPException, requests.errors.RequestsError) as exc:
                 if (
                     attempt < attempts - 1
@@ -541,6 +647,8 @@ class Client(BaseHTTPClient):
         """
         Repost (retweet)
 
+        Иногда может вернуть ошибку 404 (Not Found), если плохой прокси или по другим неизвестным причинам
+
         :return: Tweet
         """
         return await self._repost_or_search_duplicate(
@@ -548,9 +656,18 @@ class Client(BaseHTTPClient):
         )
 
     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)
@@ -597,47 +714,50 @@ class Client(BaseHTTPClient):
         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"]
@@ -689,6 +809,11 @@ class Client(BaseHTTPClient):
         media_id: int | str = None,
         search_duplicate: bool = True,
     ) -> Tweet:
+        """
+        Иногда может вернуть ошибку 404 (Not Found), если плохой прокси или по другим неизвестным причинам
+
+        :return: Tweet
+        """
         return await self._tweet_or_search_duplicate(
             text,
             media_id=media_id,
@@ -703,6 +828,11 @@ class Client(BaseHTTPClient):
         media_id: int | str = None,
         search_duplicate: bool = True,
     ) -> Tweet:
+        """
+        Иногда может вернуть ошибку 404 (Not Found), если плохой прокси или по другим неизвестным причинам
+
+        :return: Tweet
+        """
         return await self._tweet_or_search_duplicate(
             text,
             media_id=media_id,
@@ -718,6 +848,11 @@ class Client(BaseHTTPClient):
         media_id: int | str = None,
         search_duplicate: bool = True,
     ) -> Tweet:
+        """
+        Иногда может вернуть ошибку 404 (Not Found), если плохой прокси или по другим неизвестным причинам
+
+        :return: Tweet
+        """
         return await self._tweet_or_search_duplicate(
             text,
             media_id=media_id,
@@ -742,8 +877,12 @@ class Client(BaseHTTPClient):
         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
+    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 = {
@@ -751,6 +890,8 @@ class Client(BaseHTTPClient):
             "count": count,
             "includePromotedContent": False,
         }
+        if cursor:
+            variables["cursor"] = cursor
         features = {
             "rweb_lists_timeline_redesign_enabled": True,
             "responsive_web_graphql_exclude_directive_enabled": True,
@@ -793,53 +934,46 @@ class Client(BaseHTTPClient):
         return users
 
     async def request_followers(
-        self, user_id: int | str = None, count: int = 10
+        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()
-            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
+        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()
-            return await self._request_users("Following", self.account.id, count)
-
-    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
+                await self.update_account_info()
+            return await self._request_users_by_action(
+                "Following", self.account.id, count, cursor
+            )
 
     async def _request_tweet(self, tweet_id: int | str) -> Tweet:
         url, query_id = self._action_to_url("TweetDetail")
@@ -882,7 +1016,9 @@ class Client(BaseHTTPClient):
         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]:
+    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),
@@ -892,6 +1028,8 @@ class Client(BaseHTTPClient):
             "withVoice": True,
             "withV2Timeline": True,
         }
+        if cursor:
+            variables["cursor"] = cursor
         features = {
             "responsive_web_graphql_exclude_directive_enabled": True,
             "verified_phone_label_enabled": False,
@@ -928,16 +1066,14 @@ class Client(BaseHTTPClient):
         return await self._request_tweet(tweet_id)
 
     async def request_tweets(
-        self,
-        user_id: int | str = None,
-        count: int = 20,
+        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.request_user()
+                await self.update_account_info()
             user_id = self.account.id
 
-        return await self._request_tweets(user_id, count)
+        return await self._request_tweets(user_id, count, cursor)
 
     async def _update_profile_image(
         self, type: Literal["banner", "image"], media_id: str | int
@@ -1003,9 +1139,6 @@ class Client(BaseHTTPClient):
         }
         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 changed
 
@@ -1023,7 +1156,6 @@ class Client(BaseHTTPClient):
             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
         payload = {
             k: v
@@ -1035,7 +1167,6 @@ class Client(BaseHTTPClient):
             ]
             if v is not None
         }
-        # response, response_json = await self.request("POST", url, headers=headers, data=payload)
         response, data = await self.request("POST", url, data=payload)
         # Проверяем, что все переданные параметры соответствуют полученным
         updated = all(
@@ -1045,13 +1176,14 @@ class Client(BaseHTTPClient):
             updated &= URL(website) == URL(
                 data["entities"]["url"]["urls"][0]["expanded_url"]
             )
-        await self.request_user()
+        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
 
@@ -1064,17 +1196,14 @@ class Client(BaseHTTPClient):
         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"]
         updated = all(
             (
@@ -1105,6 +1234,20 @@ class Client(BaseHTTPClient):
         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
+
     async def request_messages(self) -> list[dict]:
         """
         :return: Messages data
@@ -1170,6 +1313,8 @@ class Client(BaseHTTPClient):
             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):
@@ -1183,9 +1328,23 @@ class Client(BaseHTTPClient):
             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
@@ -1196,6 +1355,7 @@ class Client(BaseHTTPClient):
                 needs_unlock,
                 start_button,
                 finish_button,
+                delete_button,
             ) = parse_unlock_html(html)
 
         funcaptcha = {
@@ -1213,8 +1373,20 @@ class Client(BaseHTTPClient):
         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,
@@ -1222,12 +1394,8 @@ class Client(BaseHTTPClient):
                 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,
@@ -1235,6 +1403,7 @@ class Client(BaseHTTPClient):
                 needs_unlock,
                 start_button,
                 finish_button,
+                delete_button,
             ) = parse_unlock_html(html)
 
             if finish_button:
@@ -1247,22 +1416,58 @@ class Client(BaseHTTPClient):
                     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 _request_login_tasks(self):
-        """
-        :return: flow_token, subtask_ids
-        """
+    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) -> tuple[str, list[Subtask]]:
         params = {
             "flow_name": "login",
         }
@@ -1317,84 +1522,89 @@ class Client(BaseHTTPClient):
                 "web_modal": 1,
             },
         }
-        return await self._task(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)
+        return await self._send_raw_subtask(params=params, json=payload, auth=False)
 
-    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._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._send_task(flow_token, subtask_inputs, auth=False)
+        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")
@@ -1411,11 +1621,11 @@ class Client(BaseHTTPClient):
         }
         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:
         """
@@ -1430,66 +1640,151 @@ class Client(BaseHTTPClient):
         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!"
+                    )
+
+                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 :<"
+                    )
 
-        # TODO IMAP Обработчик
-        if "LoginAcid" in subtask_ids:
-            raise TwitterException(f"Failed to login: email verification!")
+                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}
 
         if "LoginTwoFactorAuthChallenge" in subtask_ids:
-            flow_token, subtasks = await self._login_two_factor_auth_challenge(
-                flow_token
-            )
-
-        # TODO Делать это автоматически в методе request
-        self.account.auth_token = self._session.cookies["auth_token"]
-        self.account.ct0 = self._session.cookies["ct0"]
+            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()
+            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 = {
@@ -1543,34 +1838,37 @@ class Client(BaseHTTPClient):
                 "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",
@@ -1579,12 +1877,12 @@ class Client(BaseHTTPClient):
             {
                 "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 = [
@@ -1593,54 +1891,38 @@ class Client(BaseHTTPClient):
                 "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()
+        if not self.account.password:
+            raise ValueError("Password required to enable TOTP")
+
         await self._enable_totp()