python3-capsolver 0.9.2__py3-none-any.whl → 1.0.0a0__py3-none-any.whl

python3_capsolver/core/base.py

@@ -1,25 +1,19 @@
-import time
-import asyncio
-import logging
-from typing import Any, Dict, Type
-from urllib import parse
-
-import aiohttp
-import requests
-from pydantic import BaseModel
-from requests.adapters import HTTPAdapter
-
-from python3_capsolver.core.enum import ResponseStatusEnm, EndpointPostfixEnm
-from python3_capsolver.core.config import RETRIES, REQUEST_URL, VALID_STATUS_CODES, attempts_generator
-from python3_capsolver.core.serializer import (
-    CaptchaOptionsSer,
-    CaptchaResponseSer,
-    RequestCreateTaskSer,
-    RequestGetTaskResultSer,
-)
-
-
-class BaseCaptcha:
+from typing import Dict
+
+from python3_capsolver.core.enum import CaptchaTypeEnm
+from python3_capsolver.core.serializer import TaskSer
+
+from .const import REQUEST_URL
+from .serializer import RequestCreateTaskSer, RequestGetTaskResultSer
+from .context_instr import AIOContextManager, SIOContextManager
+from .captcha_instrument import CaptchaInstrument
+from .aio_captcha_instrument import AIOCaptchaInstrument
+from .sio_captcha_instrument import SIOCaptchaInstrument
+
+__all__ = ("CaptchaParams",)
+
+
+class CaptchaParams(SIOContextManager, AIOContextManager):
     """
     Basic Captcha solving class
 
@@ -33,195 +27,55 @@ class BaseCaptcha:
     def __init__(
         self,
         api_key: str,
+        captcha_type: CaptchaTypeEnm,
         sleep_time: int = 5,
         request_url: str = REQUEST_URL,
-        **kwargs,
     ):
         # assign args to validator
-        self.__params = CaptchaOptionsSer(**locals())
-        self.__request_url = request_url
-
-        # prepare session
-        self.__session = requests.Session()
-        self.__session.mount("http://", HTTPAdapter(max_retries=RETRIES))
-        self.__session.mount("https://", HTTPAdapter(max_retries=RETRIES))
-
-    def _prepare_create_task_payload(self, serializer: Type[BaseModel], create_params: Dict[str, Any] = None) -> None:
+        self.create_task_payload = RequestCreateTaskSer(clientKey=api_key)
+        # `task` body for task creation payload
+        self.task_params = TaskSer(type=captcha_type.value).to_dict()
+        # prepare `get task result` payload
+        self.get_result_params = RequestGetTaskResultSer(clientKey=api_key)
+        self.request_url = request_url
+        self._captcha_handling_instrument = CaptchaInstrument()
+        self.sleep_time = sleep_time
+
+    def captcha_handler(self, task_payload: Dict) -> Dict[str, str]:
         """
-        Method prepare `createTask` payload
+        Synchronous method for captcha solving
 
         Args:
-            serializer: Serializer for task creation
-            create_params: Parameters for task creation payload
+            task_payload: Some additional parameters that will be used in creating the task
+                                and will be passed to the payload under ``task`` key.
+                                Like ``proxyLogin``, ``proxyPassword`` and etc. - more info in service docs
 
-        Examples:
 
-            >>> self._prepare_create_task_payload(serializer=PostRequestSer, create_params={})
+        Returns:
+            Dict with full server response
 
+        Notes:
+            Check class docstirng for more info
         """
-        self.task_payload = serializer(clientKey=self.__params.api_key)
-        # added task params to payload
-        self.task_payload.task = {**create_params} if create_params else {}
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        if exc_type:
-            return False
-        return True
-
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, exc_type, exc_value, traceback):
-        if exc_type:
-            return False
-        return True
-
-    """
-    Sync part
-    """
+        self.task_params.update(task_payload)
+        self._captcha_handling_instrument = SIOCaptchaInstrument(captcha_params=self)
+        return self._captcha_handling_instrument.processing_captcha()
 
-    def _processing_captcha(
-        self, create_params: dict, serializer: Type[BaseModel] = RequestCreateTaskSer
-    ) -> CaptchaResponseSer:
-        self._prepare_create_task_payload(serializer=serializer, create_params=create_params)
-        self.created_task_data = CaptchaResponseSer(**self._create_task())
-
-        # if task created and ready - return result
-        if self.created_task_data.status == ResponseStatusEnm.Ready.value:
-            return self.created_task_data
-        # if captcha is not ready but task success created - waiting captcha result
-        elif self.created_task_data.errorId == 0:
-            return self._get_result()
-        return self.created_task_data
-
-    def _create_task(self, url_postfix: str = EndpointPostfixEnm.CREATE_TASK.value) -> dict:
-        """
-        Function send SYNC request to service and wait for result
+    async def aio_captcha_handler(self, task_payload: Dict) -> Dict[str, str]:
         """
-        try:
-            resp = self.__session.post(
-                parse.urljoin(self.__request_url, url_postfix), json=self.task_payload.dict(exclude_none=True)
-            )
-            if resp.status_code in VALID_STATUS_CODES:
-                return resp.json()
-            else:
-                raise ValueError(resp.raise_for_status())
-        except Exception as error:
-            logging.exception(error)
-            raise
-
-    def _get_result(self, url_postfix: str = EndpointPostfixEnm.GET_TASK_RESULT.value) -> CaptchaResponseSer:
-        """
-        Method send SYNC request to service and wait for result
-        """
-        # initial waiting
-        time.sleep(self.__params.sleep_time)
-
-        get_result_payload = RequestGetTaskResultSer(
-            clientKey=self.__params.api_key, taskId=self.created_task_data.taskId
-        )
-        attempts = attempts_generator()
-        for _ in attempts:
-            try:
-                resp = self.__session.post(
-                    parse.urljoin(self.__request_url, url_postfix), json=get_result_payload.dict(exclude_none=True)
-                )
-                if resp.status_code in VALID_STATUS_CODES:
-                    result_data = CaptchaResponseSer(**resp.json())
-                    if result_data.status in (ResponseStatusEnm.Ready, ResponseStatusEnm.Failed):
-                        # if captcha ready\failed or have unknown status - return exist data
-                        return result_data
-                else:
-                    raise ValueError(resp.raise_for_status())
-            except Exception as error:
-                logging.exception(error)
-                raise
-
-            # if captcha just created or in processing now - wait
-            time.sleep(self.__params.sleep_time)
-        # default response if server is silent
-        return CaptchaResponseSer(
-            errorId=1,
-            errorCode="ERROR_CAPTCHA_UNSOLVABLE",
-            errorDescription="Captcha not recognized",
-            taskId=self.created_task_data.taskId,
-            status=ResponseStatusEnm.Failed,
-        )
+        Asynchronous method for captcha solving
 
-    """
-    Async part
-    """
+        Args:
+            task_payload: Some additional parameters that will be used in creating the task
+                                and will be passed to the payload under ``task`` key.
+                                Like ``proxyLogin``, ``proxyPassword`` and etc. - more info in service docs
 
-    async def _aio_processing_captcha(
-        self, create_params: dict, serializer: Type[BaseModel] = RequestCreateTaskSer
-    ) -> CaptchaResponseSer:
-        self._prepare_create_task_payload(serializer=serializer, create_params=create_params)
-        self.created_task_data = CaptchaResponseSer(**await self._aio_create_task())
-
-        # if task created and already ready - return result
-        if self.created_task_data.status == ResponseStatusEnm.Ready.value:
-            return self.created_task_data
-        # if captcha is not ready but task success created - waiting captcha result
-        elif self.created_task_data.errorId == 0:
-            return await self._aio_get_result()
-        return self.created_task_data
-
-    async def _aio_create_task(self, url_postfix: str = EndpointPostfixEnm.CREATE_TASK.value) -> dict:
-        """
-        Function send the ASYNC request to service and wait for result
-        """
-        async with aiohttp.ClientSession() as session:
-            try:
-                async with session.post(
-                    parse.urljoin(self.__request_url, url_postfix), json=self.task_payload.dict(exclude_none=True)
-                ) as resp:
-                    if resp.status in VALID_STATUS_CODES:
-                        return await resp.json()
-                    else:
-                        raise ValueError(resp.reason)
-            except Exception as error:
-                logging.exception(error)
-                raise
-
-    async def _aio_get_result(self, url_postfix: str = EndpointPostfixEnm.GET_TASK_RESULT.value) -> CaptchaResponseSer:
-        """
-        Function send the ASYNC request to service and wait for result
+        Returns:
+            Dict with full server response
+
+        Notes:
+            Check class docstirng for more info
         """
-        # initial waiting
-        await asyncio.sleep(self.__params.sleep_time)
-
-        get_result_payload = RequestGetTaskResultSer(
-            clientKey=self.__params.api_key, taskId=self.created_task_data.taskId
-        )
-        attempts = attempts_generator()
-        async with aiohttp.ClientSession() as session:
-            for _ in attempts:
-                try:
-                    async with session.post(
-                        parse.urljoin(self.__request_url, url_postfix), json=get_result_payload.dict(exclude_none=True)
-                    ) as resp:
-                        if resp.status in VALID_STATUS_CODES:
-                            result_data = CaptchaResponseSer(**await resp.json())
-                            if result_data.status in (ResponseStatusEnm.Ready, ResponseStatusEnm.Failed):
-                                # if captcha ready\failed or have unknown status - return exist data
-                                return result_data
-                        else:
-                            raise ValueError(resp.reason)
-                except Exception as error:
-                    logging.exception(error)
-                    raise
-
-                # if captcha just created or in processing now - wait
-                await asyncio.sleep(self.__params.sleep_time)
-
-            # default response if server is silent
-            return CaptchaResponseSer(
-                errorId=1,
-                errorCode="ERROR_CAPTCHA_UNSOLVABLE",
-                errorDescription="Captcha not recognized",
-                taskId=self.created_task_data.taskId,
-                status=ResponseStatusEnm.Failed,
-            )
+        self.task_params.update(task_payload)
+        self._captcha_handling_instrument = AIOCaptchaInstrument(captcha_params=self)
+        return await self._captcha_handling_instrument.processing_captcha()

python3_capsolver/core/captcha_instrument.py

@@ -0,0 +1,145 @@
+import os
+import uuid
+import base64
+import shutil
+from typing import Optional
+from pathlib import Path
+
+import aiohttp
+import requests
+from requests.adapters import HTTPAdapter
+
+from .enum import SaveFormatsEnm
+from .const import RETRIES, ASYNC_RETRIES
+from .serializer import CaptchaResponseSer
+
+__all__ = ("CaptchaInstrument", "FileInstrument")
+
+
+class FileInstrument:
+    @staticmethod
+    def _local_file_captcha(captcha_file: str):
+        """
+        Method get local file, read it and prepare for sending to Captcha solving service
+        """
+        with open(captcha_file, "rb") as file:
+            return file.read()
+
+    @staticmethod
+    def _file_const_saver(content: bytes, file_path: str, file_extension: str = "png") -> str:
+        """
+        Method create and save file in folder
+        """
+        Path(file_path).mkdir(parents=True, exist_ok=True)
+
+        # generate image name
+        file_name = f"file-{uuid.uuid4()}.{file_extension}"
+
+        full_file_path = os.path.join(file_path, file_name)
+
+        # save image to folder
+        with open(full_file_path, "wb") as out_image:
+            out_image.write(content)
+        return full_file_path
+
+    @staticmethod
+    def _file_clean(full_file_path: str):
+        shutil.rmtree(full_file_path, ignore_errors=True)
+
+    @staticmethod
+    def _url_read(url: str, **kwargs):
+        """
+        Method open links
+        """
+        # prepare session
+        session = requests.Session()
+        session.mount("http://", HTTPAdapter(max_retries=RETRIES))
+        session.mount("https://", HTTPAdapter(max_retries=RETRIES))
+        session.verify = False
+        return session.get(url=url, **kwargs)
+
+    @staticmethod
+    async def _aio_url_read(url: str, **kwargs) -> bytes:
+        """
+        Async method read bytes from link
+        """
+        async with aiohttp.ClientSession() as session:
+            async for attempt in ASYNC_RETRIES:
+                with attempt:
+                    async with session.get(url=url, **kwargs) as resp:
+                        return await resp.content.read()
+
+    def file_processing(
+        self,
+        captcha_link: Optional[str] = None,
+        captcha_file: Optional[str] = None,
+        captcha_base64: Optional[bytes] = None,
+        save_format: SaveFormatsEnm = SaveFormatsEnm.TEMP,
+        img_clearing: bool = True,
+        file_path: str = "/tmp/",
+        file_extension: str = "png",
+        **kwargs,
+    ) -> str:
+        # if a local file link is passed
+        if captcha_file:
+            return base64.b64encode(self._local_file_captcha(captcha_file=captcha_file)).decode("utf-8")
+        # if the file is transferred in base64 encoding
+        elif captcha_base64:
+            return base64.b64encode(captcha_base64).decode("utf-8")
+        # if a URL is passed
+        elif captcha_link:
+            content = self._url_read(url=captcha_link, **kwargs).content
+            # according to the value of the passed parameter, select the function to save the image
+            if save_format == SaveFormatsEnm.CONST.value:
+                full_file_path = self._file_const_saver(content, file_path, file_extension=file_extension)
+                if img_clearing:
+                    self._file_clean(full_file_path=full_file_path)
+            return base64.b64encode(content).decode("utf-8")
+        else:
+            raise ValueError("No valid captcha variant is set.")
+
+    async def aio_file_processing(
+        self,
+        captcha_link: Optional[str] = None,
+        captcha_file: Optional[str] = None,
+        captcha_base64: Optional[bytes] = None,
+        save_format: SaveFormatsEnm = SaveFormatsEnm.TEMP,
+        img_clearing: bool = True,
+        file_path: str = "/tmp/",
+        file_extension: str = "png",
+        **kwargs,
+    ) -> str:
+        # if a local file link is passed
+        if captcha_file:
+            return base64.b64encode(self._local_file_captcha(captcha_file=captcha_file)).decode("utf-8")
+        # if the file is transferred in base64 encoding
+        elif captcha_base64:
+            return base64.b64encode(captcha_base64).decode("utf-8")
+        # if a URL is passed
+        elif captcha_link:
+            content = await self._aio_url_read(url=captcha_link, **kwargs)
+            # according to the value of the passed parameter, select the function to save the image
+            if save_format == SaveFormatsEnm.CONST.value:
+                full_file_path = self._file_const_saver(content, file_path, file_extension=file_extension)
+                if img_clearing:
+                    self._file_clean(full_file_path=full_file_path)
+            return base64.b64encode(content).decode("utf-8")
+
+        else:
+            raise ValueError("No valid captcha variant is set.")
+
+
+class CaptchaInstrument(FileInstrument):
+    CAPTCHA_UNSOLVABLE = "ERROR_CAPTCHA_UNSOLVABLE"
+    """
+    Basic Captcha solving class
+
+    Args:
+        api_key: Capsolver API key
+        captcha_type: Captcha type name, like `ReCaptchaV2Task` and etc.
+        sleep_time: The waiting time between requests to get the result of the Captcha
+        request_url: API address for sending requests
+    """
+
+    def __init__(self):
+        self.result = CaptchaResponseSer()

python3_capsolver/core/const.py

@@ -0,0 +1,27 @@
+import urllib3
+from tenacity import AsyncRetrying, wait_fixed, stop_after_attempt
+from requests.adapters import Retry
+
+__all__ = (
+    "APP_ID",
+    "RETRIES",
+    "REQUEST_URL",
+    "ASYNC_RETRIES",
+    "GET_RESULT_POSTFIX",
+    "VALID_STATUS_CODES",
+    "GET_BALANCE_POSTFIX",
+    "CREATE_TASK_POSTFIX",
+)
+
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+RETRIES = Retry(total=5, backoff_factor=0.9, status_forcelist=[500, 502, 503, 504])
+ASYNC_RETRIES = AsyncRetrying(wait=wait_fixed(5), stop=stop_after_attempt(5), reraise=True)
+
+REQUEST_URL = "https://api.capsolver.com"
+CREATE_TASK_POSTFIX = "/createTask"
+GET_RESULT_POSTFIX = "/getTaskResult"
+GET_BALANCE_POSTFIX = "/getBalance"
+VALID_STATUS_CODES = (200, 202, 400, 401, 405)
+
+APP_ID = "3E36E3CD-7EB5-4CAF-AA15-91011E652321"

python3_capsolver/core/context_instr.py

@@ -0,0 +1,25 @@
+__all__ = ("SIOContextManager", "AIOContextManager")
+
+
+class SIOContextManager:
+
+    # Context methods
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if exc_type:
+            return False
+        return True
+
+
+class AIOContextManager:
+
+    # Context methods
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        if exc_type:
+            return False
+        return True

python3_capsolver/core/enum.py

@@ -1,9 +1,10 @@
 from enum import Enum
-from types import DynamicClassAttribute
 from typing import List
 
+__all__ = ("EndpointPostfixEnm", "CaptchaTypeEnm", "ResponseStatusEnm", "SaveFormatsEnm")
 
-class MyEnum(Enum):
+
+class MyEnum(str, Enum):
     @classmethod
     def list(cls) -> List[Enum]:
         return list(map(lambda c: c, cls))
@@ -16,22 +17,8 @@ class MyEnum(Enum):
     def list_names(cls) -> List[str]:
         return list(map(lambda c: c.name, cls))
 
-    @DynamicClassAttribute
-    def name(self) -> str:
-        """
-        The name of the Enum member
-        """
-        return self._name_
-
-    @DynamicClassAttribute
-    def value(self) -> str:
-        """
-        The name of the Enum member
-        """
-        return self._value_
 
-
-class EndpointPostfixEnm(str, MyEnum):
+class EndpointPostfixEnm(MyEnum):
     """
     Enum stored URL postfixes for API endpoints
     """
@@ -39,93 +26,46 @@ class EndpointPostfixEnm(str, MyEnum):
     GET_BALANCE = "getBalance"
     CREATE_TASK = "createTask"
     GET_TASK_RESULT = "getTaskResult"
-    AKAMAI_BMP_INVOKE = "akamaibmp/invoke"
-    AKAMAI_WEB_INVOKE = "akamaiweb/invoke"
-
-
-class ImageToTextTaskTypeEnm(str, MyEnum):
-    ImageToTextTask = "ImageToTextTask"
-
-
-class HCaptchaTypeEnm(str, MyEnum):
-    HCaptchaTask = "HCaptchaTask"
-    HCaptchaTaskProxyless = "HCaptchaTaskProxyless"
-    HCaptchaEnterpriseTask = "HCaptchaEnterpriseTask"
-    HCaptchaEnterpriseTaskProxyLess = "HCaptchaEnterpriseTaskProxyLess"
-    HCaptchaTurboTask = "HCaptchaTurboTask"
-    HCaptchaClassification = "HCaptchaClassification"
 
 
-class HCaptchaClassificationTypeEnm(str, MyEnum):
-    HCaptchaClassification = "HCaptchaClassification"
-
-
-class FunCaptchaTypeEnm(str, MyEnum):
-    FunCaptchaTask = "FunCaptchaTask"
-    FunCaptchaTaskProxyLess = "FunCaptchaTaskProxyLess"
-
-
-class FunCaptchaClassificationTypeEnm(str, MyEnum):
-    FunCaptchaClassification = "FunCaptchaClassification"
+class CaptchaTypeEnm(MyEnum):
+    Control = "Control"
 
+    ImageToTextTask = "ImageToTextTask"
+    VisionEngine = "VisionEngine"
 
-class GeeTestCaptchaTypeEnm(str, MyEnum):
-    GeeTestTask = "GeeTestTask"
     GeeTestTaskProxyLess = "GeeTestTaskProxyLess"
 
-
-class ReCaptchaV2TypeEnm(str, MyEnum):
-    # V2
+    # re-captcha
+    ReCaptchaV2Classification = "ReCaptchaV2Classification"
     ReCaptchaV2Task = "ReCaptchaV2Task"
     ReCaptchaV2EnterpriseTask = "ReCaptchaV2EnterpriseTask"
     ReCaptchaV2TaskProxyLess = "ReCaptchaV2TaskProxyLess"
     ReCaptchaV2EnterpriseTaskProxyLess = "ReCaptchaV2EnterpriseTaskProxyLess"
 
-
-class ReCaptchaV3TypeEnm(str, MyEnum):
     ReCaptchaV3Task = "ReCaptchaV3Task"
     ReCaptchaV3EnterpriseTask = "ReCaptchaV3EnterpriseTask"
     ReCaptchaV3TaskProxyLess = "ReCaptchaV3TaskProxyLess"
     ReCaptchaV3EnterpriseTaskProxyLess = "ReCaptchaV3EnterpriseTaskProxyLess"
 
-
-class MtCaptchaTypeEnm(str, MyEnum):
     MtCaptchaTask = "MtCaptchaTask"
     MtCaptchaTaskProxyLess = "MtCaptchaTaskProxyLess"
 
-
-class DatadomeSliderTypeEnm(str, MyEnum):
     DatadomeSliderTask = "DatadomeSliderTask"
 
-
-class CloudflareTypeEnm(str, MyEnum):
+    AntiTurnstileTaskProxyLess = "AntiTurnstileTaskProxyLess"
     AntiCloudflareTask = "AntiCloudflareTask"
 
+    FriendlyCaptchaTaskProxyless = "FriendlyCaptchaTaskProxyless"
+
+    YandexCaptchaTaskProxyLess = "YandexCaptchaTaskProxyLess"
 
-class AntiAwsWafTaskTypeEnm(str, MyEnum):
     AntiAwsWafTask = "AntiAwsWafTask"
     AntiAwsWafTaskProxyLess = "AntiAwsWafTaskProxyLess"
+    AwsWafClassification = "AwsWafClassification"
 
 
-class AntiCyberSiAraTaskTypeEnm(str, MyEnum):
-    AntiCyberSiAraTask = "AntiCyberSiAraTask"
-    AntiCyberSiAraTaskProxyLess = "AntiCyberSiAraTaskProxyLess"
-
-
-class AntiAkamaiTaskEnm(str, MyEnum):
-    AntiAkamaiBMPTask = "AntiAkamaiBMPTask"
-    AntiAkamaiWebTask = "AntiAkamaiWebTask"
-
-
-class AntiImpervaTaskEnm(str, MyEnum):
-    AntiImpervaTask = "AntiImpervaTask"
-
-
-class BinanceCaptchaTaskEnm(str, MyEnum):
-    BinanceCaptchaTask = "BinanceCaptchaTask"
-
-
-class ResponseStatusEnm(str, MyEnum):
+class ResponseStatusEnm(MyEnum):
     """
     Enum store results `status` field variants
 
@@ -137,3 +77,8 @@ class ResponseStatusEnm(str, MyEnum):
     Processing = "processing"  # Task is not ready yet
     Ready = "ready"  # Task completed, solution object can be found in solution property
     Failed = "failed"  # Task failed, check the errorDescription to know why failed.
+
+
+class SaveFormatsEnm(MyEnum):
+    TEMP = "temp"
+    CONST = "const"