playwright-captcha-solver 1.0.0__py3-none-any.whl

captcha_solver/__init__.py

@@ -0,0 +1,36 @@
+from .captcha_solver import CaptchaSolver
+
+from .sdk_types import (
+    AuthToken,
+    Credentials,
+    Authentication,
+    CaptchaSolverOptions,
+    ImageChallenge,
+    RecaptchaChallenge,
+    SolveResult,
+)
+
+from .errors import (
+    CaptchaSolverError,
+    NetworkError,
+    TimeoutError,
+)
+
+__all__ = [
+    "CaptchaSolver",
+
+    "AuthToken",
+    "Credentials",
+    "Authentication",
+
+    "CaptchaSolverOptions",
+
+    "ImageChallenge",
+    "RecaptchaChallenge",
+
+    "SolveResult",
+
+    "CaptchaSolverError",
+    "NetworkError",
+    "TimeoutError",
+]

captcha_solver/api_client.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import httpx
+
+from .sdk_types import (
+    AuthToken,
+    Credentials,
+    CaptchaSolverOptions,
+)
+
+from .errors import (
+    CaptchaSolverError,
+    NetworkError,
+)
+
+
+class ApiClient:
+    def __init__(self, options: CaptchaSolverOptions):
+        self.options = options
+
+        self._client = httpx.AsyncClient(
+            follow_redirects=True,
+            timeout=options.timeout or 30,
+        )
+
+    async def close(self) -> None:
+        await self._client.aclose()
+
+    async def request(
+        self,
+        endpoint: str,
+        *,
+        method: str = "GET",
+        body: Optional[dict] = None,
+        authenticated: bool = True,
+        files: Optional[dict] = None,
+    ) -> httpx.Response:
+
+        params = None
+        data = body
+
+        if authenticated:
+            if files is not None:
+                data = self._append_authentication(body)
+            else:
+                params = self._authentication_query()
+
+        try:
+            response = await self._client.request(
+                method=method,
+                url=endpoint,
+                params=params,
+                data=data,
+                files=files,
+            )
+
+        except httpx.RequestError as exc:
+            raise NetworkError(
+                "Unable to reach the captcha service."
+            ) from exc
+
+        self._handle_errors(response)
+
+        return response
+
+    def _authentication_query(self) -> dict:
+
+        auth = self.options.auth
+
+        if isinstance(auth, AuthToken):
+            return {
+                "authtoken": auth.authtoken,
+            }
+
+        if isinstance(auth, Credentials):
+            return {
+                "username": auth.username,
+                "password": auth.password,
+            }
+
+        raise TypeError("Unsupported authentication type.")
+
+    def _append_authentication(
+        self,
+        body: Optional[dict],
+    ) -> dict:
+
+        body = dict(body or {})
+
+        auth = self.options.auth
+
+        if isinstance(auth, AuthToken):
+            body["authtoken"] = auth.authtoken
+
+        elif isinstance(auth, Credentials):
+            body["username"] = auth.username
+            body["password"] = auth.password
+
+        else:
+            raise TypeError("Unsupported authentication type.")
+
+        return body
+
+    @staticmethod
+    def _handle_errors(response: httpx.Response) -> None:
+
+        if response.is_success:
+            return
+
+        messages = {
+            255: "Not logged in. Check your credentials.",
+
+            400: (
+                "Captcha was rejected by the service. "
+                "Check that it is a valid image."
+            ),
+
+            403: (
+                "Access denied. Check your credentials, "
+                "balance, or IP address."
+            ),
+
+            413: (
+                "Captcha was rejected by the service. "
+                "Check that it is a valid image."
+            ),
+
+            503: (
+                "Service overload. "
+                "Please try again later."
+            ),
+        }
+
+        raise CaptchaSolverError(
+            response.status_code,
+            messages.get(
+                response.status_code,
+                f"Unexpected HTTP status: {response.status_code}",
+            ),
+        )

captcha_solver/captcha_reporter.py

@@ -0,0 +1,18 @@
+from .api_client import ApiClient
+
+
+class CaptchaReporter:
+    def __init__(self, api: ApiClient):
+        self.api = api
+
+    async def report(
+        self,
+        captcha_id: str,
+    ) -> None:
+
+        await self.api.request(
+            f"http://api.dbcapi.me/api/captcha/{captcha_id}/report",
+            method="POST",
+            body={},
+            authenticated=True,
+        )

captcha_solver/captcha_solver.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from .api_client import ApiClient
+from .pipeline import Pipeline
+
+from .sdk_types import (
+    AuthToken,
+    Credentials,
+    CaptchaSolverOptions,
+    SolveResult,
+)
+
+
+class CaptchaSolver:
+    def __init__(self, options: CaptchaSolverOptions):
+
+        self._validate_options(options)
+
+        self._api = ApiClient(options)
+
+        self._pipeline = Pipeline(self._api)
+
+    async def solve(self, options) -> SolveResult:
+        return await self._pipeline.solve(options)
+
+    async def report(self, captcha_id: str) -> None:
+        await self._pipeline.report_captcha(captcha_id)
+
+    async def close(self) -> None:
+        await self._api.close()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        await self.close()
+
+    @staticmethod
+    def _validate_options(
+        options: CaptchaSolverOptions,
+    ) -> None:
+
+        auth = options.auth
+
+        if isinstance(auth, AuthToken):
+            if not auth.authtoken:
+                raise ValueError(
+                    "Authentication token is required."
+                )
+            return
+
+        if isinstance(auth, Credentials):
+            if not auth.username:
+                raise ValueError(
+                    "Username is required."
+                )
+
+            if not auth.password:
+                raise ValueError(
+                    "Password is required."
+                )
+
+            return
+
+        raise TypeError(
+            "Unsupported authentication type."
+        )

captcha_solver/image_solver.py

@@ -0,0 +1,127 @@
+import asyncio
+from urllib.parse import parse_qs
+
+from playwright.async_api import Locator, Page
+
+from .api_client import ApiClient
+from .errors import TimeoutError
+
+
+class ImageSolver:
+    def __init__(self, api: ApiClient):
+        self.api = api
+
+    async def solve(
+        self,
+        page: Page,
+        captcha: Locator,
+    ):
+        image = await captcha.screenshot(type="png")
+
+        files = {
+            "captchafile": (
+                "captcha.png",
+                image,
+                "image/png",
+            )
+        }
+
+        body = {
+            "type": "0",
+        }
+
+        response = await self.api.request(
+            "http://api.dbcapi.me/api/captcha/",
+            method="POST",
+            body=body,
+            files=files,
+            authenticated=True,
+        )
+
+        params = parse_qs(response.text)
+
+        captcha_id = params.get("captcha", [None])[0]
+
+        if captcha_id is None:
+            raise RuntimeError(
+                "Captcha service did not return a captcha ID."
+            )
+
+        return await self.retrieve_token(captcha_id)
+
+    async def get_token(
+        self,
+        captcha_id: str,
+    ) -> str:
+
+        response = await self.api.request(
+            f"http://api.dbcapi.me/api/captcha/{captcha_id}",
+            authenticated=False,
+        )
+
+        return response.text
+
+    async def get_balance(self) -> float:
+
+        response = await self.api.request(
+            "http://api.dbcapi.me/api/user",
+            authenticated=True,
+        )
+
+        params = parse_qs(response.text)
+
+        balance = params.get("balance", ["0"])[0]
+
+        return float(balance) / 100
+
+    async def retrieve_token(
+        self,
+        captcha_id: str,
+    ):
+
+        print("Solving captcha...")
+        print("Captcha ID:", captcha_id)
+
+        max_attempts = 10
+
+        for attempt in range(max_attempts):
+
+            print(
+                f"Waiting 3 seconds before attempt {attempt + 1}..."
+            )
+
+            await asyncio.sleep(3)
+
+            print(
+                f"Checking result... Attempt {attempt + 1}"
+            )
+
+            result = await self.get_token(captcha_id)
+
+            params = parse_qs(result)
+
+            token = params.get("text", [None])[0]
+
+            if token and len(token) > 1:
+
+                balance = await self.get_balance()
+
+                print("Final response:")
+
+                return {
+                    "success": True,
+                    "data": token,
+                    "id": captcha_id,
+                    "balance": balance,
+                }
+
+            if token == "?":
+                return {
+                    "success": False,
+                    "error": "Empty response.",
+                }
+
+        raise TimeoutError(
+            f"Captcha {captcha_id} was not solved "
+            f"after {max_attempts} attempts."
+        )

captcha_solver/pipeline.py

@@ -0,0 +1,106 @@
+import time
+
+from .api_client import ApiClient
+from .captcha_reporter import CaptchaReporter
+from .image_solver import ImageSolver
+from .recaptcha_solver import RecaptchaSolver
+from .submitter import Submitter
+
+from .sdk_types import (
+    ImageChallenge,
+    RecaptchaChallenge,
+    SolveResult,
+)
+
+
+class Pipeline:
+    def __init__(self, api: ApiClient):
+
+        self.submitter = Submitter()
+
+        self.image_solver = ImageSolver(api)
+
+        self.recaptcha_solver = RecaptchaSolver(api)
+
+        self.captcha_reporter = CaptchaReporter(api)
+
+    async def report_captcha(
+        self,
+        captcha_id: str,
+    ) -> None:
+
+        await self.captcha_reporter.report(captcha_id)
+
+    async def solve(
+        self,
+        options,
+    ) -> SolveResult:
+
+        started = time.perf_counter()
+
+        if isinstance(options, ImageChallenge):
+
+            solution = await self.image_solver.solve(
+                options.page,
+                options.captcha,
+            )
+
+            if solution["success"]:
+
+                await self.submitter.submit_image(
+                    options.page,
+                    options.input,
+                    solution["data"],
+                )
+
+                return SolveResult(
+                    success=True,
+                    challenge="image",
+                    duration=int(
+                        (time.perf_counter() - started) * 1000
+                    ),
+                    id=solution["id"],
+                    balance=solution["balance"],
+                )
+
+            return SolveResult(
+                success=False,
+                challenge="image",
+                duration=int(
+                    (time.perf_counter() - started) * 1000
+                ),
+                id=None,
+                balance=None,
+            )
+
+        response = await self.recaptcha_solver.solve(
+            options.page,
+            options.proxy,
+        )
+
+        if response["success"]:
+
+            await self.submitter.submit_recaptcha(
+                options.page,
+                response["data"],
+            )
+
+            return SolveResult(
+                success=True,
+                challenge="recaptcha",
+                duration=int(
+                    (time.perf_counter() - started) * 1000
+                ),
+                id=response["id"],
+                balance=response["balance"],
+            )
+
+        return SolveResult(
+            success=False,
+            challenge="recaptcha",
+            duration=int(
+                (time.perf_counter() - started) * 1000
+            ),
+            id=None,
+            balance=None,
+        )

captcha_solver/recaptcha_solver.py

@@ -0,0 +1,161 @@
+import asyncio
+from urllib.parse import parse_qs, urlparse
+
+from playwright.async_api import Page
+
+from .api_client import ApiClient
+from .errors import TimeoutError
+
+
+class RecaptchaSolver:
+    def __init__(self, api: ApiClient):
+        self.api = api
+
+    async def solve(
+        self,
+        page: Page,
+        proxy: str | None = None,
+    ):
+        captcha = await self.get_captcha(page)
+
+        body = {
+            "type": "4",
+            "token_params": (
+                f'{{"pageurl":"{captcha["url"]}",'
+                f'"googlekey":"{captcha["sitekey"]}"'
+                + (
+                    f',"proxytype":"HTTP","proxy":"{proxy}"'
+                    if proxy
+                    else ""
+                )
+                + "}"
+            ),
+        }
+
+        response = await self.api.request(
+            "http://api.dbcapi.me/api/captcha/",
+            method="POST",
+            body=body,
+            authenticated=True,
+        )
+
+        params = parse_qs(response.text)
+
+        captcha_id = params.get("captcha", [None])[0]
+
+        if captcha_id is None:
+            raise RuntimeError(
+                "Captcha service did not return a captcha ID."
+            )
+
+        return await self.retrieve_token(captcha_id)
+
+    async def get_captcha(
+        self,
+        page: Page,
+    ) -> dict:
+
+        url = page.url
+
+        iframe = await page.locator(
+            'iframe[title="reCAPTCHA"]'
+        ).get_attribute("src")
+
+        if iframe is None:
+            raise RuntimeError(
+                "No reCAPTCHA iframe found."
+            )
+
+        parsed = urlparse(iframe)
+
+        params = parse_qs(parsed.query)
+
+        sitekey = params.get("k", [None])[0]
+
+        if sitekey is None:
+            raise RuntimeError(
+                "Unable to determine site key."
+            )
+
+        return {
+            "url": url,
+            "sitekey": sitekey,
+        }
+
+    async def get_token(
+        self,
+        captcha_id: str,
+    ) -> str:
+
+        response = await self.api.request(
+            f"http://api.dbcapi.me/api/captcha/{captcha_id}",
+            authenticated=False,
+        )
+
+        return response.text
+
+    async def get_balance(self) -> float:
+
+        response = await self.api.request(
+            "http://api.dbcapi.me/api/user",
+            authenticated=True,
+        )
+
+        params = parse_qs(response.text)
+
+        balance = params.get("balance", ["0"])[0]
+
+        return float(balance) / 100
+
+    async def retrieve_token(
+        self,
+        captcha_id: str,
+    ):
+
+        print("Solving reCAPTCHA...")
+        print("Captcha ID:", captcha_id)
+
+        max_attempts = 24
+
+        for attempt in range(max_attempts):
+
+            print(
+                f"Waiting 5 seconds before attempt {attempt + 1}..."
+            )
+
+            await asyncio.sleep(5)
+
+            print(
+                f"Checking result... Attempt {attempt + 1}"
+            )
+
+            result = await self.get_token(captcha_id)
+
+            params = parse_qs(result)
+
+            token = params.get("text", [None])[0]
+
+            if token and len(token) > 1:
+
+                balance = await self.get_balance()
+
+                print("Final response:")
+
+                return {
+                    "success": True,
+                    "data": token,
+                    "id": captcha_id,
+                    "balance": balance,
+                }
+
+            if token == "?":
+                return {
+                    "success": False,
+                    "error": "Empty response.",
+                }
+
+        raise TimeoutError(
+            f"Captcha {captcha_id} "
+            f"was not solved after "
+            f"{max_attempts} attempts."
+        )