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

{tweepy_self-1.9.0.dist-info → tweepy_self-1.10.0b3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tweepy-self
-Version: 1.9.0
+Version: 1.10.0b3
 Summary: Twitter (selfbot) for Python!
 Home-page: https://github.com/alenkimov/tweepy-self
 Author: Alen
@@ -12,10 +12,10 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: aiohttp (>=3.9,<4.0)
 Requires-Dist: beautifulsoup4 (>=4,<5)
 Requires-Dist: better-proxy (>=1.1,<2.0)
-Requires-Dist: curl_cffi (==0.6.0b9)
+Requires-Dist: curl_cffi (==0.6.2)
 Requires-Dist: loguru (>=0.7,<0.8)
 Requires-Dist: lxml (>=5,<6)
-Requires-Dist: pydantic (>=1)
+Requires-Dist: pydantic (>=2)
 Requires-Dist: pyotp (>=2,<3)
 Requires-Dist: requests (>=2,<3)
 Requires-Dist: tenacity (>=8,<9)

{tweepy_self-1.9.0.dist-info → tweepy_self-1.10.0b3.dist-info}/RECORD

@@ -4,20 +4,20 @@ twitter/_capsolver/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 twitter/_capsolver/core/base.py,sha256=In3qDLgRh1z1UZLaLFgYcDEdnqW3d62PVzgEjU2S4BU,8883
 twitter/_capsolver/core/config.py,sha256=8_eXT6N2hBheN2uCMNhqk8tLZRJjLDTYLK208fqIkhM,1054
 twitter/_capsolver/core/enum.py,sha256=ivfAEN6jrg3iaq5C3H7CuRqsvOloX1b8lF8cLa3zaiY,1741
-twitter/_capsolver/core/serializer.py,sha256=2KuZ84VRUQp86iE386qUxReJryFIHnqueRGQUJDQadk,2616
+twitter/_capsolver/core/serializer.py,sha256=xPEUIPgytuw2wM1ubTY3RMhJGVyp_d3bokPTx0BjF0c,2602
 twitter/_capsolver/fun_captcha.py,sha256=VVbTmn08cGnvPMGdJmPxaLfAIPxyA68oTSAyEL8RWnU,10974
-twitter/account.py,sha256=kczlNN3YQcfec7eB1DKDbjn4zmZfJPl3e5o-70IFPFA,3142
+twitter/account.py,sha256=joAB5Zw-Le5E3kOZ-1nb4DPGlTqWYv2Vs6gJ3cwu7is,3175
 twitter/base/__init__.py,sha256=Q2ko0HeOS5tiBnDVKxxaZYetwRR3YXJ67ujL3oThGd4,141
-twitter/base/client.py,sha256=4z_keQnr8YxqRCsWfilQViGDKHulCZ_YBU1fEOr0AnE,482
+twitter/base/client.py,sha256=J_iL4ZGfwTbZ2gpjtFCbBxNgt7weJ55EeMGzYsLtjf4,500
 twitter/base/session.py,sha256=JFPS-9Qae1iY3NfNcywxvWWmRDijaU_Rjs3WaQ00iFA,2071
-twitter/client.py,sha256=hLMW20v3hSPwOPwoXNUbNFFOWmlqG77jt02VGUKoQDU,64199
+twitter/client.py,sha256=gboNB1N2ftrwJFlk43HV41d_2YXkxf1W5K_ZubPp6Xw,68665
 twitter/enums.py,sha256=-OH6Ibxarq5qt4E2AhkProVawcEyIf5YG_h_G5xiV9Y,270
-twitter/errors.py,sha256=NuoHmYz97VwXU1RWAaNELXR69snpwnCtFH0bII1hHyo,5088
-twitter/models.py,sha256=3KtyNHm6GGMiapk8I4jUmbnfrRTMBCFvN4g4dEW99tI,4985
+twitter/errors.py,sha256=oNa0Neos80ZK4-0FBzqgxXonH564qFnoN-kavHalfR4,5274
+twitter/models.py,sha256=7yObMPUUEwJEbraHzFwmUKd91UhR2-zyfJTm4xIqrSQ,4834
 twitter/utils/__init__.py,sha256=usxpfcRQ7zxTTgZ-i425tT7hIz73Pwh9FDj4t6O3dYg,663
 twitter/utils/file.py,sha256=Sz2KEF9DnL04aOP1XabuMYMMF4VR8dJ_KWMEVvQ666Y,1120
 twitter/utils/html.py,sha256=hVtIRFI2yRAdWEaShFNBG-_ZWxd16og8i8OVDnFy5Hc,1971
 twitter/utils/other.py,sha256=9RIYF2AMdmNKIwClG3jBP7zlvxZPEgYfuHaIiOhURzM,1061
-tweepy_self-1.9.0.dist-info/METADATA,sha256=LgnHHwoM-zyQF9l-XTR58GuHMXiVR_QHEOWGnUm-jDg,9437
-tweepy_self-1.9.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-tweepy_self-1.9.0.dist-info/RECORD,,
+tweepy_self-1.10.0b3.dist-info/METADATA,sha256=E9sSg4Y165wtSBFd39-ol2ir5nt4sCBKgqFVrMBW6PA,9438
+tweepy_self-1.10.0b3.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+tweepy_self-1.10.0b3.dist-info/RECORD,,

twitter/_capsolver/core/serializer.py

@@ -45,7 +45,7 @@ class CaptchaResponseSer(ResponseSer):
     solution: Dict[str, Any] = Field(None, description="Task result data. Different for each type of task.")
 
     class Config:
-        allow_population_by_field_name = True
+        populate_by_name = True
 
 
 class ControlResponseSer(ResponseSer):

twitter/account.py

@@ -12,11 +12,11 @@ from .models import User
 class Account(User):
     # fmt: off
     auth_token:  str | None = Field(default=None, pattern=r"^[a-f0-9]{40}$")
-    ct0:         str | None = None
-    password:    str | None = None
-    email:       str | None = None
-    totp_secret: str | None = None
-    backup_code: str | None = None
+    ct0:         str | None = None  # 160
+    password:    str | None = None  # 128
+    email:       str | None = None  # 254
+    totp_secret: str | None = None  # 16
+    backup_code: str | None = None  # 12
     status: AccountStatus = AccountStatus.UNKNOWN
     # fmt: on
 

twitter/base/client.py

@@ -14,7 +14,7 @@ class BaseHTTPClient:
         return self
 
     async def __aexit__(self, *args):
-        self.close()
+        await self.close()
 
-    def close(self):
-        self._session.close()
+    async def close(self):
+        await self._session.close()

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
@@ -44,7 +45,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 +52,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 +84,8 @@ class Client(BaseHTTPClient):
         wait_on_rate_limit: bool = True,
         capsolver_api_key: str = None,
         max_unlock_attempts: int = 5,
+        auto_relogin: bool = True,
+        request_self_on_startup: bool = True,
         **session_kwargs,
     ):
         super().__init__(**session_kwargs)
@@ -91,13 +93,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.request_self_on_startup = request_self_on_startup
 
-    async def request(
+    async def __aenter__(self):
+        await self.on_startup()
+        return await super().__aenter__()
+
+    async def _request(
         self,
         method,
         url,
+        *,
         auth: bool = True,
         bearer: bool = True,
+        wait_on_rate_limit: bool = None,
         **kwargs,
     ) -> tuple[requests.Response, Any]:
         cookies = kwargs["cookies"] = kwargs.get("cookies") or {}
@@ -105,6 +115,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 +127,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 +147,52 @@ 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
+
+            self.account.status = AccountStatus.GOOD
+            return response, data
 
         if response.status_code == 400:
             raise BadRequest(response, data)
@@ -168,10 +209,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 +223,82 @@ 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.request_self_on_startup:
+            await self.request_user()
 
-    async def _request_oauth_2_auth_code(
+    async def _request_oauth2_auth_code(
         self,
         client_id: str,
         code_challenge: str,
@@ -255,7 +322,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 +335,7 @@ class Client(BaseHTTPClient):
             data=data,
         )
 
-    async def oauth_2(
+    async def oauth2(
         self,
         client_id: str,
         code_challenge: str,
@@ -284,15 +351,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 +366,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:
@@ -361,7 +426,7 @@ class Client(BaseHTTPClient):
         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(self, username: str) -> User | None:
         url, query_id = self._action_to_url("UserByScreenName")
         username = remove_at_sign(username)
         variables = {
@@ -389,26 +454,39 @@ 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:
+    ) -> User | Account | None:
+        """
+        Возвращает None, если задано несуществующее имя пользователя
+        """
         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
-
+        elif username:
             user = await self._request_user(username)
+        else:
+            if not self.account.username:
+                await self.request_and_set_username()
+
+            user = await self._request_user(self.account.username)
+
+            if not user:
+                bad_username = self.account.username
+                await self.request_and_set_username()
+                user = await self._request_user(self.account.username)
+                logger.warning(
+                    f"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+                    f" Bad username: {bad_username}. Requested a real username."
+                )
 
-        if self.account.username == user.username:
             self.account.update(**user.model_dump())
             user = self.account
 
@@ -437,7 +515,7 @@ class Client(BaseHTTPClient):
                 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 +619,8 @@ class Client(BaseHTTPClient):
         """
         Repost (retweet)
 
+        Иногда может вернуть ошибку 404 (Not Found), если плохой прокси или по другим неизвестным причинам
+
         :return: Tweet
         """
         return await self._repost_or_search_duplicate(
@@ -548,9 +628,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 +686,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 +781,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 +800,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 +820,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,
@@ -1051,7 +1158,7 @@ class Client(BaseHTTPClient):
     async def establish_status(self):
         url = "https://twitter.com/i/api/1.1/account/update_profile.json"
         try:
-            await self.request("POST", url)
+            await self.request("POST", url, auto_unlock=False, auto_relogin=False)
         except BadAccount:
             pass
 
@@ -1105,6 +1212,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
@@ -1213,8 +1334,19 @@ 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"{self.account} Failed to solve funcaptcha:"
+                    f"\n\tUnlock attempt: {attempt}/{self.max_unlock_attempts}"
+                    f"\n\tError ID: {solution.errorId}"
+                    f"\n\tError code: {solution.errorCode}"
+                    f"\n\tError description: {solution.errorDescription}"
+                )
+                attempt += 1
+                continue
+
             token = solution.solution["token"]
             response, html = await self._confirm_unlock(
                 authenticity_token,
@@ -1222,12 +1354,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,
@@ -1251,6 +1379,8 @@ class Client(BaseHTTPClient):
 
             attempt += 1
 
+        await self.establish_status()
+
     async def _task(self, **kwargs):
         """
         :return: flow_token, subtasks
@@ -1415,7 +1545,7 @@ class Client(BaseHTTPClient):
             "fieldToggles": to_json(field_toggles),
             "variables": to_json(variables),
         }
-        return self.request("GET", url, params=params)
+        return await self.request("GET", url, params=params)
 
     async def _request_guest_token(self) -> str:
         """
@@ -1454,18 +1584,9 @@ class Client(BaseHTTPClient):
                 flow_token
             )
 
-        # TODO Делать это автоматически в методе request
-        self.account.auth_token = self._session.cookies["auth_token"]
-        self.account.ct0 = self._session.cookies["ct0"]
-
         await self._finish_task(flow_token)
 
-    async def login(self):
-        if self.account.auth_token:
-            await self.establish_status()
-            if self.account.status != "BAD_TOKEN":
-                return
-
+    async def relogin(self):
         if not self.account.email and not self.account.username:
             raise ValueError("No email or username")
 
@@ -1473,8 +1594,17 @@ class Client(BaseHTTPClient):
             raise ValueError("No password")
 
         await self._login()
+        await self._viewer()
         await self.establish_status()
 
+    async def login(self):
+        if self.account.auth_token:
+            await self.establish_status()
+            if self.account.status not in ("BAD_TOKEN", "CONSENT_LOCKED"):
+                return
+
+        await self.relogin()
+
     async def totp_is_enabled(self):
         if not self.account.id:
             await self.request_user()
@@ -1489,7 +1619,7 @@ class Client(BaseHTTPClient):
         """
         :return: flow_token, subtask_ids
         """
-        params = {
+        query = {
             "flow_name": "two-factor-auth-app-enrollment",
         }
         payload = {
@@ -1543,7 +1673,7 @@ class Client(BaseHTTPClient):
                 "web_modal": 1,
             },
         }
-        return await self._task(params=params, json=payload)
+        return await self._task(params=query, json=payload)
 
     async def _two_factor_enrollment_verify_password_subtask(self, flow_token: str):
         subtask_inputs = [
@@ -1641,6 +1771,4 @@ class Client(BaseHTTPClient):
         if await self.totp_is_enabled():
             return
 
-        # TODO Осторожно, костыль! Перед началом работы вызываем request_user_data, чтоб убедиться что нет других ошибок
-        await self.request_user()
         await self._enable_totp()

twitter/errors.py

@@ -20,7 +20,6 @@ __all__ = [
 ]
 
 
-# TODO Возвращать аккаунт в теле исключения
 class TwitterException(Exception):
     pass
 
@@ -62,12 +61,17 @@ class HTTPException(TwitterException):
         self.api_codes: list[int] = []
         self.api_messages: list[str] = []
         self.detail: str | None = None
+        self.html: str | None = None
 
         # Если ответ — строка, то это html
         if isinstance(data, str):
-            exception_message = (
-                f"(response status: {response.status_code}) HTML Response:\n{data}"
-            )
+            if not data:
+                exception_message = (
+                    f"(response status: {response.status_code}) Empty response body."
+                )
+            else:
+                self.html = data
+                exception_message = f"(response status: {response.status_code}) HTML Response:\n{self.html}"
             if response.status_code == 429:
                 exception_message = (
                     f"(response status: {response.status_code}) Rate limit exceeded."
@@ -147,7 +151,9 @@ class BadAccount(TwitterException):
 
 class BadToken(BadAccount):
     def __init__(self, http_exception: "HTTPException", account: Account):
-        exception_message = "Bad Twitter account's auth_token."
+        exception_message = (
+            "Bad Twitter account's auth_token. Relogin to get new token."
+        )
         super().__init__(http_exception, account, exception_message)
 
 
@@ -155,14 +161,14 @@ class Locked(BadAccount):
     def __init__(self, http_exception: "HTTPException", account: Account):
         exception_message = (
             f"Twitter account is locked."
-            f" Set CapSolver API key (capsolver_api_key) to autounlock."
+            f" Set CapSolver API key (capsolver_api_key) to auto-unlock."
         )
         super().__init__(http_exception, account, exception_message)
 
 
 class ConsentLocked(BadAccount):
     def __init__(self, http_exception: "HTTPException", account: Account):
-        exception_message = f"Twitter account is consent locked. Relogin to unlock."
+        exception_message = f"Twitter account is locked."
         super().__init__(http_exception, account, exception_message)
 
 

twitter/models.py

@@ -1,50 +1,40 @@
 from typing import Optional
 from datetime import datetime, timedelta
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field, field_validator
 
 from .utils import to_datetime, tweet_url
 
 
 class Image(BaseModel):
-    type: str
-    width: int
-    height: int
+    type: str = Field(..., alias="image_type")
+    width: int = Field(..., alias="w")
+    height: int = Field(..., alias="h")
 
 
 class Media(BaseModel):
-    id: int
+    id: int = Field(..., alias="media_id")
     image: Image
     size: int
-    expires_at: datetime
+    expires_at: datetime = Field(..., alias="expires_after_secs")
+
+    @field_validator("expires_at", mode="before")
+    @classmethod
+    def set_expires_at(cls, v):
+        return datetime.now() + timedelta(seconds=v)
 
     def __str__(self):
         return str(self.id)
 
-    @classmethod
-    def from_raw_data(cls, data: dict):
-        expires_at = datetime.now() + timedelta(seconds=data["expires_after_secs"])
-        values = {
-            "image": {
-                "type": data["image"]["image_type"],
-                "width": data["image"]["w"],
-                "height": data["image"]["h"],
-            },
-            "size": data["size"],
-            "id": data["media_id"],
-            "expires_at": expires_at,
-        }
-        return cls(**values)
-
 
 class User(BaseModel):
     # fmt: off
     id:              int      | None = None
     username:        str      | None = None
-    name:            str      | None = None
+    name:            str      | None = None  # 50
     created_at:      datetime | None = None
-    description:     str      | None = None
-    location:        str      | None = None
+    description:     str      | None = None  # 160
+    location:        str      | None = None  # 30
     followers_count: int      | None = None
     friends_count:   int      | None = None
     raw_data:        dict     | None = None