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

capmonstercloudclient/CapMonsterCloudClient.py

@@ -14,22 +14,22 @@ 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)
 )
 
@@ -61,29 +61,24 @@ 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]:
         '''
@@ -99,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/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

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

@@ -1,7 +1,7 @@
-from typing import Optional, List, Dict, Union
+from typing import Dict, Union
 from pydantic import validator
 from .ComplexImageTaskBase import ComplexImageTaskRequestBase
-from ..exceptions import NumbersImagesErrors, ZeroImagesErrors, TaskNotDefinedError
+from ..exceptions import ZeroImagesErrors, TaskNotDefinedError
 
 
 class RecognitionComplexImageTaskRequest(ComplexImageTaskRequestBase):

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

capmonstercloudclient/requests/TurnstileRequest.py

@@ -1,13 +1,51 @@
-from typing import Dict
-from pydantic import Field
-from .TurnstileRequestBase import TurnstileRequestBase
-from .proxy_info import ProxyInfo
+from typing import Dict, Optional
+from pydantic import Field, validator, model_validator
+from .baseRequestWithProxy import BaseRequestWithProxy
 
 
-class TurnstileRequest(TurnstileRequestBase, ProxyInfo):
+class TurnstileRequest(BaseRequestWithProxy):
     
     type: str = Field(default="TurnstileTask")
+    websiteURL: str
+    websiteKey: str
+    pageAction: Optional[str] = Field(default=None)
+    data: Optional[str] = Field(default=None)
+    pageData: Optional[str] = Field(default=None)
+    userAgent: Optional[str] = Field(default=None)
+    cloudflareTaskType: Optional[str] = Field(default=None)
+    htmlPageBase64: Optional[str] = Field(default=None)
+    apiJsUrl: Optional[str] = Field(default=None)
 
+    @validator('cloudflareTaskType')
+    def validate_cloudflare_task(cls, value):
+        if value is not None:
+            if value not in ['cf_clearance', 'token']:
+                raise ValueError(f'cloudflareTaskType could be "cf_clearance" if you need cookie or ' \
+                                 f'"token" if required token from Turnstile.')
+        return value
+    
+    @model_validator(mode='before')
+    def validate_cloudflare_type_token(self):
+        
+        if self.get('htmlPageBase64') is None:
+            if self.get('cloudflareTaskType') == 'cf_clearance':
+                raise RuntimeError(f'Expect that "htmlPageBase64" will be filled ' \
+                    f'when cloudflareTaskType is "cf_clearance"')
+        
+        if self.get('cloudflareTaskType') == 'token':
+            for field in ['pageAction', 'pageData', 'data']:
+                if self.get(field) is None:
+                    raise RuntimeError(f'Expect that "{field}" will be filled ' \
+                    f'when "cloudflareTaskType" = "token".')
+        
+        if self.get('cloudflareTaskType') is not None:
+            if self.get('cloudflareTaskType') in ['cf_clearance', 'token']:
+                if self.get('userAgent') is None:
+                    raise RuntimeError(f'Expect that userAgent will be filled ' \
+                        f'when cloudflareTaskType specified.')
+                    
+        return self
+    
     def getTaskDict(self) -> Dict[str, str]:
         return {k: v for k, v in self.model_dump().items() if v is not None}