python-rucaptcha 6.3.2__tar.gz → 6.5.0__tar.gz

{python_rucaptcha-6.3.2 → python_rucaptcha-6.5.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Andrei
+Copyright (c) 2025 Andrei
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{python_rucaptcha-6.3.2/src/python_rucaptcha.egg-info → python_rucaptcha-6.5.0}/PKG-INFO

@@ -1,17 +1,15 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: python-rucaptcha
-Version: 6.3.2
+Version: 6.5.0
 Summary: Python 3.9+ RuCaptcha library with AIO module.
 Author-email: AndreiDrang <python-captcha@pm.me>
-License: MIT License
+License-Expression: MIT
 Project-URL: Homepage, https://andreidrang.github.io/python-rucaptcha/
 Project-URL: Documentation, https://andreidrang.github.io/python-rucaptcha/
 Project-URL: Repository, https://github.com/AndreiDrang/python-rucaptcha
 Project-URL: Issues, https://github.com/AndreiDrang/python-rucaptcha/issues
 Project-URL: Changelog, https://github.com/AndreiDrang/python-rucaptcha/releases
-Keywords: captcha,rucaptcha,2captcha,deathbycaptcha,recaptcha,geetest,hcaptcha,capypuzzle,rotatecaptcha,funcaptcha,keycaptcha,python3,recaptcha,captcha,security,tencent,atb_captcha,python-library,python-rucaptcha,rucaptcha-client,yandex,turnstile,amazon,amazon_waf,friendly-captcha
-Classifier: License :: OSI Approved :: MIT License
-Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Keywords: captcha,rucaptcha,2captcha,deathbycaptcha,recaptcha,geetest,hcaptcha,capypuzzle,rotatecaptcha,funcaptcha,keycaptcha,python3,recaptcha,captcha,security,tencent,atb_captcha,python-library,python-rucaptcha,rucaptcha-client,yandex,turnstile,amazon,amazon_waf,vk-captcha,fox-captcha,temu-captcha,friendly-captcha
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
@@ -20,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Framework :: AsyncIO
 Classifier: Operating System :: Unix
 Classifier: Operating System :: Microsoft :: Windows
@@ -31,6 +30,7 @@ Requires-Dist: requests>=2.21.0
 Requires-Dist: aiohttp>=3.9.2
 Requires-Dist: msgspec<0.20,>=0.18
 Requires-Dist: tenacity<10,>=8
+Dynamic: license-file
 
 # python-rucaptcha
 

{python_rucaptcha-6.3.2 → python_rucaptcha-6.5.0}/pyproject.toml

@@ -66,12 +66,13 @@ keywords = [    "captcha",
 				"turnstile",
 				"amazon",
 				"amazon_waf",
+				"vk-captcha",
+				"fox-captcha",
+				"temu-captcha",
 				"friendly-captcha"
             ]
-license = {text = "MIT License"}
+license = "MIT"
 classifiers = [
-        "License :: OSI Approved :: MIT License",
-        "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)",
         "Development Status :: 5 - Production/Stable",
         "Programming Language :: Python",
         "Programming Language :: Python :: 3",
@@ -80,6 +81,7 @@ classifiers = [
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
         "Framework :: AsyncIO",
         "Operating System :: Unix",
         "Operating System :: Microsoft :: Windows",

python_rucaptcha-6.5.0/src/python_rucaptcha/__version__.py

@@ -0,0 +1 @@
+__version__ = "6.5.0"

python_rucaptcha-6.5.0/src/python_rucaptcha/captcha_fox.py

@@ -0,0 +1,124 @@
+from .core.base import BaseCaptcha
+from .core.enums import CaptchaFoxEnm
+
+
+class CaptchaFox(BaseCaptcha):
+    def __init__(
+        self,
+        websiteURL: str,
+        websiteKey: str,
+        userAgent: str,
+        proxyType: str,
+        proxyAddress: str,
+        proxyPort: str,
+        *args,
+        **kwargs,
+    ):
+        """
+        The class is used to work with CaptchaFox.
+
+        Args:
+            rucaptcha_key: User API key
+            websiteURL: Full URL of the captcha page
+            websiteKey: The value of the `key` parameter.
+                            It can be found in the page source code or captured in network requests during page loading.
+            userAgent: User-Agent of your browser will be used to load the captcha.
+                            Use only modern browser's User-Agents
+            proxyType: Proxy type - `http`, `socks4`, `socks5`
+            proxyAddress: Proxy IP address or hostname
+            proxyPort: Proxy port
+            method: Captcha type
+            kwargs: Not required params for task creation request
+
+        Examples:
+            >>> CaptchaFox(rucaptcha_key="aa9011f31111181111168611f1151122",
+            ...             websiteURL="3ceb8624-1970-4e6b-91d5-70317b70b651",
+            ...             websiteKey="sk_xtNxpk6fCdFbxh1_xJeGflSdCE9tn99G",
+            ...             userAgent="Mozilla/5.0 .....",
+            ...             proxyType="socks5",
+            ...             proxyAddress="1.2.3.4",
+            ...             proxyPort="445",
+            ...             ).captcha_handler()
+            {
+               "errorId":0,
+               "status":"ready",
+               "solution":{
+                  "token":"142000f.....er"
+               },
+               "cost":"0.002",
+               "ip":"1.2.3.4",
+               "createTime":1692863536,
+               "endTime":1692863556,
+               "solveCount":0,
+               "taskId": 73243152973,
+            }
+
+            >>> await CaptchaFox(rucaptcha_key="aa9011f31111181111168611f1151122",
+            ...             websiteURL="3ceb8624-1970-4e6b-91d5-70317b70b651",
+            ...             websiteKey="sk_xtNxpk6fCdFbxh1_xJeGflSdCE9tn99G",
+            ...             userAgent="Mozilla/5.0 .....",
+            ...             proxyType="socks5",
+            ...             proxyAddress="1.2.3.4",
+            ...             proxyPort="445",
+            ...             ).aio_captcha_handler()
+            {
+               "errorId":0,
+               "status":"ready",
+               "solution":{
+                  "token":"142000f.....er"
+               },
+               "cost":"0.002",
+               "ip":"1.2.3.4",
+               "createTime":1692863536,
+               "endTime":1692863556,
+               "solveCount":0,
+               "taskId": 73243152973,
+            }
+
+        Returns:
+            Dict with full server response
+
+        Notes:
+            https://2captcha.com/api-docs/captchafox
+
+            https://rucaptcha.com/api-docs/captchafox
+        """
+        super().__init__(method=CaptchaFoxEnm.CaptchaFoxTask, *args, **kwargs)
+
+        self.create_task_payload["task"].update(
+            {
+                "websiteURL": websiteURL,
+                "websiteKey": websiteKey,
+                "userAgent": userAgent,
+                "proxyType": proxyType,
+                "proxyAddress": proxyAddress,
+                "proxyPort": proxyPort,
+            }
+        )
+
+    def captcha_handler(self, **kwargs) -> dict:
+        """
+        Sync solving method
+
+        Args:
+            kwargs: additional params for `requests` library
+
+        Returns:
+            Dict with full server response
+
+        Notes:
+            Check class docstirng for more info
+        """
+        return self._processing_response(**kwargs)
+
+    async def aio_captcha_handler(self) -> dict:
+        """
+        Async solving method
+
+        Returns:
+            Dict with full server response
+
+        Notes:
+            Check class docstirng for more info
+        """
+        return await self._aio_processing_response()

{python_rucaptcha-6.3.2 → python_rucaptcha-6.5.0}/src/python_rucaptcha/core/base.py

@@ -3,7 +3,7 @@ import time
 import uuid
 import base64
 import asyncio
-from typing import Optional
+from typing import Any, Optional
 from pathlib import Path
 
 import aiohttp
@@ -30,16 +30,32 @@ class BaseCaptcha:
         rucaptcha_key: str,
         method: str,
         sleep_time: int = 10,
-        service_type: str = ServiceEnm.TWOCAPTCHA.value,
-        **kwargs,
+        service_type: ServiceEnm | str = ServiceEnm.TWOCAPTCHA,
+        **kwargs: dict[str, Any],
     ):
         """
-        :param rucaptcha_key: User API key
-        :param method: Captcha type
-        :param sleep_time: Time to wait for captcha solution
-        :param service_type: URL with which the program will work, "2captcha" option is possible (standard)
-                              and "rucaptcha"
-        :param kwargs: Designed to pass OPTIONAL parameters to the payload for a request to RuCaptcha
+        Base class for interacting with CAPTCHA-solving services such as 2Captcha and RuCaptcha.
+
+        This class handles the setup of request payloads, session configuration, and service-specific
+        parameters required to submit CAPTCHA tasks and retrieve their results. It supports optional
+        customization of task parameters via keyword arguments and includes retry logic for HTTP requests.
+
+        Args:
+            rucaptcha_key (str):
+                API key provided by the CAPTCHA-solving service.
+            method (str):
+                Type of CAPTCHA to solve (e.g., "ImageToText", "ReCaptchaV2").
+            sleep_time (int, optional):
+                Time in seconds to wait between polling attempts. Defaults to 10.
+            service_type (ServiceEnm | str, optional):
+                Service provider to use. Accepts `ServiceEnm.TWOCAPTCHA` or `"rucaptcha"`. Defaults to TWOCAPTCHA.
+            **kwargs (dict[str, Any]):
+                Optional parameters to be injected into the task payload (e.g., `websiteURL`, `siteKey`, `proxy`).
+
+        Example:
+            >>> captcha = BaseCaptcha("your-api-key", method="ReCaptchaV2", websiteURL="https://example.com", siteKey="abc123")
+            >>> captcha.create_task_payload
+            {'clientKey': 'your-api-key', 'task': {'type': 'ReCaptchaV2', 'websiteURL': 'https://example.com', 'siteKey': 'abc123'}}
         """
         self.result = GetTaskResultResponseSer()
         # assign args to validator
@@ -48,7 +64,7 @@ class BaseCaptcha:
 
         # prepare create task payload
         self.create_task_payload = CreateTaskBaseSer(
-            clientKey=rucaptcha_key, task=TaskSer(type=method).to_dict()
+            clientKey=rucaptcha_key, task=TaskSer(type=method)
         ).to_dict()
         # prepare get task result data payload
         self.get_task_payload = GetTaskResultRequestSer(clientKey=rucaptcha_key)
@@ -61,7 +77,7 @@ class BaseCaptcha:
         self.session.mount("http://", HTTPAdapter(max_retries=RETRIES))
         self.session.mount("https://", HTTPAdapter(max_retries=RETRIES))
 
-    def _processing_response(self, **kwargs: dict) -> dict:
+    def _processing_response(self, **kwargs: dict[str, Any]) -> dict[str, Any]:
         """
         Method processing captcha solving task creation result
         :param kwargs: additional params for Requests library
@@ -90,13 +106,13 @@ class BaseCaptcha:
             url_response=self.params.url_response,
         )
 
-    def url_open(self, url: str, **kwargs):
+    def url_open(self, url: str, **kwargs: dict[str, Any]):
         """
         Method open links
         """
         return self.session.get(url=url, **kwargs)
 
-    async def aio_url_read(self, url: str, **kwargs) -> bytes:
+    async def aio_url_read(self, url: str, **kwargs: dict[str, Any]) -> bytes | None:
         """
         Async method read bytes from link
         """
@@ -106,7 +122,7 @@ class BaseCaptcha:
                     async with session.get(url=url, **kwargs) as resp:
                         return await resp.content.read()
 
-    async def _aio_processing_response(self) -> dict:
+    async def _aio_processing_response(self) -> dict[str, Any]:
         """
         Method processing async captcha solving task creation result
         """
@@ -167,23 +183,24 @@ class BaseCaptcha:
 
     def _body_file_processing(
         self,
-        save_format: SaveFormatsEnm,
+        save_format: SaveFormatsEnm | str,
         file_path: str,
         file_extension: str = "png",
-        captcha_link: Optional[str] = None,
-        captcha_file: Optional[str] = None,
-        captcha_base64: Optional[bytes] = None,
-        **kwargs,
+        image_key: str = "body",
+        captcha_link: str | None = None,
+        captcha_file: str | None = None,
+        captcha_base64: bytes | None = None,
+        **kwargs: dict[str, Any],
     ):
         # if a local file link is passed
         if captcha_file:
             self.create_task_payload["task"].update(
-                {"body": base64.b64encode(self._local_file_captcha(captcha_file)).decode("utf-8")}
+                {image_key: base64.b64encode(self._local_file_captcha(captcha_file)).decode("utf-8")}
             )
         # if the file is transferred in base64 encoding
         elif captcha_base64:
             self.create_task_payload["task"].update(
-                {"body": base64.b64encode(captcha_base64).decode("utf-8")}
+                {image_key: base64.b64encode(captcha_base64).decode("utf-8")}
             )
         # if a URL is passed
         elif captcha_link:
@@ -192,7 +209,9 @@ class BaseCaptcha:
                 # according to the value of the passed parameter, select the function to save the image
                 if save_format == SaveFormatsEnm.CONST.value:
                     self._file_const_saver(content, file_path, file_extension=file_extension)
-                self.create_task_payload["task"].update({"body": base64.b64encode(content).decode("utf-8")})
+                self.create_task_payload["task"].update(
+                    {image_key: base64.b64encode(content).decode("utf-8")}
+                )
             except Exception as error:
                 self.result.errorId = 12
                 self.result.errorCode = self.NO_CAPTCHA_ERR
@@ -204,23 +223,24 @@ class BaseCaptcha:
 
     async def _aio_body_file_processing(
         self,
-        save_format: SaveFormatsEnm,
+        save_format: SaveFormatsEnm | str,
         file_path: str,
         file_extension: str = "png",
+        image_key: str = "body",
         captcha_link: Optional[str] = None,
         captcha_file: Optional[str] = None,
         captcha_base64: Optional[bytes] = None,
-        **kwargs,
+        **kwargs: dict[str, Any],
     ):
         # if a local file link is passed
         if captcha_file:
             self.create_task_payload["task"].update(
-                {"body": base64.b64encode(self._local_file_captcha(captcha_file)).decode("utf-8")}
+                {image_key: base64.b64encode(self._local_file_captcha(captcha_file)).decode("utf-8")}
             )
         # if the file is transferred in base64 encoding
         elif captcha_base64:
             self.create_task_payload["task"].update(
-                {"body": base64.b64encode(captcha_base64).decode("utf-8")}
+                {image_key: base64.b64encode(captcha_base64).decode("utf-8")}
             )
         # if a URL is passed
         elif captcha_link:
@@ -229,7 +249,9 @@ class BaseCaptcha:
                 # according to the value of the passed parameter, select the function to save the image
                 if save_format == SaveFormatsEnm.CONST.value:
                     self._file_const_saver(content, file_path, file_extension=file_extension)
-                self.create_task_payload["task"].update({"body": base64.b64encode(content).decode("utf-8")})
+                self.create_task_payload["task"].update(
+                    {image_key: base64.b64encode(content).decode("utf-8")}
+                )
             except Exception as error:
                 self.result.errorId = 12
                 self.result.errorCode = self.NO_CAPTCHA_ERR

{python_rucaptcha-6.3.2 → python_rucaptcha-6.5.0}/src/python_rucaptcha/core/config.py

@@ -1,3 +1,5 @@
+from typing import Generator
+
 from tenacity import AsyncRetrying, wait_fixed, stop_after_attempt
 from requests.adapters import Retry
 
@@ -8,7 +10,7 @@ APP_KEY = "1899"
 
 
 # Connection retry generator
-def attempts_generator(amount: int = 20):
+def attempts_generator(amount: int = 20) -> Generator[int, None, None]:
     """
     Function generates a generator of length equal to `amount`
 

{python_rucaptcha-6.3.2 → python_rucaptcha-6.5.0}/src/python_rucaptcha/core/enums.py

@@ -164,3 +164,15 @@ class atbCaptchaEnm(str, MyEnum):
 class ProsopoEnm(str, MyEnum):
     ProsopoTask = "ProsopoTask"
     ProsopoTaskProxyless = "ProsopoTaskProxyless "
+
+
+class CaptchaFoxEnm(str, MyEnum):
+    CaptchaFoxTask = "CaptchaFoxTask"
+
+
+class VKCaptchaEnm(str, MyEnum):
+    VKCaptchaTask = "VKCaptchaTask"
+
+
+class TemuCaptchaEnm(str, MyEnum):
+    TemuCaptchaTask = "TemuCaptchaTask"

python_rucaptcha-6.5.0/src/python_rucaptcha/core/result_handler.py

@@ -0,0 +1,116 @@
+import time
+import asyncio
+import logging
+from typing import Any
+
+import aiohttp
+import requests
+
+from .config import attempts_generator
+from .serializer import GetTaskResultRequestSer, GetTaskResultResponseSer
+
+
+def get_sync_result(
+    get_payload: GetTaskResultRequestSer, sleep_time: int, url_response: str
+) -> dict[str, str]:
+    """
+    Periodically sends a synchronous request to a remote service to retrieve the result
+    of a CAPTCHA-solving task.
+
+    This function polls the service using blocking HTTP requests until the CAPTCHA is solved,
+    an error is returned, or the task times out. It handles intermediate states and retries
+    with a configurable sleep interval between attempts.
+
+    Args:
+        get_payload (GetTaskResultRequestSer):
+            Serialized request object containing the task ID and payload data.
+        sleep_time (int):
+            Time in seconds to wait between polling attempts when the task is still processing.
+        url_response (str):
+            Endpoint URL to query for the CAPTCHA-solving result.
+
+    Returns:
+        dict[str, str]:
+            A dictionary containing the final task result. If the task fails or an exception
+            occurs, the dictionary includes error details such as status, errorId, errorCode,
+            and errorDescription.
+    """
+    logging.warning(f"{url_response = }")
+    response_ser = GetTaskResultResponseSer(taskId=get_payload.taskId)
+    # generator for repeated attempts to connect to the server
+    attempts = attempts_generator()
+    for _ in attempts:
+        try:
+            # send a request for the result of solving the captcha
+            result: dict[str, Any] = requests.post(url_response, json=get_payload.to_dict()).json()
+            logging.info(f"Received captcha sync result - {result = }")
+            response_ser = GetTaskResultResponseSer(**result, taskId=get_payload.taskId)
+            # if the captcha has not been resolved yet, wait
+            if response_ser.status == "processing":
+                time.sleep(sleep_time)
+                continue
+            elif response_ser.status == "ready":
+                break
+            elif response_ser.errorId != 0:
+                return response_ser.to_dict()
+        except Exception as error:
+            response_ser.status = "failed"
+            response_ser.errorId = 12
+            response_ser.errorCode = "System error"
+            response_ser.errorDescription = str(error)
+    return response_ser.to_dict()
+
+
+async def get_async_result(
+    get_payload: GetTaskResultRequestSer, sleep_time: int, url_response: str
+) -> dict[str, str]:
+    """
+    Periodically sends an asynchronous request to a remote service to retrieve the result
+    of a CAPTCHA-solving task.
+
+    This function polls the service at regular intervals until the CAPTCHA is solved,
+    an error occurs, or the task times out. It uses aiohttp for asynchronous HTTP requests
+    and handles various response states including 'processing', 'ready', and error conditions.
+
+    Args:
+        get_payload (GetTaskResultRequestSer):
+            Serialized request object containing the task ID and payload data.
+        sleep_time (int):
+            Time in seconds to wait between polling attempts when the task is still processing.
+        url_response (str):
+            Endpoint URL to query for the CAPTCHA-solving result.
+
+    Returns:
+        dict[str, str]:
+            A dictionary containing the final task result if successful or partially failed.
+            If an exception occurs during the request, returns a dictionary with error details
+            including status, errorId, errorCode, and errorDescription.
+    """
+    response_ser = GetTaskResultResponseSer(taskId=get_payload.taskId)
+    # generator for repeated attempts to connect to the server
+    attempts = attempts_generator()
+    async with aiohttp.ClientSession() as session:
+        for _ in attempts:
+            try:
+                # send a request for the result of solving the captcha
+                async with session.post(
+                    url_response, json=get_payload.to_dict(), raise_for_status=True
+                ) as resp:
+                    result: dict[str, Any] = await resp.json(content_type=None)
+                    logging.info(f"Received captcha async result - {result = }")
+                    response_ser = GetTaskResultResponseSer(**result, taskId=get_payload.taskId)
+
+                    # if the captcha has not been resolved yet, wait
+                    if response_ser.status == "processing":
+                        await asyncio.sleep(sleep_time)
+                        continue
+                    elif response_ser.status == "ready":
+                        break
+                    elif response_ser.errorId != 0:
+                        return response_ser.to_dict()
+            except Exception as error:
+                response_ser.status = "failed"
+                response_ser.errorId = 12
+                response_ser.errorCode = "System error"
+                response_ser.errorDescription = str(error)
+    return response_ser.to_dict()

python_rucaptcha-6.5.0/src/python_rucaptcha/core/serializer.py

@@ -0,0 +1,98 @@
+from typing import Any, Literal
+from decimal import Decimal
+from datetime import date, datetime
+
+from msgspec import Struct
+
+from . import enums
+from .config import APP_KEY
+
+
+class MyBaseModel(Struct):
+    def to_dict(self) -> dict[str, Any]:
+        result = {}
+        for field in self.__struct_fields__:
+            value = getattr(self, field)
+
+            if isinstance(value, MyBaseModel):
+                result[field] = value.to_dict()
+
+            elif isinstance(value, (list, tuple)) and all(isinstance(el, Struct) for el in value):
+                result[field] = [el.to_dict() for el in value]
+
+            elif isinstance(value, (date, datetime)):
+                result[field] = value.isoformat()
+
+            elif isinstance(value, Decimal):
+                result[field] = str(value)
+
+            else:
+                result[field] = value
+
+        return result
+
+
+"""
+HTTP API Serializers
+"""
+
+
+class TaskSer(MyBaseModel):
+    type: str
+
+
+class CreateTaskBaseSer(MyBaseModel):
+    clientKey: str
+    task: TaskSer
+    languagePool: str = "en"
+    callbackUrl: str | None = None
+    soft_id: Literal[APP_KEY] = APP_KEY
+
+
+class GetTaskResultRequestSer(MyBaseModel):
+    clientKey: str
+    taskId: int | None = None
+
+
+class CaptchaOptionsSer(MyBaseModel):
+    sleep_time: int = 10
+    service_type: enums.ServiceEnm | str = enums.ServiceEnm.TWOCAPTCHA
+
+    url_request: str = f"http://api.{enums.ServiceEnm.TWOCAPTCHA.value}.com/2captcha/in.php"
+    url_response: str = f"http://api.{enums.ServiceEnm.TWOCAPTCHA.value}.com/2captcha/res.php"
+
+    def urls_set(self):
+        """
+        Set request/response URLs if they not set previously
+        """
+        if isinstance(self.service_type, enums.ServiceEnm):
+            self.service_type = self.service_type.value
+
+        if self.service_type == enums.ServiceEnm.DEATHBYCAPTCHA:
+            self.url_request = f"http://api.{self.service_type}.com/2captcha/in.php"
+            self.url_response = f"http://api.{self.service_type}.com/2captcha/res.php"
+        else:
+            self.url_request = f"https://api.{self.service_type}.com/createTask"
+            self.url_response = f"https://api.{self.service_type}.com/getTaskResult"
+
+
+"""
+HTTP API Response
+"""
+
+
+class GetTaskResultResponseSer(MyBaseModel):
+    status: str = "ready"
+    solution: dict[str, str] | None = None
+    cost: float = 0.0
+    ip: str | None = None
+    createTime: int | None = None
+    endTime: int | None = None
+    solveCount: int | None = None
+    taskId: int | None = None
+    # control method params
+    balance: float | None = None
+    # error info
+    errorId: int = 0
+    errorCode: str | None = None
+    errorDescription: str | None = None

{python_rucaptcha-6.3.2 → python_rucaptcha-6.5.0}/src/python_rucaptcha/datadome_captcha.py

@@ -34,7 +34,7 @@ class DataDomeCaptcha(BaseCaptcha):
             >>> DataDomeCaptcha(rucaptcha_key="aa9011f31111181111168611f1151122",
             ...             websiteURL="3ceb8624-1970-4e6b-91d5-70317b70b651",
             ...             captchaUrl="https://rucaptcha.com/demo/hcaptcha",
-            ...             userAgent="https://rucaptcha.com/demo/hcaptcha",
+            ...             userAgent="Mozilla/5.0 .....",
             ...             proxyType="socks5",
             ...             proxyAddress="1.2.3.4",
             ...             proxyPort="445",
@@ -56,7 +56,7 @@ class DataDomeCaptcha(BaseCaptcha):
             >>> await DataDomeCaptcha(rucaptcha_key="aa9011f31111181111168611f1151122",
             ...             websiteURL="3ceb8624-1970-4e6b-91d5-70317b70b651",
             ...             captchaUrl="https://rucaptcha.com/demo/hcaptcha",
-            ...             userAgent="https://rucaptcha.com/demo/hcaptcha",
+            ...             userAgent="Mozilla/5.0 .....",
             ...             proxyType="socks5",
             ...             proxyAddress="1.2.3.4",
             ...             proxyPort="445",

{python_rucaptcha-6.3.2 → python_rucaptcha-6.5.0}/src/python_rucaptcha/image_captcha.py

@@ -1,5 +1,5 @@
 import shutil
-from typing import Union, Optional
+from typing import Any, Union, Optional
 
 from .core.base import BaseCaptcha
 from .core.enums import SaveFormatsEnm, ImageCaptchaEnm
@@ -181,8 +181,8 @@ class ImageCaptcha(BaseCaptcha):
         captcha_link: Optional[str] = None,
         captcha_file: Optional[str] = None,
         captcha_base64: Optional[bytes] = None,
-        **kwargs,
-    ) -> dict:
+        **kwargs: dict[str, Any],
+    ) -> dict[str, Any]:
         """
         Sync solving method
 
@@ -215,8 +215,8 @@ class ImageCaptcha(BaseCaptcha):
         captcha_link: Optional[str] = None,
         captcha_file: Optional[str] = None,
         captcha_base64: Optional[bytes] = None,
-        **kwargs,
-    ) -> dict:
+        **kwargs: dict[str, Any],
+    ) -> dict[str, Any]:
         """
         Async solving method