hyperbrowser 0.2.0__tar.gz → 0.71.0__tar.gz

{hyperbrowser-0.2.0 → hyperbrowser-0.71.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 hyperbrowserai
+Copyright (c) 2025 S2 Labs Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{hyperbrowser-0.2.0 → hyperbrowser-0.71.0}/PKG-INFO

@@ -1,25 +1,32 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: hyperbrowser
-Version: 0.2.0
+Version: 0.71.0
 Summary: Python SDK for hyperbrowser
-Home-page: https://github.com/hyperbrowserai/python-sdk
 License: MIT
+License-File: LICENSE
 Author: Nikhil Shahi
 Author-email: nshahi1998@gmail.com
-Requires-Python: >=3.9,<4.0
+Requires-Python: >=3.8,<4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: aiohttp (>=3.11.7,<4.0.0)
-Requires-Dist: pydantic (>=2.10.0,<3.0.0)
-Requires-Dist: requests (>=2.32.3,<3.0.0)
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: httpx (>=0.23.0,<1)
+Requires-Dist: jsonref (>=1.1.0)
+Requires-Dist: pydantic (>=2.0,<3)
+Project-URL: Homepage, https://github.com/hyperbrowserai/python-sdk
 Project-URL: Repository, https://github.com/hyperbrowserai/python-sdk
 Description-Content-Type: text/markdown
 
+# Hyperbrowser Python SDK
+
+Checkout the full documentation [here](https://docs.hyperbrowser.ai/)
+
 ## Installation
 
 Currently Hyperbrowser supports creating a browser session in two ways:
@@ -47,15 +54,15 @@ The API key can be configured either from the constructor arguments or environme
 ```python
 import asyncio
 from pyppeteer import connect
-from hyperbrowser.client.async_client import AsyncHyperbrowser as Hyperbrowser
+from hyperbrowser import AsyncHyperbrowser
 
 HYPERBROWSER_API_KEY = "test-key"
 
 async def main():
-    async with Hyperbrowser(api_key=HYPERBROWSER_API_KEY) as client:
-        session = await client.create_session()
+    async with AsyncHyperbrowser(api_key=HYPERBROWSER_API_KEY) as client:
+        session = await client.sessions.create()
 
-        ws_endpoint = f"{session.websocket_url}&apiKey={HYPERBROWSER_API_KEY}"
+        ws_endpoint = session.ws_endpoint
         browser = await connect(browserWSEndpoint=ws_endpoint, defaultViewport=None)
 
         # Get pages
@@ -73,6 +80,7 @@ async def main():
 
         await page.close()
         await browser.disconnect()
+        await client.sessions.stop(session.id)
         print("Session completed!")
 
 # Run the asyncio event loop
@@ -82,15 +90,15 @@ asyncio.get_event_loop().run_until_complete(main())
 
 ```python
 from playwright.sync_api import sync_playwright
-from hyperbrowser.client.sync import Hyperbrowser
+from hyperbrowser import Hyperbrowser
 
 HYPERBROWSER_API_KEY = "test-key"
 
 def main():
     client = Hyperbrowser(api_key=HYPERBROWSER_API_KEY)
-    session = client.create_session()
+    session = client.sessions.create()
 
-    ws_endpoint = f"{session.websocket_url}&apiKey={HYPERBROWSER_API_KEY}"
+    ws_endpoint = session.ws_endpoint
 
     # Launch Playwright and connect to the remote browser
     with sync_playwright() as p:
@@ -112,7 +120,12 @@ def main():
         page.close()
         browser.close()
         print("Session completed!")
+    client.sessions.stop(session.id)
 
 # Run the asyncio event loop
 main()
 ```
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+

{hyperbrowser-0.2.0 → hyperbrowser-0.71.0}/README.md

@@ -1,3 +1,7 @@
+# Hyperbrowser Python SDK
+
+Checkout the full documentation [here](https://docs.hyperbrowser.ai/)
+
 ## Installation
 
 Currently Hyperbrowser supports creating a browser session in two ways:
@@ -25,15 +29,15 @@ The API key can be configured either from the constructor arguments or environme
 ```python
 import asyncio
 from pyppeteer import connect
-from hyperbrowser.client.async_client import AsyncHyperbrowser as Hyperbrowser
+from hyperbrowser import AsyncHyperbrowser
 
 HYPERBROWSER_API_KEY = "test-key"
 
 async def main():
-    async with Hyperbrowser(api_key=HYPERBROWSER_API_KEY) as client:
-        session = await client.create_session()
+    async with AsyncHyperbrowser(api_key=HYPERBROWSER_API_KEY) as client:
+        session = await client.sessions.create()
 
-        ws_endpoint = f"{session.websocket_url}&apiKey={HYPERBROWSER_API_KEY}"
+        ws_endpoint = session.ws_endpoint
         browser = await connect(browserWSEndpoint=ws_endpoint, defaultViewport=None)
 
         # Get pages
@@ -51,6 +55,7 @@ async def main():
 
         await page.close()
         await browser.disconnect()
+        await client.sessions.stop(session.id)
         print("Session completed!")
 
 # Run the asyncio event loop
@@ -60,15 +65,15 @@ asyncio.get_event_loop().run_until_complete(main())
 
 ```python
 from playwright.sync_api import sync_playwright
-from hyperbrowser.client.sync import Hyperbrowser
+from hyperbrowser import Hyperbrowser
 
 HYPERBROWSER_API_KEY = "test-key"
 
 def main():
     client = Hyperbrowser(api_key=HYPERBROWSER_API_KEY)
-    session = client.create_session()
+    session = client.sessions.create()
 
-    ws_endpoint = f"{session.websocket_url}&apiKey={HYPERBROWSER_API_KEY}"
+    ws_endpoint = session.ws_endpoint
 
     # Launch Playwright and connect to the remote browser
     with sync_playwright() as p:
@@ -90,7 +95,11 @@ def main():
         page.close()
         browser.close()
         print("Session completed!")
+    client.sessions.stop(session.id)
 
 # Run the asyncio event loop
 main()
-```
+```
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

hyperbrowser-0.71.0/hyperbrowser/client/async_client.py

@@ -0,0 +1,46 @@
+from typing import Optional
+
+from ..config import ClientConfig
+from ..transport.async_transport import AsyncTransport
+from .base import HyperbrowserBase
+from .managers.async_manager.agents import Agents
+from .managers.async_manager.crawl import CrawlManager
+from .managers.async_manager.extension import ExtensionManager
+from .managers.async_manager.extract import ExtractManager
+from .managers.async_manager.profile import ProfileManager
+from .managers.async_manager.scrape import ScrapeManager
+from .managers.async_manager.session import SessionManager
+from .managers.async_manager.team import TeamManager
+from .managers.async_manager.computer_action import ComputerActionManager
+
+
+class AsyncHyperbrowser(HyperbrowserBase):
+    """Asynchronous Hyperbrowser client"""
+
+    def __init__(
+        self,
+        config: Optional[ClientConfig] = None,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        timeout: Optional[int] = 30,
+    ):
+        super().__init__(AsyncTransport, config, api_key, base_url)
+        self.transport.client.timeout = timeout
+        self.sessions = SessionManager(self)
+        self.scrape = ScrapeManager(self)
+        self.crawl = CrawlManager(self)
+        self.extract = ExtractManager(self)
+        self.profiles = ProfileManager(self)
+        self.extensions = ExtensionManager(self)
+        self.agents = Agents(self)
+        self.team = TeamManager(self)
+        self.computer_action = ComputerActionManager(self)
+
+    async def close(self) -> None:
+        await self.transport.close()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()

{hyperbrowser-0.2.0 → hyperbrowser-0.71.0}/hyperbrowser/client/base.py

@@ -27,7 +27,7 @@ class HyperbrowserBase:
                     base_url
                     if base_url is not None
                     else os.environ.get(
-                        "HYPERBROWSER_BASE_URL", "https://app.hyperbrowser.ai"
+                        "HYPERBROWSER_BASE_URL", "https://api.hyperbrowser.ai"
                     )
                 ),
             )

hyperbrowser-0.71.0/hyperbrowser/client/managers/async_manager/agents/__init__.py

@@ -0,0 +1,14 @@
+from .browser_use import BrowserUseManager
+from .cua import CuaManager
+from .claude_computer_use import ClaudeComputerUseManager
+from .hyper_agent import HyperAgentManager
+from .gemini_computer_use import GeminiComputerUseManager
+
+
+class Agents:
+    def __init__(self, client):
+        self.browser_use = BrowserUseManager(client)
+        self.cua = CuaManager(client)
+        self.claude_computer_use = ClaudeComputerUseManager(client)
+        self.hyper_agent = HyperAgentManager(client)
+        self.gemini_computer_use = GeminiComputerUseManager(client)

hyperbrowser-0.71.0/hyperbrowser/client/managers/async_manager/agents/browser_use.py

@@ -0,0 +1,79 @@
+import asyncio
+import jsonref
+
+from hyperbrowser.exceptions import HyperbrowserError
+
+from .....models import (
+    POLLING_ATTEMPTS,
+    BasicResponse,
+    BrowserUseTaskResponse,
+    BrowserUseTaskStatusResponse,
+    StartBrowserUseTaskParams,
+    StartBrowserUseTaskResponse,
+)
+
+
+class BrowserUseManager:
+    def __init__(self, client):
+        self._client = client
+
+    async def start(
+        self, params: StartBrowserUseTaskParams
+    ) -> StartBrowserUseTaskResponse:
+        if params.output_model_schema:
+            if hasattr(params.output_model_schema, "model_json_schema"):
+                params.output_model_schema = jsonref.replace_refs(
+                    params.output_model_schema.model_json_schema(),
+                    proxies=False,
+                    lazy_load=False,
+                )
+        response = await self._client.transport.post(
+            self._client._build_url("/task/browser-use"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return StartBrowserUseTaskResponse(**response.data)
+
+    async def get(self, job_id: str) -> BrowserUseTaskResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/task/browser-use/{job_id}")
+        )
+        return BrowserUseTaskResponse(**response.data)
+
+    async def get_status(self, job_id: str) -> BrowserUseTaskStatusResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/task/browser-use/{job_id}/status")
+        )
+        return BrowserUseTaskStatusResponse(**response.data)
+
+    async def stop(self, job_id: str) -> BasicResponse:
+        response = await self._client.transport.put(
+            self._client._build_url(f"/task/browser-use/{job_id}/stop")
+        )
+        return BasicResponse(**response.data)
+
+    async def start_and_wait(
+        self, params: StartBrowserUseTaskParams
+    ) -> BrowserUseTaskResponse:
+        job_start_resp = await self.start(params)
+        job_id = job_start_resp.job_id
+        if not job_id:
+            raise HyperbrowserError("Failed to start browser-use task job")
+
+        failures = 0
+        while True:
+            try:
+                job_response = await self.get_status(job_id)
+                if (
+                    job_response.status == "completed"
+                    or job_response.status == "failed"
+                    or job_response.status == "stopped"
+                ):
+                    return await self.get(job_id)
+                failures = 0
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to poll browser-use task job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
+            await asyncio.sleep(2)

hyperbrowser-0.71.0/hyperbrowser/client/managers/async_manager/agents/claude_computer_use.py

@@ -0,0 +1,71 @@
+import asyncio
+
+from hyperbrowser.exceptions import HyperbrowserError
+
+from .....models import (
+    POLLING_ATTEMPTS,
+    BasicResponse,
+    ClaudeComputerUseTaskResponse,
+    ClaudeComputerUseTaskStatusResponse,
+    StartClaudeComputerUseTaskParams,
+    StartClaudeComputerUseTaskResponse,
+)
+
+
+class ClaudeComputerUseManager:
+    def __init__(self, client):
+        self._client = client
+
+    async def start(
+        self, params: StartClaudeComputerUseTaskParams
+    ) -> StartClaudeComputerUseTaskResponse:
+        response = await self._client.transport.post(
+            self._client._build_url("/task/claude-computer-use"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return StartClaudeComputerUseTaskResponse(**response.data)
+
+    async def get(self, job_id: str) -> ClaudeComputerUseTaskResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/task/claude-computer-use/{job_id}")
+        )
+        return ClaudeComputerUseTaskResponse(**response.data)
+
+    async def get_status(self, job_id: str) -> ClaudeComputerUseTaskStatusResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/task/claude-computer-use/{job_id}/status")
+        )
+        return ClaudeComputerUseTaskStatusResponse(**response.data)
+
+    async def stop(self, job_id: str) -> BasicResponse:
+        response = await self._client.transport.put(
+            self._client._build_url(f"/task/claude-computer-use/{job_id}/stop")
+        )
+        return BasicResponse(**response.data)
+
+    async def start_and_wait(
+        self, params: StartClaudeComputerUseTaskParams
+    ) -> ClaudeComputerUseTaskResponse:
+        job_start_resp = await self.start(params)
+        job_id = job_start_resp.job_id
+        if not job_id:
+            raise HyperbrowserError("Failed to start Claude Computer Use task job")
+
+        failures = 0
+        while True:
+            try:
+                job_response = await self.get_status(job_id)
+                if (
+                    job_response.status == "completed"
+                    or job_response.status == "failed"
+                    or job_response.status == "stopped"
+                ):
+                    return await self.get(job_id)
+                failures = 0
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to poll Claude Computer Use task job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
+            await asyncio.sleep(2)

hyperbrowser-0.71.0/hyperbrowser/client/managers/async_manager/agents/cua.py

@@ -0,0 +1,67 @@
+import asyncio
+
+from hyperbrowser.exceptions import HyperbrowserError
+
+from .....models import (
+    POLLING_ATTEMPTS,
+    BasicResponse,
+    CuaTaskResponse,
+    CuaTaskStatusResponse,
+    StartCuaTaskParams,
+    StartCuaTaskResponse,
+)
+
+
+class CuaManager:
+    def __init__(self, client):
+        self._client = client
+
+    async def start(self, params: StartCuaTaskParams) -> StartCuaTaskResponse:
+        response = await self._client.transport.post(
+            self._client._build_url("/task/cua"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return StartCuaTaskResponse(**response.data)
+
+    async def get(self, job_id: str) -> CuaTaskResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/task/cua/{job_id}")
+        )
+        return CuaTaskResponse(**response.data)
+
+    async def get_status(self, job_id: str) -> CuaTaskStatusResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/task/cua/{job_id}/status")
+        )
+        return CuaTaskStatusResponse(**response.data)
+
+    async def stop(self, job_id: str) -> BasicResponse:
+        response = await self._client.transport.put(
+            self._client._build_url(f"/task/cua/{job_id}/stop")
+        )
+        return BasicResponse(**response.data)
+
+    async def start_and_wait(self, params: StartCuaTaskParams) -> CuaTaskResponse:
+        job_start_resp = await self.start(params)
+        job_id = job_start_resp.job_id
+        if not job_id:
+            raise HyperbrowserError("Failed to start CUA task job")
+
+        failures = 0
+        while True:
+            try:
+                job_response = await self.get_status(job_id)
+                if (
+                    job_response.status == "completed"
+                    or job_response.status == "failed"
+                    or job_response.status == "stopped"
+                ):
+                    return await self.get(job_id)
+                failures = 0
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to poll CUA task job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
+            await asyncio.sleep(2)

hyperbrowser-0.71.0/hyperbrowser/client/managers/async_manager/agents/gemini_computer_use.py

@@ -0,0 +1,71 @@
+import asyncio
+
+from hyperbrowser.exceptions import HyperbrowserError
+
+from .....models import (
+    POLLING_ATTEMPTS,
+    BasicResponse,
+    GeminiComputerUseTaskResponse,
+    GeminiComputerUseTaskStatusResponse,
+    StartGeminiComputerUseTaskParams,
+    StartGeminiComputerUseTaskResponse,
+)
+
+
+class GeminiComputerUseManager:
+    def __init__(self, client):
+        self._client = client
+
+    async def start(
+        self, params: StartGeminiComputerUseTaskParams
+    ) -> StartGeminiComputerUseTaskResponse:
+        response = await self._client.transport.post(
+            self._client._build_url("/task/gemini-computer-use"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return StartGeminiComputerUseTaskResponse(**response.data)
+
+    async def get(self, job_id: str) -> GeminiComputerUseTaskResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/task/gemini-computer-use/{job_id}")
+        )
+        return GeminiComputerUseTaskResponse(**response.data)
+
+    async def get_status(self, job_id: str) -> GeminiComputerUseTaskStatusResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/task/gemini-computer-use/{job_id}/status")
+        )
+        return GeminiComputerUseTaskStatusResponse(**response.data)
+
+    async def stop(self, job_id: str) -> BasicResponse:
+        response = await self._client.transport.put(
+            self._client._build_url(f"/task/gemini-computer-use/{job_id}/stop")
+        )
+        return BasicResponse(**response.data)
+
+    async def start_and_wait(
+        self, params: StartGeminiComputerUseTaskParams
+    ) -> GeminiComputerUseTaskResponse:
+        job_start_resp = await self.start(params)
+        job_id = job_start_resp.job_id
+        if not job_id:
+            raise HyperbrowserError("Failed to start Gemini Computer Use task job")
+
+        failures = 0
+        while True:
+            try:
+                job_response = await self.get_status(job_id)
+                if (
+                    job_response.status == "completed"
+                    or job_response.status == "failed"
+                    or job_response.status == "stopped"
+                ):
+                    return await self.get(job_id)
+                failures = 0
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to poll Gemini Computer Use task job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
+            await asyncio.sleep(2)

hyperbrowser-0.71.0/hyperbrowser/client/managers/async_manager/agents/hyper_agent.py

@@ -0,0 +1,71 @@
+import asyncio
+
+from hyperbrowser.exceptions import HyperbrowserError
+
+from .....models import (
+    POLLING_ATTEMPTS,
+    BasicResponse,
+    HyperAgentTaskResponse,
+    HyperAgentTaskStatusResponse,
+    StartHyperAgentTaskParams,
+    StartHyperAgentTaskResponse,
+)
+
+
+class HyperAgentManager:
+    def __init__(self, client):
+        self._client = client
+
+    async def start(
+        self, params: StartHyperAgentTaskParams
+    ) -> StartHyperAgentTaskResponse:
+        response = await self._client.transport.post(
+            self._client._build_url("/task/hyper-agent"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return StartHyperAgentTaskResponse(**response.data)
+
+    async def get(self, job_id: str) -> HyperAgentTaskResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/task/hyper-agent/{job_id}")
+        )
+        return HyperAgentTaskResponse(**response.data)
+
+    async def get_status(self, job_id: str) -> HyperAgentTaskStatusResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/task/hyper-agent/{job_id}/status")
+        )
+        return HyperAgentTaskStatusResponse(**response.data)
+
+    async def stop(self, job_id: str) -> BasicResponse:
+        response = await self._client.transport.put(
+            self._client._build_url(f"/task/hyper-agent/{job_id}/stop")
+        )
+        return BasicResponse(**response.data)
+
+    async def start_and_wait(
+        self, params: StartHyperAgentTaskParams
+    ) -> HyperAgentTaskResponse:
+        job_start_resp = await self.start(params)
+        job_id = job_start_resp.job_id
+        if not job_id:
+            raise HyperbrowserError("Failed to start HyperAgent task")
+
+        failures = 0
+        while True:
+            try:
+                job_response = await self.get_status(job_id)
+                if (
+                    job_response.status == "completed"
+                    or job_response.status == "failed"
+                    or job_response.status == "stopped"
+                ):
+                    return await self.get(job_id)
+                failures = 0
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to poll HyperAgent task {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
+            await asyncio.sleep(2)