hyperbrowser 0.22.0__py3-none-any.whl → 0.24.0__py3-none-any.whl

hyperbrowser/client/managers/async_manager/crawl.py

@@ -1,5 +1,6 @@
 import asyncio
-from typing import Optional
+
+from hyperbrowser.models.consts import POLLING_ATTEMPTS
 from ....models.crawl import (
     CrawlJobResponse,
     GetCrawlJobParams,
@@ -32,29 +33,69 @@ class CrawlManager:
         self, params: StartCrawlJobParams, return_all_pages: bool = True
     ) -> CrawlJobResponse:
         job_start_resp = await self.start(params)
-        if not job_start_resp.job_id:
+        job_id = job_start_resp.job_id
+        if not job_id:
             raise HyperbrowserError("Failed to start crawl job")
 
         job_response: CrawlJobResponse
+        failures = 0
         while True:
-            job_response = await self.get(job_start_resp.job_id)
-            if job_response.status == "completed" or job_response.status == "failed":
-                break
+            try:
+                job_response = await self.get(
+                    job_id,
+                    params=GetCrawlJobParams(batch_size=1),
+                )
+                if (
+                    job_response.status == "completed"
+                    or job_response.status == "failed"
+                ):
+                    break
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to poll crawl job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
             await asyncio.sleep(2)
 
+        failures = 0
         if not return_all_pages:
-            return job_response
+            while True:
+                try:
+                    job_response = await self.get(job_id)
+                    return job_response
+                except Exception as e:
+                    failures += 1
+                    if failures >= POLLING_ATTEMPTS:
+                        raise HyperbrowserError(
+                            f"Failed to get crawl job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                        )
+                await asyncio.sleep(0.5)
 
+        failures = 0
+        job_response.current_page_batch = 0
+        job_response.data = []
         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
+            try:
+                tmp_job_response = await self.get(
+                    job_start_resp.job_id,
+                    GetCrawlJobParams(
+                        page=job_response.current_page_batch + 1, batch_size=100
+                    ),
+                )
+                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
+                failures = 0
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to get crawl batch page {job_response.current_page_batch} for job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
             await asyncio.sleep(0.5)
+
         return job_response

hyperbrowser/client/managers/async_manager/extract.py

@@ -1,5 +1,6 @@
 import asyncio
 from hyperbrowser.exceptions import HyperbrowserError
+from hyperbrowser.models.consts import POLLING_ATTEMPTS
 from hyperbrowser.models.extract import (
     ExtractJobResponse,
     StartExtractJobParams,
@@ -32,10 +33,24 @@ class ExtractManager:
 
     async def start_and_wait(self, params: StartExtractJobParams) -> ExtractJobResponse:
         job_start_resp = await self.start(params)
-        if not job_start_resp.job_id:
+        job_id = job_start_resp.job_id
+        if not job_id:
             raise HyperbrowserError("Failed to start extract job")
+
+        failures = 0
         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
+            try:
+                job_response = await self.get(job_id)
+                if (
+                    job_response.status == "completed"
+                    or job_response.status == "failed"
+                ):
+                    return job_response
+                failures = 0
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to poll extract job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
             await asyncio.sleep(2)

hyperbrowser/client/managers/async_manager/scrape.py

@@ -1,16 +1,116 @@
 import asyncio
 from typing import Optional
+
+from hyperbrowser.models.consts import POLLING_ATTEMPTS
 from ....models.scrape import (
+    BatchScrapeJobResponse,
+    GetBatchScrapeJobParams,
     ScrapeJobResponse,
+    StartBatchScrapeJobParams,
+    StartBatchScrapeJobResponse,
     StartScrapeJobParams,
     StartScrapeJobResponse,
 )
 from ....exceptions import HyperbrowserError
 
 
+class BatchScrapeManager:
+    def __init__(self, client):
+        self._client = client
+
+    async def start(
+        self, params: StartBatchScrapeJobParams
+    ) -> StartBatchScrapeJobResponse:
+        response = await self._client.transport.post(
+            self._client._build_url("/scrape/batch"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return StartBatchScrapeJobResponse(**response.data)
+
+    async def get(
+        self, job_id: str, params: GetBatchScrapeJobParams = GetBatchScrapeJobParams()
+    ) -> BatchScrapeJobResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/scrape/batch/{job_id}"), params=params.__dict__
+        )
+        return BatchScrapeJobResponse(**response.data)
+
+    async def start_and_wait(
+        self, params: StartBatchScrapeJobParams, return_all_pages: bool = True
+    ) -> BatchScrapeJobResponse:
+        job_start_resp = await self.start(params)
+        job_id = job_start_resp.job_id
+        if not job_id:
+            raise HyperbrowserError("Failed to start batch scrape job")
+
+        job_response: BatchScrapeJobResponse
+        failures = 0
+        while True:
+            try:
+                job_response = await self.get(
+                    job_id, params=GetBatchScrapeJobParams(batch_size=1)
+                )
+                if (
+                    job_response.status == "completed"
+                    or job_response.status == "failed"
+                ):
+                    break
+                failures = 0
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to poll batch scrape job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
+            await asyncio.sleep(2)
+
+        failures = 0
+        if not return_all_pages:
+            while True:
+                try:
+                    job_response = await self.get(job_id)
+                    return job_response
+                except Exception as e:
+                    failures += 1
+                    if failures >= POLLING_ATTEMPTS:
+                        raise HyperbrowserError(
+                            f"Failed to get batch scrape job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                        )
+                await asyncio.sleep(0.5)
+
+        failures = 0
+        job_response.current_page_batch = 0
+        job_response.data = []
+        while job_response.current_page_batch < job_response.total_page_batches:
+            try:
+                tmp_job_response = await self.get(
+                    job_id,
+                    params=GetBatchScrapeJobParams(
+                        page=job_response.current_page_batch + 1, batch_size=100
+                    ),
+                )
+                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_scraped_pages = tmp_job_response.total_scraped_pages
+                job_response.total_page_batches = tmp_job_response.total_page_batches
+                job_response.batch_size = tmp_job_response.batch_size
+                failures = 0
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to get batch page {job_response.current_page_batch} for job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
+            await asyncio.sleep(0.5)
+
+        return job_response
+
+
 class ScrapeManager:
     def __init__(self, client):
         self._client = client
+        self.batch = BatchScrapeManager(client)
 
     async def start(self, params: StartScrapeJobParams) -> StartScrapeJobResponse:
         response = await self._client.transport.post(
@@ -27,10 +127,24 @@ class ScrapeManager:
 
     async def start_and_wait(self, params: StartScrapeJobParams) -> ScrapeJobResponse:
         job_start_resp = await self.start(params)
-        if not job_start_resp.job_id:
+        job_id = job_start_resp.job_id
+        if not job_id:
             raise HyperbrowserError("Failed to start scrape job")
+
+        failures = 0
         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
+            try:
+                job_response = await self.get(job_id)
+                if (
+                    job_response.status == "completed"
+                    or job_response.status == "failed"
+                ):
+                    return job_response
+                failures = 0
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to poll scrape job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
             await asyncio.sleep(2)

hyperbrowser/client/managers/sync_manager/crawl.py

@@ -1,5 +1,7 @@
 import time
 from typing import Optional
+
+from hyperbrowser.models.consts import POLLING_ATTEMPTS
 from ....models.crawl import (
     CrawlJobResponse,
     GetCrawlJobParams,
@@ -32,29 +34,69 @@ class CrawlManager:
         self, params: StartCrawlJobParams, return_all_pages: bool = True
     ) -> CrawlJobResponse:
         job_start_resp = self.start(params)
-        if not job_start_resp.job_id:
+        job_id = job_start_resp.job_id
+        if not job_id:
             raise HyperbrowserError("Failed to start crawl job")
 
         job_response: CrawlJobResponse
+        failures = 0
         while True:
-            job_response = self.get(job_start_resp.job_id)
-            if job_response.status == "completed" or job_response.status == "failed":
-                break
+            try:
+                job_response = self.get(
+                    job_id,
+                    params=GetCrawlJobParams(batch_size=1),
+                )
+                if (
+                    job_response.status == "completed"
+                    or job_response.status == "failed"
+                ):
+                    break
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to poll crawl job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
             time.sleep(2)
 
+        failures = 0
         if not return_all_pages:
-            return job_response
+            while True:
+                try:
+                    job_response = self.get(job_id)
+                    return job_response
+                except Exception as e:
+                    failures += 1
+                    if failures >= POLLING_ATTEMPTS:
+                        raise HyperbrowserError(
+                            f"Failed to get crawl job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                        )
+                time.sleep(0.5)
 
+        failures = 0
+        job_response.current_page_batch = 0
+        job_response.data = []
         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
+            try:
+                tmp_job_response = self.get(
+                    job_id,
+                    GetCrawlJobParams(
+                        page=job_response.current_page_batch + 1, batch_size=100
+                    ),
+                )
+                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
+                failures = 0
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to get crawl batch page {job_response.current_page_batch} for job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
             time.sleep(0.5)
+
         return job_response

hyperbrowser/client/managers/sync_manager/extract.py

@@ -1,5 +1,6 @@
 import time
 from hyperbrowser.exceptions import HyperbrowserError
+from hyperbrowser.models.consts import POLLING_ATTEMPTS
 from hyperbrowser.models.extract import (
     ExtractJobResponse,
     StartExtractJobParams,
@@ -32,10 +33,23 @@ class ExtractManager:
 
     def start_and_wait(self, params: StartExtractJobParams) -> ExtractJobResponse:
         job_start_resp = self.start(params)
-        if not job_start_resp.job_id:
+        job_id = job_start_resp.job_id
+        if not job_id:
             raise HyperbrowserError("Failed to start extract job")
+
+        failures = 0
         while True:
-            job_response = self.get(job_start_resp.job_id)
-            if job_response.status == "completed" or job_response.status == "failed":
-                return job_response
+            try:
+                job_response = self.get(job_start_resp.job_id)
+                if (
+                    job_response.status == "completed"
+                    or job_response.status == "failed"
+                ):
+                    return job_response
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to poll extract job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
             time.sleep(2)

hyperbrowser/client/managers/sync_manager/scrape.py

@@ -1,16 +1,114 @@
 import time
 from typing import Optional
+
+from hyperbrowser.models.consts import POLLING_ATTEMPTS
 from ....models.scrape import (
+    BatchScrapeJobResponse,
+    GetBatchScrapeJobParams,
     ScrapeJobResponse,
+    StartBatchScrapeJobParams,
+    StartBatchScrapeJobResponse,
     StartScrapeJobParams,
     StartScrapeJobResponse,
 )
 from ....exceptions import HyperbrowserError
 
 
+class BatchScrapeManager:
+    def __init__(self, client):
+        self._client = client
+
+    def start(self, params: StartBatchScrapeJobParams) -> StartBatchScrapeJobResponse:
+        response = self._client.transport.post(
+            self._client._build_url("/scrape/batch"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return StartBatchScrapeJobResponse(**response.data)
+
+    def get(
+        self, job_id: str, params: GetBatchScrapeJobParams = GetBatchScrapeJobParams()
+    ) -> BatchScrapeJobResponse:
+        response = self._client.transport.get(
+            self._client._build_url(f"/scrape/batch/{job_id}"), params=params.__dict__
+        )
+        return BatchScrapeJobResponse(**response.data)
+
+    def start_and_wait(
+        self, params: StartBatchScrapeJobParams, return_all_pages: bool = True
+    ) -> BatchScrapeJobResponse:
+        job_start_resp = self.start(params)
+        job_id = job_start_resp.job_id
+        if not job_id:
+            raise HyperbrowserError("Failed to start batch scrape job")
+
+        job_response: BatchScrapeJobResponse
+        failures = 0
+        while True:
+            try:
+                job_response = self.get(
+                    job_id, params=GetBatchScrapeJobParams(batch_size=1)
+                )
+                if (
+                    job_response.status == "completed"
+                    or job_response.status == "failed"
+                ):
+                    break
+                failures = 0
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to poll batch scrape job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
+            time.sleep(2)
+
+        failures = 0
+        if not return_all_pages:
+            while True:
+                try:
+                    job_response = self.get(job_id)
+                    return job_response
+                except Exception as e:
+                    failures += 1
+                    if failures >= POLLING_ATTEMPTS:
+                        raise HyperbrowserError(
+                            f"Failed to get batch scrape job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                        )
+                time.sleep(0.5)
+
+        failures = 0
+        job_response.current_page_batch = 0
+        job_response.data = []
+        while job_response.current_page_batch < job_response.total_page_batches:
+            try:
+                tmp_job_response = self.get(
+                    job_start_resp.job_id,
+                    GetBatchScrapeJobParams(
+                        page=job_response.current_page_batch + 1, batch_size=100
+                    ),
+                )
+                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_scraped_pages = tmp_job_response.total_scraped_pages
+                job_response.total_page_batches = tmp_job_response.total_page_batches
+                job_response.batch_size = tmp_job_response.batch_size
+                failures = 0
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to get batch page {job_response.current_page_batch} for job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
+            time.sleep(0.5)
+
+        return job_response
+
+
 class ScrapeManager:
     def __init__(self, client):
         self._client = client
+        self.batch = BatchScrapeManager(client)
 
     def start(self, params: StartScrapeJobParams) -> StartScrapeJobResponse:
         response = self._client.transport.post(
@@ -27,10 +125,24 @@ class ScrapeManager:
 
     def start_and_wait(self, params: StartScrapeJobParams) -> ScrapeJobResponse:
         job_start_resp = self.start(params)
-        if not job_start_resp.job_id:
+        job_id = job_start_resp.job_id
+        if not job_id:
             raise HyperbrowserError("Failed to start scrape job")
+
+        failures = 0
         while True:
-            job_response = self.get(job_start_resp.job_id)
-            if job_response.status == "completed" or job_response.status == "failed":
-                return job_response
+            try:
+                job_response = self.get(job_id)
+                if (
+                    job_response.status == "completed"
+                    or job_response.status == "failed"
+                ):
+                    return job_response
+                failures = 0
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to poll scrape job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
             time.sleep(2)

hyperbrowser/models/consts.py

@@ -1,6 +1,9 @@
 from typing import Literal
 
 ScrapeFormat = Literal["markdown", "html", "links", "screenshot"]
+ScrapeWaitUntil = Literal["load", "domcontentloaded", "networkidle"]
+ScrapePageStatus = Literal["completed", "failed", "pending", "running"]
+POLLING_ATTEMPTS = 5
 
 Country = Literal[
     "AD",

hyperbrowser/models/crawl.py

@@ -18,7 +18,7 @@ class StartCrawlJobParams(BaseModel):
     )
 
     url: str
-    max_pages: int = Field(default=10, ge=1, serialization_alias="maxPages")
+    max_pages: Optional[int] = Field(default=None, 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(
@@ -69,7 +69,7 @@ class GetCrawlJobParams(BaseModel):
 
     page: Optional[int] = Field(default=None, serialization_alias="page")
     batch_size: Optional[int] = Field(
-        default=20, ge=1, le=30, serialization_alias="batchSize"
+        default=None, ge=1, serialization_alias="batchSize"
     )
 
 

hyperbrowser/models/extract.py

@@ -17,13 +17,17 @@ class StartExtractJobParams(BaseModel):
     )
 
     urls: List[str]
-    prompt: Optional[str] = None
+    system_prompt: Optional[str] = Field(
+        default=None, serialization_alias="systemPrompt"
+    )
+    prompt: Optional[str] = Field(default=None, serialization_alias="prompt")
     schema_: Optional[Any] = pydantic.Field(
         None, alias="schema", serialization_alias="schema"
     )
     session_options: Optional[CreateSessionParams] = Field(
         default=None, serialization_alias="sessionOptions"
     )
+    max_links: Optional[int] = Field(default=None, serialization_alias="maxLinks")
 
 
 class StartExtractJobResponse(BaseModel):

hyperbrowser/models/scrape.py

@@ -1,7 +1,7 @@
 from typing import List, Literal, Optional, Union
 from pydantic import BaseModel, ConfigDict, Field
 
-from hyperbrowser.models.consts import ScrapeFormat
+from hyperbrowser.models.consts import ScrapeFormat, ScrapePageStatus, ScrapeWaitUntil
 from hyperbrowser.models.session import CreateSessionParams
 
 ScrapeJobStatus = Literal["pending", "running", "completed", "failed"]
@@ -24,6 +24,9 @@ class ScrapeOptions(BaseModel):
     )
     wait_for: Optional[int] = Field(default=None, serialization_alias="waitFor")
     timeout: Optional[int] = Field(default=None, serialization_alias="timeout")
+    wait_until: Optional[ScrapeWaitUntil] = Field(
+        default=None, serialization_alias="waitUntil"
+    )
 
 
 class StartScrapeJobParams(BaseModel):
@@ -81,3 +84,78 @@ class ScrapeJobResponse(BaseModel):
     status: ScrapeJobStatus
     error: Optional[str] = None
     data: Optional[ScrapeJobData] = None
+
+
+class StartBatchScrapeJobParams(BaseModel):
+    """
+    Parameters for creating a new batch scrape job.
+    """
+
+    urls: List[str]
+    session_options: Optional[CreateSessionParams] = Field(
+        default=None, serialization_alias="sessionOptions"
+    )
+    scrape_options: Optional[ScrapeOptions] = Field(
+        default=None, serialization_alias="scrapeOptions"
+    )
+
+
+class ScrapedPage(BaseModel):
+    """
+    A scraped page.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    url: str
+    status: ScrapePageStatus
+    error: Optional[str] = None
+    metadata: Optional[dict[str, Union[str, list[str]]]] = None
+    html: Optional[str] = None
+    markdown: Optional[str] = None
+    links: Optional[List[str]] = None
+    screenshot: Optional[str] = None
+
+
+class GetBatchScrapeJobParams(BaseModel):
+    """
+    Parameters for getting a batch scrape job.
+    """
+
+    page: Optional[int] = Field(default=None, serialization_alias="page")
+    batch_size: Optional[int] = Field(
+        default=None, ge=1, serialization_alias="batchSize"
+    )
+
+
+class StartBatchScrapeJobResponse(BaseModel):
+    """
+    Response from starting a batch scrape job.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    job_id: str = Field(alias="jobId")
+
+
+class BatchScrapeJobResponse(BaseModel):
+    """
+    Response from getting a batch scrape job.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    job_id: str = Field(alias="jobId")
+    status: ScrapeJobStatus
+    error: Optional[str] = None
+    data: Optional[List[ScrapedPage]] = Field(alias="data")
+    total_scraped_pages: int = Field(alias="totalScrapedPages")
+    total_page_batches: int = Field(alias="totalPageBatches")
+    current_page_batch: int = Field(alias="currentPageBatch")
+    batch_size: int = Field(alias="batchSize")

{hyperbrowser-0.22.0.dist-info → hyperbrowser-0.24.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: hyperbrowser
-Version: 0.22.0
+Version: 0.24.0
 Summary: Python SDK for hyperbrowser
 License: MIT
 Author: Nikhil Shahi

{hyperbrowser-0.22.0.dist-info → hyperbrowser-0.24.0.dist-info}/RECORD

@@ -1,27 +1,27 @@
 hyperbrowser/__init__.py,sha256=zWGcLhqhvWy6BTwuNpzWK1-0LpIn311ks-4U9nrsb7Y,187
 hyperbrowser/client/async_client.py,sha256=L7mbzg_wOVMneOm6-bA5XaBoVWUmybuRogE4YEMR5Bg,1389
 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/crawl.py,sha256=n0KhHarVpPFwjjlc9UnhSfD5vvdC2kpcXHVr8vPiKxE,3870
 hyperbrowser/client/managers/async_manager/extension.py,sha256=a-xYtXXdCspukYtsguRgjEoQ8E_kzzA2tQAJtIyCtAs,1439
-hyperbrowser/client/managers/async_manager/extract.py,sha256=gjrAixnbBHjGlJNr6DGQIa5MbVy3MevT-9liSX00Zg4,1614
+hyperbrowser/client/managers/async_manager/extract.py,sha256=9p8dGLYmoow7smnQ0BTRN6diDmIayjW-EPRGzzvheZk,2102
 hyperbrowser/client/managers/async_manager/profile.py,sha256=f2uX2GGYdgL0fyzB0jnI-L-nWleqG6cwZ0pc1K1zdQY,1244
-hyperbrowser/client/managers/async_manager/scrape.py,sha256=7FdYS_NNEpvB9z3ShGZaZxNryKHm02MQR-g9diadGhA,1319
+hyperbrowser/client/managers/async_manager/scrape.py,sha256=Lr6oicTX3U1xooczUVQlsq2mzIhAKEW-A9909ZdSzKc,5720
 hyperbrowser/client/managers/async_manager/session.py,sha256=ObJhz1IkCCIQLwmztQ-M7lCKzKsVDr-eWCFnan2d9rQ,1692
-hyperbrowser/client/managers/sync_manager/crawl.py,sha256=lnMtBmOPcamjtvzH4BAnWbBTGbKBmHGUQiMnnZlj2tg,2222
+hyperbrowser/client/managers/sync_manager/crawl.py,sha256=uAVmjhUbamVnzAAyfswq1bdBR5c7JrfGVvPdVmmw4R8,3799
 hyperbrowser/client/managers/sync_manager/extension.py,sha256=1YoyTZtMo43trl9jAsXv95aor0nBHiJEmLva39jFW-k,1415
-hyperbrowser/client/managers/sync_manager/extract.py,sha256=rxDFjDG3tw3llaG5AAkUA3y17krevqeiTHlcNsLvaZ0,1560
+hyperbrowser/client/managers/sync_manager/extract.py,sha256=XocMKC0qAarRpE12KU4m_mi1KhUOHp3-TK4dLeiIn6E,2034
 hyperbrowser/client/managers/sync_manager/profile.py,sha256=va6mlhQ5SKZa-viEGFNzV6UBZEP5SqwVp32_oxC_NzM,1196
-hyperbrowser/client/managers/sync_manager/scrape.py,sha256=DxSvdHa-z2P_rvNUwmRfU4iQz19wiEi_M2YmBQZfLyk,1265
+hyperbrowser/client/managers/sync_manager/scrape.py,sha256=y4YB-NusXRi3brE7jBGRBHGANY-_-aHMBirKuuU6mdg,5579
 hyperbrowser/client/managers/sync_manager/session.py,sha256=74cekrDaGKW5WlP_0Qrqlk-xW2p1u4s63E-D08a4A2s,1610
 hyperbrowser/client/sync.py,sha256=HgglJY9pNdW987OzNO_5dSZgj1AfAqovCmY99WYQD2E,1213
 hyperbrowser/config.py,sha256=2J6GYNR_83vzJZ6jEV-LXO1U-q6DHIrfyAU0WrUPhw8,625
 hyperbrowser/exceptions.py,sha256=SUUkptK2OL36xDORYmSicaTYR7pMbxeWAjAgz35xnM8,1171
-hyperbrowser/models/consts.py,sha256=9hv1NQKrXoqPn-6QHbCTJOc2-Dnj--7XEOZZ0IGtvvk,4984
-hyperbrowser/models/crawl.py,sha256=cP8XmRfTqIJLAnyIHn8MXnHrYokYlYj-JagehGcY0Xc,2603
+hyperbrowser/models/consts.py,sha256=L_6A8JhqLVuR-7p1gMGU6X-eF6KKRM0QIofc_J77Vgw,5146
+hyperbrowser/models/crawl.py,sha256=22hP_DPZMfa2MAfOeJ90qj5CH4rr7VtQT1gCQqO8jO8,2610
 hyperbrowser/models/extension.py,sha256=nXjKXKt9R7RxyZ4hd3EvfqZsEGy_ufh1r5j2mqCLykQ,804
-hyperbrowser/models/extract.py,sha256=LZM4bZ96C_-8Mhf4f4LLMQYmBpvxvtOHs0AkFbswncc,1214
+hyperbrowser/models/extract.py,sha256=24rNo0BzczRPTb3JOcz_WHo5Lz3rBc1Z3-l4EhhroI0,1447
 hyperbrowser/models/profile.py,sha256=KRb_LNxxW00AsD_thzzthFS51vInJawt1RcoNz4Q9i8,1322
-hyperbrowser/models/scrape.py,sha256=yjoU-w1wvTROp5PYu9vyJUEaeuqYjErtnFkzWxxqgk4,2140
+hyperbrowser/models/scrape.py,sha256=HAQJk8KOTcTb9NuD_106tlWlUj55SOhZ6j6vzoQbsZ4,4159
 hyperbrowser/models/session.py,sha256=pBSXnwhiibx8iW7fuxm25p5YFrq1-i_wCQA7mWgFgM0,5294
 hyperbrowser/tools/__init__.py,sha256=OUaTUM-kiigYmzfbpx3XQhzMK1xT1wd8cqXgR4znsAY,2021
 hyperbrowser/tools/anthropic.py,sha256=5pEkJm1H-26GToTwXsDjo4GGqVy1hATws4Pg59mumow,1667
@@ -30,7 +30,7 @@ hyperbrowser/tools/schema.py,sha256=cR2MUX8TvUyN8TnCyeX0pccp4AmPjrdaKzuAXRThOJo,
 hyperbrowser/transport/async_transport.py,sha256=MIPJvilvZWBPXLZ96c9OohuN6TN9DaaU0EnyleG3q6g,4017
 hyperbrowser/transport/base.py,sha256=ildpMrDiM8nvrSGrH2LTOafmB17T7PQB_NQ1ODA378U,1703
 hyperbrowser/transport/sync.py,sha256=ER844H_OCPCrnmbc58cuqphWTVvCZJQn7-D7ZenCr3Y,3311
-hyperbrowser-0.22.0.dist-info/LICENSE,sha256=6rUGKlyKb_1ZAH7h7YITYAAUNFN3MNGGKCyfrw49NLE,1071
-hyperbrowser-0.22.0.dist-info/METADATA,sha256=igqa8zDQZHga9Cr_qeSOnd5HgWBCrwWXE9cXincym_4,3440
-hyperbrowser-0.22.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-hyperbrowser-0.22.0.dist-info/RECORD,,
+hyperbrowser-0.24.0.dist-info/LICENSE,sha256=6rUGKlyKb_1ZAH7h7YITYAAUNFN3MNGGKCyfrw49NLE,1071
+hyperbrowser-0.24.0.dist-info/METADATA,sha256=gyDz49SMWKu3O3XpnP7zfS3n0R9UPOUl_dA4iNz22Pg,3440
+hyperbrowser-0.24.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+hyperbrowser-0.24.0.dist-info/RECORD,,