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

tweepy_self-1.10.0b9.dist-info/METADATA

@@ -0,0 +1,303 @@
+Metadata-Version: 2.1
+Name: tweepy-self
+Version: 1.10.0b9
+Summary: Twitter (selfbot) for Python!
+Home-page: https://github.com/alenkimov/tweepy-self
+Author: Alen
+Author-email: alen.kimov@gmail.com
+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,<2.0)
+Requires-Dist: curl_cffi (==0.6.2)
+Requires-Dist: loguru (>=0.7,<0.8)
+Requires-Dist: lxml (>=5,<6)
+Requires-Dist: pydantic (>=2,<3)
+Requires-Dist: pyotp (>=2,<3)
+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
+[![Telegram channel](https://img.shields.io/endpoint?url=https://runkit.io/damiankrawczyk/telegram-badge/branches/master?url=https://t.me/cum_insider)](https://t.me/cum_insider)
+[![PyPI version info](https://img.shields.io/pypi/v/tweepy-self.svg)](https://pypi.python.org/pypi/tweepy-self)
+[![PyPI supported Python versions](https://img.shields.io/pypi/pyversions/tweepy-self.svg)](https://pypi.python.org/pypi/tweepy-self)
+[![PyPI downloads per month](https://img.shields.io/pypi/dm/tweepy-self.svg)](https://pypi.python.org/pypi/tweepy-self)
+
+A modern, easy to use, feature-rich, and async ready API wrapper for Twitter's user API written in Python.
+
+More libraries of the family:
+- [better-proxy](https://github.com/alenkimov/better_proxy)
+- [better-web3](https://github.com/alenkimov/better_web3)
+
+Отдельное спасибо [Кузнице Ботов](https://t.me/bots_forge) за код для авторизации и разморозки! Подписывайтесь на их Telegram :)
+
+## Key Features
+- Modern Pythonic API using async and await.
+- Prevents user account automation detection.
+
+## Installing
+```bash
+pip install tweepy-self
+```
+
+## Example
+```python
+import asyncio
+import twitter
+
+twitter_account = twitter.Account(auth_token="auth_token")
+
+async def main():
+    async with twitter.Client(twitter_account) as twitter_client:
+        print(f"Logged in as @{twitter_account.username} (id={twitter_account.id})")
+        tweet = await twitter_client.tweet("Hello tweepy-self! <3")
+        print(tweet)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Документация
+### Некоторые истины
+Имена пользователей нужно передавать БЕЗ знака `@`.
+Чтобы наверняка убрать этот знак можно передать имя пользователя в функцию `twitter.utils.remove_at_sign()`
+
+Automating user accounts is against the Twitter ToS. This library is a proof of concept and I cannot recommend using it. Do so at your own risk
+
+### Как включить логирование
+```python
+import sys
+from loguru import logger
+
+logger.remove()
+logger.add(sys.stdout, level="INFO")
+logger.enable("twitter")
+```
+
+`level="DEBUG"` позволяет увидеть информацию обо всех запросах.
+
+### Аккаунт
+После любого взаимодействия с Twitter устанавливается статус аккаунта:
+- `UNKNOWN` - Статус аккаунта не установлен. Это статус по умолчанию.
+- `BAD_TOKEN` - Неверный или мертвый токен.
+- `SUSPENDED` - Действие учетной записи приостановлено. Тем не менее возможен запрос данных, а также авторизация через OAuth и OAuth2.
+- `LOCKED` - Учетная запись заморожена (лок). Для разморозки (анлок) требуется прохождение капчи (funcaptcha).
+- `CONSENT_LOCKED` - Учетная запись заморожена (лок). Условия для разморозки неизвестны.
+- `GOOD` - Аккаунт в порядке.
+
+Не каждое взаимодействие с Twitter достоверно определяет статус аккаунта.
+Например, простой запрос данных об аккаунте честно вернет данные, даже если действие вашей учетной записи приостановлено.
+
+Для достоверной установки статуса аккаунта используйте метод `Client.establish_status()`
+
+### Настройка клиента
+Класс `twitter.Client` может быть сконфигурирован перед работой. Он принимает в себя следующие параметры:
+- `wait_on_rate_limit` Если включено, то при достижении Rate Limit будет ждать, вместо того, чтобы выбрасывать исключение. Включено по умолчанию.
+- `capsolver_api_key` API ключ сервиса [CapSolver](https://dashboard.capsolver.com/passport/register?inviteCode=m-aE3NeBGZLU). Нужен для автоматической разморозки аккаунта.
+- `max_unlock_attempts` Максимальное количество попыток разморозки аккаунта. По умолчанию: 5.
+- `auto_relogin` Если включено, то при невалидном токене (`BAD_TOKEN`) и предоставленных данных для авторизации (имя пользователя, пароль и totp_secret) будет произведен автоматический релогин (замена токена). Включено по умолчанию.
+- `update_account_info_on_startup` Если включено, то на старте будет автоматически запрошена информация об аккаунте. Включено по умолчанию.
+- `**session_kwargs` Любые параметры, которые может принимать сессия `curl_cffi.requests.AsyncSession`. Например, можно передать параметр `proxy`.
+
+Пример настройки клиента:
+```python
+async with twitter.Client(
+    twitter_account,
+    capsolver_api_key="CAP-00000000000000000000000000000000",
+    proxy="http://login:password@ip:port",  # Можно передавать в любом формате, так как используется библиотека better_proxy
+) as twitter_client:
+    ...
+```
+
+### Доступные методы
+Список всех методов.
+
+#### Запрос информации о собственном аккаунте
+```python
+twitter_client.update_account_info()
+print(twitter_client.account)
+```
+
+#### Запрос пользователя по username или по ID
+
+```python
+bro = twitter_client.request_user_by_username(bro_username)
+bro = twitter_client.request_user_by_id(bro_id)
+bros = twitter_client.request_users_by_ids([bro1_id, bro2_id, ...])
+```
+
+####  Загрузка изображения на сервер, смена аватарки и баннера
+```python
+image = open("image.png", "rb").read()
+media = await twitter_client.upload_image(image)
+avatar_image_url = await twitter_client.update_profile_avatar(media.id)
+banner_image_url = await twitter_client.update_profile_banner(media.id)
+```
+
+#### Изменения данных профиля
+```python
+await twitter_client.update_birthdate(day=1, month=12, year=2000)
+await twitter_client.update_profile(  # Locks account!
+    name="New Name",
+    description="New description",
+    location="New York",
+    website="https://github.com/alenkimov/tweepy-self",
+)
+```
+
+#### Включение TOTP (2FA)
+```python
+if await twitter_client.totp_is_enabled():
+    print(f"TOTP уже включен.")
+    return
+
+await twitter_client.enable_totp()
+```
+
+#### Логин, если включен TOTP (2FA)
+```python
+import twitter
+
+twitter_account = twitter.Account(auth_token="...", username="...", password="...", totp_secret="...")
+await twitter_client.login()
+print(f"Logged in! New auth_token: {twitter_account.auth_token}")
+```
+
+#### Смена имени пользователя и пароля
+```python
+twitter_account = twitter.Account("auth_token", password="password")
+...
+await twitter_client.change_username("new_username")
+await twitter_client.request_user()
+print(f"New username: {twitter_account.username}")
+
+await twitter_client.change_password("new_password")
+print(f"New password: {twitter_account.password}")
+print(f"New auth_token: {twitter_account.auth_token}")
+```
+
+#### Авторизация с OAuth
+```python
+auth_code = await twitter_client.oauth(oauth_token, **oauth_params)
+```
+
+#### Авторизация с OAuth2
+```python
+# Изучите запросы сервиса и найдите подобные данные для авторизации (привязки):
+oauth2_data = {
+    'response_type': 'code',
+    'client_id': 'TjFVQm52ZDFGWEtNT0tKaktaSWU6MTpjaQ',
+    'redirect_uri': 'https://waitlist.lens.xyz/tw/',
+    'scope': 'users.read tweet.read offline.access',
+    'state': 'state',  # Может быть как статичным, так и динамическим.
+    'code_challenge': 'challenge',
+    'code_challenge_method': 'plain'
+}
+
+auth_code = await twitter_client.oauth2(**oauth2_data)
+# Передайте код авторизации (привязки) сервису.
+# Сервис также может потребовать state, если он динамический.
+```
+
+#### Отправка сообщения:
+```python
+bro = await twitter_client.request_user("bro_username")
+await twitter_client.send_message(bro.id, "I love you!")
+```
+
+#### Запрос входящих сообщений:
+```python
+messages = await twitter_client.request_messages()
+for message in messages:
+    message_data = message["message_data"]
+    recipient_id = message_data["recipient_id"]
+    sender_id = message_data["sender_id"]
+    text = message_data["text"]
+    print(f"[id  {sender_id}] -> [id {recipient_id}]: {text}")
+```
+
+Так как мне почти не приходилось работать с сообщениями, я еще не сделал для этого удобных моделей.
+Поэтому приходится работать со словарем.
+
+#### Пост (твит)
+```python
+tweet = await twitter_client.tweet("I love you tweepy-self! <3")
+print(f"Любовь выражена! Tweet id: {tweet.id}")
+```
+
+#### Лайк, репост (ретвит), коммент (реплай)
+```python
+# Лайк
+print(f"Tweet {tweet_id} is liked: {await twitter_client.like(tweet_id)}")
+
+# Репост (ретвит)
+print(f"Tweet {tweet_id} is retweeted. Tweet id: {await twitter_client.repost(tweet_id)}")
+
+# Коммент (реплай)
+print(f"Tweet {tweet_id} is replied. Reply id: {await twitter_client.reply(tweet_id, 'tem razão')}")
+```
+
+#### Цитата
+```python
+tweet_url = 'https://twitter.com/CreamIce_Cone/status/1691735090529976489'
+# Цитата (Quote tweet)
+quote_tweet_id = await twitter_client.quote(tweet_url, 'oh....')
+print(f"Quoted! Tweet id: {quote_tweet_id}")
+```
+
+#### Подписка и отписка
+```python
+# Подписываемся на Илона Маска
+print(f"@{elonmusk.username} is followed: {await twitter_client.follow(elonmusk.id)}")
+
+# Отписываемся от Илона Маска
+print(f"@{elonmusk.username} is unfollowed: {await twitter_client.unfollow(elonmusk.id)}")
+```
+
+#### Закрепление твита
+```python
+pinned = await twitter_client.pin_tweet(tweet_id)
+print(f"Tweet is pined: {pinned}")
+```
+
+#### Запрос своих и чужих подписчиков
+```python
+
+followers = await twitter_client.request_followers()
+print("Твои подписчики:")
+for user in followers:
+    print(user)
+    
+followings = await twitter_client.request_followings()
+print(f"Ты подписан на:")
+for user in followings:
+    print(user)
+
+bro_followers = await twitter_client.request_followers(bro_id)
+print(f"Подписчики твоего бро (id={bro_id}):")
+for user in bro_followers:
+    print(user)
+
+bro_followings = await twitter_client.request_followings(bro_id)
+print(f"На твоего бро (id={bro_id}) подписаны:")
+for user in bro_followings:
+    print(user)
+```
+
+#### Голосование
+```python
+vote_data = await twitter_client.vote(tweet_id, card_id, choice_number)
+votes_count = vote_data["card"]["binding_values"]["choice1_count"]["string_value"]
+print(f"Votes: {votes_count}")
+```
+
+Так как мне почти не приходилось работать с голосованиями, я еще не сделал для этого удобных моделей.
+Поэтому приходится работать со словарем.
+

tweepy_self-1.10.0b9.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=VZ9cymxz1KMSaqVTTFfCfuC1c5xZHdRUOD0XENSf53w,75555
+twitter/enums.py,sha256=-OH6Ibxarq5qt4E2AhkProVawcEyIf5YG_h_G5xiV9Y,270
+twitter/errors.py,sha256=oNa0Neos80ZK4-0FBzqgxXonH564qFnoN-kavHalfR4,5274
+twitter/models.py,sha256=CrGb3dvA0U4PfPTkUtuprPKXpqkLpM8AR_-De4D3efM,5677
+twitter/utils/__init__.py,sha256=usxpfcRQ7zxTTgZ-i425tT7hIz73Pwh9FDj4t6O3dYg,663
+twitter/utils/file.py,sha256=Sz2KEF9DnL04aOP1XabuMYMMF4VR8dJ_KWMEVvQ666Y,1120
+twitter/utils/html.py,sha256=nrOJw0vUKfBaHgFaQSQIdXfvfZ8mdu84MU_s46kJTJ4,2087
+twitter/utils/other.py,sha256=9RIYF2AMdmNKIwClG3jBP7zlvxZPEgYfuHaIiOhURzM,1061
+tweepy_self-1.10.0b9.dist-info/METADATA,sha256=DUbx5Sw46Hy6B1ZIsQVOnFx3BTjH1qZ0yplMDTJ7njE,13153
+tweepy_self-1.10.0b9.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+tweepy_self-1.10.0b9.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)