nimble_python 0.17.0__py3-none-any.whl → 0.18.0__py3-none-any.whl

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/_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/_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/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/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,
+        )