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

python_rucaptcha/__version__.py

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

python_rucaptcha/altcha_captcha.py

@@ -0,0 +1,152 @@
+from typing import Union, Optional
+
+from .core.base import BaseCaptcha
+from .core.enums import AltchaEnm
+
+
+class AltchaCaptcha(BaseCaptcha):
+    def __init__(
+        self,
+        websiteURL: str,
+        method: Union[str, AltchaEnm] = AltchaEnm.AltchaTaskProxyless,
+        challengeURL: Optional[str] = None,
+        challengeJSON: Optional[str] = None,
+        proxyType: Optional[str] = None,
+        proxyAddress: Optional[str] = None,
+        proxyPort: Optional[int] = None,
+        proxyLogin: Optional[str] = None,
+        proxyPassword: Optional[str] = None,
+        *args,
+        **kwargs,
+    ):
+        """
+        The class is used to work with ALTCHA captcha.
+
+        Args:
+            rucaptcha_key: User API key
+            websiteURL: Full URL of the captcha page
+            method: Captcha type
+            challengeURL: Full URL of the page that contains ALTCHA challenge
+            challengeJSON: JSON-encoded ALTCHA challenge data
+            proxyType: Proxy type (http, https, socks4, socks5)
+            proxyAddress: Proxy IP address or hostname
+            proxyPort: Proxy port
+            proxyLogin: Proxy login
+            proxyPassword: Proxy password
+            kwargs: Not required params for task creation request
+
+        Examples:
+            >>> AltchaCaptcha(rucaptcha_key="aa9011f31111181111168611f1151122",
+            ...             websiteURL="https://example.com",
+            ...             challengeURL="https://example.com/altcha/challenge.js",
+            ...             method=AltchaEnm.AltchaTaskProxyless.value,
+            ...             ).captcha_handler()
+            {
+               "errorId":0,
+               "status":"ready",
+               "solution":{
+                  "token":"..."
+               },
+               "cost":"0.00145",
+               "ip":"1.2.3.4",
+               "createTime":1692863536,
+               "endTime":1692863556,
+               "solveCount":1,
+               "taskId": 73243152973,
+            }
+
+            >>> await AltchaCaptcha(rucaptcha_key="aa9011f31111181111168611f1151122",
+            ...             websiteURL="https://example.com",
+            ...             challengeJSON='{"挑战数据"}',
+            ...             method=AltchaEnm.AltchaTask.value,
+            ...             proxyType="http",
+            ...             proxyAddress="1.2.3.4",
+            ...             proxyPort=8080,
+            ...             ).aio_captcha_handler()
+            {
+               "errorId":0,
+               "status":"ready",
+               "solution":{
+                  "token":"..."
+               },
+               "cost":"0.00145",
+               "ip":"1.2.3.4",
+               "createTime":1692863536,
+               "endTime":1692863556,
+               "solveCount":1,
+               "taskId": 73243152973,
+            }
+
+        Returns:
+            Dict with full server response
+
+        Notes:
+            https://rucaptcha.com/api-docs/altcha
+        """
+
+        super().__init__(method=method, *args, **kwargs)
+
+        # XOR validation: exactly one of challengeURL or challengeJSON must be provided
+        if not (bool(challengeURL) ^ bool(challengeJSON)):
+            raise ValueError(
+                "Exactly one of 'challengeURL' or 'challengeJSON' must be provided, not both or neither"
+            )
+
+        # Validate method
+        if method not in AltchaEnm.list_values():
+            raise ValueError(f"Invalid method parameter set, available - {AltchaEnm.list_values()}")
+
+        # Build task payload
+        task_data = {"websiteURL": websiteURL}
+
+        if challengeURL:
+            task_data["challengeURL"] = challengeURL
+
+        if challengeJSON:
+            task_data["challengeJSON"] = challengeJSON
+
+        # Add proxy params only for non-proxyless methods
+        if method == AltchaEnm.AltchaTask.value:
+            if not all([proxyType, proxyAddress, proxyPort]):
+                raise ValueError(
+                    "Proxy parameters (proxyType, proxyAddress, proxyPort) are required for AltchaTask"
+                )
+            task_data.update(
+                {
+                    "proxyType": proxyType,
+                    "proxyAddress": proxyAddress,
+                    "proxyPort": proxyPort,
+                }
+            )
+            if proxyLogin and proxyPassword:
+                task_data["proxyLogin"] = proxyLogin
+                task_data["proxyPassword"] = proxyPassword
+
+        self.create_task_payload["task"].update(task_data)
+
+    def captcha_handler(self, **kwargs) -> dict:
+        """
+        Sync solving method
+
+        Args:
+            kwargs: Parameters for the `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/binance_captcha.py

@@ -0,0 +1,155 @@
+from typing import Union, Optional
+
+from .core.base import BaseCaptcha
+from .core.enums import BinanceCaptchaEnm
+
+
+class BinanceCaptcha(BaseCaptcha):
+    def __init__(
+        self,
+        websiteURL: str,
+        websiteKey: str,
+        validateId: str,
+        method: Union[str, BinanceCaptchaEnm] = BinanceCaptchaEnm.BinanceTaskProxyless,
+        userAgent: Optional[str] = None,
+        proxyType: Optional[str] = None,
+        proxyAddress: Optional[str] = None,
+        proxyPort: Optional[int] = None,
+        proxyLogin: Optional[str] = None,
+        proxyPassword: Optional[str] = None,
+        *args,
+        **kwargs,
+    ):
+        """
+        The class is used to work with Binance CAPTCHA.
+
+        Args:
+            rucaptcha_key: User API key
+            websiteURL: Full URL of the page where the captcha is loaded
+            websiteKey: Value of bizId, bizType, or bizCode from page requests
+            validateId: Dynamic value of validateId, securityId, or securityCheckResponseValidateId
+            method: Captcha type
+            userAgent: User-Agent string to be used when solving the captcha
+            proxyType: Proxy type (http, https, socks4, socks5)
+            proxyAddress: Proxy IP address or hostname
+            proxyPort: Proxy port
+            proxyLogin: Proxy login
+            proxyPassword: Proxy password
+
+        Examples:
+            >>> BinanceCaptcha(rucaptcha_key="aa9011f31111181111168611f1151122",
+            ...             websiteURL="https://example.com/page-with-binance",
+            ...             websiteKey="login",
+            ...             validateId="cb0bfefa598...e54ecd57b",
+            ...             userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+            ...                        "(KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36",
+            ...             method=BinanceCaptchaEnm.BinanceTaskProxyless.value,
+            ...             ).captcha_handler()
+            {
+               "errorId":0,
+               "status":"ready",
+               "solution":{
+                  "token":"captcha#09ba4905a79f44f...kc99maS943qIsquNP9D77",
+                  "userAgent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36"
+               },
+               "cost":"0.00299",
+               "ip":"1.2.3.4",
+               "createTime":1692863536,
+               "endTime":1692863556,
+               "solveCount":1,
+               "taskId": 73243152973,
+            }
+
+            >>> await BinanceCaptcha(rucaptcha_key="aa9011f31111181111168611f1151122",
+            ...             websiteURL="https://example.com/page-with-binance",
+            ...             websiteKey="login",
+            ...             validateId="cb0bfefa598...e54ecd57b",
+            ...             method=BinanceCaptchaEnm.BinanceTask.value,
+            ...             proxyType="http",
+            ...             proxyAddress="1.2.3.4",
+            ...             proxyPort=8080,
+            ...             ).aio_captcha_handler()
+            {
+               "errorId":0,
+               "status":"ready",
+               "solution":{
+                  "token":"captcha#09ba4905a79f44f...kc99maS943qIsquNP9D77",
+                  "userAgent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36"
+               },
+               "cost":"0.00299",
+               "ip":"1.2.3.4",
+               "createTime":1692863536,
+               "endTime":1692863556,
+               "solveCount":1,
+               "taskId": 73243152973,
+            }
+
+        Returns:
+            Dict with full server response
+
+        Notes:
+            https://2captcha.com/api-docs/binance-captcha
+
+            https://rucaptcha.com/api-docs/binance-captcha
+        """
+        super().__init__(method=method, *args, **kwargs)
+
+        # Validate method
+        if method not in BinanceCaptchaEnm.list_values():
+            raise ValueError(f"Invalid method parameter set, available - {BinanceCaptchaEnm.list_values()}")
+
+        # Build task payload
+        task_data = {
+            "websiteURL": websiteURL,
+            "websiteKey": websiteKey,
+            "validateId": validateId,
+        }
+
+        if userAgent:
+            task_data["userAgent"] = userAgent
+
+        # Add proxy params only for non-proxyless methods
+        if method == BinanceCaptchaEnm.BinanceTask.value:
+            if not all([proxyType, proxyAddress, proxyPort]):
+                raise ValueError(
+                    "Proxy parameters (proxyType, proxyAddress, proxyPort) are required for BinanceTask"
+                )
+            task_data.update(
+                {
+                    "proxyType": proxyType,
+                    "proxyAddress": proxyAddress,
+                    "proxyPort": proxyPort,
+                }
+            )
+            if proxyLogin and proxyPassword:
+                task_data["proxyLogin"] = proxyLogin
+                task_data["proxyPassword"] = proxyPassword
+
+        self.create_task_payload["task"].update(task_data)
+
+    def captcha_handler(self, **kwargs) -> dict:
+        """
+        Sync solving method
+
+        Args:
+            kwargs: Parameters for the `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/enums.py

@@ -98,6 +98,11 @@ class TurnstileCaptchaEnm(str, MyEnum):
     TurnstileTask = "TurnstileTask"
 
 
+class AltchaEnm(str, MyEnum):
+    AltchaTaskProxyless = "AltchaTaskProxyless"
+    AltchaTask = "AltchaTask"
+
+
 class AmazonWAFCaptchaEnm(str, MyEnum):
     AmazonTask = "AmazonTask"
     AmazonTaskProxyless = "AmazonTaskProxyless"
@@ -172,7 +177,23 @@ class CaptchaFoxEnm(str, MyEnum):
 
 class VKCaptchaEnm(str, MyEnum):
     VKCaptchaTask = "VKCaptchaTask"
+    VKCaptchaImageTask = "VKCaptchaImageTask"
 
 
 class TemuCaptchaEnm(str, MyEnum):
     TemuCaptchaTask = "TemuCaptchaTask"
+
+
+class BinanceCaptchaEnm(str, MyEnum):
+    BinanceTaskProxyless = "BinanceTaskProxyless"
+    BinanceTask = "BinanceTask"
+
+
+class YidunEnm(str, MyEnum):
+    YidunTaskProxyless = "YidunTaskProxyless"
+    YidunTask = "YidunTask"
+
+
+class YandexSmartCaptchaEnm(str, MyEnum):
+    YandexSmartCaptchaTaskProxyless = "YandexSmartCaptchaTaskProxyless"
+    YandexSmartCaptchaTask = "YandexSmartCaptchaTask"

python_rucaptcha/core/result_handler.py

@@ -35,7 +35,6 @@ def get_sync_result(
             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()

python_rucaptcha/vk_captcha.py

@@ -1,32 +1,43 @@
-from typing import Any
+from typing import Any, Union, Optional
 
 from .core.base import BaseCaptcha
-from .core.enums import VKCaptchaEnm
+from .core.enums import VKCaptchaEnm, SaveFormatsEnm
 
 
 class VKCaptcha(BaseCaptcha):
     def __init__(
         self,
-        redirectUri: str,
-        userAgent: str,
-        proxyType: str,
-        proxyAddress: str,
-        proxyPort: str,
+        method: Union[str, VKCaptchaEnm] = VKCaptchaEnm.VKCaptchaTask,
+        redirectUri: Optional[str] = None,
+        userAgent: Optional[str] = None,
+        proxyType: Optional[str] = None,
+        proxyAddress: Optional[str] = None,
+        proxyPort: Optional[int] = None,
+        proxyLogin: Optional[str] = None,
+        proxyPassword: Optional[str] = None,
+        save_format: Union[str, SaveFormatsEnm] = SaveFormatsEnm.TEMP,
+        img_path: str = "PythonRuCaptchaImages",
         *args,
-        **kwargs: dict[str, Any],
+        **kwargs,
     ):
         """
-        The class is used to work with VKCaptchaTask.
+        The class is used to work with VKCaptchaTask and VKCaptchaImageTask.
+
+        VKCaptchaTask requires proxy and returns a token.
+        VKCaptchaImageTask takes a captcha image and steps, returns image solution.
 
         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
+            method: Captcha type - VKCaptchaTask or VKCaptchaImageTask
+            redirectUri: The URL that is returned on requests to the captcha API (VKCaptchaTask)
+            userAgent: User-Agent of your browser will be used to load the captcha (VKCaptchaTask)
+            proxyType: Proxy type - http, https, socks5 (VKCaptchaTask)
+            proxyAddress: Proxy IP address or hostname (VKCaptchaTask)
+            proxyPort: Proxy port (VKCaptchaTask)
+            proxyLogin: Proxy login (VKCaptchaTask)
+            proxyPassword: Proxy password (VKCaptchaTask)
+            save_format: Image save format for VKCaptchaImageTask - 'temp' or 'const'
+            img_path: Folder to save captcha images for VKCaptchaImageTask
             kwargs: Not required params for task creation request
 
         Examples:
@@ -35,7 +46,7 @@ class VKCaptcha(BaseCaptcha):
             ...             userAgent="Mozilla/5.0 .....",
             ...             proxyType="socks5",
             ...             proxyAddress="1.2.3.4",
-            ...             proxyPort="445",
+            ...             proxyPort=445,
             ...             ).captcha_handler()
             {
                "errorId":0,
@@ -56,7 +67,7 @@ class VKCaptcha(BaseCaptcha):
             ...             userAgent="Mozilla/5.0 .....",
             ...             proxyType="socks5",
             ...             proxyAddress="1.2.3.4",
-            ...             proxyPort="445",
+            ...             proxyPort=445,
             ...             ).aio_captcha_handler()
             {
                "errorId":0,
@@ -72,6 +83,28 @@ class VKCaptcha(BaseCaptcha):
                "taskId": 73243152973,
             }
 
+            >>> VKCaptcha(rucaptcha_key="aa9011f31111181111168611f1151122",
+            ...             method=VKCaptchaEnm.VKCaptchaImageTask,
+            ...             ).captcha_handler(
+            ...                 captcha_link="https://example.com/vk_captcha.png", steps=[3, 4, 5]
+            ...             )
+            {
+               "errorId":0,
+               "status":"ready",
+               "solution":{
+                  "best_step": 1,
+                  "preview": "...",
+                  "solution": "...",
+                  "answer": "..."
+               },
+               "cost":"0.002",
+               "ip":"1.2.3.4",
+               "createTime":1692863536,
+               "endTime":1692863556,
+               "solveCount":0,
+               "taskId": 73243152973,
+            }
+
         Returns:
             Dict with full server response
 
@@ -80,23 +113,51 @@ class VKCaptcha(BaseCaptcha):
 
             https://rucaptcha.com/api-docs/vk-captcha
         """
-        super().__init__(method=VKCaptchaEnm.VKCaptchaTask, *args, **kwargs)
+        super().__init__(method=method, *args, **kwargs)
 
-        self.create_task_payload["task"].update(
-            {
-                "websiteURL": redirectUri,
+        if method not in VKCaptchaEnm.list_values():
+            raise ValueError(f"Invalid method parameter set, available - {VKCaptchaEnm.list_values()}")
+
+        self.method = method
+        self.save_format = save_format
+        self.img_path = img_path
+
+        if method == VKCaptchaEnm.VKCaptchaTask:
+            if not all([redirectUri, userAgent, proxyType, proxyAddress, proxyPort]):
+                raise ValueError(
+                    "redirectUri, userAgent, proxyType, proxyAddress, "
+                    "and proxyPort are required for VKCaptchaTask"
+                )
+
+            task_data = {
+                "redirectUri": redirectUri,
                 "userAgent": userAgent,
                 "proxyType": proxyType,
                 "proxyAddress": proxyAddress,
                 "proxyPort": proxyPort,
             }
-        )
+            if proxyLogin and proxyPassword:
+                task_data["proxyLogin"] = proxyLogin
+                task_data["proxyPassword"] = proxyPassword
+
+            self.create_task_payload["task"].update(task_data)
 
-    def captcha_handler(self, **kwargs: dict[str, Any]) -> dict[str, Any]:
+    def captcha_handler(
+        self,
+        captcha_link: Optional[str] = None,
+        captcha_file: Optional[str] = None,
+        captcha_base64: Optional[bytes] = None,
+        steps: Optional[list[int]] = None,
+        **kwargs: dict[str, Any],
+    ) -> dict[str, Any]:
         """
         Sync solving method
 
         Args:
+            captcha_link: Captcha image URL (VKCaptchaImageTask)
+            captcha_file: Captcha image file path (VKCaptchaImageTask)
+            captcha_base64: Captcha image BASE64 info (VKCaptchaImageTask)
+            steps: List of step values for VKCaptchaImageTask
             kwargs: additional params for `requests` library
 
         Returns:
@@ -105,16 +166,60 @@ class VKCaptcha(BaseCaptcha):
         Notes:
             Check class docstirng for more info
         """
+        if self.method == VKCaptchaEnm.VKCaptchaImageTask:
+            self._body_file_processing(
+                save_format=self.save_format,
+                file_path=self.img_path,
+                image_key="image",
+                captcha_link=captcha_link,
+                captcha_file=captcha_file,
+                captcha_base64=captcha_base64,
+            )
+            if steps:
+                self.create_task_payload["task"]["steps"] = steps
+            if not self.result.errorId:
+                return self._processing_response(**kwargs)
+            return self.result.to_dict()
+
         return self._processing_response(**kwargs)
 
-    async def aio_captcha_handler(self) -> dict[str, Any]:
+    async def aio_captcha_handler(
+        self,
+        captcha_link: Optional[str] = None,
+        captcha_file: Optional[str] = None,
+        captcha_base64: Optional[bytes] = None,
+        steps: Optional[list[int]] = None,
+        **kwargs: dict[str, Any],
+    ) -> dict[str, Any]:
         """
         Async solving method
 
+        Args:
+            captcha_link: Captcha image URL (VKCaptchaImageTask)
+            captcha_file: Captcha image file path (VKCaptchaImageTask)
+            captcha_base64: Captcha image BASE64 info (VKCaptchaImageTask)
+            steps: List of step values for VKCaptchaImageTask
+            kwargs: additional params for `aiohttp` library
+
         Returns:
             Dict with full server response
 
         Notes:
             Check class docstirng for more info
         """
+        if self.method == VKCaptchaEnm.VKCaptchaImageTask:
+            await self._aio_body_file_processing(
+                save_format=self.save_format,
+                file_path=self.img_path,
+                image_key="image",
+                captcha_link=captcha_link,
+                captcha_file=captcha_file,
+                captcha_base64=captcha_base64,
+            )
+            if steps:
+                self.create_task_payload["task"]["steps"] = steps
+            if not self.result.errorId:
+                return await self._aio_processing_response()
+            return self.result.to_dict()
+
         return await self._aio_processing_response()