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

digitalocean_genai_sdk/resources/models.py

@@ -0,0 +1,222 @@
+# 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 .._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 ..types.model import Model
+from .._base_client import make_request_options
+from ..types.model_list_response import ModelListResponse
+
+__all__ = ["ModelsResource", "AsyncModelsResource"]
+
+
+class ModelsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ModelsResourceWithRawResponse:
+        """
+        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 ModelsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ModelsResourceWithStreamingResponse:
+        """
+        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 ModelsResourceWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        model: 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,
+    ) -> Model:
+        """
+        Retrieves a model instance, providing basic information about the model such as
+        the owner and permissioning.
+
+        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 model:
+            raise ValueError(f"Expected a non-empty value for `model` but received {model!r}")
+        return self._get(
+            f"/models/{model}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Model,
+        )
+
+    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,
+    ) -> ModelListResponse:
+        """
+        Lists the currently available models, and provides basic information about each
+        one such as the owner and availability.
+        """
+        return self._get(
+            "/models",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ModelListResponse,
+        )
+
+
+class AsyncModelsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncModelsResourceWithRawResponse:
+        """
+        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 AsyncModelsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncModelsResourceWithStreamingResponse:
+        """
+        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 AsyncModelsResourceWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        model: 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,
+    ) -> Model:
+        """
+        Retrieves a model instance, providing basic information about the model such as
+        the owner and permissioning.
+
+        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 model:
+            raise ValueError(f"Expected a non-empty value for `model` but received {model!r}")
+        return await self._get(
+            f"/models/{model}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Model,
+        )
+
+    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,
+    ) -> ModelListResponse:
+        """
+        Lists the currently available models, and provides basic information about each
+        one such as the owner and availability.
+        """
+        return await self._get(
+            "/models",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ModelListResponse,
+        )
+
+
+class ModelsResourceWithRawResponse:
+    def __init__(self, models: ModelsResource) -> None:
+        self._models = models
+
+        self.retrieve = to_raw_response_wrapper(
+            models.retrieve,
+        )
+        self.list = to_raw_response_wrapper(
+            models.list,
+        )
+
+
+class AsyncModelsResourceWithRawResponse:
+    def __init__(self, models: AsyncModelsResource) -> None:
+        self._models = models
+
+        self.retrieve = async_to_raw_response_wrapper(
+            models.retrieve,
+        )
+        self.list = async_to_raw_response_wrapper(
+            models.list,
+        )
+
+
+class ModelsResourceWithStreamingResponse:
+    def __init__(self, models: ModelsResource) -> None:
+        self._models = models
+
+        self.retrieve = to_streamed_response_wrapper(
+            models.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            models.list,
+        )
+
+
+class AsyncModelsResourceWithStreamingResponse:
+    def __init__(self, models: AsyncModelsResource) -> None:
+        self._models = models
+
+        self.retrieve = async_to_streamed_response_wrapper(
+            models.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            models.list,
+        )

digitalocean_genai_sdk/resources/providers/__init__.py

@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .openai import (
+    OpenAIResource,
+    AsyncOpenAIResource,
+    OpenAIResourceWithRawResponse,
+    AsyncOpenAIResourceWithRawResponse,
+    OpenAIResourceWithStreamingResponse,
+    AsyncOpenAIResourceWithStreamingResponse,
+)
+from .anthropic import (
+    AnthropicResource,
+    AsyncAnthropicResource,
+    AnthropicResourceWithRawResponse,
+    AsyncAnthropicResourceWithRawResponse,
+    AnthropicResourceWithStreamingResponse,
+    AsyncAnthropicResourceWithStreamingResponse,
+)
+from .providers import (
+    ProvidersResource,
+    AsyncProvidersResource,
+    ProvidersResourceWithRawResponse,
+    AsyncProvidersResourceWithRawResponse,
+    ProvidersResourceWithStreamingResponse,
+    AsyncProvidersResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "AnthropicResource",
+    "AsyncAnthropicResource",
+    "AnthropicResourceWithRawResponse",
+    "AsyncAnthropicResourceWithRawResponse",
+    "AnthropicResourceWithStreamingResponse",
+    "AsyncAnthropicResourceWithStreamingResponse",
+    "OpenAIResource",
+    "AsyncOpenAIResource",
+    "OpenAIResourceWithRawResponse",
+    "AsyncOpenAIResourceWithRawResponse",
+    "OpenAIResourceWithStreamingResponse",
+    "AsyncOpenAIResourceWithStreamingResponse",
+    "ProvidersResource",
+    "AsyncProvidersResource",
+    "ProvidersResourceWithRawResponse",
+    "AsyncProvidersResourceWithRawResponse",
+    "ProvidersResourceWithStreamingResponse",
+    "AsyncProvidersResourceWithStreamingResponse",
+]

digitalocean_genai_sdk/resources/providers/anthropic/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .keys import (
+    KeysResource,
+    AsyncKeysResource,
+    KeysResourceWithRawResponse,
+    AsyncKeysResourceWithRawResponse,
+    KeysResourceWithStreamingResponse,
+    AsyncKeysResourceWithStreamingResponse,
+)
+from .anthropic import (
+    AnthropicResource,
+    AsyncAnthropicResource,
+    AnthropicResourceWithRawResponse,
+    AsyncAnthropicResourceWithRawResponse,
+    AnthropicResourceWithStreamingResponse,
+    AsyncAnthropicResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "KeysResource",
+    "AsyncKeysResource",
+    "KeysResourceWithRawResponse",
+    "AsyncKeysResourceWithRawResponse",
+    "KeysResourceWithStreamingResponse",
+    "AsyncKeysResourceWithStreamingResponse",
+    "AnthropicResource",
+    "AsyncAnthropicResource",
+    "AnthropicResourceWithRawResponse",
+    "AsyncAnthropicResourceWithRawResponse",
+    "AnthropicResourceWithStreamingResponse",
+    "AsyncAnthropicResourceWithStreamingResponse",
+]

digitalocean_genai_sdk/resources/providers/anthropic/anthropic.py

@@ -0,0 +1,102 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .keys import (
+    KeysResource,
+    AsyncKeysResource,
+    KeysResourceWithRawResponse,
+    AsyncKeysResourceWithRawResponse,
+    KeysResourceWithStreamingResponse,
+    AsyncKeysResourceWithStreamingResponse,
+)
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["AnthropicResource", "AsyncAnthropicResource"]
+
+
+class AnthropicResource(SyncAPIResource):
+    @cached_property
+    def keys(self) -> KeysResource:
+        return KeysResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AnthropicResourceWithRawResponse:
+        """
+        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 AnthropicResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AnthropicResourceWithStreamingResponse:
+        """
+        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 AnthropicResourceWithStreamingResponse(self)
+
+
+class AsyncAnthropicResource(AsyncAPIResource):
+    @cached_property
+    def keys(self) -> AsyncKeysResource:
+        return AsyncKeysResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncAnthropicResourceWithRawResponse:
+        """
+        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 AsyncAnthropicResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncAnthropicResourceWithStreamingResponse:
+        """
+        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 AsyncAnthropicResourceWithStreamingResponse(self)
+
+
+class AnthropicResourceWithRawResponse:
+    def __init__(self, anthropic: AnthropicResource) -> None:
+        self._anthropic = anthropic
+
+    @cached_property
+    def keys(self) -> KeysResourceWithRawResponse:
+        return KeysResourceWithRawResponse(self._anthropic.keys)
+
+
+class AsyncAnthropicResourceWithRawResponse:
+    def __init__(self, anthropic: AsyncAnthropicResource) -> None:
+        self._anthropic = anthropic
+
+    @cached_property
+    def keys(self) -> AsyncKeysResourceWithRawResponse:
+        return AsyncKeysResourceWithRawResponse(self._anthropic.keys)
+
+
+class AnthropicResourceWithStreamingResponse:
+    def __init__(self, anthropic: AnthropicResource) -> None:
+        self._anthropic = anthropic
+
+    @cached_property
+    def keys(self) -> KeysResourceWithStreamingResponse:
+        return KeysResourceWithStreamingResponse(self._anthropic.keys)
+
+
+class AsyncAnthropicResourceWithStreamingResponse:
+    def __init__(self, anthropic: AsyncAnthropicResource) -> None:
+        self._anthropic = anthropic
+
+    @cached_property
+    def keys(self) -> AsyncKeysResourceWithStreamingResponse:
+        return AsyncKeysResourceWithStreamingResponse(self._anthropic.keys)