capmonstercloudclient 1.6.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

capmonstercloudclient/CapMonsterCloudClient.py

@@ -14,22 +14,23 @@ from .utils import parseVersion
 
 
 _instance_config = (
-    ((RecaptchaV2ProxylessRequest, RecaptchaV2Request), getRecaptchaV2Timeouts),
-    ((RecaptchaV2EnterpriseProxylessRequest, RecaptchaV2EnterpriseRequest), getRecaptchaV2EnterpriseTimeouts),
+    ((RecaptchaV2Request,), getRecaptchaV2Timeouts),
+    ((RecaptchaV2EnterpriseRequest,), getRecaptchaV2EnterpriseTimeouts),
     ((RecaptchaV3ProxylessRequest), getRecaptchaV3Timeouts),
     ((ImageToTextRequest), getImage2TextTimeouts),
-    ((FuncaptchaProxylessRequest, FuncaptchaRequest), getFuncaptchaTimeouts),
-    ((HcaptchaProxylessRequest, HcaptchaRequest), getHcaptchaTimeouts),
-    ((GeetestProxylessRequest, GeetestRequest), getGeetestTimeouts),
-    ((TurnstileProxylessRequest, TurnstileRequest), getTurnstileTimeouts),
+    ((FuncaptchaRequest,), getFuncaptchaTimeouts),
+    ((HcaptchaRequest,), getHcaptchaTimeouts),
+    ((GeetestRequest,), getGeetestTimeouts),
+    ((TurnstileRequest,), getTurnstileTimeouts),
     ((RecaptchaComplexImageTaskRequest, HcaptchaComplexImageTaskRequest, 
       FunCaptchaComplexImageTaskRequest), getImage2TextTimeouts),
-    ((DataDomeCustomTaskRequest, DataDomeCustomTaskProxylessRequest), getDatadomeTimeouts),
-    ((TenDiCustomTaskRequest, TenDiCustomTaskProxylessRequest), getTenDiTimeouts),
-    ((BasiliskCustomTaskRequest, BasiliskCustomTaskProxylessRequest), getBasiliskTimeouts),
-    ((AmazonWafRequest, AmazonWafProxylessRequest), getAmazonWafTimeouts),
-    ((BinanceTaskRequest, BinanceTaskProxylessRequest), getBinanceTimeouts),
-    ((ImpervaCustomTaskRequest, ImpervaCustomTaskProxylessRequest), getImpervaTimeouts)
+    ((DataDomeCustomTaskRequest,), getDatadomeTimeouts),
+    ((TenDiCustomTaskRequest,), getTenDiTimeouts),
+    ((BasiliskCustomTaskRequest,), getBasiliskTimeouts),
+    ((AmazonWafRequest,), getAmazonWafTimeouts),
+    ((BinanceTaskRequest,), getBinanceTimeouts),
+    ((ImpervaCustomTaskRequest,), getImpervaTimeouts),
+    ((RecognitionComplexImageTaskRequest), getCITTimeouts)
 )
 
 
@@ -60,29 +61,25 @@ class CapMonsterClient:
                 return result
 
 
-    async def solve_captcha(self, request: Union[RecaptchaV2EnterpriseProxylessRequest,
+    async def solve_captcha(self, request: Union[
                                                  RecaptchaV2EnterpriseRequest, 
                                                  RecaptchaV2Request,
-                                                 RecaptchaV2ProxylessRequest, 
                                                  RecaptchaV3ProxylessRequest,
-                                                 ImageToTextRequest, 
-                                                 FuncaptchaProxylessRequest,
-                                                 FuncaptchaRequest, 
-                                                 HcaptchaRequest, 
-                                                 HcaptchaProxylessRequest,
-                                                 GeetestProxylessRequest, 
-                                                 GeetestRequest,
-                                                 TurnstileProxylessRequest, 
-                                                 TurnstileRequest,
-                                                 HcaptchaComplexImageTaskRequest, 
                                                  RecaptchaComplexImageTaskRequest,
+                                                 ImageToTextRequest, 
+                                                 FuncaptchaRequest,
                                                  FunCaptchaComplexImageTaskRequest,
-                                                 DataDomeCustomTaskProxylessRequest,
+                                                 HcaptchaRequest,
+                                                 HcaptchaComplexImageTaskRequest,
+                                                 GeetestRequest,
                                                  DataDomeCustomTaskRequest,
+                                                 TenDiCustomTaskRequest,
+                                                 BasiliskCustomTaskRequest,
+                                                 AmazonWafRequest,
                                                  BinanceTaskRequest,
-                                                 BinanceTaskProxylessRequest,
                                                  ImpervaCustomTaskRequest,
-                                                 ImpervaCustomTaskProxylessRequest],
+                                                 TurnstileRequest,
+                                                 RecognitionComplexImageTaskRequest],
                             ) -> Dict[str, str]:
         '''
         Non-blocking method for captcha solving. 
@@ -97,27 +94,25 @@ class CapMonsterClient:
         raise UnknownRequestInstanceError(f'Unknown request instance "{type(request)}", ' \
                                             f'expected that request will belong next instances: {rs_all}')
         
-    async def _solve(self, request: Union[RecaptchaV2EnterpriseProxylessRequest,
+    async def _solve(self, request: Union[
                                           RecaptchaV2EnterpriseRequest, 
                                           RecaptchaV2Request,
-                                          RecaptchaV2ProxylessRequest, 
                                           RecaptchaV3ProxylessRequest,
-                                          ImageToTextRequest, 
-                                          FuncaptchaProxylessRequest,
-                                          FuncaptchaRequest, 
-                                          HcaptchaRequest, 
-                                          HcaptchaProxylessRequest,
-                                          GeetestProxylessRequest, 
-                                          GeetestRequest,
-                                          TurnstileProxylessRequest, 
-                                          TurnstileRequest,
-                                          HcaptchaComplexImageTaskRequest, 
                                           RecaptchaComplexImageTaskRequest,
+                                          ImageToTextRequest, 
+                                          FuncaptchaRequest,
                                           FunCaptchaComplexImageTaskRequest,
+                                          HcaptchaRequest,
+                                          HcaptchaComplexImageTaskRequest,
+                                          GeetestRequest,
+                                          DataDomeCustomTaskRequest,
+                                          TenDiCustomTaskRequest,
+                                          BasiliskCustomTaskRequest,
+                                          AmazonWafRequest,
                                           BinanceTaskRequest,
-                                          BinanceTaskProxylessRequest,
                                           ImpervaCustomTaskRequest,
-                                          ImpervaCustomTaskProxylessRequest],
+                                          TurnstileRequest,
+                                          RecognitionComplexImageTaskRequest],
                            timeouts: GetResultTimeouts,
                            ) -> Dict[str, str]:
 

capmonstercloudclient/GetResultTimeouts.py

@@ -49,3 +49,6 @@ def getBinanceTimeouts() -> GetResultTimeouts:
 
 def getImpervaTimeouts() -> GetResultTimeouts:
     return GetResultTimeouts(1, 0, 1, 20)
+
+def getCITTimeouts() -> GetResultTimeouts:
+    return GetResultTimeouts(0.35, 0, 0.2, 10)

capmonstercloudclient/requests/AmazonWafRequest.py

@@ -1,11 +1,17 @@
-from typing import Dict, Union
-from pydantic import Field, validator
+from typing import Dict, Union, Optional
+from pydantic import Field
 
-from .proxy_info import ProxyInfo
-from .AmazonWafRequestBase import AmazonWafRequestBase
+from .baseRequestWithProxy import BaseRequestWithProxy
 
-class AmazonWafRequest(AmazonWafRequestBase, ProxyInfo):
+class AmazonWafRequest(BaseRequestWithProxy):
     type: str = 'AmazonTask'
+    websiteUrl: str
+    challengeScript: str
+    captchaScript: str
+    websiteKey: str
+    context: str
+    iv: str
+    cookieSolution: Optional[bool] = Field(default=None)
 
     def getTaskDict(self) -> Dict[str, Union[str, int, bool]]:
         task = {}
@@ -16,12 +22,13 @@ class AmazonWafRequest(AmazonWafRequestBase, ProxyInfo):
         task['websiteKey'] = self.websiteKey
         task['context'] = self.context
         task['iv'] = self.iv
-
-        task['proxyType'] = self.proxyType
-        task['proxyAddress'] = self.proxyAddress
-        task['proxyPort'] = self.proxyPort
-        task['proxyLogin'] = self.proxyLogin
-        task['proxyPassword'] = self.proxyPassword
+        
+        if self.proxy:
+            task['proxyType'] = self.proxy.proxyType
+            task['proxyAddress'] = self.proxy.proxyAddress
+            task['proxyPort'] = self.proxy.proxyPort
+            task['proxyLogin'] = self.proxy.proxyLogin
+            task['proxyPassword'] = self.proxy.proxyPassword
         
         if self.cookieSolution is not None:
             task['cookieSolution'] = self.cookieSolution

capmonstercloudclient/requests/BasiliskCustomTaskRequest.py

@@ -1,10 +1,11 @@
 from typing import Dict, Union
-from pydantic import Field, validator
+from pydantic import Field
 
-from .proxy_info import ProxyInfo
-from .BasiliskCustomTaskRequestBase import BasiliskCustomTaskRequestBase
+from .CustomTaskRequestBase import CustomTaskRequestBase
 
-class BasiliskCustomTaskRequest(BasiliskCustomTaskRequestBase, ProxyInfo):
+class BasiliskCustomTaskRequest(CustomTaskRequestBase):
+    captchaClass: str = Field(default='Basilisk')
+    websiteKey: str = Field()
     
     def getTaskDict(self) -> Dict[str, Union[str, int, bool]]:
         task = {}
@@ -12,11 +13,12 @@ class BasiliskCustomTaskRequest(BasiliskCustomTaskRequestBase, ProxyInfo):
         task['class'] = self.captchaClass
         task['websiteURL'] = self.websiteUrl
         task['websiteKey'] = self.websiteKey
-        task['proxyType'] = self.proxyType
-        task['proxyAddress'] = self.proxyAddress
-        task['proxyPort'] = self.proxyPort
-        task['proxyLogin'] = self.proxyLogin
-        task['proxyPassword'] = self.proxyPassword
+        if self.proxy:
+            task['proxyType'] = self.proxy.proxyType
+            task['proxyAddress'] = self.proxy.proxyAddress
+            task['proxyPort'] = self.proxy.proxyPort
+            task['proxyLogin'] = self.proxy.proxyLogin
+            task['proxyPassword'] = self.proxy.proxyPassword
         if self.userAgent is not None:
             task['userAgent'] = self.userAgent
         return task

capmonstercloudclient/requests/BinanceTaskRequest.py

@@ -1,22 +1,29 @@
-from typing import Dict, Union
-from pydantic import Field, validator
+from typing import Dict, Union, Optional
+from pydantic import Field
 
-from .proxy_info import ProxyInfo
-from .BinanceTaskRequestBase import BinanceTaskRequestBase
+from .baseRequestWithProxy import BaseRequestWithProxy
+
+class BinanceTaskRequest(BaseRequestWithProxy):
+    type: str = Field(default='BinanceTask')
+    websiteKey: str = Field()
+    websiteUrl: str = Field()
+    validateId: str = Field()
+    userAgent: Optional[str] = None
 
-class BinanceTaskRequest(BinanceTaskRequestBase, ProxyInfo):
-    
     def getTaskDict(self) -> Dict[str, Union[str, int, bool]]:
         task = {}
         task['type'] = self.type
         task['validateId'] = self.validateId
         task['websiteURL'] = self.websiteUrl
         task['websiteKey'] = self.websiteKey
-        task['proxyType'] = self.proxyType
-        task['proxyAddress'] = self.proxyAddress
-        task['proxyPort'] = self.proxyPort
-        task['proxyLogin'] = self.proxyLogin
-        task['proxyPassword'] = self.proxyPassword
+
+        if self.proxy:
+            task['proxyType'] = self.proxy.proxyType
+            task['proxyAddress'] = self.proxy.proxyAddress
+            task['proxyPort'] = self.proxy.proxyPort
+            task['proxyLogin'] = self.proxy.proxyLogin
+            task['proxyPassword'] = self.proxy.proxyPassword
+        
         if self.userAgent is not None:
             task['userAgent'] = self.userAgent
         return task

capmonstercloudclient/requests/CustomTaskRequestBase.py

@@ -1,8 +1,8 @@
-from typing import Optional, List, Dict
+from typing import Optional, List
 
-from .baseRequest import BaseRequest
+from .baseRequestWithProxy import BaseRequestWithProxy
 
-class CustomTaskRequestBase(BaseRequest):
+class CustomTaskRequestBase(BaseRequestWithProxy):
     captchaClass: str # Class(subtype) of ComplexImageTask
     type: str = "CustomTask" # Recognition task type
     websiteUrl: str # Address of a webpage with captcha

capmonstercloudclient/requests/DataDomeCustomTaskRequest.py

@@ -1,9 +1,9 @@
 from typing import Dict, Union
 from pydantic import Field, validator
-from .DataDomeCustomTaskRequestBase import DataDomeCustomTaskRequestBase
-from .proxy_info import ProxyInfo
+from .CustomTaskRequestBase import CustomTaskRequestBase
 
-class DataDomeCustomTaskRequest(DataDomeCustomTaskRequestBase, ProxyInfo):
+class DataDomeCustomTaskRequest(CustomTaskRequestBase):
+    captchaClass: str = Field(default='DataDome')
     metadata : Dict[str, str]
     
     @validator('metadata')
@@ -28,11 +28,12 @@ class DataDomeCustomTaskRequest(DataDomeCustomTaskRequestBase, ProxyInfo):
         task['type'] = self.type
         task['class'] = self.captchaClass
         task['websiteURL'] = self.websiteUrl
-        task['proxyType'] = self.proxyType
-        task['proxyAddress'] = self.proxyAddress
-        task['proxyPort'] = self.proxyPort
-        task['proxyLogin'] = self.proxyLogin
-        task['proxyPassword'] = self.proxyPassword
+        if self.proxy:
+            task['proxyType'] = self.proxy.proxyType
+            task['proxyAddress'] = self.proxy.proxyAddress
+            task['proxyPort'] = self.proxy.proxyPort
+            task['proxyLogin'] = self.proxy.proxyLogin
+            task['proxyPassword'] = self.proxy.proxyPassword
         task['domains'] = self.domains
         task['metadata'] = self.metadata
         if self.userAgent is not None:

capmonstercloudclient/requests/FuncaptchaRequest.py

@@ -1,22 +1,27 @@
-from typing import Dict, Union
+from typing import Dict, Union, Optional
 from pydantic import Field
 
-from .FuncaptchaRequestBase import FuncaptchaRequestBase
-from .proxy_info import ProxyInfo
+from .baseRequestWithProxy import BaseRequestWithProxy
 
-class FuncaptchaRequest(FuncaptchaRequestBase, ProxyInfo):
+class FuncaptchaRequest(BaseRequestWithProxy):
     type: str = Field(default='FunCaptchaTask')
-
+    websiteUrl: str
+    websitePublicKey: str
+    funcaptchaApiJSSubdomain: Optional[str] = Field(default=None)
+    data: Optional[str] = Field(default=None)
+    
     def getTaskDict(self) -> Dict[str, Union[str, int, bool]]:
         task = {}
         task['type'] = self.type
         task['websiteURL'] = self.websiteUrl
         task['websitePublicKey'] = self.websitePublicKey
-        task['proxyType'] = self.proxyType
-        task['proxyAddress'] = self.proxyAddress
-        task['proxyPort'] = self.proxyPort
-        task['proxyLogin'] = self.proxyLogin
-        task['proxyPassword'] = self.proxyPassword
+        if self.proxy:
+            task['proxyType'] = self.proxy.proxyType
+            task['proxyAddress'] = self.proxy.proxyAddress
+            task['proxyPort'] = self.proxy.proxyPort
+            task['proxyLogin'] = self.proxy.proxyLogin
+            task['proxyPassword'] = self.proxy.proxyPassword
+        
         if self.funcaptchaApiJSSubdomain is not None:
             task['funcaptchaApiJSSubdomain'] = self.funcaptchaApiJSSubdomain
         if self.data is not None:

capmonstercloudclient/requests/GeetestRequest.py

@@ -1,12 +1,26 @@
-from pydantic import Field
-from typing import Dict, Union
+from pydantic import Field, validator
+from typing import Dict, Union, Optional
 
-from .GeetestRequestBase import GeetestRequestBase
-from .proxy_info import ProxyInfo
+from .baseRequestWithProxy import BaseRequestWithProxy
 
-class GeetestRequest(GeetestRequestBase, ProxyInfo):
+
+class GeetestRequest(BaseRequestWithProxy):
     type: str = Field(default='GeeTestTask')
+    websiteUrl: str
+    gt: str
+    challenge: Optional[str] = Field(default=None)
+    version: int = Field(default=3)
+    initParameters: Optional[Dict] = Field(default=None)
+    geetestApiServerSubdomain: Optional[str] = Field(default=None)
+    geetestGetLib: Optional[str] = Field(default=None)
+    user_agent: Optional[str] = Field(default=None)
 
+    @validator('version')
+    def validate_version(cls, value):
+        if value not in [3, 4]:
+            raise ValueError(f"Geetest version could be 3 or 4, not {value}")
+        return value
+    
     def getTaskDict(self) -> Dict[str, Union[str, int, bool]]:
         task = {}
         task['type'] = self.type
@@ -30,9 +44,10 @@ class GeetestRequest(GeetestRequestBase, ProxyInfo):
         if self.user_agent is not None:
             task['userAgent'] = self.user_agent
         
-        task['proxyType'] = self.proxyType
-        task['proxyAddress'] = self.proxyAddress
-        task['proxyPort'] = self.proxyPort
-        task['proxyLogin'] = self.proxyLogin
-        task['proxyPassword'] = self.proxyPassword
+        if self.proxy:
+            task['proxyType'] = self.proxy.proxyType
+            task['proxyAddress'] = self.proxy.proxyAddress
+            task['proxyPort'] = self.proxy.proxyPort
+            task['proxyLogin'] = self.proxy.proxyLogin
+            task['proxyPassword'] = self.proxy.proxyPassword
         return task

capmonstercloudclient/requests/HcaptchaRequest.py

@@ -1,11 +1,17 @@
 from pydantic import Field
-from typing import Dict, Union
+from typing import Dict, Union, Optional
 
-from .HcaptchaRequestBase import HcaptchaRequestBase
-from .proxy_info import ProxyInfo
+from .baseRequestWithProxy import BaseRequestWithProxy
 
-class HcaptchaRequest(HcaptchaRequestBase, ProxyInfo):
+class HcaptchaRequest(BaseRequestWithProxy):
     type: str = Field(default='HCaptchaTask')
+    websiteUrl: str
+    websiteKey: str
+    is_invisible: Optional[bool] = Field(default=None)
+    data: Optional[str] = Field(default=None)
+    user_agent: Optional[str] = Field(default=None)
+    cookies: Optional[str] = Field(default=None)
+    fallbackToActualUA: Optional[bool] = Field(default=None)
 
     def getTaskDict(self) -> Dict[str, Union[str, int, bool]]:
 
@@ -13,11 +19,12 @@ class HcaptchaRequest(HcaptchaRequestBase, ProxyInfo):
         task['type'] = self.type
         task['websiteURL'] = self.websiteUrl
         task['websiteKey'] = self.websiteKey
-        task['proxyType'] = self.proxyType
-        task['proxyAddress'] = self.proxyAddress
-        task['proxyPort'] = self.proxyPort
-        task['proxyLogin'] = self.proxyLogin
-        task['proxyPassword'] = self.proxyPassword
+        if self.proxy:
+            task['proxyType'] = self.proxy.proxyType
+            task['proxyAddress'] = self.proxy.proxyAddress
+            task['proxyPort'] = self.proxy.proxyPort
+            task['proxyLogin'] = self.proxy.proxyLogin
+            task['proxyPassword'] = self.proxy.proxyPassword
         if self.is_invisible is not None:
             task['isInvisible'] = self.is_invisible
         if self.data is not None:

capmonstercloudclient/requests/ImageToTextRequest.py

@@ -1,6 +1,6 @@
 import base64
 
-from pydantic import validator, Field, BaseModel
+from pydantic import validator, Field
 from typing import Optional, Dict, Union
 from .baseRequest import BaseRequest
 from .enums import TextModules

capmonstercloudclient/requests/ImpervaCustomTaskRequest.py

@@ -1,10 +1,10 @@
 from typing import Dict, Union
 from pydantic import Field, validator
 
-from .proxy_info import ProxyInfo
-from .ImpervaCustomTaskRequestBase import ImpervaCustomTaskRequestBase
+from .CustomTaskRequestBase import CustomTaskRequestBase
 
-class ImpervaCustomTaskRequest(ImpervaCustomTaskRequestBase, ProxyInfo):
+class ImpervaCustomTaskRequest(CustomTaskRequestBase):
+    captchaClass: str = Field(default='Imperva')
     metadata : Dict[str, str]
     
     @validator('metadata')
@@ -29,11 +29,12 @@ class ImpervaCustomTaskRequest(ImpervaCustomTaskRequestBase, ProxyInfo):
         task['class'] = self.captchaClass
         task['websiteURL'] = self.websiteUrl
         task['metadata'] = self.metadata
-        task['proxyType'] = self.proxyType
-        task['proxyAddress'] = self.proxyAddress
-        task['proxyPort'] = self.proxyPort
-        task['proxyLogin'] = self.proxyLogin
-        task['proxyPassword'] = self.proxyPassword
+        if self.proxy:
+            task['proxyType'] = self.proxy.proxyType
+            task['proxyAddress'] = self.proxy.proxyAddress
+            task['proxyPort'] = self.proxy.proxyPort
+            task['proxyLogin'] = self.proxy.proxyLogin
+            task['proxyPassword'] = self.proxy.proxyPassword
         if self.userAgent is not None:
             task['userAgent'] = self.userAgent
         return task

capmonstercloudclient/requests/RecaptchaComplexImageTask.py

@@ -1,4 +1,4 @@
-from typing import Dict, Union, Optional
+from typing import Dict, Union
 from pydantic import Field, validator
 
 from .ComplexImageTaskBase import ComplexImageTaskRequestBase
@@ -71,7 +71,7 @@ class RecaptchaComplexImageTaskRequest(ComplexImageTaskRequestBase):
             
         if self.websiteUrl is not None:
             task["websiteUrl"] = self.websiteUrl
-        
+
         return task
     
     

capmonstercloudclient/requests/RecaptchaV2EnterpiseRequest.py

@@ -1,22 +1,26 @@
-from typing import Dict, Union
+from typing import Dict, Union, Optional
 from pydantic import Field
 
-from .RecaptchaV2EnterpriseRequestBase import RecaptchaV2EnterpriseRequestBase
-from .proxy_info import ProxyInfo
+from .baseRequestWithProxy import BaseRequestWithProxy
 
-class RecaptchaV2EnterpriseRequest(RecaptchaV2EnterpriseRequestBase, ProxyInfo):
+class RecaptchaV2EnterpriseRequest(BaseRequestWithProxy):
     type: str = Field(default='RecaptchaV2EnterpriseTask')
-
+    websiteUrl: str
+    websiteKey: str
+    enterprisePayload: Optional[str] = Field(default=None)
+    apiDomain: Optional[str] = Field(default=None)
+    
     def getTaskDict(self) -> Dict[str, Union[str, int]]:
         task = {}
         task['type'] = self.type
         task['websiteURL'] = self.websiteUrl
         task['websiteKey'] = self.websiteKey
-        task['proxyType'] = self.proxyType
-        task['proxyAddress'] = self.proxyAddress
-        task['proxyPort'] = self.proxyPort
-        task['proxyLogin'] = self.proxyLogin
-        task['proxyPassword'] = self.proxyPassword
+        if self.proxy:
+            task['proxyType'] = self.proxy.proxyType
+            task['proxyAddress'] = self.proxy.proxyAddress
+            task['proxyPort'] = self.proxy.proxyPort
+            task['proxyLogin'] = self.proxy.proxyLogin
+            task['proxyPassword'] = self.proxy.proxyPassword
         if self.enterprisePayload is not None:
             task['enterprisePayload'] = {'s': self.enterprisePayload}
         if self.apiDomain is not None:

capmonstercloudclient/requests/RecaptchaV2Request.py

@@ -1,23 +1,28 @@
-from typing import Dict, Union
+from typing import Dict, Union, Optional
 from pydantic import Field
-from .RecaptchaV2RequestBase import RecaptchaV2RequestBase
-from .proxy_info import ProxyInfo
+from .baseRequestWithProxy import BaseRequestWithProxy
 
 
-class RecaptchaV2Request(RecaptchaV2RequestBase, ProxyInfo):
+class RecaptchaV2Request(BaseRequestWithProxy):
     
     type: str = Field(default="NoCaptchaTask")
+    websiteUrl: str
+    websiteKey: str
+    dataSValue: Optional[str] = Field(default=None)
+    userAgent: Optional[str] = Field(default=None)
+    cookies: Optional[str] = Field(default=None)
 
     def getTaskDict(self) -> Dict[str, Union[str, int]]:
         task = {}
         task['type'] = self.type
         task['websiteURL'] = self.websiteUrl
         task['websiteKey'] = self.websiteKey
-        task['proxyType'] = self.proxyType
-        task['proxyAddress'] = self.proxyAddress
-        task['proxyPort'] = self.proxyPort
-        task['proxyLogin'] = self.proxyLogin
-        task['proxyPassword'] = self.proxyPassword
+        if self.proxy:
+            task['proxyType'] = self.proxy.proxyType
+            task['proxyAddress'] = self.proxy.proxyAddress
+            task['proxyPort'] = self.proxy.proxyPort
+            task['proxyLogin'] = self.proxy.proxyLogin
+            task['proxyPassword'] = self.proxy.proxyPassword
 
         if self.dataSValue is not None:
            task['recaptchaDataSValue'] = self.dataSValue

capmonstercloudclient/requests/RecognitionComplexImageTaskRequest.py

@@ -0,0 +1,45 @@
+from typing import Dict, Union
+from pydantic import validator
+from .ComplexImageTaskBase import ComplexImageTaskRequestBase
+from ..exceptions import ZeroImagesErrors, TaskNotDefinedError
+
+
+class RecognitionComplexImageTaskRequest(ComplexImageTaskRequestBase):
+    captchaClass: str = 'recognition'
+    metadata: Dict[str, str]
+
+    @validator('metadata')
+    def validate_metadata(cls, value):
+        if value.get('Task') is None:
+            raise TaskNotDefinedError(f'Expect that Task will be defined.')
+        else:
+            if not isinstance(value.get('Task'), str):
+                raise TypeError(f'Expect that Task will be str.')
+        if not set(value.keys()).issubset(set(["Task", "TaskArgument"])):
+            raise TypeError(f'Allowed keys for metadata are "Task" and "TaskArgument"')
+        return value
+    
+    @validator('imagesBase64')
+    def validate_images_array(cls, value):
+        if value is not None:
+            if not isinstance(value, (list, tuple)):
+                raise TypeError(f'Expect that type imagesBase64 array will be <list> or <tuple>, got {type(value)}')
+            elif not len(value):
+                raise ZeroImagesErrors(f'At least one image base64 expected, got {len(value)}')
+            # Check for each element type
+            contain_types = [isinstance(x, str) for x in value]
+            if not all(contain_types):
+                raise TypeError(f'Next images from imagesBase64 array are not string: {contain_types}')
+        else:
+            raise ZeroImagesErrors(f'At least one image base64 expected, got {len(value)}')
+        return value
+    
+    def getTaskDict(self) -> Dict[str, Union[str, int, bool]]:
+        task = {}
+        task['type'] = self.taskType
+        task['class'] = self.captchaClass
+        task['imagesBase64'] = self.imagesBase64
+        task['metadata'] = self.metadata
+        if self.userAgent is not None:
+            task['userAgent'] = self.userAgent
+        return task

capmonstercloudclient/requests/TenDiCustomTaskRequest.py

@@ -1,22 +1,24 @@
 from typing import Dict, Union
-from pydantic import Field, validator
+from pydantic import Field
 
-from .proxy_info import ProxyInfo
-from .TenDiCustomTaskRequestBase import TenDiCustomTaskRequestBase
+from .CustomTaskRequestBase import CustomTaskRequestBase
+
+class TenDiCustomTaskRequest(CustomTaskRequestBase):
+    captchaClass: str = Field(default='TenDI')
+    websiteKey: str = Field()
 
-class TenDiCustomTaskRequest(TenDiCustomTaskRequestBase, ProxyInfo):
-    
     def getTaskDict(self) -> Dict[str, Union[str, int, bool]]:
         task = {}
         task['type'] = self.type
         task['class'] = self.captchaClass
         task['websiteURL'] = self.websiteUrl
         task['websiteKey'] = self.websiteKey
-        task['proxyType'] = self.proxyType
-        task['proxyAddress'] = self.proxyAddress
-        task['proxyPort'] = self.proxyPort
-        task['proxyLogin'] = self.proxyLogin
-        task['proxyPassword'] = self.proxyPassword
+        if self.proxy:
+            task['proxyType'] = self.proxy.proxyType
+            task['proxyAddress'] = self.proxy.proxyAddress
+            task['proxyPort'] = self.proxy.proxyPort
+            task['proxyLogin'] = self.proxy.proxyLogin
+            task['proxyPassword'] = self.proxy.proxyPassword
         if self.userAgent is not None:
             task['userAgent'] = self.userAgent
         return task