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

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"

python3_capsolver/core/serializer.py

@@ -1,30 +1,47 @@
-from typing import Any, Dict, List, Literal, Optional
+from enum import Enum
+from typing import Any, Dict, Literal, Optional
 
-from pydantic import Field, BaseModel, conint
+from msgspec import Struct
+
+from .enum import ResponseStatusEnm
+from .const import APP_ID
+
+__all__ = ("PostRequestSer", "TaskSer", "RequestCreateTaskSer", "CaptchaResponseSer", "RequestGetTaskResultSer")
+
+
+class MyBaseModel(Struct):
+    def to_dict(self) -> Dict[str, Any]:
+        result = {}
+        for f in self.__struct_fields__:
+            if isinstance(getattr(self, f), Enum):
+                result.update({f: getattr(self, f).value})
+            else:
+                result.update({f: getattr(self, f)})
+        return result
 
-from python3_capsolver.core.enum import ResponseStatusEnm
-from python3_capsolver.core.config import APP_ID
 
 """
 HTTP API Request ser
 """
 
 
-class PostRequestSer(BaseModel):
-    clientKey: str = Field(..., description="Client account key, can be found in user account")
-    task: dict = Field(None, description="Task object")
+class PostRequestSer(MyBaseModel):
+    clientKey: str
+    task: Dict = {}
+    callbackUrl: Optional[str] = None
 
 
-class TaskSer(BaseModel):
-    type: str = Field(..., description="Task type name", alias="captcha_type")
+class TaskSer(MyBaseModel):
+    type: str
 
 
 class RequestCreateTaskSer(PostRequestSer):
     appId: Literal[APP_ID] = APP_ID
 
 
-class RequestGetTaskResultSer(PostRequestSer):
-    taskId: Optional[str] = Field(None, description="ID created by the createTask method")
+class RequestGetTaskResultSer(MyBaseModel):
+    clientKey: str
+    taskId: Optional[str] = None
 
 
 """
@@ -32,124 +49,14 @@ HTTP API Response ser
 """
 
 
-class ResponseSer(BaseModel):
-    errorId: int = Field(..., description="Error message: `False` - no error, `True` - with error")
+class ResponseSer(MyBaseModel):
+    errorId: int = 0
     # error info
-    errorCode: Optional[str] = Field(None, description="Error code")
-    errorDescription: Optional[str] = Field(None, description="Error description")
+    errorCode: Optional[str] = None
+    errorDescription: Optional[str] = None
 
 
 class CaptchaResponseSer(ResponseSer):
-    taskId: Optional[str] = Field(None, description="Task ID for future use in getTaskResult method.")
-    status: ResponseStatusEnm = Field(ResponseStatusEnm.Processing, description="Task current status")
-    solution: Dict[str, Any] = Field(None, description="Task result data. Different for each type of task.")
-
-    class Config:
-        populate_by_name = True
-
-
-class ControlResponseSer(ResponseSer):
-    balance: Optional[float] = Field(0, description="Account balance value in USD")
-
-
-"""
-Other ser
-"""
-
-
-class CaptchaOptionsSer(BaseModel):
-    api_key: str
-    sleep_time: conint(ge=5) = 5
-
-
-"""
-Captcha tasks ser
-"""
-
-
-class WebsiteDataOptionsSer(TaskSer):
-    websiteURL: str = Field(..., description="Address of a webpage with Captcha")
-    websiteKey: Optional[str] = Field(None, description="Website key")
-
-
-class ReCaptchaV3Ser(WebsiteDataOptionsSer):
-    pageAction: str = Field(
-        "verify",
-        description="Widget action value."
-        "Website owner defines what user is doing on the page through this parameter",
-    )
-
-
-class HCaptchaClassificationOptionsSer(TaskSer):
-    queries: List[str] = Field(..., description="Base64-encoded images, do not include 'data:image/***;base64,'")
-    question: str = Field(
-        ..., description="Question ID. Support English and Chinese, other languages please convert yourself"
-    )
-
-
-class FunCaptchaClassificationOptionsSer(TaskSer):
-    images: List[str] = Field(..., description="Base64-encoded images, do not include 'data:image/***;base64,'")
-    question: str = Field(
-        ...,
-        description="Question name. this param value from API response game_variant field. Exmaple: maze,maze2,flockCompass,3d_rollball_animals",
-    )
-
-
-class GeeTestSer(TaskSer):
-    websiteURL: str = Field(..., description="Address of a webpage with Geetest")
-    gt: str = Field(..., description="The domain public key, rarely updated")
-    challenge: Optional[str] = Field(
-        "",
-        description="If you need to solve Geetest V3 you must use this parameter, don't need if you need to solve GeetestV4",
-    )
-
-
-class FunCaptchaSer(TaskSer):
-    websiteURL: str = Field(..., description="Address of a webpage with Funcaptcha")
-    websitePublicKey: str = Field(..., description="Funcaptcha website key.")
-    funcaptchaApiJSSubdomain: Optional[str] = Field(
-        None,
-        description="A special subdomain of funcaptcha.com, from which the JS captcha widget should be loaded."
-        "Most FunCaptcha installations work from shared domains.",
-    )
-
-
-class DatadomeSliderSer(TaskSer):
-    websiteURL: str = Field(..., description="Address of a webpage with DatadomeSlider")
-    captchaUrl: str = Field(..., description="Captcha Url where is the captcha")
-    userAgent: str = Field(..., description="Browser's User-Agent which is used in emulation")
-
-
-class CloudflareTurnstileSer(WebsiteDataOptionsSer): ...
-
-
-class CyberSiAraSer(WebsiteDataOptionsSer):
-    SlideMasterUrlId: str = Field(
-        ..., description="You can get MasterUrlId param form `api/CyberSiara/GetCyberSiara` endpoint request"
-    )
-    UserAgent: str = Field(..., description="Browser userAgent, you need submit your userAgent")
-
-
-class AntiAkamaiBMPTaskSer(TaskSer):
-    packageName: str = Field("de.zalando.iphone", description="Package name of AkamaiBMP mobile APP")
-    version: str = Field("3.2.6", description="AKAMAI BMP Version number")
-    country: str = Field("US", description="AKAMAI BMP country")
-
-
-class AntiAkamaiWebTaskSer(TaskSer):
-    url: str = Field(..., description="Browser url address")
-
-
-class AntiImpervaTaskSer(TaskSer):
-    websiteUrl: str = Field(..., description="The website url")
-    userAgent: str = Field(..., description="Browser userAgent")
-    utmvc: bool = Field(
-        True, description="If cookie contains `incap_see_xxx`, `nlbi_xxx`, `visid_inap_xxx`, mean is true"
-    )
-    reese84: bool = Field(True, description="if cookie conains `reese84`, set it true")
-
-
-class BinanceCaptchaTaskSer(TaskSer):
-    websiteURL: str = Field(..., description="Address of a webpage with Binance captcha")
-    websiteKey: str = Field("login", description="`bizId` always be `login`")
-    validateId: str = Field(..., description="`validateId` bncaptcha validateId field")
+    taskId: Optional[str] = None
+    status: ResponseStatusEnm = ResponseStatusEnm.Processing
+    solution: Optional[Dict[str, Any]] = None

python3_capsolver/core/sio_captcha_instrument.py

@@ -0,0 +1,116 @@
+import time
+import logging
+from typing import Optional
+from urllib import parse
+
+import requests
+from requests.adapters import HTTPAdapter
+
+from .enum import ResponseStatusEnm, EndpointPostfixEnm
+from .const import RETRIES, REQUEST_URL, VALID_STATUS_CODES, GET_BALANCE_POSTFIX
+from .utils import attempts_generator
+from .serializer import CaptchaResponseSer
+from .captcha_instrument import CaptchaInstrument
+
+__all__ = ("SIOCaptchaInstrument",)
+
+
+class SIOCaptchaInstrument(CaptchaInstrument):
+    """
+    Instrument for working with sync captcha
+    """
+
+    def __init__(self, captcha_params: "CaptchaParams"):
+        super().__init__()
+        self.captcha_params = captcha_params
+        self.created_task_data = CaptchaResponseSer
+        # prepare session
+        self.session = requests.Session()
+        self.session.mount("http://", HTTPAdapter(max_retries=RETRIES))
+        self.session.mount("https://", HTTPAdapter(max_retries=RETRIES))
+        self.session.verify = False
+
+    def processing_captcha(self) -> dict:
+        self.captcha_params.create_task_payload.task = self.captcha_params.task_params
+
+        self.created_task_data = CaptchaResponseSer(**self.__create_task())
+
+        # if task created and ready - return result
+        if self.created_task_data.errorId == 0 and self.created_task_data.status == ResponseStatusEnm.Processing:
+            return 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()
+
+    def __create_task(self, url_postfix: str = EndpointPostfixEnm.CREATE_TASK.value) -> dict:
+        """
+        Function send SYNC request to service and wait for result
+        """
+        try:
+            resp = self.session.post(
+                parse.urljoin(self.captcha_params.request_url, url_postfix),
+                json=self.captcha_params.create_task_payload.to_dict(),
+            )
+            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.captcha_params.sleep_time)
+
+        self.captcha_params.get_result_params.taskId = self.created_task_data.taskId
+
+        attempts = attempts_generator()
+        for _ in attempts:
+            try:
+                resp = self.session.post(
+                    parse.urljoin(self.captcha_params.request_url, url_postfix),
+                    json=self.captcha_params.get_result_params.to_dict(),
+                )
+                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.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
+    def send_post_request(
+        payload: Optional[dict] = None,
+        session: requests.Session = requests.Session(),
+        url_postfix: str = GET_BALANCE_POSTFIX,
+    ) -> dict:
+        """
+        Function send SYNC request to service and wait for result
+        """
+        try:
+            resp = session.post(parse.urljoin(REQUEST_URL, url_postfix), json=payload)
+            if resp.status_code == 200:
+                return resp.json()
+            else:
+                raise ValueError(resp.status_code)
+        except Exception as error:
+            logging.exception(error)
+            raise

python3_capsolver/core/{config.py → utils.py}

@@ -1,15 +1,6 @@
 from typing import Generator
 
-from tenacity import AsyncRetrying, wait_fixed, stop_after_attempt
-from requests.adapters import Retry
-
-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"
-VALID_STATUS_CODES = (200, 202, 400, 401, 405)
-
-APP_ID = "3E36E3CD-7EB5-4CAF-AA15-91011E652321"
+__all__ = ("attempts_generator",)
 
 
 # Connection retry generator

python3_capsolver/datadome_slider.py

@@ -1,103 +1,75 @@
 from typing import Union
 
-from python3_capsolver.core.base import BaseCaptcha
-from python3_capsolver.core.enum import DatadomeSliderTypeEnm
-from python3_capsolver.core.serializer import DatadomeSliderSer, CaptchaResponseSer
+from .core.base import CaptchaParams
+from .core.enum import CaptchaTypeEnm
 
 
-class DatadomeSlider(BaseCaptcha):
+class DatadomeSlider(CaptchaParams):
     """
-    The class is used to work with Capsolver DatadomeSlider method.
+    The class is used to work with Capsolver DatadomeSliderTask method.
 
     Args:
         api_key: Capsolver API key
-        websiteURL: Address of the webpage
-        captchaUrl: Captcha Url where is the captcha
-        proxy: Proxy data
-        userAgent: Browser's User-Agent which is used in emulation
+        captcha_type: Captcha type name, like ``DatadomeSliderTask`` and etc.
+        kwargs: additional params for client, like captcha waiting time
+                    available keys:
+                     - sleep_time: int - captcha solution waintig time in sec
+                     - request_url: str - API address for sending requests,
+                                            else official will be used
 
     Examples:
-        >>> DatadomeSlider(api_key="CAI-1324...",
-        ...         captcha_type=DatadomeSliderTypeEnm.DatadomeSliderTask,
-        ...         websiteURL="https://www.some-url.com/",
-        ...         captchaUrl="https://www.some-url.com/to-page-with-captcha",
-        ...         proxy="socks5:158.120.100.23:334:user:pass",
-        ...         userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36",
-        ...        ).captcha_handler()
-        CaptchaResponseSer(errorId=0,
-                           errorCode=None,
-                           errorDescription=None,
-                           taskId='73bdcd28-6c77-4414-8....',
-                           status=<ResponseStatusEnm.Ready: 'ready'>,
-                           solution={'gRecaptchaResponse': '44795sds...'}
-                          )
-
-        >>> await DatadomeSlider(api_key="CAI-1324...",
-        ...         captcha_type="DatadomeSliderTask",
-        ...         websiteURL="https://www.some-url.com/",
-        ...         captchaUrl="https://www.some-url.com/to-page-with-captcha",
-        ...         proxy="socks5:158.120.100.23:334:user:pass",
-        ...         userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36",
-        ...        ).aio_captcha_handler()
-        CaptchaResponseSer(errorId=0,
-                           errorCode=None,
-                           errorDescription=None,
-                           taskId='73bdcd28-6c77-4414-8....',
-                           status=<ResponseStatusEnm.Ready: 'ready'>,
-                           solution={'gRecaptchaResponse': '44795sds...'}
-                          )
-
-    Returns:
-        CaptchaResponseSer model with full server response
+        >>> from python3_capsolver.datadome_slider import DatadomeSlider
+        >>> from python3_capsolver.core.enum import CaptchaTypeEnm
+        >>> DatadomeSlider(api_key="CAI-12345....",
+        ...             captcha_type=CaptchaTypeEnm.DatadomeSliderTask)
+        ...         .captcha_handler(task_payload={
+        ...                 "captchaUrl": "https://geo.captchaxxxxxx",
+        ...                 "userAgent": "Mozilla/5.0 xxxx",
+        ...                 "proxy": "0.0.0.0:334:user:pass"
+        ...         })
+        {
+           "errorId":0,
+           "errorCode":"None",
+           "errorDescription":"None",
+           "taskId":"db0a3153-621d-4f5e-8554-a1c032597ee7",
+           "status":"ready",
+           "solution":{
+                "userAgent": "Mozilla/5.0 xxxx",
+                "cookie": "datadome=yzj_BK..xxxx"
+           }
+        }
+
+        >>> import asyncio
+        >>> from python3_capsolver.datadome_slider import DatadomeSlider
+        >>> from python3_capsolver.core.enum import CaptchaTypeEnm
+        >>> asyncio.run(DatadomeSlider(api_key="CAI-12345....",
+        ...             captcha_type=CaptchaTypeEnm.DatadomeSliderTask)
+        ...         .aio_captcha_handler(task_payload={
+        ...                 "captchaUrl": "https://geo.captchaxxxxxx",
+        ...                 "userAgent": "Mozilla/5.0 xxxx",
+        ...                 "proxy": "0.0.0.0:334:user:pass"
+        ...         }))
+        {
+           "errorId":0,
+           "errorCode":"None",
+           "errorDescription":"None",
+           "taskId":"db0a3153-621d-4f5e-8554-a1c032597ee7",
+           "status":"ready",
+           "solution":{
+                "userAgent": "Mozilla/5.0 xxxx",
+                "cookie": "datadome=yzj_BK..xxxx"
+           }
+        }
 
     Notes:
-        https://docs.capsolver.com/guide/antibots/datadome.html
+        https://docs.capsolver.com/en/guide/captcha/datadome/
     """
 
     def __init__(
         self,
-        websiteURL: str,
-        captchaUrl: str,
-        userAgent: str,
-        captcha_type: Union[DatadomeSliderTypeEnm, str] = DatadomeSliderTypeEnm.DatadomeSliderTask,
-        *args,
+        api_key: str,
+        captcha_type: Union[CaptchaTypeEnm, str] = CaptchaTypeEnm.DatadomeSliderTask,
         **kwargs,
     ):
-        super().__init__(*args, **kwargs)
-
-        if captcha_type in DatadomeSliderTypeEnm.list():
-            self.task_params = DatadomeSliderSer(**locals()).dict()
-        else:
-            raise ValueError(
-                f"""Invalid `captcha_type` parameter set for `{self.__class__.__name__}`,
-                available - {DatadomeSliderTypeEnm.list()}"""
-            )
-        for key in kwargs:
-            self.task_params.update({key: kwargs[key]})
-
-    def captcha_handler(self) -> CaptchaResponseSer:
-        """
-        Sync method for captcha solving
-
-        Returns:
-            CaptchaResponseSer model with full service response
-
-        Notes:
-            Check class docstring for more info
-        """
-        return self._processing_captcha(create_params=self.task_params)
-
-    async def aio_captcha_handler(
-        self,
-        **additional_params,
-    ) -> CaptchaResponseSer:
-        """
-        Async method for captcha solving
-
-        Returns:
-            CaptchaResponseSer model with full service response
 
-        Notes:
-            Check class docstring for more info
-        """
-        return await self._aio_processing_captcha(create_params=self.task_params)
+        super().__init__(api_key=api_key, captcha_type=captcha_type, **kwargs)