hyperbrowser 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

hyperbrowser/client/async_client.py

@@ -1,25 +1,9 @@
 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 .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 ..models.session import (
-    BasicResponse,
-    CreateSessionParams,
-    SessionDetail,
-    SessionListParams,
-    SessionListResponse,
-)
+from ..transport.async_transport import AsyncTransport
 from ..config import ClientConfig
 
 
@@ -33,59 +17,9 @@ class AsyncHyperbrowser(HyperbrowserBase):
         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)
+        self.sessions = SessionManager(self)
+        self.scrape = ScrapeManager(self)
+        self.crawl = CrawlManager(self)
 
     async def close(self) -> None:
         await self.transport.close()

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/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/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/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/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/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/client/sync.py

@@ -1,25 +1,9 @@
 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 .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 ..models.session import (
-    BasicResponse,
-    CreateSessionParams,
-    SessionDetail,
-    SessionListParams,
-    SessionListResponse,
-)
+from ..transport.sync import SyncTransport
 from ..config import ClientConfig
 
 
@@ -33,53 +17,9 @@ class Hyperbrowser(HyperbrowserBase):
         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)
+        self.sessions = SessionManager(self)
+        self.scrape = ScrapeManager(self)
+        self.crawl = CrawlManager(self)
 
     def close(self) -> None:
         self.transport.close()

hyperbrowser/models/consts.py

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

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/models/scrape.py

@@ -1,54 +1,59 @@
-from typing import List, Literal, Optional
+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 StartScrapeJobParams(BaseModel):
+class ScrapeOptions(BaseModel):
     """
-    Parameters for creating a new scrape job.
+    Options for scraping a page.
     """
 
-    model_config = ConfigDict(
-        populate_by_alias=True,
+    formats: Optional[List[ScrapeFormat]] = None
+    include_tags: Optional[List[str]] = Field(
+        default=None, serialization_alias="includeTags"
     )
-
-    url: str
-    use_proxy: bool = Field(default=False, serialization_alias="useProxy")
-    solve_captchas: bool = Field(default=False, serialization_alias="solveCaptchas")
+    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 StartScrapeJobResponse(BaseModel):
+class StartScrapeJobParams(BaseModel):
     """
-    Response from creating a scrape job.
+    Parameters for creating a new scrape job.
     """
 
     model_config = ConfigDict(
         populate_by_alias=True,
     )
 
-    job_id: str = Field(alias="jobId")
+    url: str
+    session_options: Optional[CreateSessionParams] = Field(
+        default=None, serialization_alias="sessionOptions"
+    )
+    scrape_options: Optional[ScrapeOptions] = Field(
+        default=None, serialization_alias="scrapeOptions"
+    )
 
 
-class ScrapeJobMetadata(BaseModel):
+class StartScrapeJobResponse(BaseModel):
     """
-    Metadata for the scraped site.
+    Response from creating a scrape job.
     """
 
     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")
+    job_id: str = Field(alias="jobId")
 
 
 class ScrapeJobData(BaseModel):
@@ -56,8 +61,10 @@ class ScrapeJobData(BaseModel):
     Data from a scraped site.
     """
 
-    metadata: ScrapeJobMetadata
-    markdown: str
+    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):
@@ -69,6 +76,7 @@ class ScrapeJobResponse(BaseModel):
         populate_by_alias=True,
     )
 
+    job_id: str = Field(alias="jobId")
     status: ScrapeJobStatus
     error: Optional[str] = None
     data: Optional[ScrapeJobData] = None

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
 
@@ -33,6 +33,7 @@ class Session(BaseModel):
     end_time: Optional[int] = Field(default=None, alias="endTime")
     duration: Optional[int] = None
     session_url: str = Field(alias="sessionUrl")
+    token: str = Field(alias="token")
 
     @field_validator("start_time", "end_time", mode="before")
     @classmethod
@@ -50,7 +51,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 +97,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 +133,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.dist-info → hyperbrowser-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hyperbrowser
-Version: 0.7.0
+Version: 0.9.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.9.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+LICENSE,sha256=6rUGKlyKb_1ZAH7h7YITYAAUNFN3MNGGKCyfrw49NLE,1071
+hyperbrowser/__init__.py,sha256=zWGcLhqhvWy6BTwuNpzWK1-0LpIn311ks-4U9nrsb7Y,187
+hyperbrowser/client/async_client.py,sha256=ppJI8O7SQi89mwMhIHVgTgFeRu2aZbLl2zbFaI3sXNU,984
+hyperbrowser/client/base.py,sha256=9gFma7RdvJBUlDCqr8tZd315UPrjn4ldU4B0-Y-L4O4,1268
+hyperbrowser/client/managers/async_manager/crawl.py,sha256=hBS2WwfE0-ZopCW9PjP30meU5iTDdRViFl1C1OF1hVU,2291
+hyperbrowser/client/managers/async_manager/scrape.py,sha256=7FdYS_NNEpvB9z3ShGZaZxNryKHm02MQR-g9diadGhA,1319
+hyperbrowser/client/managers/async_manager/session.py,sha256=uFHWQISthvQHLFaTf8p4orj95-CKTLmfE9yF-GvRtqE,1595
+hyperbrowser/client/managers/sync_manager/crawl.py,sha256=lnMtBmOPcamjtvzH4BAnWbBTGbKBmHGUQiMnnZlj2tg,2222
+hyperbrowser/client/managers/sync_manager/scrape.py,sha256=DxSvdHa-z2P_rvNUwmRfU4iQz19wiEi_M2YmBQZfLyk,1265
+hyperbrowser/client/managers/sync_manager/session.py,sha256=J-OVwgDmKScUYVhytM-w-svUitHe43i1v58c5WgQLiU,1513
+hyperbrowser/client/sync.py,sha256=CzXlPksK4D7eazQDzbra-pM64Sy0bLrg0zjv5xBKZdk,811
+hyperbrowser/config.py,sha256=2J6GYNR_83vzJZ6jEV-LXO1U-q6DHIrfyAU0WrUPhw8,625
+hyperbrowser/exceptions.py,sha256=SUUkptK2OL36xDORYmSicaTYR7pMbxeWAjAgz35xnM8,1171
+hyperbrowser/models/consts.py,sha256=xsMBPivE4M6wGJ5Q0x3oRTgt0Koi1occtAeHthes9ZY,4970
+hyperbrowser/models/crawl.py,sha256=DWeJRwuZ0EXOEpEx0OyUZp_HOdGfpptg_mNo5J0u6po,2566
+hyperbrowser/models/scrape.py,sha256=e3Z5HgCkLD1FxOjXtPmI6SAJ9wsrAKXj7WElXFXy8yE,2103
+hyperbrowser/models/session.py,sha256=QVcPc4rkXqTfSE9roEImRgsJ4xxHruTaKubQSHy__xI,4541
+hyperbrowser/transport/async_transport.py,sha256=P-nX9iczGVYJyvqtqlGAOFQ3PghRC2_bE6Lruiiecn0,3511
+hyperbrowser/transport/base.py,sha256=9l7k-qTX4Q2KaZIR_fwsNlxDgOzsmc8zgucZ9tfHgkw,1622
+hyperbrowser/transport/sync.py,sha256=DFDPYqF-_WQSZkRbWDRFTPowQMzz-B3N869r2vvocPc,2829
+hyperbrowser-0.9.0.dist-info/LICENSE,sha256=6rUGKlyKb_1ZAH7h7YITYAAUNFN3MNGGKCyfrw49NLE,1071
+hyperbrowser-0.9.0.dist-info/METADATA,sha256=Si_LKjvhplK4Wbi8CxjFBA9O_dWd-0gp-k-HKfmvUOY,3289
+hyperbrowser-0.9.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+hyperbrowser-0.9.0.dist-info/RECORD,,

hyperbrowser-0.7.0.dist-info/RECORD

@@ -1,18 +0,0 @@
-LICENSE,sha256=6rUGKlyKb_1ZAH7h7YITYAAUNFN3MNGGKCyfrw49NLE,1071
-hyperbrowser/__init__.py,sha256=zWGcLhqhvWy6BTwuNpzWK1-0LpIn311ks-4U9nrsb7Y,187
-hyperbrowser/client/async_client.py,sha256=nmbbqaIEOWk01-mqBCYkg8hU01_sQLrAJNiPaWfINEI,3225
-hyperbrowser/client/base.py,sha256=9gFma7RdvJBUlDCqr8tZd315UPrjn4ldU4B0-Y-L4O4,1268
-hyperbrowser/client/sync.py,sha256=2ZembYQu7h0ph57jYFUH6ytXA0ebohceu39PevwSWaM,2895
-hyperbrowser/config.py,sha256=2J6GYNR_83vzJZ6jEV-LXO1U-q6DHIrfyAU0WrUPhw8,625
-hyperbrowser/exceptions.py,sha256=SUUkptK2OL36xDORYmSicaTYR7pMbxeWAjAgz35xnM8,1171
-hyperbrowser/models/consts.py,sha256=VmtqbXqK6WTvlD5XExL3e2JE3WaFTi_iniEAQlRSQgs,4917
-hyperbrowser/models/crawl.py,sha256=-u0pJ28sNjyycfbuLHjuA5bftDtkV60ZFvek7Z510ao,2582
-hyperbrowser/models/scrape.py,sha256=JIS6zbHlpv-U1hc9qVYeCazXYHBiRzjQX6y_TXsl4js,1678
-hyperbrowser/models/session.py,sha256=N05NLI0NFul7uQPkLihOv82-JCjXkWW8hlMbQsPZMvo,4173
-hyperbrowser/transport/async_transport.py,sha256=P-nX9iczGVYJyvqtqlGAOFQ3PghRC2_bE6Lruiiecn0,3511
-hyperbrowser/transport/base.py,sha256=9l7k-qTX4Q2KaZIR_fwsNlxDgOzsmc8zgucZ9tfHgkw,1622
-hyperbrowser/transport/sync.py,sha256=DFDPYqF-_WQSZkRbWDRFTPowQMzz-B3N869r2vvocPc,2829
-hyperbrowser-0.7.0.dist-info/LICENSE,sha256=6rUGKlyKb_1ZAH7h7YITYAAUNFN3MNGGKCyfrw49NLE,1071
-hyperbrowser-0.7.0.dist-info/METADATA,sha256=tgrKlcUojlBC7D1cClvMIMiA7_krPD7NGpxyuHLGLA0,3289
-hyperbrowser-0.7.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-hyperbrowser-0.7.0.dist-info/RECORD,,