nimble_python 0.17.0__tar.gz → 0.18.0__tar.gz

nimble_python-0.18.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.18.0"
+}

{nimble_python-0.17.0 → nimble_python-0.18.0}/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.18.0 (2026-05-10)
+
+Full Changelog: [v0.17.0...v0.18.0](https://github.com/Nimbleway/nimble-python/compare/v0.17.0...v0.18.0)
+
+### Features
+
+* **api:** Add media, serp and domain_knowledge ([d1e33f1](https://github.com/Nimbleway/nimble-python/commit/d1e33f1e44507ba4a817532d58e25f109c58e776))
+
+
+### Bug Fixes
+
+* **client:** add missing f-string prefix in file type error message ([972cbcd](https://github.com/Nimbleway/nimble-python/commit/972cbcd40b4e4091a7364288d3d0b6033983826c))
+
 ## 0.17.0 (2026-05-06)
 
 Full Changelog: [v0.16.0...v0.17.0](https://github.com/Nimbleway/nimble-python/compare/v0.16.0...v0.17.0)

{nimble_python-0.17.0 → nimble_python-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nimble_python
-Version: 0.17.0
+Version: 0.18.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.17.0 → nimble_python-0.18.0}/api.md

@@ -115,3 +115,42 @@ Methods:
 - <code title="get /v1/batches">client.batches.<a href="./src/nimble_python/resources/batches.py">list</a>() -> None</code>
 - <code title="get /v1/batches/{batch_id}">client.batches.<a href="./src/nimble_python/resources/batches.py">get</a>(batch_id) -> <a href="./src/nimble_python/types/batch_get_response.py">BatchGetResponse</a></code>
 - <code title="get /v1/batches/{batch_id}/progress">client.batches.<a href="./src/nimble_python/resources/batches.py">progress</a>(batch_id) -> <a href="./src/nimble_python/types/batch_progress_response.py">BatchProgressResponse</a></code>
+
+# DomainKnowledge
+
+Types:
+
+```python
+from nimble_python.types import DomainKnowledgeGetDriverResponse
+```
+
+Methods:
+
+- <code title="get /v1/domain-knowledge/driver">client.domain_knowledge.<a href="./src/nimble_python/resources/domain_knowledge.py">get_driver</a>(\*\*<a href="src/nimble_python/types/domain_knowledge_get_driver_params.py">params</a>) -> <a href="./src/nimble_python/types/domain_knowledge_get_driver_response.py">DomainKnowledgeGetDriverResponse</a></code>
+
+# Media
+
+Types:
+
+```python
+from nimble_python.types import MediaRunResponse, MediaRunAsyncResponse
+```
+
+Methods:
+
+- <code title="post /v1/media">client.media.<a href="./src/nimble_python/resources/media.py">run</a>(\*\*<a href="src/nimble_python/types/media_run_params.py">params</a>) -> <a href="./src/nimble_python/types/media_run_response.py">MediaRunResponse</a></code>
+- <code title="post /v1/media/async">client.media.<a href="./src/nimble_python/resources/media.py">run_async</a>(\*\*<a href="src/nimble_python/types/media_run_async_params.py">params</a>) -> <a href="./src/nimble_python/types/media_run_async_response.py">MediaRunAsyncResponse</a></code>
+
+# Serp
+
+Types:
+
+```python
+from nimble_python.types import SerpRunResponse, SerpRunAsyncResponse, SerpRunBatchResponse
+```
+
+Methods:
+
+- <code title="post /v1/serp">client.serp.<a href="./src/nimble_python/resources/serp.py">run</a>(\*\*<a href="src/nimble_python/types/serp_run_params.py">params</a>) -> <a href="./src/nimble_python/types/serp_run_response.py">SerpRunResponse</a></code>
+- <code title="post /v1/serp/async">client.serp.<a href="./src/nimble_python/resources/serp.py">run_async</a>(\*\*<a href="src/nimble_python/types/serp_run_async_params.py">params</a>) -> <a href="./src/nimble_python/types/serp_run_async_response.py">SerpRunAsyncResponse</a></code>
+- <code title="post /v1/serp/batch">client.serp.<a href="./src/nimble_python/resources/serp.py">run_batch</a>(\*\*<a href="src/nimble_python/types/serp_run_batch_params.py">params</a>) -> <a href="./src/nimble_python/types/serp_run_batch_response.py">SerpRunBatchResponse</a></code>

{nimble_python-0.17.0 → nimble_python-0.18.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nimble_python"
-version = "0.17.0"
+version = "0.18.0"
 description = "The official Python library for the nimble API"
 dynamic = ["readme"]
 license = "Apache-2.0"

{nimble_python-0.17.0 → nimble_python-0.18.0}/src/nimble_python/_client.py

@@ -61,11 +61,14 @@ from .types.extract_async_response import ExtractAsyncResponse
 from .types.extract_batch_response import ExtractBatchResponse
 
 if TYPE_CHECKING:
-    from .resources import agent, crawl, tasks, batches
+    from .resources import serp, agent, crawl, media, tasks, batches, 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.domain_knowledge import DomainKnowledgeResource, AsyncDomainKnowledgeResource
 
 __all__ = ["Timeout", "Transport", "ProxiesTypes", "RequestOptions", "Nimble", "AsyncNimble", "Client", "AsyncClient"]
 
@@ -162,6 +165,24 @@ class Nimble(SyncAPIClient):
 
         return BatchesResource(self)
 
+    @cached_property
+    def domain_knowledge(self) -> DomainKnowledgeResource:
+        from .resources.domain_knowledge import DomainKnowledgeResource
+
+        return DomainKnowledgeResource(self)
+
+    @cached_property
+    def media(self) -> MediaResource:
+        from .resources.media import MediaResource
+
+        return MediaResource(self)
+
+    @cached_property
+    def serp(self) -> SerpResource:
+        from .resources.serp import SerpResource
+
+        return SerpResource(self)
+
     @cached_property
     def with_raw_response(self) -> NimbleWithRawResponse:
         return NimbleWithRawResponse(self)
@@ -3394,6 +3415,24 @@ class AsyncNimble(AsyncAPIClient):
 
         return AsyncBatchesResource(self)
 
+    @cached_property
+    def domain_knowledge(self) -> AsyncDomainKnowledgeResource:
+        from .resources.domain_knowledge import AsyncDomainKnowledgeResource
+
+        return AsyncDomainKnowledgeResource(self)
+
+    @cached_property
+    def media(self) -> AsyncMediaResource:
+        from .resources.media import AsyncMediaResource
+
+        return AsyncMediaResource(self)
+
+    @cached_property
+    def serp(self) -> AsyncSerpResource:
+        from .resources.serp import AsyncSerpResource
+
+        return AsyncSerpResource(self)
+
     @cached_property
     def with_raw_response(self) -> AsyncNimbleWithRawResponse:
         return AsyncNimbleWithRawResponse(self)
@@ -6580,6 +6619,24 @@ class NimbleWithRawResponse:
 
         return BatchesResourceWithRawResponse(self._client.batches)
 
+    @cached_property
+    def domain_knowledge(self) -> domain_knowledge.DomainKnowledgeResourceWithRawResponse:
+        from .resources.domain_knowledge import DomainKnowledgeResourceWithRawResponse
+
+        return DomainKnowledgeResourceWithRawResponse(self._client.domain_knowledge)
+
+    @cached_property
+    def media(self) -> media.MediaResourceWithRawResponse:
+        from .resources.media import MediaResourceWithRawResponse
+
+        return MediaResourceWithRawResponse(self._client.media)
+
+    @cached_property
+    def serp(self) -> serp.SerpResourceWithRawResponse:
+        from .resources.serp import SerpResourceWithRawResponse
+
+        return SerpResourceWithRawResponse(self._client.serp)
+
 
 class AsyncNimbleWithRawResponse:
     _client: AsyncNimble
@@ -6627,6 +6684,24 @@ class AsyncNimbleWithRawResponse:
 
         return AsyncBatchesResourceWithRawResponse(self._client.batches)
 
+    @cached_property
+    def domain_knowledge(self) -> domain_knowledge.AsyncDomainKnowledgeResourceWithRawResponse:
+        from .resources.domain_knowledge import AsyncDomainKnowledgeResourceWithRawResponse
+
+        return AsyncDomainKnowledgeResourceWithRawResponse(self._client.domain_knowledge)
+
+    @cached_property
+    def media(self) -> media.AsyncMediaResourceWithRawResponse:
+        from .resources.media import AsyncMediaResourceWithRawResponse
+
+        return AsyncMediaResourceWithRawResponse(self._client.media)
+
+    @cached_property
+    def serp(self) -> serp.AsyncSerpResourceWithRawResponse:
+        from .resources.serp import AsyncSerpResourceWithRawResponse
+
+        return AsyncSerpResourceWithRawResponse(self._client.serp)
+
 
 class NimbleWithStreamedResponse:
     _client: Nimble
@@ -6674,6 +6749,24 @@ class NimbleWithStreamedResponse:
 
         return BatchesResourceWithStreamingResponse(self._client.batches)
 
+    @cached_property
+    def domain_knowledge(self) -> domain_knowledge.DomainKnowledgeResourceWithStreamingResponse:
+        from .resources.domain_knowledge import DomainKnowledgeResourceWithStreamingResponse
+
+        return DomainKnowledgeResourceWithStreamingResponse(self._client.domain_knowledge)
+
+    @cached_property
+    def media(self) -> media.MediaResourceWithStreamingResponse:
+        from .resources.media import MediaResourceWithStreamingResponse
+
+        return MediaResourceWithStreamingResponse(self._client.media)
+
+    @cached_property
+    def serp(self) -> serp.SerpResourceWithStreamingResponse:
+        from .resources.serp import SerpResourceWithStreamingResponse
+
+        return SerpResourceWithStreamingResponse(self._client.serp)
+
 
 class AsyncNimbleWithStreamedResponse:
     _client: AsyncNimble
@@ -6721,6 +6814,24 @@ class AsyncNimbleWithStreamedResponse:
 
         return AsyncBatchesResourceWithStreamingResponse(self._client.batches)
 
+    @cached_property
+    def domain_knowledge(self) -> domain_knowledge.AsyncDomainKnowledgeResourceWithStreamingResponse:
+        from .resources.domain_knowledge import AsyncDomainKnowledgeResourceWithStreamingResponse
+
+        return AsyncDomainKnowledgeResourceWithStreamingResponse(self._client.domain_knowledge)
+
+    @cached_property
+    def media(self) -> media.AsyncMediaResourceWithStreamingResponse:
+        from .resources.media import AsyncMediaResourceWithStreamingResponse
+
+        return AsyncMediaResourceWithStreamingResponse(self._client.media)
+
+    @cached_property
+    def serp(self) -> serp.AsyncSerpResourceWithStreamingResponse:
+        from .resources.serp import AsyncSerpResourceWithStreamingResponse
+
+        return AsyncSerpResourceWithStreamingResponse(self._client.serp)
+
 
 Client = Nimble
 

{nimble_python-0.17.0 → nimble_python-0.18.0}/src/nimble_python/_files.py

@@ -99,7 +99,7 @@ async def async_to_httpx_files(files: RequestFiles | None) -> HttpxRequestFiles
     elif is_sequence_t(files):
         files = [(key, await _async_transform_file(file)) for key, file in files]
     else:
-        raise TypeError("Unexpected file type input {type(files)}, expected mapping or sequence")
+        raise TypeError(f"Unexpected file type input {type(files)}, expected mapping or sequence")
 
     return files
 

{nimble_python-0.17.0 → nimble_python-0.18.0}/src/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.17.0"  # x-release-please-version
+__version__ = "0.18.0"  # x-release-please-version

{nimble_python-0.17.0 → nimble_python-0.18.0}/src/nimble_python/resources/__init__.py

@@ -1,5 +1,13 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from .serp import (
+    SerpResource,
+    AsyncSerpResource,
+    SerpResourceWithRawResponse,
+    AsyncSerpResourceWithRawResponse,
+    SerpResourceWithStreamingResponse,
+    AsyncSerpResourceWithStreamingResponse,
+)
 from .agent import (
     AgentResource,
     AsyncAgentResource,
@@ -16,6 +24,14 @@ from .crawl import (
     CrawlResourceWithStreamingResponse,
     AsyncCrawlResourceWithStreamingResponse,
 )
+from .media import (
+    MediaResource,
+    AsyncMediaResource,
+    MediaResourceWithRawResponse,
+    AsyncMediaResourceWithRawResponse,
+    MediaResourceWithStreamingResponse,
+    AsyncMediaResourceWithStreamingResponse,
+)
 from .tasks import (
     TasksResource,
     AsyncTasksResource,
@@ -32,6 +48,14 @@ from .batches import (
     BatchesResourceWithStreamingResponse,
     AsyncBatchesResourceWithStreamingResponse,
 )
+from .domain_knowledge import (
+    DomainKnowledgeResource,
+    AsyncDomainKnowledgeResource,
+    DomainKnowledgeResourceWithRawResponse,
+    AsyncDomainKnowledgeResourceWithRawResponse,
+    DomainKnowledgeResourceWithStreamingResponse,
+    AsyncDomainKnowledgeResourceWithStreamingResponse,
+)
 
 __all__ = [
     "AgentResource",
@@ -58,4 +82,22 @@ __all__ = [
     "AsyncBatchesResourceWithRawResponse",
     "BatchesResourceWithStreamingResponse",
     "AsyncBatchesResourceWithStreamingResponse",
+    "DomainKnowledgeResource",
+    "AsyncDomainKnowledgeResource",
+    "DomainKnowledgeResourceWithRawResponse",
+    "AsyncDomainKnowledgeResourceWithRawResponse",
+    "DomainKnowledgeResourceWithStreamingResponse",
+    "AsyncDomainKnowledgeResourceWithStreamingResponse",
+    "MediaResource",
+    "AsyncMediaResource",
+    "MediaResourceWithRawResponse",
+    "AsyncMediaResourceWithRawResponse",
+    "MediaResourceWithStreamingResponse",
+    "AsyncMediaResourceWithStreamingResponse",
+    "SerpResource",
+    "AsyncSerpResource",
+    "SerpResourceWithRawResponse",
+    "AsyncSerpResourceWithRawResponse",
+    "SerpResourceWithStreamingResponse",
+    "AsyncSerpResourceWithStreamingResponse",
 ]

nimble_python-0.18.0/src/nimble_python/resources/domain_knowledge.py

@@ -0,0 +1,195 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ..types import domain_knowledge_get_driver_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.domain_knowledge_get_driver_response import DomainKnowledgeGetDriverResponse
+
+__all__ = ["DomainKnowledgeResource", "AsyncDomainKnowledgeResource"]
+
+
+class DomainKnowledgeResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> DomainKnowledgeResourceWithRawResponse:
+        """
+        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 DomainKnowledgeResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> DomainKnowledgeResourceWithStreamingResponse:
+        """
+        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 DomainKnowledgeResourceWithStreamingResponse(self)
+
+    def get_driver(
+        self,
+        *,
+        agent: str | Omit = omit,
+        url: str | 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,
+    ) -> DomainKnowledgeGetDriverResponse:
+        """Resolves the suggested driver for a given URL or agent name.
+
+        Exactly one of
+        `url` or `agent` must be provided.
+
+        Args:
+          agent: Agent name to resolve driver for (e.g. nimble-ecommerce).
+
+          url: Target domain to resolve driver for (e.g. amazon.com).
+
+          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._get(
+            "/v1/domain-knowledge/driver",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "agent": agent,
+                        "url": url,
+                    },
+                    domain_knowledge_get_driver_params.DomainKnowledgeGetDriverParams,
+                ),
+            ),
+            cast_to=DomainKnowledgeGetDriverResponse,
+        )
+
+
+class AsyncDomainKnowledgeResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncDomainKnowledgeResourceWithRawResponse:
+        """
+        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 AsyncDomainKnowledgeResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncDomainKnowledgeResourceWithStreamingResponse:
+        """
+        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 AsyncDomainKnowledgeResourceWithStreamingResponse(self)
+
+    async def get_driver(
+        self,
+        *,
+        agent: str | Omit = omit,
+        url: str | 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,
+    ) -> DomainKnowledgeGetDriverResponse:
+        """Resolves the suggested driver for a given URL or agent name.
+
+        Exactly one of
+        `url` or `agent` must be provided.
+
+        Args:
+          agent: Agent name to resolve driver for (e.g. nimble-ecommerce).
+
+          url: Target domain to resolve driver for (e.g. amazon.com).
+
+          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._get(
+            "/v1/domain-knowledge/driver",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {
+                        "agent": agent,
+                        "url": url,
+                    },
+                    domain_knowledge_get_driver_params.DomainKnowledgeGetDriverParams,
+                ),
+            ),
+            cast_to=DomainKnowledgeGetDriverResponse,
+        )
+
+
+class DomainKnowledgeResourceWithRawResponse:
+    def __init__(self, domain_knowledge: DomainKnowledgeResource) -> None:
+        self._domain_knowledge = domain_knowledge
+
+        self.get_driver = to_raw_response_wrapper(
+            domain_knowledge.get_driver,
+        )
+
+
+class AsyncDomainKnowledgeResourceWithRawResponse:
+    def __init__(self, domain_knowledge: AsyncDomainKnowledgeResource) -> None:
+        self._domain_knowledge = domain_knowledge
+
+        self.get_driver = async_to_raw_response_wrapper(
+            domain_knowledge.get_driver,
+        )
+
+
+class DomainKnowledgeResourceWithStreamingResponse:
+    def __init__(self, domain_knowledge: DomainKnowledgeResource) -> None:
+        self._domain_knowledge = domain_knowledge
+
+        self.get_driver = to_streamed_response_wrapper(
+            domain_knowledge.get_driver,
+        )
+
+
+class AsyncDomainKnowledgeResourceWithStreamingResponse:
+    def __init__(self, domain_knowledge: AsyncDomainKnowledgeResource) -> None:
+        self._domain_knowledge = domain_knowledge
+
+        self.get_driver = async_to_streamed_response_wrapper(
+            domain_knowledge.get_driver,
+        )