nimble_python 0.12.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

nimble_python/_client.py

@@ -60,10 +60,11 @@ from .types.extract_async_response import ExtractAsyncResponse
 from .types.extract_batch_response import ExtractBatchResponse
 
 if TYPE_CHECKING:
-    from .resources import agent, crawl, tasks
+    from .resources import agent, crawl, tasks, batches
     from .resources.agent import AgentResource, AsyncAgentResource
     from .resources.crawl import CrawlResource, AsyncCrawlResource
     from .resources.tasks import TasksResource, AsyncTasksResource
+    from .resources.batches import BatchesResource, AsyncBatchesResource
 
 __all__ = ["Timeout", "Transport", "ProxiesTypes", "RequestOptions", "Nimble", "AsyncNimble", "Client", "AsyncClient"]
 
@@ -137,6 +138,12 @@ class Nimble(SyncAPIClient):
 
         return TasksResource(self)
 
+    @cached_property
+    def batches(self) -> BatchesResource:
+        from .resources.batches import BatchesResource
+
+        return BatchesResource(self)
+
     @cached_property
     def with_raw_response(self) -> NimbleWithRawResponse:
         return NimbleWithRawResponse(self)
@@ -3331,6 +3338,12 @@ class AsyncNimble(AsyncAPIClient):
 
         return AsyncTasksResource(self)
 
+    @cached_property
+    def batches(self) -> AsyncBatchesResource:
+        from .resources.batches import AsyncBatchesResource
+
+        return AsyncBatchesResource(self)
+
     @cached_property
     def with_raw_response(self) -> AsyncNimbleWithRawResponse:
         return AsyncNimbleWithRawResponse(self)
@@ -6496,6 +6509,12 @@ class NimbleWithRawResponse:
 
         return TasksResourceWithRawResponse(self._client.tasks)
 
+    @cached_property
+    def batches(self) -> batches.BatchesResourceWithRawResponse:
+        from .resources.batches import BatchesResourceWithRawResponse
+
+        return BatchesResourceWithRawResponse(self._client.batches)
+
 
 class AsyncNimbleWithRawResponse:
     _client: AsyncNimble
@@ -6537,6 +6556,12 @@ class AsyncNimbleWithRawResponse:
 
         return AsyncTasksResourceWithRawResponse(self._client.tasks)
 
+    @cached_property
+    def batches(self) -> batches.AsyncBatchesResourceWithRawResponse:
+        from .resources.batches import AsyncBatchesResourceWithRawResponse
+
+        return AsyncBatchesResourceWithRawResponse(self._client.batches)
+
 
 class NimbleWithStreamedResponse:
     _client: Nimble
@@ -6578,6 +6603,12 @@ class NimbleWithStreamedResponse:
 
         return TasksResourceWithStreamingResponse(self._client.tasks)
 
+    @cached_property
+    def batches(self) -> batches.BatchesResourceWithStreamingResponse:
+        from .resources.batches import BatchesResourceWithStreamingResponse
+
+        return BatchesResourceWithStreamingResponse(self._client.batches)
+
 
 class AsyncNimbleWithStreamedResponse:
     _client: AsyncNimble
@@ -6619,6 +6650,12 @@ class AsyncNimbleWithStreamedResponse:
 
         return AsyncTasksResourceWithStreamingResponse(self._client.tasks)
 
+    @cached_property
+    def batches(self) -> batches.AsyncBatchesResourceWithStreamingResponse:
+        from .resources.batches import AsyncBatchesResourceWithStreamingResponse
+
+        return AsyncBatchesResourceWithStreamingResponse(self._client.batches)
+
 
 Client = Nimble
 

nimble_python/_utils/__init__.py

@@ -1,3 +1,4 @@
+from ._path import path_template as path_template
 from ._sync import asyncify as asyncify
 from ._proxy import LazyProxy as LazyProxy
 from ._utils import (

nimble_python/_utils/_path.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import re
+from typing import (
+    Any,
+    Mapping,
+    Callable,
+)
+from urllib.parse import quote
+
+# Matches '.' or '..' where each dot is either literal or percent-encoded (%2e / %2E).
+_DOT_SEGMENT_RE = re.compile(r"^(?:\.|%2[eE]){1,2}$")
+
+_PLACEHOLDER_RE = re.compile(r"\{(\w+)\}")
+
+
+def _quote_path_segment_part(value: str) -> str:
+    """Percent-encode `value` for use in a URI path segment.
+
+    Considers characters not in `pchar` set from RFC 3986 §3.3 to be unsafe.
+    https://datatracker.ietf.org/doc/html/rfc3986#section-3.3
+    """
+    # quote() already treats unreserved characters (letters, digits, and -._~)
+    # as safe, so we only need to add sub-delims, ':', and '@'.
+    # Notably, unlike the default `safe` for quote(), / is unsafe and must be quoted.
+    return quote(value, safe="!$&'()*+,;=:@")
+
+
+def _quote_query_part(value: str) -> str:
+    """Percent-encode `value` for use in a URI query string.
+
+    Considers &, = and characters not in `query` set from RFC 3986 §3.4 to be unsafe.
+    https://datatracker.ietf.org/doc/html/rfc3986#section-3.4
+    """
+    return quote(value, safe="!$'()*+,;:@/?")
+
+
+def _quote_fragment_part(value: str) -> str:
+    """Percent-encode `value` for use in a URI fragment.
+
+    Considers characters not in `fragment` set from RFC 3986 §3.5 to be unsafe.
+    https://datatracker.ietf.org/doc/html/rfc3986#section-3.5
+    """
+    return quote(value, safe="!$&'()*+,;=:@/?")
+
+
+def _interpolate(
+    template: str,
+    values: Mapping[str, Any],
+    quoter: Callable[[str], str],
+) -> str:
+    """Replace {name} placeholders in `template`, quoting each value with `quoter`.
+
+    Placeholder names are looked up in `values`.
+
+    Raises:
+        KeyError: If a placeholder is not found in `values`.
+    """
+    # re.split with a capturing group returns alternating
+    # [text, name, text, name, ..., text] elements.
+    parts = _PLACEHOLDER_RE.split(template)
+
+    for i in range(1, len(parts), 2):
+        name = parts[i]
+        if name not in values:
+            raise KeyError(f"a value for placeholder {{{name}}} was not provided")
+        val = values[name]
+        if val is None:
+            parts[i] = "null"
+        elif isinstance(val, bool):
+            parts[i] = "true" if val else "false"
+        else:
+            parts[i] = quoter(str(values[name]))
+
+    return "".join(parts)
+
+
+def path_template(template: str, /, **kwargs: Any) -> str:
+    """Interpolate {name} placeholders in `template` from keyword arguments.
+
+    Args:
+        template: The template string containing {name} placeholders.
+        **kwargs: Keyword arguments to interpolate into the template.
+
+    Returns:
+        The template with placeholders interpolated and percent-encoded.
+
+        Safe characters for percent-encoding are dependent on the URI component.
+        Placeholders in path and fragment portions are percent-encoded where the `segment`
+        and `fragment` sets from RFC 3986 respectively are considered safe.
+        Placeholders in the query portion are percent-encoded where the `query` set from
+        RFC 3986 §3.3 is considered safe except for = and & characters.
+
+    Raises:
+        KeyError: If a placeholder is not found in `kwargs`.
+        ValueError: If resulting path contains /./ or /../ segments (including percent-encoded dot-segments).
+    """
+    # Split the template into path, query, and fragment portions.
+    fragment_template: str | None = None
+    query_template: str | None = None
+
+    rest = template
+    if "#" in rest:
+        rest, fragment_template = rest.split("#", 1)
+    if "?" in rest:
+        rest, query_template = rest.split("?", 1)
+    path_template = rest
+
+    # Interpolate each portion with the appropriate quoting rules.
+    path_result = _interpolate(path_template, kwargs, _quote_path_segment_part)
+
+    # Reject dot-segments (. and ..) in the final assembled path.  The check
+    # runs after interpolation so that adjacent placeholders or a mix of static
+    # text and placeholders that together form a dot-segment are caught.
+    # Also reject percent-encoded dot-segments to protect against incorrectly
+    # implemented normalization in servers/proxies.
+    for segment in path_result.split("/"):
+        if _DOT_SEGMENT_RE.match(segment):
+            raise ValueError(f"Constructed path {path_result!r} contains dot-segment {segment!r} which is not allowed")
+
+    result = path_result
+    if query_template is not None:
+        result += "?" + _interpolate(query_template, kwargs, _quote_query_part)
+    if fragment_template is not None:
+        result += "#" + _interpolate(fragment_template, kwargs, _quote_fragment_part)
+
+    return result

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.12.0"  # x-release-please-version
+__version__ = "0.13.0"  # x-release-please-version

nimble_python/resources/__init__.py

@@ -24,6 +24,14 @@ from .tasks import (
     TasksResourceWithStreamingResponse,
     AsyncTasksResourceWithStreamingResponse,
 )
+from .batches import (
+    BatchesResource,
+    AsyncBatchesResource,
+    BatchesResourceWithRawResponse,
+    AsyncBatchesResourceWithRawResponse,
+    BatchesResourceWithStreamingResponse,
+    AsyncBatchesResourceWithStreamingResponse,
+)
 
 __all__ = [
     "AgentResource",
@@ -44,4 +52,10 @@ __all__ = [
     "AsyncTasksResourceWithRawResponse",
     "TasksResourceWithStreamingResponse",
     "AsyncTasksResourceWithStreamingResponse",
+    "BatchesResource",
+    "AsyncBatchesResource",
+    "BatchesResourceWithRawResponse",
+    "AsyncBatchesResourceWithRawResponse",
+    "BatchesResourceWithStreamingResponse",
+    "AsyncBatchesResourceWithStreamingResponse",
 ]

nimble_python/resources/agent.py

@@ -9,7 +9,7 @@ import httpx
 
 from ..types import agent_run_params, agent_list_params, agent_run_async_params
 from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
-from .._utils import maybe_transform, async_maybe_transform
+from .._utils import path_template, maybe_transform, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import (
@@ -131,7 +131,7 @@ class AgentResource(SyncAPIResource):
         if not template_name:
             raise ValueError(f"Expected a non-empty value for `template_name` but received {template_name!r}")
         return self._get(
-            f"/v1/agents/{template_name}",
+            path_template("/v1/agents/{template_name}", template_name=template_name),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -345,7 +345,7 @@ class AsyncAgentResource(AsyncAPIResource):
         if not template_name:
             raise ValueError(f"Expected a non-empty value for `template_name` but received {template_name!r}")
         return await self._get(
-            f"/v1/agents/{template_name}",
+            path_template("/v1/agents/{template_name}", template_name=template_name),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),

nimble_python/resources/batches.py

@@ -0,0 +1,305 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from .._types import Body, Query, Headers, NoneType, NotGiven, not_given
+from .._utils import path_template
+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.batch_get_response import BatchGetResponse
+from ..types.batch_progress_response import BatchProgressResponse
+
+__all__ = ["BatchesResource", "AsyncBatchesResource"]
+
+
+class BatchesResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> BatchesResourceWithRawResponse:
+        """
+        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 BatchesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> BatchesResourceWithStreamingResponse:
+        """
+        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 BatchesResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        # 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,
+    ) -> None:
+        """Retrieve a paginated list of batches for the authenticated account."""
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._get(
+            "/v1/batches",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    def get(
+        self,
+        batch_id: str,
+        *,
+        # 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,
+    ) -> BatchGetResponse:
+        """
+        Retrieve the details of a batch including all its tasks and completion status.
+
+        Args:
+          batch_id: The unique identifier of the batch.
+
+          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
+        """
+        if not batch_id:
+            raise ValueError(f"Expected a non-empty value for `batch_id` but received {batch_id!r}")
+        return self._get(
+            path_template("/v1/batches/{batch_id}", batch_id=batch_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BatchGetResponse,
+        )
+
+    def progress(
+        self,
+        batch_id: str,
+        *,
+        # 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,
+    ) -> BatchProgressResponse:
+        """
+        Retrieve lightweight progress information for a batch without fetching all task
+        details.
+
+        Args:
+          batch_id: The unique identifier of the batch.
+
+          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
+        """
+        if not batch_id:
+            raise ValueError(f"Expected a non-empty value for `batch_id` but received {batch_id!r}")
+        return self._get(
+            path_template("/v1/batches/{batch_id}/progress", batch_id=batch_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BatchProgressResponse,
+        )
+
+
+class AsyncBatchesResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncBatchesResourceWithRawResponse:
+        """
+        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 AsyncBatchesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncBatchesResourceWithStreamingResponse:
+        """
+        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 AsyncBatchesResourceWithStreamingResponse(self)
+
+    async def list(
+        self,
+        *,
+        # 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,
+    ) -> None:
+        """Retrieve a paginated list of batches for the authenticated account."""
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._get(
+            "/v1/batches",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    async def get(
+        self,
+        batch_id: str,
+        *,
+        # 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,
+    ) -> BatchGetResponse:
+        """
+        Retrieve the details of a batch including all its tasks and completion status.
+
+        Args:
+          batch_id: The unique identifier of the batch.
+
+          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
+        """
+        if not batch_id:
+            raise ValueError(f"Expected a non-empty value for `batch_id` but received {batch_id!r}")
+        return await self._get(
+            path_template("/v1/batches/{batch_id}", batch_id=batch_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BatchGetResponse,
+        )
+
+    async def progress(
+        self,
+        batch_id: str,
+        *,
+        # 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,
+    ) -> BatchProgressResponse:
+        """
+        Retrieve lightweight progress information for a batch without fetching all task
+        details.
+
+        Args:
+          batch_id: The unique identifier of the batch.
+
+          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
+        """
+        if not batch_id:
+            raise ValueError(f"Expected a non-empty value for `batch_id` but received {batch_id!r}")
+        return await self._get(
+            path_template("/v1/batches/{batch_id}/progress", batch_id=batch_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BatchProgressResponse,
+        )
+
+
+class BatchesResourceWithRawResponse:
+    def __init__(self, batches: BatchesResource) -> None:
+        self._batches = batches
+
+        self.list = to_raw_response_wrapper(
+            batches.list,
+        )
+        self.get = to_raw_response_wrapper(
+            batches.get,
+        )
+        self.progress = to_raw_response_wrapper(
+            batches.progress,
+        )
+
+
+class AsyncBatchesResourceWithRawResponse:
+    def __init__(self, batches: AsyncBatchesResource) -> None:
+        self._batches = batches
+
+        self.list = async_to_raw_response_wrapper(
+            batches.list,
+        )
+        self.get = async_to_raw_response_wrapper(
+            batches.get,
+        )
+        self.progress = async_to_raw_response_wrapper(
+            batches.progress,
+        )
+
+
+class BatchesResourceWithStreamingResponse:
+    def __init__(self, batches: BatchesResource) -> None:
+        self._batches = batches
+
+        self.list = to_streamed_response_wrapper(
+            batches.list,
+        )
+        self.get = to_streamed_response_wrapper(
+            batches.get,
+        )
+        self.progress = to_streamed_response_wrapper(
+            batches.progress,
+        )
+
+
+class AsyncBatchesResourceWithStreamingResponse:
+    def __init__(self, batches: AsyncBatchesResource) -> None:
+        self._batches = batches
+
+        self.list = async_to_streamed_response_wrapper(
+            batches.list,
+        )
+        self.get = async_to_streamed_response_wrapper(
+            batches.get,
+        )
+        self.progress = async_to_streamed_response_wrapper(
+            batches.progress,
+        )

nimble_python/resources/crawl.py

@@ -9,7 +9,7 @@ import httpx
 
 from ..types import crawl_run_params, crawl_list_params
 from .._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given
-from .._utils import maybe_transform, async_maybe_transform
+from .._utils import path_template, maybe_transform, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import (
@@ -211,7 +211,7 @@ class CrawlResource(SyncAPIResource):
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._get(
-            f"/v1/crawl/{id}",
+            path_template("/v1/crawl/{id}", id=id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -246,7 +246,7 @@ class CrawlResource(SyncAPIResource):
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._delete(
-            f"/v1/crawl/{id}",
+            path_template("/v1/crawl/{id}", id=id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -438,7 +438,7 @@ class AsyncCrawlResource(AsyncAPIResource):
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return await self._get(
-            f"/v1/crawl/{id}",
+            path_template("/v1/crawl/{id}", id=id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -473,7 +473,7 @@ class AsyncCrawlResource(AsyncAPIResource):
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return await self._delete(
-            f"/v1/crawl/{id}",
+            path_template("/v1/crawl/{id}", id=id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),

nimble_python/resources/tasks.py

@@ -6,7 +6,7 @@ import httpx
 
 from ..types import task_list_params
 from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
-from .._utils import maybe_transform, async_maybe_transform
+from .._utils import path_template, maybe_transform, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import (
@@ -117,7 +117,7 @@ class TasksResource(SyncAPIResource):
         if not task_id:
             raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}")
         return self._get(
-            f"/v1/tasks/{task_id}",
+            path_template("/v1/tasks/{task_id}", task_id=task_id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -152,7 +152,7 @@ class TasksResource(SyncAPIResource):
         if not task_id:
             raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}")
         return self._get(
-            f"/v1/tasks/{task_id}/results",
+            path_template("/v1/tasks/{task_id}/results", task_id=task_id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -254,7 +254,7 @@ class AsyncTasksResource(AsyncAPIResource):
         if not task_id:
             raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}")
         return await self._get(
-            f"/v1/tasks/{task_id}",
+            path_template("/v1/tasks/{task_id}", task_id=task_id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -289,7 +289,7 @@ class AsyncTasksResource(AsyncAPIResource):
         if not task_id:
             raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}")
         return await self._get(
-            f"/v1/tasks/{task_id}/results",
+            path_template("/v1/tasks/{task_id}/results", task_id=task_id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),

nimble_python/types/__init__.py

@@ -29,6 +29,7 @@ from .crawl_list_params import CrawlListParams as CrawlListParams
 from .task_get_response import TaskGetResponse as TaskGetResponse
 from .agent_get_response import AgentGetResponse as AgentGetResponse
 from .agent_run_response import AgentRunResponse as AgentRunResponse
+from .batch_get_response import BatchGetResponse as BatchGetResponse
 from .crawl_run_response import CrawlRunResponse as CrawlRunResponse
 from .task_list_response import TaskListResponse as TaskListResponse
 from .agent_list_response import AgentListResponse as AgentListResponse
@@ -40,6 +41,7 @@ from .task_results_response import TaskResultsResponse as TaskResultsResponse
 from .agent_run_async_params import AgentRunAsyncParams as AgentRunAsyncParams
 from .extract_async_response import ExtractAsyncResponse as ExtractAsyncResponse
 from .extract_batch_response import ExtractBatchResponse as ExtractBatchResponse
+from .batch_progress_response import BatchProgressResponse as BatchProgressResponse
 from .agent_run_async_response import AgentRunAsyncResponse as AgentRunAsyncResponse
 from .crawl_terminate_response import CrawlTerminateResponse as CrawlTerminateResponse
 from .client_extract_async_params import ClientExtractAsyncParams as ClientExtractAsyncParams

nimble_python/types/batch_get_response.py

@@ -0,0 +1,82 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["BatchGetResponse", "Task"]
+
+
+class Task(BaseModel):
+    id: str
+    """Unique task identifier."""
+
+    api_query: object = FieldInfo(alias="_query")
+
+    created_at: str
+    """Timestamp when the task was created."""
+
+    input: object
+    """Original input data for the task."""
+
+    state: Literal["pending", "success", "error"]
+    """Current state of the task."""
+
+    status_url: str
+    """URL for checking the task status."""
+
+    account_name: Optional[str] = None
+    """Account name that owns the task."""
+
+    api_type: Optional[Literal["web", "serp", "ecommerce", "social", "media", "agent", "extract"]] = None
+
+    batch_id: Optional[str] = None
+    """Batch ID if this task is part of a batch."""
+
+    download_url: Optional[str] = None
+    """URL for downloading the task results."""
+
+    error: Optional[str] = None
+    """Error message if the task failed."""
+
+    error_type: Optional[str] = None
+    """Classification of the error type."""
+
+    modified_at: Optional[str] = None
+    """Timestamp when the task was last modified."""
+
+    output_url: Optional[str] = None
+    """Storage location of the output data."""
+
+    status_code: Optional[float] = None
+    """HTTP status code from the task execution."""
+
+
+class BatchGetResponse(BaseModel):
+    """Response containing batch details with all tasks."""
+
+    id: str
+    """Unique identifier for the batch."""
+
+    completed: bool
+    """Whether all tasks in the batch have finished."""
+
+    completed_count: float
+    """Number of tasks that have completed so far."""
+
+    created_at: str
+    """ISO timestamp when the batch was created."""
+
+    progress: float
+    """Completion ratio between 0 and 1."""
+
+    status: Literal["success"]
+
+    tasks: List[Optional[Task]]
+    """List of tasks in the batch."""
+
+    completed_at: Optional[str] = None
+    """ISO timestamp when the batch completed."""

nimble_python/types/batch_progress_response.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["BatchProgressResponse"]
+
+
+class BatchProgressResponse(BaseModel):
+    """Lightweight batch progress without task details."""
+
+    id: str
+    """Unique identifier for the batch."""
+
+    completed: bool
+    """Whether all tasks in the batch have finished."""
+
+    completed_count: float
+    """Number of tasks that have completed so far."""
+
+    progress: float
+    """Completion ratio between 0 and 1."""
+
+    status: Literal["success"]
+
+    completed_at: Optional[str] = None
+    """ISO timestamp when the batch completed."""

{nimble_python-0.12.0.dist-info → nimble_python-0.13.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nimble_python
-Version: 0.12.0
+Version: 0.13.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.12.0.dist-info → nimble_python-0.13.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 nimble_python/__init__.py,sha256=QWpm5I50gjoMEPPXsRiT0i3aqvsJby6NegnPHYrhCfs,2645
 nimble_python/_base_client.py,sha256=IR2D-rcC7Lz8L2c0xH_4dOX50NJEgUK0IzpKAbK11FU,73665
-nimble_python/_client.py,sha256=7IPr-Y-Uh3Fq6i2K4gewRF4C48HBI1JBrWK_nMWU3Lc,161446
+nimble_python/_client.py,sha256=_GMgzEZcpnxPgOW9acL5pBkSUTIQ_TfvGQ9WvniKUsI,162827
 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,13 +11,14 @@ 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=ZhbxWgjPQAqNY4ePn8aUJV26mm5oDBrZqskA1XyjlQ0,7601
-nimble_python/_version.py,sha256=x8_94XEGAlMP0yPgP6rjCT98zGwLvbd88UV75ts5Olg,166
+nimble_python/_version.py,sha256=TcQZZa0vIO5XcLn_ZZyy_q1SpsidGKGndL4HCzqDrM4,166
 nimble_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nimble_python/_utils/__init__.py,sha256=7fch0GT9zpNnErbciSpUNa-SjTxxjY6kxHxKMOM4AGs,2305
+nimble_python/_utils/__init__.py,sha256=DJEWihdzRWrZI23vwocBkgvZCwn9iG7yV0c_9vKaysU,2355
 nimble_python/_utils/_compat.py,sha256=33246eDcl3pwL6kWsEhVuT4Akrd8gZEW9LPTm465ohk,1231
 nimble_python/_utils/_datetime_parse.py,sha256=bABTs0Bc6rabdFvnIwXjEhWL15TcRgWZ_6XGTqN8xUk,4204
 nimble_python/_utils/_json.py,sha256=bl95uuIWwgSfXX-gP1trK_lDAPwJujYfJ05Cxo2SEC4,962
 nimble_python/_utils/_logs.py,sha256=3AXiQXDxC6I4wW59jczmelNgZhO00lEDtVTBTDCRX_8,788
+nimble_python/_utils/_path.py,sha256=Dk294levuJXP5e4m20YRDDZFPl7zegXvc9Kb3dUCwJI,4701
 nimble_python/_utils/_proxy.py,sha256=aglnj2yBTDyGX9Akk2crZHrl10oqRmceUy2Zp008XEs,1975
 nimble_python/_utils/_reflection.py,sha256=ZmGkIgT_PuwedyNBrrKGbxoWtkpytJNU1uU4QHnmEMU,1364
 nimble_python/_utils/_resources_proxy.py,sha256=PKCHRwjhwNIH5920LKi6DV8tnyPvYnEcutvqUmCxq6I,624
@@ -27,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=ugfUaneOK7I8h9b3656flwf5u_kthY0gvNuqvgOLoSU,12252
 nimble_python/lib/.keep,sha256=wuNrz-5SXo3jJaJOJgz4vFHM41YH_g20F5cRQo0vLes,224
-nimble_python/resources/__init__.py,sha256=Tw4jTo3742_EIeLVKIni8RmOPpeKwqLF168u9bQ5Fps,1413
-nimble_python/resources/agent.py,sha256=YjMJdOjB56f0AKNb0q1dUBdTMKhHIHkMi9pFVjCf-Cc,18987
-nimble_python/resources/crawl.py,sha256=QfzBxaqBMj_kyxtNxLozRm-gCWXDHvU0vGwVrra6TlM,20552
-nimble_python/resources/tasks.py,sha256=hkJB_TMtdu5-vwLWgz2s1Fb3HfZ8Nk9aHmUrBDJlNfg,12882
-nimble_python/types/__init__.py,sha256=XJtnVvQtC-1dYR_jMV5_xZs5t8jrnhi1XTzI95n0YNA,2592
+nimble_python/resources/__init__.py,sha256=Wh5Ns-DfhwV5B1NL1sauYogLEctZiqtJxLuEVQzUvVw,1876
+nimble_python/resources/agent.py,sha256=HDsKDK7zYFSplZcG9pVFAdvEptZJ2t2A5XRqx3IT7s4,19088
+nimble_python/resources/batches.py,sha256=LxPXo7mpDcXmtJAv7prVnDpJHkhHypix6ZNSxh9kpQU,11688
+nimble_python/resources/crawl.py,sha256=GOMDGANIPAfay-J3ujW9ghlK-h-aIy99ChIKRN-pZK8,20651
+nimble_python/resources/tasks.py,sha256=8rV6YZNpx8rq_83L8UZvt7HlPlRhY8SGrbVQAFDjBtM,13021
+nimble_python/types/__init__.py,sha256=al8UTqmM7bIeUUKbqDTHc6-23McbQAmVjF12tfN8r5g,2745
 nimble_python/types/agent_get_response.py,sha256=qQtjNztWHGWGJ_LKLn2-VtQlzv2AfkPvu0QaADRXqIg,1131
 nimble_python/types/agent_list_params.py,sha256=yUwgtiXrzfEXd3I--X_ISovY2BSHKXDvFZ2XUCUR9ew,670
 nimble_python/types/agent_list_response.py,sha256=kBEVOD9nlby5QsfaDkjPLXDJyQotph3HBo321jP8rb4,599
@@ -39,6 +41,8 @@ nimble_python/types/agent_run_async_params.py,sha256=vaDEeQx9X1XWJlUcLSa0Bht0c65
 nimble_python/types/agent_run_async_response.py,sha256=aawcjhtW6FaWxIPcg-l-1yIhsQDLUoYOaoSf_MLJ67s,321
 nimble_python/types/agent_run_params.py,sha256=WbmK8oa-Iv0QS1I8X6AAXhrbbMPzNACV5IHSq8rdwGg,365
 nimble_python/types/agent_run_response.py,sha256=xvHQbGDhgaWyZy4gcNMfYEQ4YLSUVRiF54Qm2SwIE2g,8036
+nimble_python/types/batch_get_response.py,sha256=5MIDHw3xt4UPdZY7eeYMDTJHbvyP4fCWNFMOLmuxcGM,2117
+nimble_python/types/batch_progress_response.py,sha256=oHEHXclc0NnI3TiGMalfElhZ15rfvR7nZRub9Gg_nqs,726
 nimble_python/types/client_extract_async_params.py,sha256=RMRSJB--VkxfuMBrf_zFan7dyp08GitRkRfuz6ON1RI,19328
 nimble_python/types/client_extract_batch_params.py,sha256=S9xPUAjDlpdbTuIaqUXQYWLEETkHwH8F645omihIMqw,19961
 nimble_python/types/client_extract_params.py,sha256=BH0nixa69BoJr1EfRTLvzIqhIqyj1DN0G68o61g_W5g,18968
@@ -87,7 +91,7 @@ nimble_python/types/shared_params/scroll_action.py,sha256=6PJMWVc9JhjyrXeAsFnvHR
 nimble_python/types/shared_params/wait_action.py,sha256=2jlVgNNZcC2M9tka3xbmLkDocCJuoX_1qIGOmd6a2DU,1046
 nimble_python/types/shared_params/wait_for_element_action.py,sha256=cKhvFe09G2aQBFKBXg00S43ykQqgNyTLYR1DoJmDvTA,1364
 nimble_python/types/shared_params/wait_for_navigation_action.py,sha256=oPAK3OxZObqJjDEh9v0_q1ntHfWqgtXOp_k-oX8ZiHE,1257
-nimble_python-0.12.0.dist-info/METADATA,sha256=LKH3JASu-yC5XletWN_XsIgCEBOC97zCsT-XqISgNqE,15816
-nimble_python-0.12.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-nimble_python-0.12.0.dist-info/licenses/LICENSE,sha256=khtIpaYdgNbXXcmzsxlSL_iKmh160uTREZTiMQKCB24,11336
-nimble_python-0.12.0.dist-info/RECORD,,
+nimble_python-0.13.0.dist-info/METADATA,sha256=uWvrB1XoHTU8i_6rqk1kdANTn2qKd1Q6SZ0k1JqvX-0,15816
+nimble_python-0.13.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+nimble_python-0.13.0.dist-info/licenses/LICENSE,sha256=khtIpaYdgNbXXcmzsxlSL_iKmh160uTREZTiMQKCB24,11336
+nimble_python-0.13.0.dist-info/RECORD,,