tweepy-self 1.6.3__py3-none-any.whl → 1.10.0b1__py3-none-any.whl

{tweepy_self-1.6.3.dist-info → tweepy_self-1.10.0b1.dist-info}/METADATA

@@ -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.10.0b1.dist-info/RECORD

@@ -0,0 +1,23 @@
+twitter/__init__.py,sha256=-CmcPdm1z-OkG8LkJVe75PwdYKBqBfMpD9WdoXcnGuc,732
+twitter/_capsolver/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+twitter/_capsolver/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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=xPEUIPgytuw2wM1ubTY3RMhJGVyp_d3bokPTx0BjF0c,2602
+twitter/_capsolver/fun_captcha.py,sha256=VVbTmn08cGnvPMGdJmPxaLfAIPxyA68oTSAyEL8RWnU,10974
+twitter/account.py,sha256=joAB5Zw-Le5E3kOZ-1nb4DPGlTqWYv2Vs6gJ3cwu7is,3175
+twitter/base/__init__.py,sha256=Q2ko0HeOS5tiBnDVKxxaZYetwRR3YXJ67ujL3oThGd4,141
+twitter/base/client.py,sha256=J_iL4ZGfwTbZ2gpjtFCbBxNgt7weJ55EeMGzYsLtjf4,500
+twitter/base/session.py,sha256=JFPS-9Qae1iY3NfNcywxvWWmRDijaU_Rjs3WaQ00iFA,2071
+twitter/client.py,sha256=CySQ-hTFiPGFKhPBNw4nn_xnO5hdpjmXK90QpSEzRG4,66878
+twitter/enums.py,sha256=-OH6Ibxarq5qt4E2AhkProVawcEyIf5YG_h_G5xiV9Y,270
+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.10.0b1.dist-info/METADATA,sha256=FRxYUeZHlrxUB9Jr_nbxlhEkLc1pjO-ik_XiShkwARg,9438
+tweepy_self-1.10.0b1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+tweepy_self-1.10.0b1.dist-info/RECORD,,

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")

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,
+            )

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)

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.

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.",
+    )