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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tweepy-self
-Version: 1.6.3
+Version: 1.10.0b1
 Summary: Twitter (selfbot) for Python!
 Home-page: https://github.com/alenkimov/tweepy-self
 Author: Alen
@@ -9,15 +9,19 @@ Requires-Python: >=3.11,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: aiohttp (>=3.9,<4.0)
 Requires-Dist: beautifulsoup4 (>=4,<5)
-Requires-Dist: better-proxy (==1.1.1)
-Requires-Dist: curl_cffi (==0.6.0b9)
+Requires-Dist: better-proxy (>=1.1,<2.0)
+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: pyotp (>=2,<3)
-Requires-Dist: python3-capsolver (>=0.9,<0.10)
+Requires-Dist: requests (>=2,<3)
+Requires-Dist: tenacity (>=8,<9)
 Requires-Dist: yarl (>=1,<2)
 Project-URL: Repository, https://github.com/alenkimov/tweepy-self
+Project-URL: Source, https://github.com/alenkimov/tweepy-self
 Description-Content-Type: text/markdown
 
 # Tweepy-self
@@ -99,9 +103,10 @@ Automating user accounts is against the Twitter ToS. This library is a proof of
 
 ### Примеры работы
 Запрос информации о пользователе:
+
 ```python
 # Запрос информации о текущем пользователе:
-me = await twitter_client.request_user_data()
+me = await twitter_client.request_user()
 print(f"[{account.short_auth_token}] {me}")
 print(f"Аккаунт создан: {me.created_at}")
 print(f"Following (подписан ты): {me.followings_count}")
@@ -109,17 +114,18 @@ print(f"Followers (подписаны на тебя): {me.followers_count}")
 print(f"Прочая информация: {me.raw_data}")
 
 # Запрос информации об ином пользователе:
-elonmusk = await twitter.request_user_data("@elonmusk")
+elonmusk = await twitter.request_user("@elonmusk")
 print(elonmusk)
 ```
 
 Смена имени пользователя и пароля:
+
 ```python
 account = twitter.Account("auth_token", password="password")
 ...
 await twitter_client.change_username("new_username")
-await twitter_client.request_user_data()
-print(f"New username: {account.data.username}")
+await twitter_client.request_user()
+print(f"New username: {account.username}")
 
 await twitter_client.change_password("new_password")
 print(f"New password: {account.password}")
@@ -165,8 +171,9 @@ bind_code = await twitter_client.oauth_2(**bind_data)
 ```
 
 Отправка сообщения:
+
 ```python
-bro = await twitter_client.request_user_data("@username")
+bro = await twitter_client.request_user("@username")
 await twitter_client.send_message(bro.id, "I love you!")
 ```
 

{tweepy_self-1.6.3 → tweepy_self-1.10.0b1}/README.md

@@ -77,9 +77,10 @@ Automating user accounts is against the Twitter ToS. This library is a proof of
 
 ### Примеры работы
 Запрос информации о пользователе:
+
 ```python
 # Запрос информации о текущем пользователе:
-me = await twitter_client.request_user_data()
+me = await twitter_client.request_user()
 print(f"[{account.short_auth_token}] {me}")
 print(f"Аккаунт создан: {me.created_at}")
 print(f"Following (подписан ты): {me.followings_count}")
@@ -87,17 +88,18 @@ print(f"Followers (подписаны на тебя): {me.followers_count}")
 print(f"Прочая информация: {me.raw_data}")
 
 # Запрос информации об ином пользователе:
-elonmusk = await twitter.request_user_data("@elonmusk")
+elonmusk = await twitter.request_user("@elonmusk")
 print(elonmusk)
 ```
 
 Смена имени пользователя и пароля:
+
 ```python
 account = twitter.Account("auth_token", password="password")
 ...
 await twitter_client.change_username("new_username")
-await twitter_client.request_user_data()
-print(f"New username: {account.data.username}")
+await twitter_client.request_user()
+print(f"New username: {account.username}")
 
 await twitter_client.change_password("new_password")
 print(f"New password: {account.password}")
@@ -143,8 +145,9 @@ bind_code = await twitter_client.oauth_2(**bind_data)
 ```
 
 Отправка сообщения:
+
 ```python
-bro = await twitter_client.request_user_data("@username")
+bro = await twitter_client.request_user("@username")
 await twitter_client.send_message(bro.id, "I love you!")
 ```
 

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

@@ -1,22 +1,28 @@
 [tool.poetry]
 name = "tweepy-self"
-version = "1.6.3"
+version = "1.10.0.b1"
 description = "Twitter (selfbot) for Python!"
 authors = ["Alen <alen.kimov@gmail.com>"]
 readme = "README.md"
 repository = "https://github.com/alenkimov/tweepy-self"
 packages = [{include = "twitter"}]
 
+[tool.poetry.urls]
+Source = "https://github.com/alenkimov/tweepy-self"
+
 [tool.poetry.dependencies]
 python = "^3.11"
-curl_cffi = {version = "0.6.0b9", allow-prereleases = true}
-python3-capsolver = "^0.9"
-better-proxy = "1.1.1"
+curl_cffi = "0.6.2"
+better-proxy = "^1.1"
 beautifulsoup4 = "^4"
 pydantic = ">=1"
 lxml = "^5"
 pyotp = "^2"
 yarl = "^1"
+aiohttp = "^3.9"
+tenacity = "^8"
+requests = "^2"
+loguru = "^0.7"
 
 [tool.poetry.group.dev.dependencies]
 black = "^24"

{tweepy_self-1.6.3 → tweepy_self-1.10.0b1}/twitter/__init__.py

@@ -6,14 +6,23 @@ A basic wrapper for the Twitter user API.
 """
 
 from .client import Client
-from .account import Account, AccountStatus, load_accounts_from_file, extract_accounts_to_file
-from .models import Tweet, UserData
+from .account import (
+    Account,
+    AccountStatus,
+    load_accounts_from_file,
+    extract_accounts_to_file,
+)
+from .models import Tweet, User, Media, Image
 from . import errors, utils
 
 __all__ = [
     "Client",
     "Account",
     "AccountStatus",
+    "Tweet",
+    "User",
+    "Media",
+    "Image",
     "utils",
     "errors",
     "load_accounts_from_file",
@@ -22,9 +31,10 @@ __all__ = [
 
 
 import warnings
+
 # HACK: Ignore event loop warnings from curl_cffi
-warnings.filterwarnings('ignore', module='curl_cffi')
+warnings.filterwarnings("ignore", module="curl_cffi")
 
+from loguru import logger
 
-from python3_capsolver.core import config
-config.APP_ID = "6F895B2F-F454-44D1-8FE0-77ACAD3DBDC8"
+logger.disable("twitter")

tweepy_self-1.10.0b1/twitter/_capsolver/core/base.py

@@ -0,0 +1,227 @@
+import time
+import asyncio
+import logging
+from typing import Any, Dict, Type
+from urllib import parse
+
+import aiohttp
+import requests
+from pydantic import BaseModel
+from requests.adapters import HTTPAdapter
+
+from .enum import ResponseStatusEnm, EndpointPostfixEnm
+from .config import RETRIES, REQUEST_URL, VALID_STATUS_CODES, attempts_generator
+from .serializer import (
+    CaptchaOptionsSer,
+    CaptchaResponseSer,
+    RequestCreateTaskSer,
+    RequestGetTaskResultSer,
+)
+
+
+class BaseCaptcha:
+    """
+    Basic Captcha solving class
+
+    Args:
+        api_key: Capsolver API key
+        captcha_type: Captcha type name, like `ReCaptchaV2Task` and etc.
+        sleep_time: The waiting time between requests to get the result of the Captcha
+        request_url: API address for sending requests
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        sleep_time: int = 5,
+        request_url: str = REQUEST_URL,
+        **kwargs,
+    ):
+        # assign args to validator
+        self.__params = CaptchaOptionsSer(**locals())
+        self.__request_url = request_url
+
+        # prepare session
+        self.__session = requests.Session()
+        self.__session.mount("http://", HTTPAdapter(max_retries=RETRIES))
+        self.__session.mount("https://", HTTPAdapter(max_retries=RETRIES))
+
+    def _prepare_create_task_payload(self, serializer: Type[BaseModel], create_params: Dict[str, Any] = None) -> None:
+        """
+        Method prepare `createTask` payload
+
+        Args:
+            serializer: Serializer for task creation
+            create_params: Parameters for task creation payload
+
+        Examples:
+
+            >>> self._prepare_create_task_payload(serializer=PostRequestSer, create_params={})
+
+        """
+        self.task_payload = serializer(clientKey=self.__params.api_key)
+        # added task params to payload
+        self.task_payload.task = {**create_params} if create_params else {}
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if exc_type:
+            return False
+        return True
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        if exc_type:
+            return False
+        return True
+
+    """
+    Sync part
+    """
+
+    def _processing_captcha(
+        self, create_params: dict, serializer: Type[BaseModel] = RequestCreateTaskSer
+    ) -> CaptchaResponseSer:
+        self._prepare_create_task_payload(serializer=serializer, create_params=create_params)
+        self.created_task_data = CaptchaResponseSer(**self._create_task())
+
+        # if task created and ready - return result
+        if self.created_task_data.status == ResponseStatusEnm.Ready.value:
+            return self.created_task_data
+        # if captcha is not ready but task success created - waiting captcha result
+        elif self.created_task_data.errorId == 0:
+            return self._get_result()
+        return self.created_task_data
+
+    def _create_task(self, url_postfix: str = EndpointPostfixEnm.CREATE_TASK.value) -> dict:
+        """
+        Function send SYNC request to service and wait for result
+        """
+        try:
+            resp = self.__session.post(
+                parse.urljoin(self.__request_url, url_postfix), json=self.task_payload.dict(exclude_none=True)
+            )
+            if resp.status_code in VALID_STATUS_CODES:
+                return resp.json()
+            else:
+                raise ValueError(resp.raise_for_status())
+        except Exception as error:
+            logging.exception(error)
+            raise
+
+    def _get_result(self, url_postfix: str = EndpointPostfixEnm.GET_TASK_RESULT.value) -> CaptchaResponseSer:
+        """
+        Method send SYNC request to service and wait for result
+        """
+        # initial waiting
+        time.sleep(self.__params.sleep_time)
+
+        get_result_payload = RequestGetTaskResultSer(
+            clientKey=self.__params.api_key, taskId=self.created_task_data.taskId
+        )
+        attempts = attempts_generator()
+        for _ in attempts:
+            try:
+                resp = self.__session.post(
+                    parse.urljoin(self.__request_url, url_postfix), json=get_result_payload.dict(exclude_none=True)
+                )
+                if resp.status_code in VALID_STATUS_CODES:
+                    result_data = CaptchaResponseSer(**resp.json())
+                    if result_data.status in (ResponseStatusEnm.Ready, ResponseStatusEnm.Failed):
+                        # if captcha ready\failed or have unknown status - return exist data
+                        return result_data
+                else:
+                    raise ValueError(resp.raise_for_status())
+            except Exception as error:
+                logging.exception(error)
+                raise
+
+            # if captcha just created or in processing now - wait
+            time.sleep(self.__params.sleep_time)
+        # default response if server is silent
+        return CaptchaResponseSer(
+            errorId=1,
+            errorCode="ERROR_CAPTCHA_UNSOLVABLE",
+            errorDescription="Captcha not recognized",
+            taskId=self.created_task_data.taskId,
+            status=ResponseStatusEnm.Failed,
+        )
+
+    """
+    Async part
+    """
+
+    async def _aio_processing_captcha(
+        self, create_params: dict, serializer: Type[BaseModel] = RequestCreateTaskSer
+    ) -> CaptchaResponseSer:
+        self._prepare_create_task_payload(serializer=serializer, create_params=create_params)
+        self.created_task_data = CaptchaResponseSer(**await self._aio_create_task())
+
+        # if task created and already ready - return result
+        if self.created_task_data.status == ResponseStatusEnm.Ready.value:
+            return self.created_task_data
+        # if captcha is not ready but task success created - waiting captcha result
+        elif self.created_task_data.errorId == 0:
+            return await self._aio_get_result()
+        return self.created_task_data
+
+    async def _aio_create_task(self, url_postfix: str = EndpointPostfixEnm.CREATE_TASK.value) -> dict:
+        """
+        Function send the ASYNC request to service and wait for result
+        """
+        async with aiohttp.ClientSession() as session:
+            try:
+                async with session.post(
+                    parse.urljoin(self.__request_url, url_postfix), json=self.task_payload.dict(exclude_none=True)
+                ) as resp:
+                    if resp.status in VALID_STATUS_CODES:
+                        return await resp.json()
+                    else:
+                        raise ValueError(resp.reason)
+            except Exception as error:
+                logging.exception(error)
+                raise
+
+    async def _aio_get_result(self, url_postfix: str = EndpointPostfixEnm.GET_TASK_RESULT.value) -> CaptchaResponseSer:
+        """
+        Function send the ASYNC request to service and wait for result
+        """
+        # initial waiting
+        await asyncio.sleep(self.__params.sleep_time)
+
+        get_result_payload = RequestGetTaskResultSer(
+            clientKey=self.__params.api_key, taskId=self.created_task_data.taskId
+        )
+        attempts = attempts_generator()
+        async with aiohttp.ClientSession() as session:
+            for _ in attempts:
+                try:
+                    async with session.post(
+                        parse.urljoin(self.__request_url, url_postfix), json=get_result_payload.dict(exclude_none=True)
+                    ) as resp:
+                        if resp.status in VALID_STATUS_CODES:
+                            result_data = CaptchaResponseSer(**await resp.json())
+                            if result_data.status in (ResponseStatusEnm.Ready, ResponseStatusEnm.Failed):
+                                # if captcha ready\failed or have unknown status - return exist data
+                                return result_data
+                        else:
+                            raise ValueError(resp.reason)
+                except Exception as error:
+                    logging.exception(error)
+                    raise
+
+                # if captcha just created or in processing now - wait
+                await asyncio.sleep(self.__params.sleep_time)
+
+            # default response if server is silent
+            return CaptchaResponseSer(
+                errorId=1,
+                errorCode="ERROR_CAPTCHA_UNSOLVABLE",
+                errorDescription="Captcha not recognized",
+                taskId=self.created_task_data.taskId,
+                status=ResponseStatusEnm.Failed,
+            )

tweepy_self-1.10.0b1/twitter/_capsolver/core/config.py

@@ -0,0 +1,36 @@
+from typing import Generator
+
+from tenacity import AsyncRetrying, wait_fixed, stop_after_attempt
+from requests.adapters import Retry
+
+RETRIES = Retry(total=5, backoff_factor=0.9, status_forcelist=[500, 502, 503, 504])
+ASYNC_RETRIES = AsyncRetrying(wait=wait_fixed(5), stop=stop_after_attempt(5), reraise=True)
+
+REQUEST_URL = "https://api.capsolver.com"
+VALID_STATUS_CODES = (200, 202, 400, 401, 405)
+
+APP_ID = "6F895B2F-F454-44D1-8FE0-77ACAD3DBDC8"
+
+
+# Connection retry generator
+def attempts_generator(amount: int = 16) -> Generator:
+    """
+    Function generates a generator of length equal to `amount`
+
+    Args:
+        amount: number of attempts generated
+
+    Yields:
+        int: The next number in the range of 1 to ``amount`` - 1.
+
+    Examples:
+        Examples should be written in doctest format, and should illustrate how
+        to use the function.
+
+        >>> print([i for i in attempts_generator(5)])
+        [1, 2, 3, 4]
+
+    Returns:
+        Attempt number
+    """
+    yield from range(1, amount)

tweepy_self-1.10.0b1/twitter/_capsolver/core/enum.py

@@ -0,0 +1,66 @@
+from enum import Enum
+from types import DynamicClassAttribute
+from typing import List
+
+
+class MyEnum(Enum):
+    @classmethod
+    def list(cls) -> List[Enum]:
+        return list(map(lambda c: c, cls))
+
+    @classmethod
+    def list_values(cls) -> List[str]:
+        return list(map(lambda c: c.value, cls))
+
+    @classmethod
+    def list_names(cls) -> List[str]:
+        return list(map(lambda c: c.name, cls))
+
+    @DynamicClassAttribute
+    def name(self) -> str:
+        """
+        The name of the Enum member
+        """
+        return self._name_
+
+    @DynamicClassAttribute
+    def value(self) -> str:
+        """
+        The name of the Enum member
+        """
+        return self._value_
+
+
+class EndpointPostfixEnm(str, MyEnum):
+    """
+    Enum stored URL postfixes for API endpoints
+    """
+
+    GET_BALANCE = "getBalance"
+    CREATE_TASK = "createTask"
+    GET_TASK_RESULT = "getTaskResult"
+    AKAMAI_BMP_INVOKE = "akamaibmp/invoke"
+    AKAMAI_WEB_INVOKE = "akamaiweb/invoke"
+
+
+class FunCaptchaTypeEnm(str, MyEnum):
+    FunCaptchaTask = "FunCaptchaTask"
+    FunCaptchaTaskProxyLess = "FunCaptchaTaskProxyLess"
+
+
+class FunCaptchaClassificationTypeEnm(str, MyEnum):
+    FunCaptchaClassification = "FunCaptchaClassification"
+
+
+class ResponseStatusEnm(str, MyEnum):
+    """
+    Enum store results `status` field variants
+
+    Notes:
+        https://docs.capsolver.com/guide/api-createtask.html
+    """
+
+    Idle = "idle"  # Task created
+    Processing = "processing"  # Task is not ready yet
+    Ready = "ready"  # Task completed, solution object can be found in solution property
+    Failed = "failed"  # Task failed, check the errorDescription to know why failed.

tweepy_self-1.10.0b1/twitter/_capsolver/core/serializer.py

@@ -0,0 +1,85 @@
+from typing import Any, Dict, List, Literal, Optional
+
+from pydantic import Field, BaseModel, conint
+
+from .enum import ResponseStatusEnm
+from .config import APP_ID
+
+"""
+HTTP API Request ser
+"""
+
+
+class PostRequestSer(BaseModel):
+    clientKey: str = Field(..., description="Client account key, can be found in user account")
+    task: dict = Field(None, description="Task object")
+
+
+class TaskSer(BaseModel):
+    type: str = Field(..., description="Task type name", alias="captcha_type")
+
+
+class RequestCreateTaskSer(PostRequestSer):
+    appId: Literal[APP_ID] = APP_ID
+
+
+class RequestGetTaskResultSer(PostRequestSer):
+    taskId: Optional[str] = Field(None, description="ID created by the createTask method")
+
+
+"""
+HTTP API Response ser
+"""
+
+
+class ResponseSer(BaseModel):
+    errorId: int = Field(..., description="Error message: `False` - no error, `True` - with error")
+    # error info
+    errorCode: Optional[str] = Field(None, description="Error code")
+    errorDescription: Optional[str] = Field(None, description="Error description")
+
+
+class CaptchaResponseSer(ResponseSer):
+    taskId: Optional[str] = Field(None, description="Task ID for future use in getTaskResult method.")
+    status: ResponseStatusEnm = Field(ResponseStatusEnm.Processing, description="Task current status")
+    solution: Dict[str, Any] = Field(None, description="Task result data. Different for each type of task.")
+
+    class Config:
+        populate_by_name = True
+
+
+class ControlResponseSer(ResponseSer):
+    balance: Optional[float] = Field(0, description="Account balance value in USD")
+
+
+"""
+Other ser
+"""
+
+
+class CaptchaOptionsSer(BaseModel):
+    api_key: str
+    sleep_time: conint(ge=5) = 5
+
+
+"""
+Captcha tasks ser
+"""
+
+
+class FunCaptchaClassificationOptionsSer(TaskSer):
+    images: List[str] = Field(..., description="Base64-encoded images, do not include 'data:image/***;base64,'")
+    question: str = Field(
+        ...,
+        description="Question name. this param value from API response game_variant field. Exmaple: maze,maze2,flockCompass,3d_rollball_animals",
+    )
+
+
+class FunCaptchaSer(TaskSer):
+    websiteURL: str = Field(..., description="Address of a webpage with Funcaptcha")
+    websitePublicKey: str = Field(..., description="Funcaptcha website key.")
+    funcaptchaApiJSSubdomain: Optional[str] = Field(
+        None,
+        description="A special subdomain of funcaptcha.com, from which the JS captcha widget should be loaded."
+        "Most FunCaptcha installations work from shared domains.",
+    )