python-rucaptcha 5.1.5a0__py3-none-any.whl → 5.2.1__py3-none-any.whl

python_rucaptcha/__version__.py

@@ -1 +1 @@
-__version__ = "5.1.5a"
+__version__ = "5.2.1"

python_rucaptcha/amazon_waf.py

@@ -5,7 +5,6 @@ from .core.enums import AmazonWAFCaptchaEnm
 class AmazonWAF(BaseCaptcha):
     def __init__(
         self,
-        rucaptcha_key: str,
         pageurl: str,
         sitekey: str,
         iv: str,
@@ -56,7 +55,7 @@ class AmazonWAF(BaseCaptcha):
         Notes:
             https://rucaptcha.com/api-rucaptcha#amazon-waf
         """
-        super().__init__(rucaptcha_key=rucaptcha_key, method=method, *args, **kwargs)
+        super().__init__(method=method, *args, **kwargs)
 
         self.post_payload.update({"sitekey": sitekey, "pageurl": pageurl, "iv": iv, "context": context})
 

python_rucaptcha/audio_captcha.py

@@ -0,0 +1,208 @@
+import base64
+import shutil
+from typing import Optional
+
+from .core.base import BaseCaptcha
+from .core.enums import SaveFormatsEnm, AudioCaptchaEnm
+
+
+class AudioCaptcha(BaseCaptcha):
+    def __init__(
+        self,
+        save_format: str = SaveFormatsEnm.TEMP.value,
+        audio_clearing: bool = True,
+        audio_path: str = "PythonRuCaptchaAudio",
+        lang: str = "en",
+        *args,
+        **kwargs,
+    ):
+        """
+        The class is used to work with Text Captcha.
+
+        Args:
+            rucaptcha_key: User API key
+            save_format: The format in which the file will be saved, or as a temporary file - 'temp',
+                                 or as a regular file to a folder created by the library - 'const'.
+            audio_clearing: True - delete file after solution, False - don't delete file after solution
+            audio_path: Folder to save captcha audio
+            lang: Captcha audio lang: `en`, `fr`, `de`, `el`, `pt`, `ru`
+
+        Examples:
+            >>> AudioCaptcha(rucaptcha_key="aa9011f31111181111168611f1151122",
+            ...             lang='en'
+            ...             ).captcha_handler(captcha_file='examples/mediacaptcha_audio/recaptcha_55914.mp3')
+            {
+                'captchaSolve': 'five five nine one four',
+                'taskId': 73243152973,
+                'error': False,
+                'errorBody': None
+            }
+
+            >>> await AudioCaptcha(rucaptcha_key="aa9011f31111181111168611f1151122",
+            ...             lang='en'
+            ...             ).aio_captcha_handler(captcha_file='examples/mediacaptcha_audio/recaptcha_55914.mp3')
+            {
+                'captchaSolve': 'five five nine one four',
+                'taskId': 73243152973,
+                'error': False,
+                'errorBody': None
+            }
+
+        Returns:
+            Dict with full server response
+
+        Notes:
+            https://rucaptcha.com/api-rucaptcha#audio
+        """
+
+        super().__init__(method=AudioCaptchaEnm.AUDIO.value, *args, **kwargs)
+        self.save_format = save_format
+        self.audio_clearing = audio_clearing
+        self.audio_path = audio_path
+
+        self.post_payload.update({"lang": lang})
+
+    def captcha_handler(
+        self,
+        captcha_link: Optional[str] = None,
+        captcha_file: Optional[str] = None,
+        captcha_base64: Optional[bytes] = None,
+        **kwargs,
+    ) -> dict:
+        """
+        Synchronous method for captcha solving
+
+        Args:
+            captcha_link: Captcha file URL
+            captcha_file: Captcha file path
+            captcha_base64: Captcha file BASE64 info
+            kwargs: additional params for `requests` library
+
+        Examples:
+            >>> AudioCaptcha(rucaptcha_key="aa9011f31111181111168611f1151122",
+            ...             lang='en'
+            ...             ).captcha_handler(captcha_file='examples/mediacaptcha_audio/recaptcha_55914.mp3')
+            {
+                'captchaSolve': 'five five nine one four',
+                'taskId': 73243152973,
+                'error': False,
+                'errorBody': None
+            }
+
+            >>> AudioCaptcha(rucaptcha_key="aa9011f31111181111168611f1151122",
+            ...             lang='en'
+            ...             ).captcha_handler(captcha_link='http://some/link/address/recaptcha_55914.mp3')
+            {
+                'captchaSolve': 'five five nine one four',
+                'taskId': 73243152973,
+                'error': False,
+                'errorBody': None
+            }
+
+        Returns:
+            Dict with full server response
+
+        Notes:
+            Check class docstirng for more info
+        """
+        # if a local file link is passed
+        if captcha_file:
+            self.post_payload.update({"body": base64.b64encode(self._local_file_captcha(captcha_file)).decode("utf-8")})
+        # if the file is transferred in base64 encoding
+        elif captcha_base64:
+            self.post_payload.update({"body": base64.b64encode(captcha_base64).decode("utf-8")})
+        # if a URL is passed
+        elif captcha_link:
+            try:
+                content = self.url_open(url=captcha_link, **kwargs).content
+            except Exception as error:
+                self.result.error = True
+                self.result.errorBody = str(error)
+                return self.result.dict()
+
+            # according to the value of the passed parameter, select the function to save the file
+            if self.save_format == SaveFormatsEnm.CONST.value:
+                self._file_const_saver(content, self.audio_path, file_extension="mp3")
+            self.post_payload.update({"body": base64.b64encode(content).decode("utf-8")})
+
+        else:
+            # if none of the parameters are passed
+            self.result.error = True
+            self.result.errorBody = self.NO_CAPTCHA_ERR
+            return self.result.dict()
+
+        return self._processing_response(**kwargs)
+
+    async def aio_captcha_handler(
+        self,
+        captcha_link: Optional[str] = None,
+        captcha_file: Optional[str] = None,
+        captcha_base64: Optional[bytes] = None,
+        **kwargs,
+    ) -> dict:
+        """
+        Asynchronous method for captcha solving
+
+        Args:
+            captcha_link: Captcha file URL
+            captcha_file: Captcha file path
+            captcha_base64: Captcha file BASE64
+            kwargs: additional params for `aiohttp` library
+
+        Examples:
+            >>> await AudioCaptcha(rucaptcha_key="aa9011f31111181111168611f1151122",
+            ...             lang='en'
+            ...             ).aio_captcha_handler(captcha_file='examples/mediacaptcha_audio/recaptcha_55914.mp3')
+            {
+                'captchaSolve': 'five five nine one four',
+                'taskId': 73243152973,
+                'error': False,
+                'errorBody': None
+            }
+            >>> await AudioCaptcha(rucaptcha_key="aa9011f31111181111168611f1151122",
+            ...             lang='en'
+            ...             ).aio_captcha_handler(captcha_link='http://some/link/address/recaptcha_55914.mp3')
+            {
+                'captchaSolve': 'five five nine one four',
+                'taskId': 73243152973,
+                'error': False,
+                'errorBody': None
+            }
+
+        Returns:
+            Dict with full server response
+
+        Notes:
+            Check class docstirng for more info
+        """
+        # if a local file link is passed
+        if captcha_file:
+            self.post_payload.update({"body": base64.b64encode(self._local_file_captcha(captcha_file)).decode("utf-8")})
+        # if the file is transferred in base64 encoding
+        elif captcha_base64:
+            self.post_payload.update({"body": base64.b64encode(captcha_base64).decode("utf-8")})
+        # if a URL is passed
+        elif captcha_link:
+            try:
+                content = await self.aio_url_read(url=captcha_link, **kwargs)
+            except Exception as error:
+                self.result.error = True
+                self.result.errorBody = str(error)
+                return self.result.dict()
+
+            # according to the value of the passed parameter, select the function to save the file
+            if self.save_format == SaveFormatsEnm.CONST.value:
+                self._file_const_saver(content, self.audio_path, file_extension="mp3")
+            self.post_payload.update({"body": base64.b64encode(content).decode("utf-8")})
+
+        else:
+            # if none of the parameters are passed
+            self.result.error = True
+            self.result.errorBody = self.NO_CAPTCHA_ERR
+            return self.result.dict()
+
+        return await self._aio_processing_response()
+
+    def __del__(self):
+        if self.save_format == SaveFormatsEnm.CONST.value and self.audio_clearing:
+            shutil.rmtree(self.audio_path)

python_rucaptcha/control.py

@@ -37,6 +37,31 @@ class Control(BaseCaptcha):
                 'errorBody': None
             }
 
+            Death By Captcha example:
+
+            >>> Control(rucaptcha_key="service_username:service_password",
+            ...         service_type="other-captcha-services",
+            ...         action=ControlEnm.GETBALANCE.value).additional_methods()
+            {
+                'captchaSolve': '0.00',
+                'taskId': None,
+                'error': False,
+                'errorBody': None
+            }
+
+            Death By Captcha example:
+
+            >>> from python_rucaptcha.core.enums import ControlEnm, ServiceEnm
+            >>> Control(rucaptcha_key="service_username:service_password",
+            ...         service_type=ServiceEnm.DEATHBYCAPTCHA,
+            ...         action=ControlEnm.GETBALANCE.value).additional_methods()
+            {
+                'captchaSolve': '0.00',
+                'taskId': None,
+                'error': False,
+                'errorBody': None
+            }
+
         Returns:
             Dict with full server response
 
@@ -46,7 +71,7 @@ class Control(BaseCaptcha):
             https://rucaptcha.com/api-rucaptcha#additional
         """
 
-        super().__init__(action=action, *args, **kwargs)
+        super().__init__(method=ControlEnm.CONTROL.value, action=action, *args, **kwargs)
 
         # check user params
         if action not in ControlEnm.list_values():

python_rucaptcha/core/base.py

@@ -0,0 +1,191 @@
+import os
+import time
+import uuid
+import asyncio
+from pathlib import Path
+
+import aiohttp
+import requests
+from requests.adapters import HTTPAdapter
+
+from . import enums
+from .config import RETRIES, ASYNC_RETRIES
+from .serializer import ResponseSer, GetRequestSer, PostRequestSer, CaptchaOptionsSer, ServicePostResponseSer
+from .result_handler import get_sync_result, get_async_result
+
+
+class BaseCaptcha:
+    NO_CAPTCHA_ERR = "You did not send any file, local link or URL."
+
+    def __init__(
+        self,
+        rucaptcha_key: str,
+        method: str,
+        action: str = "get",
+        sleep_time: int = 15,
+        service_type: str = enums.ServiceEnm.TWOCAPTCHA.value,
+        **kwargs,
+    ):
+        """
+        :param rucaptcha_key: User API key
+        :param method: Captcha type
+        :param action: Server action
+        :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
+        """
+        # assign args to validator
+        self.params = CaptchaOptionsSer(**locals(), **kwargs)
+
+        # prepare POST payload
+        self.post_payload = PostRequestSer(key=self.params.rucaptcha_key, method=method).dict(by_alias=True)
+        # prepare GET payload
+        self.get_payload = GetRequestSer(key=self.params.rucaptcha_key, action=action).dict(
+            by_alias=True, exclude_none=True
+        )
+        # prepare result payload
+        self.result = ResponseSer()
+
+        for key in kwargs:
+            self.post_payload.update({key: kwargs[key]})
+
+        # prepare session
+        self.session = requests.Session()
+        self.session.mount("http://", HTTPAdapter(max_retries=RETRIES))
+        self.session.mount("https://", HTTPAdapter(max_retries=RETRIES))
+
+    def _processing_response(self, **kwargs: dict) -> dict:
+        """
+        Method processing captcha solving task creation result
+        :param kwargs: additional params for Requests library
+        """
+        try:
+            response = ServicePostResponseSer(
+                **self.session.post(self.params.url_request, data=self.post_payload, **kwargs).json()
+            )
+            # check response status
+            if response.status == 1:
+                self.result.taskId = response.request
+            else:
+                self.result.error = True
+                self.result.errorBody = response.request
+        except Exception as error:
+            self.result.error = True
+            self.result.errorBody = str(error)
+
+        # check for errors while make request to server
+        if self.result.error:
+            return self.result.dict()
+
+        # if all is ok - send captcha to service and wait solution
+        # update payload - add captcha taskId
+        self.get_payload.update({"id": self.result.taskId})
+
+        # wait captcha solving
+        time.sleep(self.params.sleep_time)
+        return get_sync_result(
+            get_payload=self.get_payload,
+            sleep_time=self.params.sleep_time,
+            url_response=self.params.url_response,
+            result=self.result,
+        )
+
+    def url_open(self, url: str, **kwargs):
+        """
+        Method open links
+        """
+        return self.session.get(url=url, **kwargs)
+
+    async def aio_url_read(self, 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()
+
+    async def _aio_processing_response(self) -> dict:
+        """
+        Method processing async captcha solving task creation result
+        """
+        try:
+            # make async or sync request
+            response = await self.__aio_make_post_request()
+            # check response status
+            if response.status == 1:
+                self.result.taskId = response.request
+            else:
+                self.result.error = True
+                self.result.errorBody = response.request
+        except Exception as error:
+            self.result.error = True
+            self.result.errorBody = str(error)
+
+        # check for errors while make request to server
+        if self.result.error:
+            return self.result.dict()
+
+        # if all is ok - send captcha to service and wait solution
+        # update payload - add captcha taskId
+        self.get_payload.update({"id": self.result.taskId})
+
+        # wait captcha solving
+        await asyncio.sleep(self.params.sleep_time)
+        return await get_async_result(
+            get_payload=self.get_payload,
+            sleep_time=self.params.sleep_time,
+            url_response=self.params.url_response,
+            result=self.result,
+        )
+
+    async def __aio_make_post_request(self) -> ServicePostResponseSer:
+        async with aiohttp.ClientSession() as session:
+            async for attempt in ASYNC_RETRIES:
+                with attempt:
+                    async with session.post(
+                        self.params.url_request, data=self.post_payload, raise_for_status=True
+                    ) as resp:
+                        response_json = await resp.json()
+                        return ServicePostResponseSer(**response_json)
+
+    # Working with images methods
+
+    @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()
+
+    def _file_const_saver(self, content: bytes, file_path: str, file_extension: str = "png"):
+        """
+        Method create and save file in folder
+        """
+        Path(file_path).mkdir(parents=True, exist_ok=True)
+
+        # generate image name
+        self._file_name = f"file-{uuid.uuid4()}.{file_extension}"
+
+        # save image to folder
+        with open(os.path.join(file_path, self._file_name), "wb") as out_image:
+            out_image.write(content)
+
+    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

python_rucaptcha/core/config.py

@@ -0,0 +1,21 @@
+from tenacity import AsyncRetrying, wait_fixed, stop_after_attempt
+from requests.adapters import Retry
+
+RETRIES = Retry(total=5, backoff_factor=0.5)
+ASYNC_RETRIES = AsyncRetrying(wait=wait_fixed(5), stop=stop_after_attempt(5), reraise=True)
+# Application key
+APP_KEY = "1899"
+
+
+# Connection retry generator
+def attempts_generator(amount: int = 7):
+    """
+    Function generates a generator of length equal to `amount`
+
+    Args:
+        amount: number of attempts generated
+
+    Returns:
+        Attempt number
+    """
+    yield from range(1, amount)

python_rucaptcha/core/enums.py

@@ -0,0 +1,112 @@
+from enum import Enum
+from typing import List
+
+
+class MyEnum(Enum):
+    """
+    Base class for work with updated Enums
+    """
+
+    @classmethod
+    def list(cls) -> List[Enum]:
+        return list(map(lambda c: c, cls))
+
+    @classmethod
+    def list_values(cls) -> List[str]:
+        return list(map(lambda c: c.value, cls))
+
+    @classmethod
+    def list_names(cls) -> List[str]:
+        return list(map(lambda c: c.name, cls))
+
+
+class ServiceEnm(str, MyEnum):
+    TWOCAPTCHA = "2captcha"
+    RUCAPTCHA = "rucaptcha"
+    DEATHBYCAPTCHA = "other-captcha-services"
+
+
+class SaveFormatsEnm(str, MyEnum):
+    TEMP = "temp"
+    CONST = "const"
+
+
+class GeetestEnm(str, MyEnum):
+    GEETEST = "geetest"
+    GEETEST_V4 = "geetest_v4"
+
+
+class ImageCaptchaEnm(str, MyEnum):
+    BASE64 = "base64"
+
+
+class CapyPuzzleEnm(str, MyEnum):
+    CAPY = "capy"
+
+
+class FunCaptchaEnm(str, MyEnum):
+    FUNCAPTCHA = "funcaptcha"
+
+
+class ReCaptchaEnm(str, MyEnum):
+    USER_RECAPTCHA = "userrecaptcha"
+
+
+class LeminCroppedCaptchaEnm(str, MyEnum):
+    LEMIN = "lemin"
+
+
+class HCaptchaEnm(str, MyEnum):
+    HCAPTCHA = "hcaptcha"
+
+
+class KeyCaptchaEnm(str, MyEnum):
+    KEYCAPTCHA = "keycaptcha"
+
+
+class RotateCaptchaEnm(str, MyEnum):
+    ROTATECAPTCHA = "rotatecaptcha"
+
+
+class TikTokCaptchaEnm(str, MyEnum):
+    TIKTOK = "tiktok"
+
+
+class ControlEnm(str, MyEnum):
+    # control method
+    CONTROL = "control"
+
+    # default
+    GET = "get"
+    # https://rucaptcha.com/api-rucaptcha#manage_pingback
+    ADD_PINGBACK = "add_pingback"
+    GET_PINGBACK = "get_pingback"
+    DEL_PINGBACK = "del_pingback"
+
+    # https://rucaptcha.com/api-rucaptcha#additional
+    GETBALANCE = "getbalance"
+    GET2 = "get2"
+
+    # https://rucaptcha.com/api-rucaptcha#complain
+    REPORTGOOD = "reportgood"
+    REPORTBAD = "reportbad"
+
+
+class YandexSmartCaptchaEnm(str, MyEnum):
+    YANDEX = "yandex"
+
+
+class TurnstileCaptchaEnm(str, MyEnum):
+    TURNSTILE = "turnstile"
+
+
+class AmazonWAFCaptchaEnm(str, MyEnum):
+    AMAZON_WAF = "amazon_waf"
+
+
+class TextCaptchaEnm(str, MyEnum):
+    TEXT = "text"
+
+
+class AudioCaptchaEnm(str, MyEnum):
+    AUDIO = "audio"

python_rucaptcha/core/result_handler.py

@@ -0,0 +1,92 @@
+import time
+import asyncio
+
+import aiohttp
+import requests
+
+from .config import attempts_generator
+from .serializer import ResponseSer, ServiceGetResponseSer
+
+
+def result_processing(captcha_response: ServiceGetResponseSer, result: ResponseSer) -> dict:
+    """
+    Function processing service response status values
+    """
+
+    # on error during solving
+    if captcha_response.status == 0:
+        result.error = True
+        result.errorBody = captcha_response.request
+
+    # if solving is success
+    elif captcha_response.status == 1:
+        result.error = False
+        result.errorBody = None
+        result.captchaSolve = captcha_response.request
+
+        # if this is ReCaptcha v3 then we get it from the server
+        if captcha_response.user_check and captcha_response.user_score:
+            result = result.dict()
+            result.update(
+                {
+                    "user_check": captcha_response.user_check,
+                    "user_score": captcha_response.user_score,
+                }
+            )
+            return result
+
+    return result.dict()
+
+
+def get_sync_result(get_payload: dict, sleep_time: int, url_response: str, result: ResponseSer) -> dict:
+    """
+    Function periodically send the SYNC request to service and wait for captcha solving result
+    """
+    # 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 = ServiceGetResponseSer(**requests.get(url_response, params=get_payload).json())
+            # if the captcha has not been resolved yet, wait
+            if captcha_response.request == "CAPCHA_NOT_READY":
+                time.sleep(sleep_time)
+                result.error = True
+                result.errorBody = "ERROR_CAPTCHA_UNSOLVABLE"
+            else:
+                return result_processing(captcha_response, result)
+
+        except Exception as error:
+            result.error = True
+            result.errorBody = str(error)
+
+    return result.dict()
+
+
+async def get_async_result(get_payload: dict, sleep_time: int, url_response: str, result: ResponseSer) -> dict:
+    """
+    Function periodically send the ASYNC request to service and wait for captcha solving result
+    """
+    # generator for repeated attempts to connect to the server
+    attempts = attempts_generator()
+    async with aiohttp.ClientSession() as session:
+        for _ in attempts:
+            try:
+                # send a request for the result of solving the captcha
+                async with session.get(url_response, params=get_payload, raise_for_status=True) as resp:
+                    captcha_response = await resp.json()
+                    captcha_response = ServiceGetResponseSer(**captcha_response)
+
+                    # if the captcha has not been resolved yet, wait
+                    if captcha_response.request == "CAPCHA_NOT_READY":
+                        await asyncio.sleep(sleep_time)
+                        result.error = True
+                        result.errorBody = "ERROR_CAPTCHA_UNSOLVABLE"
+
+                    else:
+                        return result_processing(captcha_response, result)
+
+            except Exception as error:
+                result.error = True
+                result.errorBody = str(error)
+    return result.dict()

python_rucaptcha/core/serializer.py

@@ -0,0 +1,171 @@
+import logging
+from uuid import uuid4
+from typing import Union, Optional
+
+from pydantic import Field, BaseModel, conint, constr, validator, root_validator
+
+from . import enums
+from .config import APP_KEY
+
+"""
+Socket API Serializers
+"""
+
+
+class MyBaseModel(BaseModel):
+    class Config:
+        validate_assignment = True
+
+
+class CaptchaOptionsSocketSer(MyBaseModel):
+    phrase: bool = False
+    caseSensitive: bool = False
+    numeric: conint(ge=1, le=4) = 0
+    calc: bool = False
+    minLen: conint(ge=0, le=20) = 0
+    maxLen: conint(ge=0, le=20) = 0
+    lang: str = ""
+    hintText: constr(max_length=139) = ""
+    hintImg: str = ""
+    softId: str = Field(APP_KEY, const=True)
+
+
+class NormalCaptchaSocketSer(BaseModel):
+    method: str = "normal"
+    requestId: str = Field(default_factory=lambda: str(uuid4()))
+    body: str = str()
+    options: "CaptchaOptionsSocketSer" = CaptchaOptionsSocketSer()
+
+
+class TextCaptchaSocketSer(BaseModel):
+    method: str = "text"
+    requestId: str = Field(default_factory=lambda: str(uuid4()))
+    body: str = str()
+    options: "CaptchaOptionsSocketSer" = CaptchaOptionsSocketSer()
+
+
+class ControlCaptchaSocketSer(BaseModel):
+    method: str
+    requestId: str = Field(default_factory=lambda: str(uuid4()))
+    success: str = None
+    captchaId: int = None
+
+
+class SocketResponse(BaseModel):
+    method: str = None
+    success: bool = None
+    code: str = None
+    # captcha task ID at RuCaptcha service
+    captchaId: int = None
+    # manually generated requestID
+    requestId: str = Field(default_factory=lambda: str(uuid4()))
+    error: str = None
+    # specific fields for balance request response
+    balance: float = None
+    valute: str = None
+
+
+class SockAuthSer(BaseModel):
+    method: str = "auth"
+    requestId: str = Field(default_factory=lambda: str(uuid4()))
+    key: str
+    options: dict
+
+
+"""
+HTTP API Serializers
+"""
+
+
+class PostRequestSer(MyBaseModel):
+    key: str
+    method: str
+    soft_id: str = Field(APP_KEY, const=True)
+    field_json: int = Field(1, alias="json")
+
+
+class GetRequestSer(BaseModel):
+    key: str
+    action: str = "get"
+    field_json: int = Field(1, alias="json")
+
+    # Control keys
+    ids: str = None
+    id: str = None
+
+
+class CaptchaOptionsSer(BaseModel):
+    method: str
+    action: str
+    sleep_time: conint(gt=5) = 10
+    service_type: str = enums.ServiceEnm.TWOCAPTCHA.value
+    rucaptcha_key: constr(min_length=1)
+
+    url_request: Optional[str] = None  # /in.php
+    url_response: Optional[str] = None  # /res.php
+
+    @validator("rucaptcha_key")
+    def rucaptcha_key_check(cls, value, values, **kwargs):
+        service_type = values.get("service_type")
+        if service_type in (enums.ServiceEnm.RUCAPTCHA, enums.ServiceEnm.TWOCAPTCHA):
+            if len(value) != 32:
+                raise ValueError(f"Invalid `rucaptcha_key` len, it must be - 32, u send - {len(value)}")
+        return value
+
+    @validator("service_type")
+    def service_type_check(cls, value):
+        if value not in enums.ServiceEnm.list_values():
+            logging.warning(
+                f"We support only this list of services - '{', '.join(enums.ServiceEnm.list_values())}', u send - '{value}'. "
+                f"All other services you use at your own risk"
+            )
+        return value
+
+    @root_validator
+    def urls_set(cls, values):
+        """
+        Set request \ response URLs if they not set previously
+        """
+        if not values.get("url_request") and not values.get("url_response"):
+            service_type = values.get("service_type")
+            if service_type == enums.ServiceEnm.DEATHBYCAPTCHA:
+                values.update(
+                    {
+                        "url_request": f"http://api.{service_type}.com/2captcha/in.php",
+                        "url_response": f"http://api.{service_type}.com/2captcha/res.php",
+                    }
+                )
+            else:
+                values.update(
+                    {
+                        "url_request": f"http://{service_type}.com/in.php",
+                        "url_response": f"http://{service_type}.com/res.php",
+                    }
+                )
+        return values
+
+
+"""
+HTTP API Response
+"""
+
+
+class ServicePostResponseSer(MyBaseModel):
+    status: int
+    request: str
+
+
+class ServiceGetResponseSer(BaseModel):
+    status: int
+    request: Union[str, dict]
+
+    # ReCaptcha V3 params
+    user_check: str = ""
+    user_score: str = ""
+
+
+class ResponseSer(MyBaseModel):
+    captchaSolve: Union[dict, str] = {}
+    taskId: Optional[int] = None
+    error: bool = False
+    errorBody: Optional[str] = None

python_rucaptcha/image_captcha.py

@@ -112,13 +112,11 @@ class ImageCaptcha(BaseCaptcha):
             Dict with full server response
 
         Notes:
-            https://rucaptcha.com/api-rucaptcha#solving_funcaptcha_new
+            Check class docstirng for more info
         """
         # if a local file link is passed
         if captcha_file:
-            self.post_payload.update(
-                {"body": base64.b64encode(self._local_image_captcha(captcha_file)).decode("utf-8")}
-            )
+            self.post_payload.update({"body": base64.b64encode(self._local_file_captcha(captcha_file)).decode("utf-8")})
         # if the file is transferred in base64 encoding
         elif captcha_base64:
             self.post_payload.update({"body": base64.b64encode(captcha_base64).decode("utf-8")})
@@ -133,7 +131,7 @@ class ImageCaptcha(BaseCaptcha):
 
             # according to the value of the passed parameter, select the function to save the image
             if self.save_format == SaveFormatsEnm.CONST.value:
-                self._image_const_saver(content, self.img_path)
+                self._file_const_saver(content, self.img_path)
             self.post_payload.update({"body": base64.b64encode(content).decode("utf-8")})
 
         else:
@@ -183,13 +181,11 @@ class ImageCaptcha(BaseCaptcha):
             Dict with full server response
 
         Notes:
-            https://rucaptcha.com/api-rucaptcha#solving_funcaptcha_new
+            Check class docstirng for more info
         """
         # if a local file link is passed
         if captcha_file:
-            self.post_payload.update(
-                {"body": base64.b64encode(self._local_image_captcha(captcha_file)).decode("utf-8")}
-            )
+            self.post_payload.update({"body": base64.b64encode(self._local_file_captcha(captcha_file)).decode("utf-8")})
         # if the file is transferred in base64 encoding
         elif captcha_base64:
             self.post_payload.update({"body": base64.b64encode(captcha_base64).decode("utf-8")})
@@ -204,7 +200,7 @@ class ImageCaptcha(BaseCaptcha):
 
             # according to the value of the passed parameter, select the function to save the image
             if self.save_format == SaveFormatsEnm.CONST.value:
-                self._image_const_saver(content, self.img_path)
+                self._file_const_saver(content, self.img_path)
             self.post_payload.update({"body": base64.b64encode(content).decode("utf-8")})
 
         else:

python_rucaptcha/text_captcha.py

@@ -1,10 +1,10 @@
 from .core.base import BaseCaptcha
+from .core.enums import TextCaptchaEnm
 
 
 class TextCaptcha(BaseCaptcha):
     def __init__(
         self,
-        rucaptcha_key: str,
         language: int = 0,
         *args,
         **kwargs,
@@ -45,7 +45,7 @@ class TextCaptcha(BaseCaptcha):
             https://rucaptcha.com/api-rucaptcha#solving_text_captcha
         """
 
-        super().__init__(rucaptcha_key=rucaptcha_key, *args, **kwargs)
+        super().__init__(method=TextCaptchaEnm.TEXT.value, *args, **kwargs)
 
         self.post_payload.update({"language": language})
 

{python_rucaptcha-5.1.5a0.dist-info → python_rucaptcha-5.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-rucaptcha
-Version: 5.1.5a0
+Version: 5.2.1
 Summary: Python 3.7+ RuCaptcha library with AIO module.
 Home-page: https://andreidrang.github.io/python-rucaptcha/
 Author: AndreiDrang, redV0ID
@@ -13,6 +13,7 @@ Project-URL: Issue tracker, https://github.com/AndreiDrang/python-rucaptcha/issu
 Keywords: captcha
 				rucaptcha
 				2captcha
+				deathbycaptcha
 				recaptcha
 				geetest
 				hcaptcha
@@ -114,6 +115,8 @@ Is described in the [documentation-website](https://andreidrang.github.io/python
 
 ### Changelog
 
+- v.5.3 - Added support for [Death By Captcha](https://deathbycaptcha.com/) and other services by changing `service_type` and `url_request` \ `url_response` parameters.
+- v.5.2 - Added Audio captcha method.
 - v.5.1 - Check [releases page](https://github.com/AndreiDrang/python-rucaptcha/releases).
 - v.5.0 - Added AmazonWAF captcha method.
 - v.4.2 - Added [Yandex Smart Captcha](https://rucaptcha.com/api-rucaptcha#yandex).

python_rucaptcha-5.2.1.dist-info/RECORD

@@ -0,0 +1,29 @@
+python_rucaptcha/SocketAPI.py,sha256=W_ZmEaNTMx--lvaYiLJyckWGt3P-gxoZf0qdxK-onb0,4291
+python_rucaptcha/TikTokCaptcha.py,sha256=PF1ZeV3tb1e2ig3w6kfqqHQzAMOhmGxKjiAyizBRzks,2122
+python_rucaptcha/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_rucaptcha/__version__.py,sha256=Wz6OktWKdFA8wb3DR2SbK1ll5ntwA4r6J1py_6STnmA,22
+python_rucaptcha/amazon_waf.py,sha256=On5PdMYuyWp0DLdmnCs04CuYALEx-aKo0P-USsk-dgk,4385
+python_rucaptcha/audio_captcha.py,sha256=4PPViYfpRksZ1CB8ATVUIgC2MtrgrSAMxDqdims7SJQ,7925
+python_rucaptcha/capy_puzzle.py,sha256=wgofttv2qp-7_xHClKE8E6jlV1ca0H4m9fw0ZVnq7RU,7077
+python_rucaptcha/control.py,sha256=xOLHFrXh2OCb-UFYI9Kxcxkj_B4CX2FsLqMHCWjoMHI,13476
+python_rucaptcha/fun_captcha.py,sha256=0IdsCe_4HxSgtdhBb3B6w_LaSel89IUEQYL7_m2D2i4,3859
+python_rucaptcha/gee_test.py,sha256=-mHV8w717UhsmjQUknZgl1elNEXRz-h5GC6S3QtEM6U,10436
+python_rucaptcha/hcaptcha.py,sha256=lvBpIqlZnELEu6aXcAn0hGWybtYvXn0Gmzq4KXO9hPg,3844
+python_rucaptcha/image_captcha.py,sha256=hSLEHV6w-ekthZfdIsIzIM5Wm4QYd3XsDiewb6FRoAM,9281
+python_rucaptcha/key_captcha.py,sha256=qdWlHdLg2RzBGtkBDdGwyfpsLu821Iy2Pk2tIe1p7WI,5022
+python_rucaptcha/lemin_cropped_captcha.py,sha256=m51lbpFk_QHAXUIlaBS7YEkTetZmyKDz0tzHeufz-mU,5209
+python_rucaptcha/re_captcha.py,sha256=9k9_ErZkSge-IrjMAYMbrmkScDD9XAMnny0ko3gNx5I,5437
+python_rucaptcha/rotate_captcha.py,sha256=P5eNM-fLGnW1TVoF2OxlF-Kou-jVPY7yjAvTw5V_Gfc,6187
+python_rucaptcha/text_captcha.py,sha256=Qj32p71KNj02laARIbpAzSszBeuUGTLrSyRoesvubf0,3118
+python_rucaptcha/turnstile.py,sha256=O2Q10oei6pSt47Wdq3lJjCagH_1x2U_h-LcPu0gXaDM,3790
+python_rucaptcha/yandex_smart_captcha.py,sha256=YGBhflfTxWJ603o3COvYAYHSFvbXBb5KrsduBI25YKQ,4695
+python_rucaptcha/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_rucaptcha/core/base.py,sha256=UzbJYseQX4nGjGKcjWgAAmXqo9defTd4CURTV1xyrn4,6666
+python_rucaptcha/core/config.py,sha256=SRbH3ENNpVLwqCkXU_cqVILkSqtorUlkYBs-_XMXYzQ,552
+python_rucaptcha/core/enums.py,sha256=QYdnxgALuplSD5dWkW16OP5dMcRCT3BHXPWBKIBFHag,2109
+python_rucaptcha/core/result_handler.py,sha256=OPCpfaItugyUMLJsrNaUZhZAHjb3wzHUOGO02av5KoE,3390
+python_rucaptcha/core/serializer.py,sha256=2C-qTZIDNtH-ENqGORpguOQBnkSbkC1Ka1Ig5aT8Hd8,4617
+python_rucaptcha-5.2.1.dist-info/METADATA,sha256=Rd2bf75L8_HIi2l4ZLtwTuu7Z6s9RvqujOZxYRp5ylA,5660
+python_rucaptcha-5.2.1.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+python_rucaptcha-5.2.1.dist-info/top_level.txt,sha256=Eu_atEB79Y7jCsfXPcXF5N8OLt6kKVbvhuRsI1BmSWM,17
+python_rucaptcha-5.2.1.dist-info/RECORD,,

python_rucaptcha-5.1.5a0.dist-info/RECORD

@@ -1,22 +0,0 @@
-python_rucaptcha/SocketAPI.py,sha256=W_ZmEaNTMx--lvaYiLJyckWGt3P-gxoZf0qdxK-onb0,4291
-python_rucaptcha/TikTokCaptcha.py,sha256=PF1ZeV3tb1e2ig3w6kfqqHQzAMOhmGxKjiAyizBRzks,2122
-python_rucaptcha/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_rucaptcha/__version__.py,sha256=nGoohGy6jSVYePb6MpNIuoW_hv5m2Blij1ChyLuHosw,23
-python_rucaptcha/amazon_waf.py,sha256=ef1YhPb0Q2BoQSFY1XsLWk-bmeG5ISHu85EOUTGbeYE,4442
-python_rucaptcha/capy_puzzle.py,sha256=wgofttv2qp-7_xHClKE8E6jlV1ca0H4m9fw0ZVnq7RU,7077
-python_rucaptcha/control.py,sha256=kGKX1DtFGRCoooGJ5lW5U0Xb7w6hjACU9RLOF7qjLOk,12513
-python_rucaptcha/fun_captcha.py,sha256=0IdsCe_4HxSgtdhBb3B6w_LaSel89IUEQYL7_m2D2i4,3859
-python_rucaptcha/gee_test.py,sha256=-mHV8w717UhsmjQUknZgl1elNEXRz-h5GC6S3QtEM6U,10436
-python_rucaptcha/hcaptcha.py,sha256=lvBpIqlZnELEu6aXcAn0hGWybtYvXn0Gmzq4KXO9hPg,3844
-python_rucaptcha/image_captcha.py,sha256=TXmJmlBHoqeepVu0NxLrBYj1FoyIdNwAXLPqpwCUT-k,9391
-python_rucaptcha/key_captcha.py,sha256=qdWlHdLg2RzBGtkBDdGwyfpsLu821Iy2Pk2tIe1p7WI,5022
-python_rucaptcha/lemin_cropped_captcha.py,sha256=m51lbpFk_QHAXUIlaBS7YEkTetZmyKDz0tzHeufz-mU,5209
-python_rucaptcha/re_captcha.py,sha256=9k9_ErZkSge-IrjMAYMbrmkScDD9XAMnny0ko3gNx5I,5437
-python_rucaptcha/rotate_captcha.py,sha256=P5eNM-fLGnW1TVoF2OxlF-Kou-jVPY7yjAvTw5V_Gfc,6187
-python_rucaptcha/text_captcha.py,sha256=HUnhPbN7zvgRAzcXUn88YER-dyXW3UOcM27VV8ZVark,3102
-python_rucaptcha/turnstile.py,sha256=O2Q10oei6pSt47Wdq3lJjCagH_1x2U_h-LcPu0gXaDM,3790
-python_rucaptcha/yandex_smart_captcha.py,sha256=YGBhflfTxWJ603o3COvYAYHSFvbXBb5KrsduBI25YKQ,4695
-python_rucaptcha-5.1.5a0.dist-info/METADATA,sha256=6JPv2UXW3JV7mZGKTTfCqJN0lFYzWvE2a6vWBlS7Yh4,5436
-python_rucaptcha-5.1.5a0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-python_rucaptcha-5.1.5a0.dist-info/top_level.txt,sha256=Eu_atEB79Y7jCsfXPcXF5N8OLt6kKVbvhuRsI1BmSWM,17
-python_rucaptcha-5.1.5a0.dist-info/RECORD,,