python3-capsolver 0.9.4__py3-none-any.whl → 1.0.1__py3-none-any.whl

python3_capsolver/core/aio_captcha_instrument.py

@@ -0,0 +1,109 @@
+import asyncio
+import logging
+from typing import Optional
+from urllib import parse
+
+import aiohttp
+
+from .enum import ResponseStatusEnm, EndpointPostfixEnm
+from .const import REQUEST_URL, VALID_STATUS_CODES, GET_BALANCE_POSTFIX
+from .utils import attempts_generator
+from .serializer import CaptchaResponseSer
+from .captcha_instrument import CaptchaInstrument
+
+__all__ = ("AIOCaptchaInstrument",)
+
+
+class AIOCaptchaInstrument(CaptchaInstrument):
+    """
+    Instrument for working with async captcha
+    """
+
+    def __init__(self, captcha_params: "CaptchaParams"):
+        super().__init__()
+        self.captcha_params = captcha_params
+        self.created_task_data = CaptchaResponseSer
+
+    async def processing_captcha(self) -> dict:
+        self.captcha_params.create_task_payload.task = self.captcha_params.task_params
+        self.created_task_data = CaptchaResponseSer(**await self.__create_task())
+
+        # if task created and already ready - return result
+        if self.created_task_data.errorId == 0 and self.created_task_data.status == ResponseStatusEnm.Processing.value:
+            return (await self.__get_result()).to_dict()
+        elif self.created_task_data.errorId != 0:
+            self.created_task_data.status = ResponseStatusEnm.Failed
+
+        return self.created_task_data.to_dict()
+
+    async def __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.captcha_params.request_url, url_postfix),
+                    json=self.captcha_params.create_task_payload.to_dict(),
+                ) 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 __get_result(self, url_postfix: str = EndpointPostfixEnm.GET_TASK_RESULT.value) -> CaptchaResponseSer:
+        """
+        Function send the ASYNC request to service and wait for result
+        """
+        # initial waiting
+        await asyncio.sleep(self.captcha_params.sleep_time)
+
+        self.captcha_params.get_result_params.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.captcha_params.request_url, url_postfix),
+                        json=self.captcha_params.get_result_params.to_dict(),
+                    ) 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.captcha_params.sleep_time)
+
+            # default response if server is silent
+            self.result.errorId = 1
+            self.result.errorCode = self.CAPTCHA_UNSOLVABLE
+            self.result.errorDescription = "Captcha not recognized"
+            self.result.taskId = self.created_task_data.taskId
+            self.result.status = ResponseStatusEnm.Failed
+
+    @staticmethod
+    async def send_post_request(payload: Optional[dict] = None, url_postfix: str = GET_BALANCE_POSTFIX) -> dict:
+        """
+        Function send ASYNC request to service and wait for result
+        """
+
+        async with aiohttp.ClientSession() as session:
+            try:
+                async with session.post(parse.urljoin(REQUEST_URL, url_postfix), json=payload) as resp:
+                    if resp.status == 200:
+                        return await resp.json()
+                    else:
+                        raise ValueError(resp.status)
+            except Exception as error:
+                logging.exception(error)
+                raise

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
+from typing import Any, Dict
 
-import aiohttp
-import requests
-from pydantic import BaseModel
-from requests.adapters import HTTPAdapter
+from python3_capsolver.core.enum import CaptchaTypeEnm
+from python3_capsolver.core.serializer import TaskSer
 
-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,
-)
+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 BaseCaptcha:
+
+class CaptchaParams(SIOContextManager, AIOContextManager):
     """
     Basic Captcha solving class
 
@@ -33,195 +27,56 @@ 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, Any]:
         """
-        Method prepare `createTask` payload
+        Synchronous method for captcha solving
 
         Args:
-            serializer: Serializer for task creation
-            create_params: Parameters for task creation payload
-
-        Examples:
-
-            >>> self._prepare_create_task_payload(serializer=PostRequestSer, create_params={})
-
-        """
-        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
-    """
-
-    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())
+            task_payload: Some additional parameters that will be used in creating the task
+                            and will be passed to the payload under ``task`` key.
+                            Like ``websiteURL``, ``image``, ``proxyPassword``, ``websiteKey`` and etc.
+                            more info in service docs
 
-        # 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
+        Returns:
+            Dict with full server response
 
-    def _create_task(self, url_postfix: str = EndpointPostfixEnm.CREATE_TASK.value) -> dict:
+        Notes:
+            Check class docstirng for more info
         """
-        Function send SYNC request to service and wait for result
-        """
-        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
+        self.task_params.update(task_payload)
+        self._captcha_handling_instrument = SIOCaptchaInstrument(captcha_params=self)
+        return self._captcha_handling_instrument.processing_captcha()
 
-    def _get_result(self, url_postfix: str = EndpointPostfixEnm.GET_TASK_RESULT.value) -> CaptchaResponseSer:
-        """
-        Method send SYNC request to service and wait for result
+    async def aio_captcha_handler(self, task_payload: Dict) -> Dict[str, Any]:
         """
-        # 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,
-        )
-
-    """
-    Async part
-    """
-
-    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())
+        Asynchronous method for captcha solving
 
-        # 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
+        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 ``websiteURL``, ``image``, ``proxyPassword``, ``websiteKey`` and etc.
+                            more info in service docs
 
-    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
+        Returns:
+            Dict with full server response
 
-    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
+        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