tweepy-self 1.9.0__tar.gz → 1.10.0b1__tar.gz

{tweepy_self-1.9.0 → tweepy_self-1.10.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tweepy-self
-Version: 1.9.0
+Version: 1.10.0b1
 Summary: Twitter (selfbot) for Python!
 Home-page: https://github.com/alenkimov/tweepy-self
 Author: Alen
@@ -12,7 +12,7 @@ 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)

{tweepy_self-1.9.0 → tweepy_self-1.10.0b1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "tweepy-self"
-version = "1.9.0"
+version = "1.10.0.b1"
 description = "Twitter (selfbot) for Python!"
 authors = ["Alen <alen.kimov@gmail.com>"]
 readme = "README.md"
@@ -12,7 +12,7 @@ Source = "https://github.com/alenkimov/tweepy-self"
 
 [tool.poetry.dependencies]
 python = "^3.11"
-curl_cffi = {version = "0.6.0b9", allow-prereleases = true}
+curl_cffi = "0.6.2"
 better-proxy = "^1.1"
 beautifulsoup4 = "^4"
 pydantic = ">=1"

{tweepy_self-1.9.0 → tweepy_self-1.10.0b1}/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):

{tweepy_self-1.9.0 → tweepy_self-1.10.0b1}/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
 

{tweepy_self-1.9.0 → tweepy_self-1.10.0b1}/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()

{tweepy_self-1.9.0 → tweepy_self-1.10.0b1}/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"
@@ -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.info(
+                f"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+                f" Requested new auth_token!"
+            )
+
+        try:
             data = response.json()
+        except json.decoder.JSONDecodeError:
+            pass
 
-        if response.status_code == 429:
-            if self.wait_on_rate_limit:
-                reset_time = int(response.headers["x-rate-limit-reset"])
-                sleep_time = reset_time - int(time()) + 1
-                if sleep_time > 0:
-                    await asyncio.sleep(sleep_time)
-                return await self.request(method, url, auth, bearer, **kwargs)
-            raise RateLimited(response, data)
+        if 300 > response.status_code >= 200:
+            if isinstance(data, dict) and "errors" in data:
+                exc = HTTPException(response, data)
+
+                if 141 in exc.api_codes:
+                    self.account.status = AccountStatus.SUSPENDED
+                    raise Suspended(exc, self.account)
+
+                if 326 in exc.api_codes:
+                    for error_data in exc.api_errors:
+                        if (
+                            error_data.get("code") == 326
+                            and error_data.get("bounce_location")
+                            == "/i/flow/consent_flow"
+                        ):
+                            self.account.status = AccountStatus.CONSENT_LOCKED
+                            raise ConsentLocked(exc, self.account)
+
+                    self.account.status = AccountStatus.LOCKED
+                    raise Locked(exc, self.account)
+                raise exc
+
+            self.account.status = AccountStatus.GOOD
+            return response, data
 
         if response.status_code == 400:
             raise BadRequest(response, data)
@@ -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.info(
+                    f"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+                    f"Rate limited! Sleep time: {sleep_time} sec."
+                )
+                await asyncio.sleep(sleep_time)
+            return await self._request(
+                method,
+                url,
+                auth=auth,
+                bearer=bearer,
+                wait_on_rate_limit=wait_on_rate_limit,
+                **kwargs,
+            )
+
         if response.status_code >= 500:
             raise ServerError(response, data)
 
-        if not 200 <= response.status_code < 300:
-            raise HTTPException(response, data)
-
-        if isinstance(data, dict) and "errors" in data:
-            exc = HTTPException(response, data)
+    async def request(
+        self,
+        method,
+        url,
+        *,
+        auto_unlock: bool = True,
+        auto_relogin: bool = None,
+        **kwargs,
+    ) -> tuple[requests.Response, Any]:
+        try:
+            return await self._request(method, url, **kwargs)
 
-            if 141 in exc.api_codes:
-                self.account.status = AccountStatus.SUSPENDED
-                raise Suspended(exc, self.account)
+        except Locked:
+            if not self.capsolver_api_key or not auto_unlock:
+                raise
 
-            if 326 in exc.api_codes:
-                for error_data in exc.api_errors:
-                    if (
-                        error_data.get("code") == 326
-                        and error_data.get("bounce_location") == "/i/flow/consent_flow"
-                    ):
-                        self.account.status = AccountStatus.CONSENT_LOCKED
-                        raise ConsentLocked(exc, self.account)
+            await self.unlock()
+            return await self._request(method, url, **kwargs)
 
-                self.account.status = AccountStatus.LOCKED
-                if not self.capsolver_api_key:
-                    raise Locked(exc, self.account)
+        except BadToken:
+            if auto_relogin is None:
+                auto_relogin = self.auto_relogin
+            if (
+                not auto_relogin
+                or not self.account.password
+                or not (self.account.email or self.account.username)
+            ):
+                raise
 
-                await self.unlock()
-                return await self.request(method, url, auth, bearer, **kwargs)
+            await self.relogin()
+            return await self._request(method, url, **kwargs)
 
-            raise exc
+        except Forbidden as exc:
+            if 353 in exc.api_codes and "ct0" in exc.response.cookies:
+                return await self._request(method, url, **kwargs)
+            else:
+                raise
 
-        self.account.status = AccountStatus.GOOD
-        return response, data
+    async def on_startup(self):
+        if self.request_self_on_startup:
+            await self.request_user()
 
-    async def _request_oauth_2_auth_code(
+    async def _request_oauth2_auth_code(
         self,
         client_id: str,
         code_challenge: str,
@@ -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:
@@ -437,7 +502,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
@@ -1051,7 +1116,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 +1170,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 +1292,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 +1312,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 +1337,8 @@ class Client(BaseHTTPClient):
 
             attempt += 1
 
+        await self.establish_status()
+
     async def _task(self, **kwargs):
         """
         :return: flow_token, subtasks
@@ -1415,7 +1503,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 +1542,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 +1552,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 +1577,7 @@ class Client(BaseHTTPClient):
         """
         :return: flow_token, subtask_ids
         """
-        params = {
+        query = {
             "flow_name": "two-factor-auth-app-enrollment",
         }
         payload = {
@@ -1543,7 +1631,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 +1729,4 @@ class Client(BaseHTTPClient):
         if await self.totp_is_enabled():
             return
 
-        # TODO Осторожно, костыль! Перед началом работы вызываем request_user_data, чтоб убедиться что нет других ошибок
-        await self.request_user()
         await self._enable_totp()

{tweepy_self-1.9.0 → tweepy_self-1.10.0b1}/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)
 
 

{tweepy_self-1.9.0 → tweepy_self-1.10.0b1}/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