nimble_python 0.20.0__py3-none-any.whl → 0.21.0__py3-none-any.whl

nimble_python/_client.py

@@ -61,13 +61,14 @@ from .types.extract_async_response import ExtractAsyncResponse
 from .types.extract_batch_response import ExtractBatchResponse
 
 if TYPE_CHECKING:
-    from .resources import jobs, serp, agent, crawl, media, tasks, batches, task_agent, domain_knowledge
+    from .resources import jobs, serp, agent, crawl, media, tasks, batches, fast_serp, task_agent, domain_knowledge
     from .resources.serp import SerpResource, AsyncSerpResource
     from .resources.agent import AgentResource, AsyncAgentResource
     from .resources.crawl import CrawlResource, AsyncCrawlResource
     from .resources.media import MediaResource, AsyncMediaResource
     from .resources.tasks import TasksResource, AsyncTasksResource
     from .resources.batches import BatchesResource, AsyncBatchesResource
+    from .resources.fast_serp import FastSerpResource, AsyncFastSerpResource
     from .resources.jobs.jobs import JobsResource, AsyncJobsResource
     from .resources.domain_knowledge import DomainKnowledgeResource, AsyncDomainKnowledgeResource
     from .resources.task_agent.task_agent import TaskAgentResource, AsyncTaskAgentResource
@@ -185,6 +186,12 @@ class Nimble(SyncAPIClient):
 
         return SerpResource(self)
 
+    @cached_property
+    def fast_serp(self) -> FastSerpResource:
+        from .resources.fast_serp import FastSerpResource
+
+        return FastSerpResource(self)
+
     @cached_property
     def task_agent(self) -> TaskAgentResource:
         from .resources.task_agent import TaskAgentResource
@@ -3459,6 +3466,12 @@ class AsyncNimble(AsyncAPIClient):
 
         return AsyncSerpResource(self)
 
+    @cached_property
+    def fast_serp(self) -> AsyncFastSerpResource:
+        from .resources.fast_serp import AsyncFastSerpResource
+
+        return AsyncFastSerpResource(self)
+
     @cached_property
     def task_agent(self) -> AsyncTaskAgentResource:
         from .resources.task_agent import AsyncTaskAgentResource
@@ -6687,6 +6700,12 @@ class NimbleWithRawResponse:
 
         return SerpResourceWithRawResponse(self._client.serp)
 
+    @cached_property
+    def fast_serp(self) -> fast_serp.FastSerpResourceWithRawResponse:
+        from .resources.fast_serp import FastSerpResourceWithRawResponse
+
+        return FastSerpResourceWithRawResponse(self._client.fast_serp)
+
     @cached_property
     def task_agent(self) -> task_agent.TaskAgentResourceWithRawResponse:
         from .resources.task_agent import TaskAgentResourceWithRawResponse
@@ -6764,6 +6783,12 @@ class AsyncNimbleWithRawResponse:
 
         return AsyncSerpResourceWithRawResponse(self._client.serp)
 
+    @cached_property
+    def fast_serp(self) -> fast_serp.AsyncFastSerpResourceWithRawResponse:
+        from .resources.fast_serp import AsyncFastSerpResourceWithRawResponse
+
+        return AsyncFastSerpResourceWithRawResponse(self._client.fast_serp)
+
     @cached_property
     def task_agent(self) -> task_agent.AsyncTaskAgentResourceWithRawResponse:
         from .resources.task_agent import AsyncTaskAgentResourceWithRawResponse
@@ -6841,6 +6866,12 @@ class NimbleWithStreamedResponse:
 
         return SerpResourceWithStreamingResponse(self._client.serp)
 
+    @cached_property
+    def fast_serp(self) -> fast_serp.FastSerpResourceWithStreamingResponse:
+        from .resources.fast_serp import FastSerpResourceWithStreamingResponse
+
+        return FastSerpResourceWithStreamingResponse(self._client.fast_serp)
+
     @cached_property
     def task_agent(self) -> task_agent.TaskAgentResourceWithStreamingResponse:
         from .resources.task_agent import TaskAgentResourceWithStreamingResponse
@@ -6918,6 +6949,12 @@ class AsyncNimbleWithStreamedResponse:
 
         return AsyncSerpResourceWithStreamingResponse(self._client.serp)
 
+    @cached_property
+    def fast_serp(self) -> fast_serp.AsyncFastSerpResourceWithStreamingResponse:
+        from .resources.fast_serp import AsyncFastSerpResourceWithStreamingResponse
+
+        return AsyncFastSerpResourceWithStreamingResponse(self._client.fast_serp)
+
     @cached_property
     def task_agent(self) -> task_agent.AsyncTaskAgentResourceWithStreamingResponse:
         from .resources.task_agent import AsyncTaskAgentResourceWithStreamingResponse

nimble_python/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "nimble_python"
-__version__ = "0.20.0"  # x-release-please-version
+__version__ = "0.21.0"  # x-release-please-version

nimble_python/resources/__init__.py

@@ -56,6 +56,14 @@ from .batches import (
     BatchesResourceWithStreamingResponse,
     AsyncBatchesResourceWithStreamingResponse,
 )
+from .fast_serp import (
+    FastSerpResource,
+    AsyncFastSerpResource,
+    FastSerpResourceWithRawResponse,
+    AsyncFastSerpResourceWithRawResponse,
+    FastSerpResourceWithStreamingResponse,
+    AsyncFastSerpResourceWithStreamingResponse,
+)
 from .task_agent import (
     TaskAgentResource,
     AsyncTaskAgentResource,
@@ -116,6 +124,12 @@ __all__ = [
     "AsyncSerpResourceWithRawResponse",
     "SerpResourceWithStreamingResponse",
     "AsyncSerpResourceWithStreamingResponse",
+    "FastSerpResource",
+    "AsyncFastSerpResource",
+    "FastSerpResourceWithRawResponse",
+    "AsyncFastSerpResourceWithRawResponse",
+    "FastSerpResourceWithStreamingResponse",
+    "AsyncFastSerpResourceWithStreamingResponse",
     "TaskAgentResource",
     "AsyncTaskAgentResource",
     "TaskAgentResourceWithRawResponse",

nimble_python/resources/fast_serp.py

@@ -0,0 +1,293 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal
+
+import httpx
+
+from ..types import fast_serp_run_params
+from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from .._utils import maybe_transform, async_maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from .._base_client import make_request_options
+from ..types.fast_serp_run_response import FastSerpRunResponse
+
+__all__ = ["FastSerpResource", "AsyncFastSerpResource"]
+
+
+class FastSerpResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> FastSerpResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/Nimbleway/nimble-python#accessing-raw-response-data-eg-headers
+        """
+        return FastSerpResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> FastSerpResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Nimbleway/nimble-python#with_streaming_response
+        """
+        return FastSerpResourceWithStreamingResponse(self)
+
+    def run(
+        self,
+        *,
+        search_engine: Literal[
+            "google_search",
+            "google_sge",
+            "google_aio",
+            "google_maps_search",
+            "google_maps_reviews",
+            "google_maps_place",
+            "google_news",
+            "google_images",
+            "bing_search",
+            "yandex_search",
+        ],
+        country: str | Omit = omit,
+        device: Literal["desktop", "mobile"] | Omit = omit,
+        domain: str | Omit = omit,
+        locale: str | Omit = omit,
+        location: str | Omit = omit,
+        num_results: int | Omit = omit,
+        page: int | Omit = omit,
+        parse: bool | Omit = omit,
+        query: str | Omit = omit,
+        render: bool | Omit = omit,
+        show_hidden_results: bool | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FastSerpRunResponse:
+        """
+        Fast SERP
+
+        Args:
+          search_engine: The search engine to query.
+
+          country: ISO Alpha-2 country code used to access the target search engine (e.g. US, DE,
+              GB).
+
+          device: Device type used for the search request.
+
+          domain: Top-level domain for the search engine (e.g. "com", "co.uk", "de").
+
+          locale: Locale used for the search request.
+
+          location: Geo-location for the search (canonical Google location name).
+
+          num_results: Number of results to return (1–100).
+
+          page: The result page number for pagination.
+
+          parse: When true, the SERP response is parsed into structured JSON.
+
+          query: The search keyword or phrase to query.
+
+          render: Whether to render the page in a browser before extracting.
+
+          show_hidden_results: When true, disables Google result filtering (filter=0) so omitted/duplicate and
+              highly similar pages are also returned. Applies to Google search engines.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/v1/fast-serp",
+            body=maybe_transform(
+                {
+                    "search_engine": search_engine,
+                    "country": country,
+                    "device": device,
+                    "domain": domain,
+                    "locale": locale,
+                    "location": location,
+                    "num_results": num_results,
+                    "page": page,
+                    "parse": parse,
+                    "query": query,
+                    "render": render,
+                    "show_hidden_results": show_hidden_results,
+                },
+                fast_serp_run_params.FastSerpRunParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FastSerpRunResponse,
+        )
+
+
+class AsyncFastSerpResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncFastSerpResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/Nimbleway/nimble-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncFastSerpResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncFastSerpResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Nimbleway/nimble-python#with_streaming_response
+        """
+        return AsyncFastSerpResourceWithStreamingResponse(self)
+
+    async def run(
+        self,
+        *,
+        search_engine: Literal[
+            "google_search",
+            "google_sge",
+            "google_aio",
+            "google_maps_search",
+            "google_maps_reviews",
+            "google_maps_place",
+            "google_news",
+            "google_images",
+            "bing_search",
+            "yandex_search",
+        ],
+        country: str | Omit = omit,
+        device: Literal["desktop", "mobile"] | Omit = omit,
+        domain: str | Omit = omit,
+        locale: str | Omit = omit,
+        location: str | Omit = omit,
+        num_results: int | Omit = omit,
+        page: int | Omit = omit,
+        parse: bool | Omit = omit,
+        query: str | Omit = omit,
+        render: bool | Omit = omit,
+        show_hidden_results: bool | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FastSerpRunResponse:
+        """
+        Fast SERP
+
+        Args:
+          search_engine: The search engine to query.
+
+          country: ISO Alpha-2 country code used to access the target search engine (e.g. US, DE,
+              GB).
+
+          device: Device type used for the search request.
+
+          domain: Top-level domain for the search engine (e.g. "com", "co.uk", "de").
+
+          locale: Locale used for the search request.
+
+          location: Geo-location for the search (canonical Google location name).
+
+          num_results: Number of results to return (1–100).
+
+          page: The result page number for pagination.
+
+          parse: When true, the SERP response is parsed into structured JSON.
+
+          query: The search keyword or phrase to query.
+
+          render: Whether to render the page in a browser before extracting.
+
+          show_hidden_results: When true, disables Google result filtering (filter=0) so omitted/duplicate and
+              highly similar pages are also returned. Applies to Google search engines.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/v1/fast-serp",
+            body=await async_maybe_transform(
+                {
+                    "search_engine": search_engine,
+                    "country": country,
+                    "device": device,
+                    "domain": domain,
+                    "locale": locale,
+                    "location": location,
+                    "num_results": num_results,
+                    "page": page,
+                    "parse": parse,
+                    "query": query,
+                    "render": render,
+                    "show_hidden_results": show_hidden_results,
+                },
+                fast_serp_run_params.FastSerpRunParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FastSerpRunResponse,
+        )
+
+
+class FastSerpResourceWithRawResponse:
+    def __init__(self, fast_serp: FastSerpResource) -> None:
+        self._fast_serp = fast_serp
+
+        self.run = to_raw_response_wrapper(
+            fast_serp.run,
+        )
+
+
+class AsyncFastSerpResourceWithRawResponse:
+    def __init__(self, fast_serp: AsyncFastSerpResource) -> None:
+        self._fast_serp = fast_serp
+
+        self.run = async_to_raw_response_wrapper(
+            fast_serp.run,
+        )
+
+
+class FastSerpResourceWithStreamingResponse:
+    def __init__(self, fast_serp: FastSerpResource) -> None:
+        self._fast_serp = fast_serp
+
+        self.run = to_streamed_response_wrapper(
+            fast_serp.run,
+        )
+
+
+class AsyncFastSerpResourceWithStreamingResponse:
+    def __init__(self, fast_serp: AsyncFastSerpResource) -> None:
+        self._fast_serp = fast_serp
+
+        self.run = async_to_streamed_response_wrapper(
+            fast_serp.run,
+        )

nimble_python/types/__init__.py

@@ -47,6 +47,7 @@ from .crawl_list_response import CrawlListResponse as CrawlListResponse
 from .job_create_response import JobCreateResponse as JobCreateResponse
 from .job_update_response import JobUpdateResponse as JobUpdateResponse
 from .client_search_params import ClientSearchParams as ClientSearchParams
+from .fast_serp_run_params import FastSerpRunParams as FastSerpRunParams
 from .agent_generate_params import AgentGenerateParams as AgentGenerateParams
 from .client_extract_params import ClientExtractParams as ClientExtractParams
 from .crawl_status_response import CrawlStatusResponse as CrawlStatusResponse
@@ -58,6 +59,7 @@ from .agent_run_async_params import AgentRunAsyncParams as AgentRunAsyncParams
 from .agent_run_batch_params import AgentRunBatchParams as AgentRunBatchParams
 from .extract_async_response import ExtractAsyncResponse as ExtractAsyncResponse
 from .extract_batch_response import ExtractBatchResponse as ExtractBatchResponse
+from .fast_serp_run_response import FastSerpRunResponse as FastSerpRunResponse
 from .media_run_async_params import MediaRunAsyncParams as MediaRunAsyncParams
 from .task_agent_list_params import TaskAgentListParams as TaskAgentListParams
 from .agent_generate_response import AgentGenerateResponse as AgentGenerateResponse

nimble_python/types/fast_serp_run_params.py

@@ -0,0 +1,64 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["FastSerpRunParams"]
+
+
+class FastSerpRunParams(TypedDict, total=False):
+    search_engine: Required[
+        Literal[
+            "google_search",
+            "google_sge",
+            "google_aio",
+            "google_maps_search",
+            "google_maps_reviews",
+            "google_maps_place",
+            "google_news",
+            "google_images",
+            "bing_search",
+            "yandex_search",
+        ]
+    ]
+    """The search engine to query."""
+
+    country: str
+    """ISO Alpha-2 country code used to access the target search engine (e.g.
+
+    US, DE, GB).
+    """
+
+    device: Literal["desktop", "mobile"]
+    """Device type used for the search request."""
+
+    domain: str
+    """Top-level domain for the search engine (e.g. "com", "co.uk", "de")."""
+
+    locale: str
+    """Locale used for the search request."""
+
+    location: str
+    """Geo-location for the search (canonical Google location name)."""
+
+    num_results: int
+    """Number of results to return (1–100)."""
+
+    page: int
+    """The result page number for pagination."""
+
+    parse: bool
+    """When true, the SERP response is parsed into structured JSON."""
+
+    query: str
+    """The search keyword or phrase to query."""
+
+    render: bool
+    """Whether to render the page in a browser before extracting."""
+
+    show_hidden_results: bool
+    """
+    When true, disables Google result filtering (filter=0) so omitted/duplicate and
+    highly similar pages are also returned. Applies to Google search engines.
+    """

nimble_python/types/fast_serp_run_response.py

@@ -0,0 +1,339 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = [
+    "FastSerpRunResponse",
+    "Data",
+    "DataBrowserActions",
+    "DataBrowserActionsResult",
+    "DataNetworkCapture",
+    "DataNetworkCaptureFilter",
+    "DataNetworkCaptureFilterURL",
+    "DataNetworkCaptureResult",
+    "DataNetworkCaptureResultRequest",
+    "DataNetworkCaptureResultResponse",
+    "DataParsing",
+    "DataParsingParsingSuccessResult",
+    "DataParsingParsingErrorResult",
+    "DataRedirect",
+    "Metadata",
+    "Debug",
+    "Pagination",
+    "PaginationNextPageParams",
+    "PaginationUnionMember1",
+]
+
+
+class DataBrowserActionsResult(BaseModel):
+    duration: float
+
+    name: Literal[
+        "goto",
+        "wait",
+        "wait_for_element",
+        "wait_for_navigation",
+        "click",
+        "fill",
+        "press",
+        "scroll",
+        "auto_scroll",
+        "screenshot",
+        "get_cookies",
+        "eval",
+        "fetch",
+    ]
+
+    status: Literal["no-run", "in-progress", "done", "error", "skipped"]
+
+    error: Optional[str] = None
+
+    result: Optional[object] = None
+
+
+class DataBrowserActions(BaseModel):
+    """Browser actions execution results.
+
+    Present only when browser_actions were specified in the request.
+    """
+
+    results: List[DataBrowserActionsResult]
+
+    success: bool
+
+    total_duration: float
+
+
+class DataNetworkCaptureFilterURL(BaseModel):
+    type: Literal["exact", "contains"]
+
+    value: str
+
+
+class DataNetworkCaptureFilter(BaseModel):
+    validation: bool
+
+    wait_for_requests_count: float
+
+    method: Optional[Literal["GET", "HEAD", "POST", "PUT", "DELETE", "CONNECT", "OPTIONS", "TRACE", "PATCH"]] = None
+
+    resource_type: Union[
+        Literal[
+            "document",
+            "stylesheet",
+            "image",
+            "media",
+            "font",
+            "script",
+            "texttrack",
+            "xhr",
+            "fetch",
+            "prefetch",
+            "eventsource",
+            "websocket",
+            "manifest",
+            "signedexchange",
+            "ping",
+            "cspviolationreport",
+            "preflight",
+            "other",
+            "fedcm",
+        ],
+        List[
+            Literal[
+                "document",
+                "stylesheet",
+                "image",
+                "media",
+                "font",
+                "script",
+                "texttrack",
+                "xhr",
+                "fetch",
+                "prefetch",
+                "eventsource",
+                "websocket",
+                "manifest",
+                "signedexchange",
+                "ping",
+                "cspviolationreport",
+                "preflight",
+                "other",
+                "fedcm",
+            ]
+        ],
+        None,
+    ] = None
+    """Resource type for network capture filtering"""
+
+    status_code: Union[float, List[float], None] = None
+
+    url: Optional[DataNetworkCaptureFilterURL] = None
+
+    wait_for_requests_count_timeout: Optional[float] = None
+
+
+class DataNetworkCaptureResultRequest(BaseModel):
+    headers: Dict[str, str]
+
+    method: str
+
+    resource_type: Literal[
+        "document",
+        "stylesheet",
+        "image",
+        "media",
+        "font",
+        "script",
+        "texttrack",
+        "xhr",
+        "fetch",
+        "prefetch",
+        "eventsource",
+        "websocket",
+        "manifest",
+        "signedexchange",
+        "ping",
+        "cspviolationreport",
+        "preflight",
+        "other",
+        "fedcm",
+    ]
+    """Resource type for network capture filtering"""
+
+    url: str
+
+    body: Optional[str] = None
+
+
+class DataNetworkCaptureResultResponse(BaseModel):
+    body: str
+
+    headers: Dict[str, str]
+
+    serialization: Literal["none", "base64"]
+
+    status: float
+
+    status_text: str
+
+
+class DataNetworkCaptureResult(BaseModel):
+    request: DataNetworkCaptureResultRequest
+
+    response: DataNetworkCaptureResultResponse
+
+
+class DataNetworkCapture(BaseModel):
+    filter: DataNetworkCaptureFilter
+
+    results: List[DataNetworkCaptureResult]
+
+    error_message: Optional[str] = FieldInfo(alias="errorMessage", default=None)
+
+
+class DataParsingParsingSuccessResult(BaseModel):
+    entities: Dict[str, object]
+
+    status: Literal["success"]
+
+
+class DataParsingParsingErrorResult(BaseModel):
+    error: str
+
+    status: Literal["error"]
+
+
+DataParsing: TypeAlias = Union[DataParsingParsingSuccessResult, DataParsingParsingErrorResult, Dict[str, object]]
+
+
+class DataRedirect(BaseModel):
+    status_code: float
+
+    url: str
+
+
+class Data(BaseModel):
+    browser_actions: Optional[DataBrowserActions] = None
+    """Browser actions execution results.
+
+    Present only when browser_actions were specified in the request.
+    """
+
+    cookies: Optional[List[object]] = None
+    """The cookies collected from browser actions during the task."""
+
+    eval: Optional[List[object]] = None
+    """The evaluation results from browser actions during the task."""
+
+    fetch: Optional[List[object]] = None
+    """The http requests from browser actions made during the task."""
+
+    headers: Optional[Dict[str, str]] = None
+    """The headers received during the task."""
+
+    html: Optional[str] = None
+    """The HTML content of the page."""
+
+    links: Optional[List[str]] = None
+    """List of all unique URLs found on the page."""
+
+    markdown: Optional[str] = None
+    """The Markdown version of the HTML content."""
+
+    network_capture: Optional[List[DataNetworkCapture]] = None
+    """The network capture data collected during the task."""
+
+    pages_html: Optional[List[str]] = None
+    """Individual HTML content of each pagination page, before merging."""
+
+    parsing: Optional[DataParsing] = None
+    """The parsing results extracted from the HTML & network content."""
+
+    redirects: Optional[List[DataRedirect]] = None
+    """The list of redirects that occurred during the task."""
+
+    screenshots: Optional[List[object]] = None
+    """
+    Screenshots taken during the task, from browser actions, or the screenshot
+    format.
+    """
+
+
+class Metadata(BaseModel):
+    agent: Optional[str] = None
+    """The name of the agent used for the query."""
+
+    driver: Optional[str] = None
+    """The driver used for the task."""
+
+    localization_id: Optional[str] = None
+    """The localization identifier for the query."""
+
+    query_duration: Optional[float] = None
+    """The duration in milliseconds of the query processing."""
+
+    query_time: Optional[str] = None
+    """The time when the query was received."""
+
+    response_parameters: Optional[object] = None
+    """Additional response parameters."""
+
+    tag: Optional[str] = None
+    """A tag associated with the query."""
+
+
+class Debug(BaseModel):
+    performance_metrics: Optional[Dict[str, float]] = None
+    """Performance metrics collected during the task."""
+
+    proxy_total_bytes_usage: Optional[float] = None
+    """Total bytes used by the proxy during the task."""
+
+    transformed_output: Optional[object] = None
+    """The transformed output after applying any transformations."""
+
+    userbrowser: Optional[object] = None
+    """The userbrowser instance using during the task."""
+
+
+class PaginationNextPageParams(BaseModel):
+    next_page_params: Dict[str, object]
+
+
+class PaginationUnionMember1(BaseModel):
+    next_page_params: Dict[str, object]
+
+
+Pagination: TypeAlias = Union[PaginationNextPageParams, List[PaginationUnionMember1]]
+
+
+class FastSerpRunResponse(BaseModel):
+    data: Data
+
+    metadata: Metadata
+
+    status: Literal["success", "skipped", "fatal", "error", "postponed", "ignored", "rejected", "blocked"]
+    """The status of the task."""
+
+    task_id: str
+    """Unique identifier for the task."""
+
+    url: str
+    """The final URL."""
+
+    debug: Optional[Debug] = None
+
+    pagination: Optional[Pagination] = None
+    """Pagination information if applicable."""
+
+    status_code: Optional[float] = None
+    """The HTTP status code of the task."""
+
+    warnings: Optional[List[str]] = None
+    """List of warnings generated during the task."""

{nimble_python-0.20.0.dist-info → nimble_python-0.21.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nimble_python
-Version: 0.20.0
+Version: 0.21.0
 Summary: The official Python library for the nimble API
 Project-URL: Homepage, https://github.com/Nimbleway/nimble-python
 Project-URL: Repository, https://github.com/Nimbleway/nimble-python

{nimble_python-0.20.0.dist-info → nimble_python-0.21.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 nimble_python/__init__.py,sha256=QWpm5I50gjoMEPPXsRiT0i3aqvsJby6NegnPHYrhCfs,2645
 nimble_python/_base_client.py,sha256=GVMopeALSRNw5GTAmUQfFvON3_tSKYw-MjKo8lDRfos,73932
-nimble_python/_client.py,sha256=d-qY78zc2eX7emWgSvXyo4Fo5yRWWqZgmc00ubn3gH0,174580
+nimble_python/_client.py,sha256=qCMYrp3dd1qAGxAi18F_8o6to3sTDzbBU7YEjOauaA8,176025
 nimble_python/_compat.py,sha256=_9guQfzYnL3DNtudX5W7T2cdSskx89B5AFfhPQDxMUk,6811
 nimble_python/_constants.py,sha256=giUwuSKDnpjRLaHvgzErnXB3CSYjKMaI5xnBQJI-23s,464
 nimble_python/_exceptions.py,sha256=x1M0s_wI9jkJ5ARR07APUuDZfxl7BjQ53snlFU-jAoQ,3220
@@ -11,7 +11,7 @@ nimble_python/_resource.py,sha256=TDtzjUMbNHRGQNq-4HJqce3T3THBD5Q7ESrONYPvKdI,11
 nimble_python/_response.py,sha256=hrLOCn3D0gCapH31eR9BVOgBpTYliUTVUsdeWc1J76A,28983
 nimble_python/_streaming.py,sha256=StqGzUAIG9gQNCkRQnEAbN3IyiX4hDdCp2QR7_DANw8,10550
 nimble_python/_types.py,sha256=rYClHO7LPhg_rRUmxWuC34Tf2mVPfmCZBIANhQ2fC3o,7709
-nimble_python/_version.py,sha256=AjKYAokwwPRnCZsme2iuN_DURFAosFDdE8VzvLzvgKk,166
+nimble_python/_version.py,sha256=jl823KJq9Giw46Ew2crhmdc3TDEf974aGq6FBHUgZAM,166
 nimble_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nimble_python/_utils/__init__.py,sha256=nQq-iFa5YxTaWySaLigatew5rHgTR0M75FNYm4mrO1s,2313
 nimble_python/_utils/_compat.py,sha256=33246eDcl3pwL6kWsEhVuT4Akrd8gZEW9LPTm465ohk,1231
@@ -28,11 +28,12 @@ nimble_python/_utils/_transform.py,sha256=NjCzmnfqYrsAikUHQig6N9QfuTVbKipuP3ur9m
 nimble_python/_utils/_typing.py,sha256=N_5PPuFNsaygbtA_npZd98SVN1LQQvFTKL6bkWPBZGU,4786
 nimble_python/_utils/_utils.py,sha256=2nPOzDrPe2GADpLCRM4bNQS8Mu7LjEiCG_LJ2AAL6jg,13111
 nimble_python/lib/.keep,sha256=wuNrz-5SXo3jJaJOJgz4vFHM41YH_g20F5cRQo0vLes,224
-nimble_python/resources/__init__.py,sha256=KNqIDLUtFlrEUotM1BhBPVzcgtnjzqxGZ_Nys9xhThc,4219
+nimble_python/resources/__init__.py,sha256=fEdOPLxbknKr1fG3dPZCaz4BaepPQXiILm1ZsjLcitc,4696
 nimble_python/resources/agent.py,sha256=gbg6brKI85KN_YXWBLyRvKPc4dORDGxpuB6M0Zkqd-E,34849
 nimble_python/resources/batches.py,sha256=LxPXo7mpDcXmtJAv7prVnDpJHkhHypix6ZNSxh9kpQU,11688
 nimble_python/resources/crawl.py,sha256=GOMDGANIPAfay-J3ujW9ghlK-h-aIy99ChIKRN-pZK8,20651
 nimble_python/resources/domain_knowledge.py,sha256=9mY_-oYkZqBxavLJmWzwSh_7vvTloppOqQL9KMKHd1I,7378
+nimble_python/resources/fast_serp.py,sha256=3hmuwIUbLju6BMNQR7CJQUA0lB2n2J4NIbSZTw2zQnM,10510
 nimble_python/resources/media.py,sha256=CK0czHssE1GpQYUlCOv4WxsdmYT4DStmcg7ygY4REeA,12363
 nimble_python/resources/serp.py,sha256=xkUv64bmkE59yK_SjYZFPrJBb0YcD1Zg1_VbRBOwFyQ,23472
 nimble_python/resources/tasks.py,sha256=8rV6YZNpx8rq_83L8UZvt7HlPlRhY8SGrbVQAFDjBtM,13021
@@ -45,7 +46,7 @@ nimble_python/resources/task_agent/__init__.py,sha256=Vn8OE0ZRaNggpFEbPoDnIKo5tr
 nimble_python/resources/task_agent/runs.py,sha256=_of_Ydc_Kenuab2A403Cx875h9jAVqgVl5WEizqBMjE,21425
 nimble_python/resources/task_agent/task_agent.py,sha256=JHwrJcxypOEsIouhVmA-HvRAZqWKVbJZG2sWLmGOEjQ,29987
 nimble_python/resources/task_agent/templates.py,sha256=WCVDL7cHs9wuvgiQImhoplyEw4eq2LGWz4T-WeKxWQw,10170
-nimble_python/types/__init__.py,sha256=SPJqbV50JMTQynGhAFFycL6n1nTKDCKpqKvhiJRcQm8,5425
+nimble_python/types/__init__.py,sha256=bQVFqX-OAp6wcQkPwnsjLdYOyaUxV_kcc4ptxs2ml7o,5577
 nimble_python/types/agent_generate_params.py,sha256=IBnmlBaruvVugX6e3wVtu8tEnfh5ZqXPLgnqTnI4LKs,1085
 nimble_python/types/agent_generate_response.py,sha256=4yQ4mhR6MiQMiIWCdzIUCB4zFZJXQspBrQvbka3sOw4,1480
 nimble_python/types/agent_get_generation_response.py,sha256=299Pc6c0IJMdjZ2loKw9y-MqfuGzS6MddMcIAx9cd_8,1490
@@ -76,6 +77,8 @@ nimble_python/types/domain_knowledge_get_driver_response.py,sha256=LbQLAXrwO2KHo
 nimble_python/types/extract_async_response.py,sha256=B8COYO0Aou7_1eAs1Hk42QHdgm4Nqq5BemiQqVnv4N0,1799
 nimble_python/types/extract_batch_response.py,sha256=f48Dq32SnwnN2jBZxyCTBTiXLB7Fl0jgFVW2U051mVk,1787
 nimble_python/types/extract_response.py,sha256=67CkH4vOsZTUvGOWEMLANPBK_d2hgDcqlmEB_B3LhMk,8245
+nimble_python/types/fast_serp_run_params.py,sha256=iN_ndjEkUnld4TOggVSrnc9UR7jtCvohenD6zXE7Tq0,1709
+nimble_python/types/fast_serp_run_response.py,sha256=QaScD_aRW4txdYVATauXICPD7T4QxcsIWclIs2XV2zM,8253
 nimble_python/types/job_create_params.py,sha256=Ep5MGCGt5-whjBmYK5kVzy7Hu1SPcZlqTjEKfq6cVB8,993
 nimble_python/types/job_create_response.py,sha256=9BkYs0M_93BF9cxDKhs1-el-ol8WtLtsRmRd3lWR4Bc,1240
 nimble_python/types/job_get_response.py,sha256=E8YjA3EszHztJ7CzHKR1JkVbxhnUjvKBcX3AoJYpDMA,1234
@@ -155,7 +158,7 @@ nimble_python/types/task_agent/run_list_response.py,sha256=ukjowSnTanzUOzOfoXBEd
 nimble_python/types/task_agent/template_get_response.py,sha256=CNsbA1uNMYTfkEELIq5WPoAFAqvxfGFwGHf4IXPLCaw,1007
 nimble_python/types/task_agent/template_list_params.py,sha256=9zRXI2fd24e7aPqz4tnH5dscMxqhdDogWW-qHe8AVaA,365
 nimble_python/types/task_agent/template_list_response.py,sha256=LtH39vwXZU6hXWISP31mTyU0xMgBLN3QaECYBTdIKOE,1358
-nimble_python-0.20.0.dist-info/METADATA,sha256=wBTEnrD7UXKAt5fwZBJH5ECrrn4vfdmzKbLEFRm7Y7c,15816
-nimble_python-0.20.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-nimble_python-0.20.0.dist-info/licenses/LICENSE,sha256=khtIpaYdgNbXXcmzsxlSL_iKmh160uTREZTiMQKCB24,11336
-nimble_python-0.20.0.dist-info/RECORD,,
+nimble_python-0.21.0.dist-info/METADATA,sha256=GT7tOj-2Q4Sp8_MaFRu1EP0S0qpziZviucTq-AxZ_SQ,15816
+nimble_python-0.21.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+nimble_python-0.21.0.dist-info/licenses/LICENSE,sha256=khtIpaYdgNbXXcmzsxlSL_iKmh160uTREZTiMQKCB24,11336
+nimble_python-0.21.0.dist-info/RECORD,,