c63a5cfe-b235-4fbe-8bbb-82a9e02a482a-python 0.1.0a3__py3-none-any.whl → 0.1.0a4__py3-none-any.whl

digitalocean_genai_sdk/resources/auth/agents/token.py

@@ -1,173 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-import httpx
-
-from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-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.auth.agents import token_create_params
-from ....types.auth.agents.token_create_response import TokenCreateResponse
-
-__all__ = ["TokenResource", "AsyncTokenResource"]
-
-
-class TokenResource(SyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> TokenResourceWithRawResponse:
-        """
-        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/digitalocean/genai-python#accessing-raw-response-data-eg-headers
-        """
-        return TokenResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> TokenResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
-        """
-        return TokenResourceWithStreamingResponse(self)
-
-    def create(
-        self,
-        path_agent_uuid: str,
-        *,
-        body_agent_uuid: str | NotGiven = NOT_GIVEN,
-        # 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,
-    ) -> TokenCreateResponse:
-        """
-        To issue an agent token, send a POST request to
-        `/v2/gen-ai/auth/agents/{agent_uuid}/token`.
-
-        Args:
-          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 path_agent_uuid:
-            raise ValueError(f"Expected a non-empty value for `path_agent_uuid` but received {path_agent_uuid!r}")
-        return self._post(
-            f"/v2/genai/auth/agents/{path_agent_uuid}/token",
-            body=maybe_transform({"body_agent_uuid": body_agent_uuid}, token_create_params.TokenCreateParams),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=TokenCreateResponse,
-        )
-
-
-class AsyncTokenResource(AsyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> AsyncTokenResourceWithRawResponse:
-        """
-        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/digitalocean/genai-python#accessing-raw-response-data-eg-headers
-        """
-        return AsyncTokenResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncTokenResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
-        """
-        return AsyncTokenResourceWithStreamingResponse(self)
-
-    async def create(
-        self,
-        path_agent_uuid: str,
-        *,
-        body_agent_uuid: str | NotGiven = NOT_GIVEN,
-        # 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,
-    ) -> TokenCreateResponse:
-        """
-        To issue an agent token, send a POST request to
-        `/v2/gen-ai/auth/agents/{agent_uuid}/token`.
-
-        Args:
-          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 path_agent_uuid:
-            raise ValueError(f"Expected a non-empty value for `path_agent_uuid` but received {path_agent_uuid!r}")
-        return await self._post(
-            f"/v2/genai/auth/agents/{path_agent_uuid}/token",
-            body=await async_maybe_transform(
-                {"body_agent_uuid": body_agent_uuid}, token_create_params.TokenCreateParams
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=TokenCreateResponse,
-        )
-
-
-class TokenResourceWithRawResponse:
-    def __init__(self, token: TokenResource) -> None:
-        self._token = token
-
-        self.create = to_raw_response_wrapper(
-            token.create,
-        )
-
-
-class AsyncTokenResourceWithRawResponse:
-    def __init__(self, token: AsyncTokenResource) -> None:
-        self._token = token
-
-        self.create = async_to_raw_response_wrapper(
-            token.create,
-        )
-
-
-class TokenResourceWithStreamingResponse:
-    def __init__(self, token: TokenResource) -> None:
-        self._token = token
-
-        self.create = to_streamed_response_wrapper(
-            token.create,
-        )
-
-
-class AsyncTokenResourceWithStreamingResponse:
-    def __init__(self, token: AsyncTokenResource) -> None:
-        self._token = token
-
-        self.create = async_to_streamed_response_wrapper(
-            token.create,
-        )

digitalocean_genai_sdk/resources/auth/auth.py

@@ -1,102 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-from ..._compat import cached_property
-from ..._resource import SyncAPIResource, AsyncAPIResource
-from .agents.agents import (
-    AgentsResource,
-    AsyncAgentsResource,
-    AgentsResourceWithRawResponse,
-    AsyncAgentsResourceWithRawResponse,
-    AgentsResourceWithStreamingResponse,
-    AsyncAgentsResourceWithStreamingResponse,
-)
-
-__all__ = ["AuthResource", "AsyncAuthResource"]
-
-
-class AuthResource(SyncAPIResource):
-    @cached_property
-    def agents(self) -> AgentsResource:
-        return AgentsResource(self._client)
-
-    @cached_property
-    def with_raw_response(self) -> AuthResourceWithRawResponse:
-        """
-        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/digitalocean/genai-python#accessing-raw-response-data-eg-headers
-        """
-        return AuthResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AuthResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
-        """
-        return AuthResourceWithStreamingResponse(self)
-
-
-class AsyncAuthResource(AsyncAPIResource):
-    @cached_property
-    def agents(self) -> AsyncAgentsResource:
-        return AsyncAgentsResource(self._client)
-
-    @cached_property
-    def with_raw_response(self) -> AsyncAuthResourceWithRawResponse:
-        """
-        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/digitalocean/genai-python#accessing-raw-response-data-eg-headers
-        """
-        return AsyncAuthResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncAuthResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
-        """
-        return AsyncAuthResourceWithStreamingResponse(self)
-
-
-class AuthResourceWithRawResponse:
-    def __init__(self, auth: AuthResource) -> None:
-        self._auth = auth
-
-    @cached_property
-    def agents(self) -> AgentsResourceWithRawResponse:
-        return AgentsResourceWithRawResponse(self._auth.agents)
-
-
-class AsyncAuthResourceWithRawResponse:
-    def __init__(self, auth: AsyncAuthResource) -> None:
-        self._auth = auth
-
-    @cached_property
-    def agents(self) -> AsyncAgentsResourceWithRawResponse:
-        return AsyncAgentsResourceWithRawResponse(self._auth.agents)
-
-
-class AuthResourceWithStreamingResponse:
-    def __init__(self, auth: AuthResource) -> None:
-        self._auth = auth
-
-    @cached_property
-    def agents(self) -> AgentsResourceWithStreamingResponse:
-        return AgentsResourceWithStreamingResponse(self._auth.agents)
-
-
-class AsyncAuthResourceWithStreamingResponse:
-    def __init__(self, auth: AsyncAuthResource) -> None:
-        self._auth = auth
-
-    @cached_property
-    def agents(self) -> AsyncAgentsResourceWithStreamingResponse:
-        return AsyncAgentsResourceWithStreamingResponse(self._auth.agents)

digitalocean_genai_sdk/resources/embeddings.py

@@ -1,201 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-from typing import List, Union
-
-import httpx
-
-from ..types import embedding_create_params
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-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.embedding_create_response import EmbeddingCreateResponse
-
-__all__ = ["EmbeddingsResource", "AsyncEmbeddingsResource"]
-
-
-class EmbeddingsResource(SyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> EmbeddingsResourceWithRawResponse:
-        """
-        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/digitalocean/genai-python#accessing-raw-response-data-eg-headers
-        """
-        return EmbeddingsResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> EmbeddingsResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
-        """
-        return EmbeddingsResourceWithStreamingResponse(self)
-
-    def create(
-        self,
-        *,
-        input: Union[str, List[str]],
-        model: str,
-        user: str | NotGiven = NOT_GIVEN,
-        # 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,
-    ) -> EmbeddingCreateResponse:
-        """
-        Creates an embedding vector representing the input text.
-
-        Args:
-          input: Input text to embed, encoded as a string or array of tokens. To embed multiple
-              inputs in a single request, pass an array of strings.
-
-          model: ID of the model to use. You can use the List models API to see all of your
-              available models.
-
-          user: A unique identifier representing your end-user, which can help DigitalOcean to
-              monitor and detect abuse.
-
-          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(
-            "/embeddings",
-            body=maybe_transform(
-                {
-                    "input": input,
-                    "model": model,
-                    "user": user,
-                },
-                embedding_create_params.EmbeddingCreateParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=EmbeddingCreateResponse,
-        )
-
-
-class AsyncEmbeddingsResource(AsyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> AsyncEmbeddingsResourceWithRawResponse:
-        """
-        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/digitalocean/genai-python#accessing-raw-response-data-eg-headers
-        """
-        return AsyncEmbeddingsResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncEmbeddingsResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
-        """
-        return AsyncEmbeddingsResourceWithStreamingResponse(self)
-
-    async def create(
-        self,
-        *,
-        input: Union[str, List[str]],
-        model: str,
-        user: str | NotGiven = NOT_GIVEN,
-        # 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,
-    ) -> EmbeddingCreateResponse:
-        """
-        Creates an embedding vector representing the input text.
-
-        Args:
-          input: Input text to embed, encoded as a string or array of tokens. To embed multiple
-              inputs in a single request, pass an array of strings.
-
-          model: ID of the model to use. You can use the List models API to see all of your
-              available models.
-
-          user: A unique identifier representing your end-user, which can help DigitalOcean to
-              monitor and detect abuse.
-
-          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(
-            "/embeddings",
-            body=await async_maybe_transform(
-                {
-                    "input": input,
-                    "model": model,
-                    "user": user,
-                },
-                embedding_create_params.EmbeddingCreateParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=EmbeddingCreateResponse,
-        )
-
-
-class EmbeddingsResourceWithRawResponse:
-    def __init__(self, embeddings: EmbeddingsResource) -> None:
-        self._embeddings = embeddings
-
-        self.create = to_raw_response_wrapper(
-            embeddings.create,
-        )
-
-
-class AsyncEmbeddingsResourceWithRawResponse:
-    def __init__(self, embeddings: AsyncEmbeddingsResource) -> None:
-        self._embeddings = embeddings
-
-        self.create = async_to_raw_response_wrapper(
-            embeddings.create,
-        )
-
-
-class EmbeddingsResourceWithStreamingResponse:
-    def __init__(self, embeddings: EmbeddingsResource) -> None:
-        self._embeddings = embeddings
-
-        self.create = to_streamed_response_wrapper(
-            embeddings.create,
-        )
-
-
-class AsyncEmbeddingsResourceWithStreamingResponse:
-    def __init__(self, embeddings: AsyncEmbeddingsResource) -> None:
-        self._embeddings = embeddings
-
-        self.create = async_to_streamed_response_wrapper(
-            embeddings.create,
-        )

digitalocean_genai_sdk/resources/regions.py

@@ -1,191 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-import httpx
-
-from ..types import region_list_params
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-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.region_list_response import RegionListResponse
-
-__all__ = ["RegionsResource", "AsyncRegionsResource"]
-
-
-class RegionsResource(SyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> RegionsResourceWithRawResponse:
-        """
-        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/digitalocean/genai-python#accessing-raw-response-data-eg-headers
-        """
-        return RegionsResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> RegionsResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
-        """
-        return RegionsResourceWithStreamingResponse(self)
-
-    def list(
-        self,
-        *,
-        serves_batch: bool | NotGiven = NOT_GIVEN,
-        serves_inference: bool | NotGiven = NOT_GIVEN,
-        # 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,
-    ) -> RegionListResponse:
-        """
-        To list all datacenter regions, send a GET request to `/v2/gen-ai/regions`.
-
-        Args:
-          serves_batch: include datacenters that are capable of running batch jobs.
-
-          serves_inference: include datacenters that serve inference.
-
-          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(
-            "/v2/genai/regions",
-            options=make_request_options(
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
-                query=maybe_transform(
-                    {
-                        "serves_batch": serves_batch,
-                        "serves_inference": serves_inference,
-                    },
-                    region_list_params.RegionListParams,
-                ),
-            ),
-            cast_to=RegionListResponse,
-        )
-
-
-class AsyncRegionsResource(AsyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> AsyncRegionsResourceWithRawResponse:
-        """
-        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/digitalocean/genai-python#accessing-raw-response-data-eg-headers
-        """
-        return AsyncRegionsResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncRegionsResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
-        """
-        return AsyncRegionsResourceWithStreamingResponse(self)
-
-    async def list(
-        self,
-        *,
-        serves_batch: bool | NotGiven = NOT_GIVEN,
-        serves_inference: bool | NotGiven = NOT_GIVEN,
-        # 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,
-    ) -> RegionListResponse:
-        """
-        To list all datacenter regions, send a GET request to `/v2/gen-ai/regions`.
-
-        Args:
-          serves_batch: include datacenters that are capable of running batch jobs.
-
-          serves_inference: include datacenters that serve inference.
-
-          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(
-            "/v2/genai/regions",
-            options=make_request_options(
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
-                query=await async_maybe_transform(
-                    {
-                        "serves_batch": serves_batch,
-                        "serves_inference": serves_inference,
-                    },
-                    region_list_params.RegionListParams,
-                ),
-            ),
-            cast_to=RegionListResponse,
-        )
-
-
-class RegionsResourceWithRawResponse:
-    def __init__(self, regions: RegionsResource) -> None:
-        self._regions = regions
-
-        self.list = to_raw_response_wrapper(
-            regions.list,
-        )
-
-
-class AsyncRegionsResourceWithRawResponse:
-    def __init__(self, regions: AsyncRegionsResource) -> None:
-        self._regions = regions
-
-        self.list = async_to_raw_response_wrapper(
-            regions.list,
-        )
-
-
-class RegionsResourceWithStreamingResponse:
-    def __init__(self, regions: RegionsResource) -> None:
-        self._regions = regions
-
-        self.list = to_streamed_response_wrapper(
-            regions.list,
-        )
-
-
-class AsyncRegionsResourceWithStreamingResponse:
-    def __init__(self, regions: AsyncRegionsResource) -> None:
-        self._regions = regions
-
-        self.list = async_to_streamed_response_wrapper(
-            regions.list,
-        )

digitalocean_genai_sdk/types/auth/agents/__init__.py

@@ -1,6 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-from .token_create_params import TokenCreateParams as TokenCreateParams
-from .token_create_response import TokenCreateResponse as TokenCreateResponse

digitalocean_genai_sdk/types/auth/agents/token_create_params.py

@@ -1,13 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-from typing_extensions import Annotated, TypedDict
-
-from ...._utils import PropertyInfo
-
-__all__ = ["TokenCreateParams"]
-
-
-class TokenCreateParams(TypedDict, total=False):
-    body_agent_uuid: Annotated[str, PropertyInfo(alias="agent_uuid")]