python-rucaptcha 6.3.2__py3-none-any.whl → 6.5.0__py3-none-any.whl

python_rucaptcha/__version__.py

@@ -1 +1 @@
-__version__ = "6.3.2"
+__version__ = "6.5.0"

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/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/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/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/core/result_handler.py

@@ -1,7 +1,7 @@
 import time
 import asyncio
 import logging
-from typing import Union
+from typing import Any
 
 import aiohttp
 import requests
@@ -12,38 +12,81 @@ from .serializer import GetTaskResultRequestSer, GetTaskResultResponseSer
 
 def get_sync_result(
     get_payload: GetTaskResultRequestSer, sleep_time: int, url_response: str
-) -> Union[dict, Exception]:
+) -> dict[str, str]:
     """
-    Function periodically send the SYNC request to service and wait for captcha solving result
+    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
-            captcha_response = GetTaskResultResponseSer(
-                **requests.post(url_response, json=get_payload.to_dict()).json(), taskId=get_payload.taskId
-            )
-            logging.warning(f"{captcha_response = }")
+            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 captcha_response.status == "processing":
+            if response_ser.status == "processing":
                 time.sleep(sleep_time)
                 continue
-            elif captcha_response.status == "ready":
+            elif response_ser.status == "ready":
                 break
-            elif captcha_response.errorId != 0:
-                return captcha_response.to_dict()
+            elif response_ser.errorId != 0:
+                return response_ser.to_dict()
         except Exception as error:
-            return error
-    return captcha_response.to_dict()
+            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
-) -> Union[dict, Exception]:
+) -> dict[str, str]:
     """
-    Function periodically send the ASYNC request to service and wait for captcha solving result
+    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:
@@ -53,17 +96,21 @@ async def get_async_result(
                 async with session.post(
                     url_response, json=get_payload.to_dict(), raise_for_status=True
                 ) as resp:
-                    captcha_response = await resp.json(content_type=None)
-                    captcha_response = GetTaskResultResponseSer(**captcha_response, taskId=get_payload.taskId)
+                    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 captcha_response.status == "processing":
+                    if response_ser.status == "processing":
                         await asyncio.sleep(sleep_time)
                         continue
-                    elif captcha_response.status == "ready":
+                    elif response_ser.status == "ready":
                         break
-                    elif captcha_response.errorId != 0:
-                        return captcha_response.to_dict()
+                    elif response_ser.errorId != 0:
+                        return response_ser.to_dict()
             except Exception as error:
-                return error
-    return captcha_response.to_dict()
+                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/core/serializer.py

@@ -1,4 +1,6 @@
-from typing import Literal, Optional
+from typing import Any, Literal
+from decimal import Decimal
+from datetime import date, datetime
 
 from msgspec import Struct
 
@@ -7,8 +9,27 @@ from .config import APP_KEY
 
 
 class MyBaseModel(Struct):
-    def to_dict(self):
-        return {f: getattr(self, f) for f in self.__struct_fields__}
+    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
 
 
 """
@@ -22,28 +43,31 @@ class TaskSer(MyBaseModel):
 
 class CreateTaskBaseSer(MyBaseModel):
     clientKey: str
-    task: TaskSer = {}
+    task: TaskSer
     languagePool: str = "en"
-    callbackUrl: str = None
+    callbackUrl: str | None = None
     soft_id: Literal[APP_KEY] = APP_KEY
 
 
 class GetTaskResultRequestSer(MyBaseModel):
     clientKey: str
-    taskId: int = None
+    taskId: int | None = None
 
 
 class CaptchaOptionsSer(MyBaseModel):
     sleep_time: int = 10
-    service_type: enums.ServiceEnm = enums.ServiceEnm.TWOCAPTCHA.value
+    service_type: enums.ServiceEnm | str = enums.ServiceEnm.TWOCAPTCHA
 
-    url_request: Optional[str] = None
-    url_response: Optional[str] = None
+    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"
@@ -59,16 +83,16 @@ HTTP API Response
 
 class GetTaskResultResponseSer(MyBaseModel):
     status: str = "ready"
-    solution: dict = None
-    cost: float = None
-    ip: str = None
-    createTime: int = None
-    endTime: int = None
-    solveCount: int = None
-    taskId: int = None
+    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
+    balance: float | None = None
     # error info
     errorId: int = 0
-    errorCode: str = None
-    errorDescription: str = None
+    errorCode: str | None = None
+    errorDescription: str | None = None

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/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
 

python_rucaptcha/temu_captcha.py

@@ -0,0 +1,152 @@
+import shutil
+from typing import Any, Union
+
+from .core.base import BaseCaptcha
+from .core.enums import SaveFormatsEnm, TemuCaptchaEnm
+
+
+class TemuCaptcha(BaseCaptcha):
+    def __init__(
+        self,
+        save_format: Union[str, SaveFormatsEnm] = SaveFormatsEnm.TEMP,
+        img_clearing: bool = True,
+        img_path: str = "PythonRuCaptchaImages",
+        *args,
+        **kwargs: dict[str, Any],
+    ):
+        """
+        Solve TemuImageTask CAPTCHA via 2Captcha/RuCaptcha API.
+
+        This class creates and monitors TemuImageTask jobs, which require
+        a base64‐encoded background image plus an array of movable image
+        pieces (parts) in base64 format.  It extends BaseCaptcha to handle
+        the low‐level request/response workflow.
+
+        Args:
+            save_format (str | SaveFormatsEnm): Where to save temporary images.
+                - SaveFormatsEnm.TEMP: use system temp directory
+                - SaveFormatsEnm.CONST: keep files in img_path until deletion
+            img_clearing (bool): If True and save_format is CONST, delete the
+                img_path directory when this instance is destroyed.
+            img_path (str): Directory under which to store downloaded or decoded
+                images before sending to the API.
+            *args: Positional args forwarded to BaseCaptcha constructor (e.g.
+                client_key, method override).
+            **kwargs: Keyword args forwarded to BaseCaptcha for task creation.
+                Common params include:
+                - redirectUri: URL to confirm CAPTCHA resolution
+                - any other API‐supported parameters
+
+        Examples:
+            >>> captcha = TemuCaptcha(rucaptcha_key="YOUR_API_KEY")
+            >>> response = captcha.captcha_handler(
+            ...     parts=["part1_b64", "part2_b64", "part3_b64"],
+            ...     captcha_base64=b"full_image_b64"
+            ... )
+            >>> print(response)
+            {
+                "errorId": 0,
+                "status": "ready",
+                "solution": {
+                    "coordinates": [{"x":155,"y":358}, {"x":152,"y":153}, {"x":251,"y":333}]
+                },
+                "cost": "0.0012",
+                "createTime": 1754563182,
+                "endTime": 1754563190,
+                "taskId": 80306543329,
+                "ip": "46.53.232.76",
+                "solveCount": 1
+            }
+
+        Notes:
+            https://2captcha.com/api-docs/temu-captcha
+
+            https://rucaptcha.com/api-docs/temu-captcha
+        """
+        super().__init__(method=TemuCaptchaEnm.TemuCaptchaTask, *args, **kwargs)
+
+        self.save_format = save_format
+        self.img_clearing = img_clearing
+        self.img_path = img_path
+
+    def captcha_handler(
+        self,
+        parts: list[str],
+        captcha_link: str | None = None,
+        captcha_file: str | None = None,
+        captcha_base64: bytes | None = None,
+        **kwargs: dict[str, Any],
+    ) -> dict[str, Any]:
+        """
+        Synchronously solve a TemuImageTask.
+
+        Args:
+            parts (list[str]): List of base64‐encoded strings for each
+                movable image piece.
+            captcha_link (str | None): URL to background image. Overrides
+                captcha_file and captcha_base64 if provided.
+            captcha_file (str | None): Path to an image file to read & send.
+            captcha_base64 (bytes | None): Raw bytes or base64 string of
+                the background image.
+            **kwargs: Passed through to the HTTP request call (e.g. timeout,
+                headers).
+
+        Returns:
+            dict[str, Any]: Full JSON response from the 2Captcha/RuCaptcha API,
+                including errorId, taskId, status, solution, cost, times, etc.
+        """
+        self.create_task_payload["task"].update({"parts": parts})
+        self._body_file_processing(
+            save_format=self.save_format,
+            file_path=self.img_path,
+            captcha_link=captcha_link,
+            captcha_file=captcha_file,
+            captcha_base64=captcha_base64,
+            image_key="image",
+            **kwargs,
+        )
+        if not self.result.errorId:
+            return self._processing_response(**kwargs)
+        return self.result.to_dict()
+
+    async def aio_captcha_handler(
+        self,
+        parts: list[str],
+        captcha_link: str | None = None,
+        captcha_file: str | None = None,
+        captcha_base64: bytes | None = None,
+    ) -> dict[str, Any]:
+        """
+        Asynchronously solve a TemuImageTask.
+
+        Args:
+            parts (list[str]): List of base64‐encoded strings for each
+                movable image piece.
+            captcha_link (str | None): URL to background image.
+            captcha_file (str | None): Path to an image file to read & send.
+            captcha_base64 (bytes | None): Raw bytes or base64 string of image.
+            **kwargs: Passed through to the async HTTP request call.
+
+        Returns:
+            dict[str, Any]: API response containing task status and solution.
+        """
+        self.create_task_payload["task"].update({"parts": parts})
+        await self._aio_body_file_processing(
+            save_format=self.save_format,
+            file_path=self.img_path,
+            captcha_link=captcha_link,
+            captcha_file=captcha_file,
+            captcha_base64=captcha_base64,
+            image_key="image",
+            **kwargs,
+        )
+        if not self.result.errorId:
+            return await self._aio_processing_response()
+        return self.result.to_dict()
+
+    def __del__(self):
+        """
+        Cleanup saved images folder if configured to do so.
+        """
+        if self.save_format == SaveFormatsEnm.CONST.value and self.img_clearing:
+            shutil.rmtree(self.img_path)

python_rucaptcha/vk_captcha.py

@@ -0,0 +1,120 @@
+from typing import Any
+
+from .core.base import BaseCaptcha
+from .core.enums import VKCaptchaEnm
+
+
+class VKCaptcha(BaseCaptcha):
+    def __init__(
+        self,
+        redirectUri: str,
+        userAgent: str,
+        proxyType: str,
+        proxyAddress: str,
+        proxyPort: str,
+        *args,
+        **kwargs: dict[str, Any],
+    ):
+        """
+        The class is used to work with VKCaptchaTask.
+
+        Args:
+            rucaptcha_key: User API key
+            redirectUri: The URL that is returned on requests to the captcha API.
+            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:
+            >>> VKCaptcha(rucaptcha_key="aa9011f31111181111168611f1151122",
+            ...             redirectUri="https://id.vk.com/not_robot_captcha?domain=vk.com...",
+            ...             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 VKCaptcha(rucaptcha_key="aa9011f31111181111168611f1151122",
+            ...             redirectUri="https://id.vk.com/not_robot_captcha?domain=vk.com...",
+            ...             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/vk-captcha
+
+            https://rucaptcha.com/api-docs/vk-captcha
+        """
+        super().__init__(method=VKCaptchaEnm.VKCaptchaTask, *args, **kwargs)
+
+        self.create_task_payload["task"].update(
+            {
+                "websiteURL": redirectUri,
+                "userAgent": userAgent,
+                "proxyType": proxyType,
+                "proxyAddress": proxyAddress,
+                "proxyPort": proxyPort,
+            }
+        )
+
+    def captcha_handler(self, **kwargs: dict[str, Any]) -> dict[str, Any]:
+        """
+        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[str, Any]:
+        """
+        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.dist-info → python_rucaptcha-6.5.0.dist-info}/METADATA

@@ -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.dist-info → python_rucaptcha-6.5.0.dist-info}/RECORD

@@ -1,39 +1,42 @@
 python_rucaptcha/__init__.py,sha256=odkQWtwx2RgIjD8pw2ZF-KR-5nL0Yu2Wn7Mu2YdBrSk,61
-python_rucaptcha/__version__.py,sha256=OKZjcwD69U3MrIvrJgcMdYy2P_EAc5PTibD6foeyE_E,22
+python_rucaptcha/__version__.py,sha256=gp-lLlwFu2zSdoW-9KJF20SpGpKvzbNC2pWwy2d56R0,22
 python_rucaptcha/amazon_waf.py,sha256=psEg-sym8xQlMPPto1ND_HE0vGV_SRRrDnsKuEbbxNA,3625
 python_rucaptcha/atb_captcha.py,sha256=FuGG9MKTy7f_Sku7WQLZ7TCZ1ISFnu_0h4I3_Qri8JQ,3724
 python_rucaptcha/audio_captcha.py,sha256=Bp6-gF3cTnYL8aeY8k4D4Ii7zPqy1Qo2OFRooSEd0MQ,5600
 python_rucaptcha/bounding_box_captcha.py,sha256=JvJEU1Y0A1SVkJV9jEFgBQ7Nis-vFkTmfUBoHIeTinY,10648
+python_rucaptcha/captcha_fox.py,sha256=sm2cusbBYeOtMMZmZn51o0rtX8SQzPR_6oYmUSVWTCc,4101
 python_rucaptcha/capy_puzzle.py,sha256=ITr1HNALlaKtBkrBht2QtEtP-u6K4-JXpDKKwih7RhA,4973
 python_rucaptcha/control.py,sha256=1KnPaUOVEU7DY6x9-CJvuyV8nFapBcxGRfE9y3dprTo,4993
 python_rucaptcha/coordinates_captcha.py,sha256=lmotaD_dOzo2T9MdcaOgQdB5opL-Hs-ZVUW5nTy-KJ0,9911
 python_rucaptcha/cutcaptcha.py,sha256=glhvQe8Q35ap7J5dyD7hcXkcswG27fkJpYsvyIoTTRg,4050
 python_rucaptcha/cyber_siara_captcha.py,sha256=P8oLkn3UZDuy3XjEyd59cK2QOHYesV6KQ5pMbw2deiA,3909
-python_rucaptcha/datadome_captcha.py,sha256=6ab7vDjYjUT4X_H5VJuAcuGtfUcBidzY-5vo7YH4lWY,4196
+python_rucaptcha/datadome_captcha.py,sha256=lM-zITgqsBS9F4hlkZgkRJjHT8rLct6Yb9FmFIUDpOA,4160
 python_rucaptcha/draw_around_captcha.py,sha256=uUaVk--31p0xh6sqTxtRdtxl0F4ZQ9KeESpmqY1WPR0,11837
 python_rucaptcha/friendly_captcha.py,sha256=c5sbhAHq5zPlk2-5gGcoPhjslEkBT24EtFip2S8cGao,4232
 python_rucaptcha/fun_captcha.py,sha256=iU_twFRGKjeQPPBXfcqEK0d0kffNaCxPpHrihzBRg5w,3518
 python_rucaptcha/gee_test.py,sha256=lxhqWm2uWWS_uQK5ufArjr-508pfecDYAEh4Ct-FthI,8583
 python_rucaptcha/grid_captcha.py,sha256=ssfl1BnBzxR1CHGdnjEG4wunTvEk9NvGIoiXQWHrt20,9001
 python_rucaptcha/hcaptcha.py,sha256=7i0S7A4LvBePUgVsCGpay8733Ve2rzjiZcR-CMTwa8s,3732
-python_rucaptcha/image_captcha.py,sha256=jWTO-kLSKXG12koO2X9dsFXCr3OjvXgj2aNJyhSomf4,8391
+python_rucaptcha/image_captcha.py,sha256=mSLmqAbN2hO47FA-lm4q7PNakBKeEv1-Yt6jDF_q9-s,8448
 python_rucaptcha/key_captcha.py,sha256=hufzqYEb3ZR23AsLWIL82HFTJnA8JsOJtXUA92b9tws,4017
 python_rucaptcha/lemin_captcha.py,sha256=inEq-UWUbMX9aZdpyZBGRER-67YCS3PqxnDIpPAzmqM,4086
 python_rucaptcha/mt_captcha.py,sha256=usQK_LR9piDQM7lxkZbSKi6KIXedIBYyytKJBJe8jNg,3415
 python_rucaptcha/prosopo.py,sha256=kZLn_iZsm1mzQ8pNuPAzbfNfH8UBnLg1iy996Ti3nMo,3516
 python_rucaptcha/re_captcha.py,sha256=XyJncVbmaV5jZR-qxZ1JdFum10W5yk5zeVrDbZ5dSKo,6083
 python_rucaptcha/rotate_captcha.py,sha256=o9y9SVLPI6G6NqK1siv3xbOSYm7PGNquJbbhXuxTIDE,6278
+python_rucaptcha/temu_captcha.py,sha256=Uny8OY-g4Nbl4_X8wZM8TsZzivG1r12AuPhYpdIM-fI,5830
 python_rucaptcha/tencent.py,sha256=f7lnRBUl-X5rL2FNRnrlh9ITRCcerTaS6XGUXnQdnOA,3649
 python_rucaptcha/text_captcha.py,sha256=lZDPwTgpMLvqvfjPbT-uNuNu6JRdWTEE9qfjnRQ5y-A,3708
 python_rucaptcha/turnstile.py,sha256=VpmYGYJoRVX6NHipO6-g2U5EpwxZToAZRmULj4ReDD0,3686
+python_rucaptcha/vk_captcha.py,sha256=kpVQsyhd2eS9WqoK_30e30vOA3EBKrHcBwjCf4LHw1w,3837
 python_rucaptcha/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_rucaptcha/core/base.py,sha256=MvP0zQspHUmAgI8mZle_sYhs7H0ynUKwdhz5PwaIx4c,9425
-python_rucaptcha/core/config.py,sha256=UHP9iAaW3VpVC_7eHz_ihkYWIMAA9t_UXERfs5LwKiM,553
-python_rucaptcha/core/enums.py,sha256=t_7jYpRgTxnAgNx_S0LIBUUmTXBHCqnXxVJ6NhnfAOk,3913
-python_rucaptcha/core/result_handler.py,sha256=LJskNbfgsOdxwzXoNknzVPzCnxBrSR6EwsvOJgs0aD8,2724
-python_rucaptcha/core/serializer.py,sha256=asJRFD14uwOXG8gaNqsfaukiPBbsxt4r0rDA7lCuNHk,1739
-python_rucaptcha-6.3.2.dist-info/LICENSE,sha256=N_utAsqhTp1pXXp-PTE-CFMg5BfIIqTbF-phwwzOHeQ,1063
-python_rucaptcha-6.3.2.dist-info/METADATA,sha256=fnY8wPnogkl-HHdUdAn580hiMq8yEyBWSqJBDXvtJ1k,6674
-python_rucaptcha-6.3.2.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-python_rucaptcha-6.3.2.dist-info/top_level.txt,sha256=Eu_atEB79Y7jCsfXPcXF5N8OLt6kKVbvhuRsI1BmSWM,17
-python_rucaptcha-6.3.2.dist-info/RECORD,,
+python_rucaptcha/core/base.py,sha256=nCQ3tU1-8xV4t90gQjeFzWLjNZ88SanCRteg-HBQ6gI,10706
+python_rucaptcha/core/config.py,sha256=ocoPeMXfn-2iqaqcjewZWfRpu73D5dY2AL2zqXVrG9Q,613
+python_rucaptcha/core/enums.py,sha256=qGIM2e0Acz2i35uZVTrVIcrQ7dRobuSWzh-ojs9rDCE,4135
+python_rucaptcha/core/result_handler.py,sha256=gSblrOEe-tJ_kfvNSsN1lbnV8-9Oh2RGTZu6LDzl9M0,5118
+python_rucaptcha/core/serializer.py,sha256=xFem0kEvbjn9nOwXyc5p9ziY5-c2P1pe-JmXnjs9exI,2695
+python_rucaptcha-6.5.0.dist-info/licenses/LICENSE,sha256=ZQeZG4IrO4YywdTal32gqyyrwdMlrMa3EwJCbgM8b2k,1063
+python_rucaptcha-6.5.0.dist-info/METADATA,sha256=A_Xixc0I07xGPbL9CZ_Hce2stb8kAPoZamwcBIIYglY,6659
+python_rucaptcha-6.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+python_rucaptcha-6.5.0.dist-info/top_level.txt,sha256=Eu_atEB79Y7jCsfXPcXF5N8OLt6kKVbvhuRsI1BmSWM,17
+python_rucaptcha-6.5.0.dist-info/RECORD,,

{python_rucaptcha-6.3.2.dist-info → python_rucaptcha-6.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{python_rucaptcha-6.3.2.dist-info → python_rucaptcha-6.5.0.dist-info/licenses}/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