xselfbot 4.0.0__py3-none-any.whl

xselfbot/__init__.py

@@ -0,0 +1,34 @@
+"""
+=========
+XSelfBot
+=========
+
+A Python library for interacting with x.com: posting, reading, searching and
+streaming over a cookie session, with no API key.
+
+https://github.com/Tky567/xselfbot
+"""
+
+__version__ = '4.0.0'
+
+import asyncio
+import os
+
+if os.name == 'nt':
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+from ._captcha import Capsolver
+from .bookmark import BookmarkFolder
+from .errors import *
+from .utils import build_query
+from .client.client import Client
+from .community import Community, CommunityCreator, CommunityMember, CommunityRule
+from .geo import Place
+from .group import Group, GroupMessage
+from .list import List
+from .message import Message
+from .notification import Notification
+from .trend import Trend
+from .tweet import CommunityNote, Poll, ScheduledTweet, Tweet
+from .content_disclosure import build_content_disclosure, applied_disclosures
+from .user import User

xselfbot/_captcha/__init__.py

@@ -0,0 +1,2 @@
+from .base import CaptchaSolver
+from .capsolver import Capsolver

xselfbot/_captcha/base.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING, NamedTuple
+
+from bs4 import BeautifulSoup
+from httpx import Response
+from ..constants import DOMAIN
+
+if TYPE_CHECKING:
+    from ..client.client import Client
+
+
+class UnlockHTML(NamedTuple):
+    authenticity_token: str
+    assignment_token: str
+    needs_unlock: bool
+    start_button: bool
+    finish_button: bool
+    delete_button: bool
+    blob: str
+
+
+class CaptchaSolver:
+    client: Client
+    max_attempts: int
+
+    CAPTCHA_URL = f'https://{DOMAIN}/account/access'
+    CAPTCHA_SITE_KEY = '0152B4EB-D2DC-460A-89A1-629838B529C9'
+
+    async def get_unlock_html(self) -> tuple[Response, UnlockHTML]:
+        headers = {
+            'X-Twitter-Client-Language': 'en-US',
+            'User-Agent': self.client._user_agent,
+            'Upgrade-Insecure-Requests': '1'
+        }
+        _, response = await self.client.get(
+            self.CAPTCHA_URL, headers=headers
+        )
+        return response, parse_unlock_html(response.text)
+
+    async def ui_metrix(self) -> str:
+        js, _ = await self.client.get(
+            f'https://{DOMAIN}/i/js_inst?c_name=ui_metrics'
+        )
+        return re.findall(r'return ({.*?});', js, re.DOTALL)[0]
+
+    async def confirm_unlock(
+        self,
+        authenticity_token: str,
+        assignment_token: str,
+        verification_string: str = None,
+        ui_metrics: bool = False
+    ) -> tuple[Response, UnlockHTML]:
+        data = {
+            'authenticity_token': authenticity_token,
+            'assignment_token': assignment_token,
+            'lang': 'en',
+            'flow': '',
+        }
+        params = {}
+        if verification_string:
+            data['verification_string'] = verification_string
+            data['language_code'] = 'en'
+            params['lang'] = 'en'
+        if ui_metrics:
+            data['ui_metrics'] = await self.client._ui_metrix()
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Upgrade-Insecure-Requests': '1',
+            'Referer': self.CAPTCHA_URL
+        }
+        _, response = await self.client.post(
+            self.CAPTCHA_URL, params=params, data=data, headers=headers
+        )
+        return response, parse_unlock_html(response.text)
+
+
+def parse_unlock_html(html: str) -> UnlockHTML:
+    soup = BeautifulSoup(html, 'lxml')
+
+    authenticity_token = None
+    authenticity_token_element = soup.find(
+        'input', {'name': 'authenticity_token'}
+    )
+    if authenticity_token_element is not None:
+        authenticity_token: str = authenticity_token_element.get('value')
+
+    assignment_token = None
+    assignment_token_element = soup.find('input', {'name': 'assignment_token'})
+    if assignment_token_element is not None:
+        assignment_token = assignment_token_element.get('value')
+
+    verification_string = soup.find('input', id='verification_string')
+    needs_unlock = bool(verification_string)
+    start_button = bool(soup.find('input', value='Start'))
+    finish_button = bool(soup.find('input', value='Continue to X'))
+    delete_button = bool(soup.find('input', value='Delete'))
+
+    iframe = soup.find(id='arkose_iframe')
+    blob = re.findall(r'data=(.+)', iframe['src'])[0] if iframe else None
+
+    return UnlockHTML(
+        authenticity_token,
+        assignment_token,
+        needs_unlock,
+        start_button,
+        finish_button,
+        delete_button,
+        blob
+    )

xselfbot/_captcha/capsolver.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from time import sleep
+
+import httpx
+
+from .base import CaptchaSolver
+
+
+class Capsolver(CaptchaSolver):
+    """
+    You can automatically unlock the account by passing the `captcha_solver`
+    argument when initialising the :class:`.Client`.
+
+    First, visit https://capsolver.com and obtain your Capsolver API key.
+    Next, pass the Capsolver instance to the client as shown in the example.
+
+    .. code-block:: python
+
+        from xselfbot import Capsolver, Client
+        solver = Capsolver(
+            api_key='your_api_key',
+            max_attempts=10
+        )
+        client = Client(captcha_solver=solver)
+
+    Parameters
+    ----------
+    api_key : :class:`str`
+        Capsolver API key.
+    max_attempts : :class:`int`, default=3
+        The maximum number of attempts to solve the captcha.
+    get_result_interval : :class:`float`, default=1.0
+
+    use_blob_data : :class:`bool`, default=False
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        max_attempts: int = 3,
+        get_result_interval: float = 1.0,
+        use_blob_data: bool = False
+    ) -> None:
+        self.api_key = api_key
+        self.get_result_interval = get_result_interval
+        self.max_attempts = max_attempts
+        self.use_blob_data = use_blob_data
+
+    def create_task(self, task_data: dict) -> dict:
+        data = {
+            'clientKey': self.api_key,
+            'task': task_data
+        }
+        response = httpx.post(
+            'https://api.capsolver.com/createTask',
+            json=data,
+            headers={'content-type': 'application/json'}
+        ).json()
+        return response
+
+    def get_task_result(self, task_id: str) -> dict:
+        data = {
+            'clientKey': self.api_key,
+            'taskId': task_id
+        }
+        response = httpx.post(
+            'https://api.capsolver.com/getTaskResult',
+            json=data,
+            headers={'content-type': 'application/json'}
+        ).json()
+        return response
+
+    def solve_funcaptcha(self, blob: str) -> dict:
+        if self.client.proxy is None:
+            captcha_type = 'FunCaptchaTaskProxyLess'
+        else:
+            captcha_type = 'FunCaptchaTask'
+
+        task_data = {
+            'type': captcha_type,
+            'websiteURL': 'https://iframe.arkoselabs.com',
+            'websitePublicKey': self.CAPTCHA_SITE_KEY,
+            'funcaptchaApiJSSubdomain': 'https://client-api.arkoselabs.com',
+            'proxy': self.client.proxy
+        }
+        if self.use_blob_data:
+            task_data['data'] = '{"blob":"%s"}' % blob
+            task_data['userAgent'] = self.client._user_agent
+        task = self.create_task(task_data)
+        while True:
+            sleep(self.get_result_interval)
+            result = self.get_task_result(task['taskId'])
+            if result['status'] in ('ready', 'failed'):
+                return result

xselfbot/bookmark.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from httpx import Response
+
+    from .client.client import Client
+    from .tweet import Tweet
+    from .utils import Result
+
+
+class BookmarkFolder:
+    """
+    Attributes
+    ----------
+    id : :class:`str`
+        The ID of the folder.
+    name : :class:`str`
+        The name of the folder
+    media : :class:`str`
+        Icon image data.
+    """
+    def __init__(self, client: Client, data: dict) -> None:
+        self._client = client
+
+        self.id: str = data['id']
+        self.name: str = data['name']
+        self.media: dict = data['media']
+
+    async def get_tweets(self, cursor: str | None = None) -> Result[Tweet]:
+        """
+        Retrieves tweets from the folder.
+        """
+        return await self._client.get_bookmarks(
+            cursor=cursor, folder_id=self.id
+        )
+
+    async def edit(self, name: str) -> BookmarkFolder:
+        """
+        Edits the folder.
+        """
+        return await self._client.edit_bookmark_folder(self.id, name)
+
+    async def delete(self) -> Response:
+        """
+        Deletes the folder.
+        """
+        return await self._client.delete_bookmark_folder(self.id)
+
+    async def add(self, tweet_id: str) -> Response:
+        """
+        Adds a tweet to the folder.
+        """
+        return await self._client.bookmark_tweet(tweet_id, self.id)
+
+    def __eq__(self, __value: object) -> bool:
+        return isinstance(__value, BookmarkFolder) and self.id == __value.id
+
+    def __ne__(self, __value: object) -> bool:
+        return not self == __value
+
+    def __repr__(self) -> str:
+        return f'<BookmarkFolder id="{self.id}">'