hyperbrowser 0.7.0__tar.gz → 0.8.0__tar.gz

{hyperbrowser-0.7.0 → hyperbrowser-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hyperbrowser
-Version: 0.7.0
+Version: 0.8.0
 Summary: Python SDK for hyperbrowser
 Home-page: https://github.com/hyperbrowserai/python-sdk
 License: MIT
@@ -52,9 +52,9 @@ HYPERBROWSER_API_KEY = "test-key"
 
 async def main():
     async with AsyncHyperbrowser(api_key=HYPERBROWSER_API_KEY) as client:
-        session = await client.create_session()
+        session = await client.sessions.create()
 
-        ws_endpoint = session.websocket_url
+        ws_endpoint = session.ws_endpoint
         browser = await connect(browserWSEndpoint=ws_endpoint, defaultViewport=None)
 
         # Get pages
@@ -72,7 +72,7 @@ async def main():
 
         await page.close()
         await browser.disconnect()
-        await client.stop_session(session.id)
+        await client.sessions.stop(session.id)
         print("Session completed!")
 
 # Run the asyncio event loop
@@ -88,9 +88,9 @@ HYPERBROWSER_API_KEY = "test-key"
 
 def main():
     client = Hyperbrowser(api_key=HYPERBROWSER_API_KEY)
-    session = client.create_session()
+    session = client.sessions.create()
 
-    ws_endpoint = session.websocket_url
+    ws_endpoint = session.ws_endpoint
 
     # Launch Playwright and connect to the remote browser
     with sync_playwright() as p:
@@ -112,7 +112,7 @@ def main():
         page.close()
         browser.close()
         print("Session completed!")
-    client.stop_session(session.id)
+    client.sessions.stop(session.id)
 
 # Run the asyncio event loop
 main()

{hyperbrowser-0.7.0 → hyperbrowser-0.8.0}/README.md

@@ -31,9 +31,9 @@ HYPERBROWSER_API_KEY = "test-key"
 
 async def main():
     async with AsyncHyperbrowser(api_key=HYPERBROWSER_API_KEY) as client:
-        session = await client.create_session()
+        session = await client.sessions.create()
 
-        ws_endpoint = session.websocket_url
+        ws_endpoint = session.ws_endpoint
         browser = await connect(browserWSEndpoint=ws_endpoint, defaultViewport=None)
 
         # Get pages
@@ -51,7 +51,7 @@ async def main():
 
         await page.close()
         await browser.disconnect()
-        await client.stop_session(session.id)
+        await client.sessions.stop(session.id)
         print("Session completed!")
 
 # Run the asyncio event loop
@@ -67,9 +67,9 @@ HYPERBROWSER_API_KEY = "test-key"
 
 def main():
     client = Hyperbrowser(api_key=HYPERBROWSER_API_KEY)
-    session = client.create_session()
+    session = client.sessions.create()
 
-    ws_endpoint = session.websocket_url
+    ws_endpoint = session.ws_endpoint
 
     # Launch Playwright and connect to the remote browser
     with sync_playwright() as p:
@@ -91,7 +91,7 @@ def main():
         page.close()
         browser.close()
         print("Session completed!")
-    client.stop_session(session.id)
+    client.sessions.stop(session.id)
 
 # Run the asyncio event loop
 main()

hyperbrowser-0.8.0/hyperbrowser/client/async_client.py

@@ -0,0 +1,31 @@
+from typing import Optional
+from .managers.async_manager.session import SessionManager
+from .managers.async_manager.scrape import ScrapeManager
+from .managers.async_manager.crawl import CrawlManager
+from .base import HyperbrowserBase
+from ..transport.async_transport import AsyncTransport
+from ..config import ClientConfig
+
+
+class AsyncHyperbrowser(HyperbrowserBase):
+    """Asynchronous Hyperbrowser client"""
+
+    def __init__(
+        self,
+        config: Optional[ClientConfig] = None,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+    ):
+        super().__init__(AsyncTransport, config, api_key, base_url)
+        self.sessions = SessionManager(self)
+        self.scrape = ScrapeManager(self)
+        self.crawl = CrawlManager(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.8.0/hyperbrowser/client/managers/async_manager/crawl.py

@@ -0,0 +1,60 @@
+import asyncio
+from typing import Optional
+from ....models.crawl import (
+    CrawlJobResponse,
+    GetCrawlJobParams,
+    StartCrawlJobParams,
+    StartCrawlJobResponse,
+)
+from ....exceptions import HyperbrowserError
+
+
+class CrawlManager:
+    def __init__(self, client):
+        self._client = client
+
+    async def start(self, params: StartCrawlJobParams) -> StartCrawlJobResponse:
+        response = await self._client.transport.post(
+            self._client._build_url("/crawl"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return StartCrawlJobResponse(**response.data)
+
+    async def get(
+        self, job_id: str, params: GetCrawlJobParams = GetCrawlJobParams()
+    ) -> CrawlJobResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/crawl/{job_id}"), params=params.__dict__
+        )
+        return CrawlJobResponse(**response.data)
+
+    async def start_and_wait(
+        self, params: StartCrawlJobParams, return_all_pages: bool = True
+    ) -> CrawlJobResponse:
+        job_start_resp = await self.start(params)
+        if not job_start_resp.job_id:
+            raise HyperbrowserError("Failed to start crawl job")
+
+        job_response: CrawlJobResponse
+        while True:
+            job_response = await self.get(job_start_resp.job_id)
+            if job_response.status == "completed" or job_response.status == "failed":
+                break
+            await asyncio.sleep(2)
+
+        if not return_all_pages:
+            return job_response
+
+        while job_response.current_page_batch < job_response.total_page_batches:
+            tmp_job_response = await self.get(
+                job_start_resp.job_id,
+                GetCrawlJobParams(page=job_response.current_page_batch + 1),
+            )
+            if tmp_job_response.data:
+                job_response.data.extend(tmp_job_response.data)
+            job_response.current_page_batch = tmp_job_response.current_page_batch
+            job_response.total_crawled_pages = tmp_job_response.total_crawled_pages
+            job_response.total_page_batches = tmp_job_response.total_page_batches
+            job_response.batch_size = tmp_job_response.batch_size
+            await asyncio.sleep(0.5)
+        return job_response

hyperbrowser-0.8.0/hyperbrowser/client/managers/async_manager/scrape.py

@@ -0,0 +1,36 @@
+import asyncio
+from typing import Optional
+from ....models.scrape import (
+    ScrapeJobResponse,
+    StartScrapeJobParams,
+    StartScrapeJobResponse,
+)
+from ....exceptions import HyperbrowserError
+
+
+class ScrapeManager:
+    def __init__(self, client):
+        self._client = client
+
+    async def start(self, params: StartScrapeJobParams) -> StartScrapeJobResponse:
+        response = await self._client.transport.post(
+            self._client._build_url("/scrape"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return StartScrapeJobResponse(**response.data)
+
+    async def get(self, job_id: str) -> ScrapeJobResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/scrape/{job_id}")
+        )
+        return ScrapeJobResponse(**response.data)
+
+    async def start_and_wait(self, params: StartScrapeJobParams) -> ScrapeJobResponse:
+        job_start_resp = await self.start(params)
+        if not job_start_resp.job_id:
+            raise HyperbrowserError("Failed to start scrape job")
+        while True:
+            job_response = await self.get(job_start_resp.job_id)
+            if job_response.status == "completed" or job_response.status == "failed":
+                return job_response
+            await asyncio.sleep(2)

hyperbrowser-0.8.0/hyperbrowser/client/managers/async_manager/session.py

@@ -0,0 +1,47 @@
+from typing import List
+from ....models.session import (
+    BasicResponse,
+    CreateSessionParams,
+    SessionDetail,
+    SessionListParams,
+    SessionListResponse,
+    SessionRecording,
+)
+
+
+class SessionManager:
+    def __init__(self, client):
+        self._client = client
+
+    async def create(self, params: CreateSessionParams) -> SessionDetail:
+        response = await self._client.transport.post(
+            self._client._build_url("/session"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return SessionDetail(**response.data)
+
+    async def get(self, id: str) -> SessionDetail:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/session/{id}")
+        )
+        return SessionDetail(**response.data)
+
+    async def stop(self, id: str) -> BasicResponse:
+        response = await self._client.transport.put(
+            self._client._build_url(f"/session/{id}/stop")
+        )
+        return BasicResponse(**response.data)
+
+    async def list(
+        self, params: SessionListParams = SessionListParams()
+    ) -> SessionListResponse:
+        response = await self._client.transport.get(
+            self._client._build_url("/sessions"), params=params.__dict__
+        )
+        return SessionListResponse(**response.data)
+
+    async def get_recording(self, id: str) -> List[SessionRecording]:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/session/{id}/recording")
+        )
+        return [SessionRecording(**recording) for recording in response.data]

hyperbrowser-0.8.0/hyperbrowser/client/managers/sync_manager/crawl.py

@@ -0,0 +1,60 @@
+import time
+from typing import Optional
+from ....models.crawl import (
+    CrawlJobResponse,
+    GetCrawlJobParams,
+    StartCrawlJobParams,
+    StartCrawlJobResponse,
+)
+from ....exceptions import HyperbrowserError
+
+
+class CrawlManager:
+    def __init__(self, client):
+        self._client = client
+
+    def start(self, params: StartCrawlJobParams) -> StartCrawlJobResponse:
+        response = self._client.transport.post(
+            self._client._build_url("/crawl"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return StartCrawlJobResponse(**response.data)
+
+    def get(
+        self, job_id: str, params: GetCrawlJobParams = GetCrawlJobParams()
+    ) -> CrawlJobResponse:
+        response = self._client.transport.get(
+            self._client._build_url(f"/crawl/{job_id}"), params=params.__dict__
+        )
+        return CrawlJobResponse(**response.data)
+
+    def start_and_wait(
+        self, params: StartCrawlJobParams, return_all_pages: bool = True
+    ) -> CrawlJobResponse:
+        job_start_resp = self.start(params)
+        if not job_start_resp.job_id:
+            raise HyperbrowserError("Failed to start crawl job")
+
+        job_response: CrawlJobResponse
+        while True:
+            job_response = self.get(job_start_resp.job_id)
+            if job_response.status == "completed" or job_response.status == "failed":
+                break
+            time.sleep(2)
+
+        if not return_all_pages:
+            return job_response
+
+        while job_response.current_page_batch < job_response.total_page_batches:
+            tmp_job_response = self.get(
+                job_start_resp.job_id,
+                GetCrawlJobParams(page=job_response.current_page_batch + 1),
+            )
+            if tmp_job_response.data:
+                job_response.data.extend(tmp_job_response.data)
+            job_response.current_page_batch = tmp_job_response.current_page_batch
+            job_response.total_crawled_pages = tmp_job_response.total_crawled_pages
+            job_response.total_page_batches = tmp_job_response.total_page_batches
+            job_response.batch_size = tmp_job_response.batch_size
+            time.sleep(0.5)
+        return job_response

hyperbrowser-0.8.0/hyperbrowser/client/managers/sync_manager/scrape.py

@@ -0,0 +1,36 @@
+import time
+from typing import Optional
+from ....models.scrape import (
+    ScrapeJobResponse,
+    StartScrapeJobParams,
+    StartScrapeJobResponse,
+)
+from ....exceptions import HyperbrowserError
+
+
+class ScrapeManager:
+    def __init__(self, client):
+        self._client = client
+
+    def start(self, params: StartScrapeJobParams) -> StartScrapeJobResponse:
+        response = self._client.transport.post(
+            self._client._build_url("/scrape"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return StartScrapeJobResponse(**response.data)
+
+    def get(self, job_id: str) -> ScrapeJobResponse:
+        response = self._client.transport.get(
+            self._client._build_url(f"/scrape/{job_id}")
+        )
+        return ScrapeJobResponse(**response.data)
+
+    def start_and_wait(self, params: StartScrapeJobParams) -> ScrapeJobResponse:
+        job_start_resp = self.start(params)
+        if not job_start_resp.job_id:
+            raise HyperbrowserError("Failed to start scrape job")
+        while True:
+            job_response = self.get(job_start_resp.job_id)
+            if job_response.status == "completed" or job_response.status == "failed":
+                return job_response
+            time.sleep(2)

hyperbrowser-0.8.0/hyperbrowser/client/managers/sync_manager/session.py

@@ -0,0 +1,45 @@
+from typing import List
+from ....models.session import (
+    BasicResponse,
+    CreateSessionParams,
+    SessionDetail,
+    SessionListParams,
+    SessionListResponse,
+    SessionRecording,
+)
+
+
+class SessionManager:
+    def __init__(self, client):
+        self._client = client
+
+    def create(self, params: CreateSessionParams) -> SessionDetail:
+        response = self._client.transport.post(
+            self._client._build_url("/session"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return SessionDetail(**response.data)
+
+    def get(self, id: str) -> SessionDetail:
+        response = self._client.transport.get(self._client._build_url(f"/session/{id}"))
+        return SessionDetail(**response.data)
+
+    def stop(self, id: str) -> BasicResponse:
+        response = self._client.transport.put(
+            self._client._build_url(f"/session/{id}/stop")
+        )
+        return BasicResponse(**response.data)
+
+    def list(
+        self, params: SessionListParams = SessionListParams()
+    ) -> SessionListResponse:
+        response = self._client.transport.get(
+            self._client._build_url("/sessions"), params=params.__dict__
+        )
+        return SessionListResponse(**response.data)
+
+    def get_recording(self, id: str) -> List[SessionRecording]:
+        response = self._client.transport.get(
+            self._client._build_url(f"/session/{id}/recording")
+        )
+        return [SessionRecording(**recording) for recording in response.data]

hyperbrowser-0.8.0/hyperbrowser/client/sync.py

@@ -0,0 +1,25 @@
+from typing import Optional
+from .managers.sync_manager.session import SessionManager
+from .managers.sync_manager.scrape import ScrapeManager
+from .managers.sync_manager.crawl import CrawlManager
+from .base import HyperbrowserBase
+from ..transport.sync import SyncTransport
+from ..config import ClientConfig
+
+
+class Hyperbrowser(HyperbrowserBase):
+    """Synchronous Hyperbrowser client"""
+
+    def __init__(
+        self,
+        config: Optional[ClientConfig] = None,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+    ):
+        super().__init__(SyncTransport, config, api_key, base_url)
+        self.sessions = SessionManager(self)
+        self.scrape = ScrapeManager(self)
+        self.crawl = CrawlManager(self)
+
+    def close(self) -> None:
+        self.transport.close()

{hyperbrowser-0.7.0 → hyperbrowser-0.8.0}/hyperbrowser/models/consts.py

@@ -1,5 +1,7 @@
 from typing import Literal
 
+ScrapeFormat = Literal["markdown", "html", "links"]
+
 Country = Literal[
     "AD",
     "AE",

{hyperbrowser-0.7.0 → hyperbrowser-0.8.0}/hyperbrowser/models/crawl.py

@@ -1,7 +1,11 @@
-from typing import List, Literal, Optional
+from typing import List, Literal, Optional, Union
 from pydantic import BaseModel, ConfigDict, Field
 
+from hyperbrowser.models.scrape import ScrapeOptions
+from hyperbrowser.models.session import CreateSessionParams
+
 CrawlJobStatus = Literal["pending", "running", "completed", "failed"]
+CrawlPageStatus = Literal["completed", "failed"]
 
 
 class StartCrawlJobParams(BaseModel):
@@ -14,16 +18,21 @@ class StartCrawlJobParams(BaseModel):
     )
 
     url: str
-    max_pages: int = Field(default=10, ge=1, le=50, serialization_alias="maxPages")
+    max_pages: int = Field(default=10, ge=1, serialization_alias="maxPages")
     follow_links: bool = Field(default=True, serialization_alias="followLinks")
+    ignore_sitemap: bool = Field(default=False, serialization_alias="ignoreSitemap")
     exclude_patterns: List[str] = Field(
         default=[], serialization_alias="excludePatterns"
     )
     include_patterns: List[str] = Field(
         default=[], serialization_alias="includePatterns"
     )
-    use_proxy: bool = Field(default=False, serialization_alias="useProxy")
-    solve_captchas: bool = Field(default=False, serialization_alias="solveCaptchas")
+    session_options: Optional[CreateSessionParams] = Field(
+        default=None, serialization_alias="sessionOptions"
+    )
+    scrape_options: Optional[ScrapeOptions] = Field(
+        default=None, serialization_alias="scrapeOptions"
+    )
 
 
 class StartCrawlJobResponse(BaseModel):
@@ -38,35 +47,18 @@ class StartCrawlJobResponse(BaseModel):
     job_id: str = Field(alias="jobId")
 
 
-class CrawledPageMetadata(BaseModel):
-    """
-    Metadata for the crawled page.
-    """
-
-    model_config = ConfigDict(
-        populate_by_alias=True,
-    )
-
-    title: str
-    description: str
-    robots: str
-    og_title: str = Field(alias="ogTitle")
-    og_description: str = Field(alias="ogDescription")
-    og_url: str = Field(alias="ogUrl")
-    og_image: str = Field(alias="ogImage")
-    og_locale_alternate: List[str] = Field(alias="ogLocaleAlternate")
-    og_site_name: str = Field(alias="ogSiteName")
-    source_url: str = Field(alias="sourceURL")
-
-
 class CrawledPage(BaseModel):
     """
     Data from a crawled page.
     """
 
-    metadata: CrawledPageMetadata
-    markdown: str
+    metadata: Optional[dict[str, Union[str, list[str]]]] = None
+    html: Optional[str] = None
+    markdown: Optional[str] = None
+    links: Optional[List[str]] = None
     url: str
+    status: CrawlPageStatus
+    error: Optional[str] = None
 
 
 class GetCrawlJobParams(BaseModel):
@@ -76,7 +68,7 @@ class GetCrawlJobParams(BaseModel):
 
     page: Optional[int] = Field(default=None, serialization_alias="page")
     batch_size: Optional[int] = Field(
-        default=20, ge=1, le=50, serialization_alias="batchSize"
+        default=20, ge=1, le=30, serialization_alias="batchSize"
     )
 
 
@@ -89,6 +81,7 @@ class CrawlJobResponse(BaseModel):
         populate_by_alias=True,
     )
 
+    job_id: str = Field(alias="jobId")
     status: CrawlJobStatus
     error: Optional[str] = None
     data: List[CrawledPage] = Field(alias="data")

hyperbrowser-0.8.0/hyperbrowser/models/scrape.py

@@ -0,0 +1,82 @@
+from typing import List, Literal, Optional, Union
+from pydantic import BaseModel, ConfigDict, Field
+
+from hyperbrowser.models.consts import ScrapeFormat
+from hyperbrowser.models.session import CreateSessionParams
+
+ScrapeJobStatus = Literal["pending", "running", "completed", "failed"]
+
+
+class ScrapeOptions(BaseModel):
+    """
+    Options for scraping a page.
+    """
+
+    formats: Optional[List[ScrapeFormat]] = None
+    include_tags: Optional[List[str]] = Field(
+        default=None, serialization_alias="includeTags"
+    )
+    exclude_tags: Optional[List[str]] = Field(
+        default=None, serialization_alias="excludeTags"
+    )
+    only_main_content: Optional[bool] = Field(
+        default=None, serialization_alias="onlyMainContent"
+    )
+    wait_for: Optional[int] = Field(default=None, serialization_alias="waitFor")
+    timeout: Optional[int] = Field(default=None, serialization_alias="timeout")
+
+
+class StartScrapeJobParams(BaseModel):
+    """
+    Parameters for creating a new scrape job.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    url: str
+    session_options: Optional[CreateSessionParams] = Field(
+        default=None, serialization_alias="sessionOptions"
+    )
+    scrape_options: Optional[ScrapeOptions] = Field(
+        default=None, serialization_alias="scrapeOptions"
+    )
+
+
+class StartScrapeJobResponse(BaseModel):
+    """
+    Response from creating a scrape job.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    job_id: str = Field(alias="jobId")
+
+
+class ScrapeJobData(BaseModel):
+    """
+    Data from a scraped site.
+    """
+
+    metadata: Optional[dict[str, Union[str, list[str]]]] = None
+    html: Optional[str] = None
+    markdown: Optional[str] = None
+    links: Optional[List[str]] = None
+
+
+class ScrapeJobResponse(BaseModel):
+    """
+    Response from getting a scrape job.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    job_id: str = Field(alias="jobId")
+    status: ScrapeJobStatus
+    error: Optional[str] = None
+    data: Optional[ScrapeJobData] = None

{hyperbrowser-0.7.0 → hyperbrowser-0.8.0}/hyperbrowser/models/session.py

@@ -1,4 +1,4 @@
-from typing import List, Literal, Optional, Union
+from typing import Any, List, Literal, Optional, Union
 from datetime import datetime
 from pydantic import BaseModel, Field, ConfigDict, field_validator
 
@@ -50,7 +50,7 @@ class SessionDetail(Session):
     Detailed session information including websocket endpoint.
     """
 
-    websocket_url: Optional[str] = Field(alias="wsEndpoint", default=None)
+    ws_endpoint: Optional[str] = Field(alias="wsEndpoint", default=None)
 
 
 class SessionListParams(BaseModel):
@@ -96,8 +96,8 @@ class ScreenConfig(BaseModel):
     Screen configuration parameters for browser session.
     """
 
-    width: int = Field(default=1280, le=3840, ge=640, serialization_alias="width")
-    height: int = Field(default=720, le=2160, ge=360, serialization_alias="height")
+    width: int = Field(default=1280, serialization_alias="width")
+    height: int = Field(default=720, serialization_alias="height")
 
 
 class CreateSessionParams(BaseModel):
@@ -132,3 +132,21 @@ class CreateSessionParams(BaseModel):
     adblock: bool = Field(default=False, serialization_alias="adblock")
     trackers: bool = Field(default=False, serialization_alias="trackers")
     annoyances: bool = Field(default=False, serialization_alias="annoyances")
+    enable_web_recording: Optional[bool] = Field(
+        default=False, serialization_alias="enableWebRecording"
+    )
+
+
+class SessionRecording(BaseModel):
+    """
+    Model for session recording data.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    type: int
+    data: Any
+    timestamp: int
+    delay: Optional[int] = None

{hyperbrowser-0.7.0 → hyperbrowser-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "hyperbrowser"
-version = "0.7.0"
+version = "0.8.0"
 description = "Python SDK for hyperbrowser"
 authors = ["Nikhil Shahi <nshahi1998@gmail.com>"]
 license = "MIT"

hyperbrowser-0.7.0/hyperbrowser/client/async_client.py

@@ -1,97 +0,0 @@
-from typing import Optional
-
-from hyperbrowser.models.crawl import (
-    CrawlJobResponse,
-    GetCrawlJobParams,
-    StartCrawlJobParams,
-    StartCrawlJobResponse,
-)
-from hyperbrowser.models.scrape import (
-    ScrapeJobResponse,
-    StartScrapeJobParams,
-    StartScrapeJobResponse,
-)
-from ..transport.async_transport import AsyncTransport
-from .base import HyperbrowserBase
-from ..models.session import (
-    BasicResponse,
-    CreateSessionParams,
-    SessionDetail,
-    SessionListParams,
-    SessionListResponse,
-)
-from ..config import ClientConfig
-
-
-class AsyncHyperbrowser(HyperbrowserBase):
-    """Asynchronous Hyperbrowser client"""
-
-    def __init__(
-        self,
-        config: Optional[ClientConfig] = None,
-        api_key: Optional[str] = None,
-        base_url: Optional[str] = None,
-    ):
-        super().__init__(AsyncTransport, config, api_key, base_url)
-
-    async def create_session(self, params: CreateSessionParams) -> SessionDetail:
-        response = await self.transport.post(
-            self._build_url("/session"),
-            data=params.model_dump(exclude_none=True, by_alias=True),
-        )
-        return SessionDetail(**response.data)
-
-    async def get_session(self, id: str) -> SessionDetail:
-        response = await self.transport.get(self._build_url(f"/session/{id}"))
-        return SessionDetail(**response.data)
-
-    async def stop_session(self, id: str) -> BasicResponse:
-        response = await self.transport.put(self._build_url(f"/session/{id}/stop"))
-        return BasicResponse(**response.data)
-
-    async def get_session_list(
-        self, params: SessionListParams = SessionListParams()
-    ) -> SessionListResponse:
-        response = await self.transport.get(
-            self._build_url("/sessions"), params=params.__dict__
-        )
-        return SessionListResponse(**response.data)
-
-    async def start_scrape_job(
-        self, params: StartScrapeJobParams
-    ) -> StartScrapeJobResponse:
-        response = await self.transport.post(
-            self._build_url("/scrape"),
-            data=params.model_dump(exclude_none=True, by_alias=True),
-        )
-        return StartScrapeJobResponse(**response.data)
-
-    async def get_scrape_job(self, job_id: str) -> ScrapeJobResponse:
-        response = await self.transport.get(self._build_url(f"/scrape/{job_id}"))
-        return ScrapeJobResponse(**response.data)
-
-    async def start_crawl_job(
-        self, params: StartCrawlJobParams
-    ) -> StartCrawlJobResponse:
-        response = await self.transport.post(
-            self._build_url("/crawl"),
-            data=params.model_dump(exclude_none=True, by_alias=True),
-        )
-        return StartCrawlJobResponse(**response.data)
-
-    async def get_crawl_job(
-        self, job_id: str, params: GetCrawlJobParams = GetCrawlJobParams()
-    ) -> CrawlJobResponse:
-        response = await self.transport.get(
-            self._build_url(f"/crawl/{job_id}"), params=params.__dict__
-        )
-        return CrawlJobResponse(**response.data)
-
-    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.7.0/hyperbrowser/client/sync.py

@@ -1,85 +0,0 @@
-from typing import Optional
-
-from hyperbrowser.models.crawl import (
-    CrawlJobResponse,
-    GetCrawlJobParams,
-    StartCrawlJobParams,
-    StartCrawlJobResponse,
-)
-from hyperbrowser.models.scrape import (
-    ScrapeJobResponse,
-    StartScrapeJobParams,
-    StartScrapeJobResponse,
-)
-from ..transport.sync import SyncTransport
-from .base import HyperbrowserBase
-from ..models.session import (
-    BasicResponse,
-    CreateSessionParams,
-    SessionDetail,
-    SessionListParams,
-    SessionListResponse,
-)
-from ..config import ClientConfig
-
-
-class Hyperbrowser(HyperbrowserBase):
-    """Synchronous Hyperbrowser client"""
-
-    def __init__(
-        self,
-        config: Optional[ClientConfig] = None,
-        api_key: Optional[str] = None,
-        base_url: Optional[str] = None,
-    ):
-        super().__init__(SyncTransport, config, api_key, base_url)
-
-    def create_session(self, params: CreateSessionParams) -> SessionDetail:
-        response = self.transport.post(
-            self._build_url("/session"),
-            data=params.model_dump(exclude_none=True, by_alias=True),
-        )
-        return SessionDetail(**response.data)
-
-    def get_session(self, id: str) -> SessionDetail:
-        response = self.transport.get(self._build_url(f"/session/{id}"))
-        return SessionDetail(**response.data)
-
-    def stop_session(self, id: str) -> BasicResponse:
-        response = self.transport.put(self._build_url(f"/session/{id}/stop"))
-        return BasicResponse(**response.data)
-
-    def get_session_list(self, params: SessionListParams) -> SessionListResponse:
-        response = self.transport.get(
-            self._build_url("/sessions"), params=params.__dict__
-        )
-        return SessionListResponse(**response.data)
-
-    def start_scrape_job(self, params: StartScrapeJobParams) -> StartScrapeJobResponse:
-        response = self.transport.post(
-            self._build_url("/scrape"),
-            data=params.model_dump(exclude_none=True, by_alias=True),
-        )
-        return StartScrapeJobResponse(**response.data)
-
-    def get_scrape_job(self, job_id: str) -> ScrapeJobResponse:
-        response = self.transport.get(self._build_url(f"/scrape/{job_id}"))
-        return ScrapeJobResponse(**response.data)
-
-    def start_crawl_job(self, params: StartCrawlJobParams) -> StartCrawlJobResponse:
-        response = self.transport.post(
-            self._build_url("/crawl"),
-            data=params.model_dump(exclude_none=True, by_alias=True),
-        )
-        return StartCrawlJobResponse(**response.data)
-
-    def get_crawl_job(
-        self, job_id: str, params: GetCrawlJobParams = GetCrawlJobParams()
-    ) -> CrawlJobResponse:
-        response = self.transport.get(
-            self._build_url(f"/crawl/{job_id}"), params=params.__dict__
-        )
-        return CrawlJobResponse(**response.data)
-
-    def close(self) -> None:
-        self.transport.close()

hyperbrowser-0.7.0/hyperbrowser/models/scrape.py

@@ -1,74 +0,0 @@
-from typing import List, Literal, Optional
-from pydantic import BaseModel, ConfigDict, Field
-
-ScrapeJobStatus = Literal["pending", "running", "completed", "failed"]
-
-
-class StartScrapeJobParams(BaseModel):
-    """
-    Parameters for creating a new scrape job.
-    """
-
-    model_config = ConfigDict(
-        populate_by_alias=True,
-    )
-
-    url: str
-    use_proxy: bool = Field(default=False, serialization_alias="useProxy")
-    solve_captchas: bool = Field(default=False, serialization_alias="solveCaptchas")
-
-
-class StartScrapeJobResponse(BaseModel):
-    """
-    Response from creating a scrape job.
-    """
-
-    model_config = ConfigDict(
-        populate_by_alias=True,
-    )
-
-    job_id: str = Field(alias="jobId")
-
-
-class ScrapeJobMetadata(BaseModel):
-    """
-    Metadata for the scraped site.
-    """
-
-    model_config = ConfigDict(
-        populate_by_alias=True,
-    )
-
-    title: str
-    description: str
-    robots: str
-    og_title: str = Field(alias="ogTitle")
-    og_description: str = Field(alias="ogDescription")
-    og_url: str = Field(alias="ogUrl")
-    og_image: str = Field(alias="ogImage")
-    og_locale_alternate: List[str] = Field(alias="ogLocaleAlternate")
-    og_site_name: str = Field(alias="ogSiteName")
-    source_url: str = Field(alias="sourceURL")
-
-
-class ScrapeJobData(BaseModel):
-    """
-    Data from a scraped site.
-    """
-
-    metadata: ScrapeJobMetadata
-    markdown: str
-
-
-class ScrapeJobResponse(BaseModel):
-    """
-    Response from getting a scrape job.
-    """
-
-    model_config = ConfigDict(
-        populate_by_alias=True,
-    )
-
-    status: ScrapeJobStatus
-    error: Optional[str] = None
-    data: Optional[ScrapeJobData] = None