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

{digitalocean_genai_sdk → do_gradientai}/resources/agents/versions.py

@@ -29,7 +29,7 @@ class VersionsResource(SyncAPIResource):
         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
+        For more information, see https://www.github.com/digitalocean/gradientai-python#accessing-raw-response-data-eg-headers
         """
         return VersionsResourceWithRawResponse(self)
 
@@ -38,7 +38,7 @@ class VersionsResource(SyncAPIResource):
         """
         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
+        For more information, see https://www.github.com/digitalocean/gradientai-python#with_streaming_response
         """
         return VersionsResourceWithStreamingResponse(self)
 
@@ -71,7 +71,9 @@ class VersionsResource(SyncAPIResource):
         if not path_uuid:
             raise ValueError(f"Expected a non-empty value for `path_uuid` but received {path_uuid!r}")
         return self._put(
-            f"/v2/gen-ai/agents/{path_uuid}/versions",
+            f"/v2/gen-ai/agents/{path_uuid}/versions"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{path_uuid}/versions",
             body=maybe_transform(
                 {
                     "body_uuid": body_uuid,
@@ -118,7 +120,9 @@ class VersionsResource(SyncAPIResource):
         if not uuid:
             raise ValueError(f"Expected a non-empty value for `uuid` but received {uuid!r}")
         return self._get(
-            f"/v2/gen-ai/agents/{uuid}/versions",
+            f"/v2/gen-ai/agents/{uuid}/versions"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{uuid}/versions",
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -143,7 +147,7 @@ class AsyncVersionsResource(AsyncAPIResource):
         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
+        For more information, see https://www.github.com/digitalocean/gradientai-python#accessing-raw-response-data-eg-headers
         """
         return AsyncVersionsResourceWithRawResponse(self)
 
@@ -152,7 +156,7 @@ class AsyncVersionsResource(AsyncAPIResource):
         """
         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
+        For more information, see https://www.github.com/digitalocean/gradientai-python#with_streaming_response
         """
         return AsyncVersionsResourceWithStreamingResponse(self)
 
@@ -185,7 +189,9 @@ class AsyncVersionsResource(AsyncAPIResource):
         if not path_uuid:
             raise ValueError(f"Expected a non-empty value for `path_uuid` but received {path_uuid!r}")
         return await self._put(
-            f"/v2/gen-ai/agents/{path_uuid}/versions",
+            f"/v2/gen-ai/agents/{path_uuid}/versions"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{path_uuid}/versions",
             body=await async_maybe_transform(
                 {
                     "body_uuid": body_uuid,
@@ -232,7 +238,9 @@ class AsyncVersionsResource(AsyncAPIResource):
         if not uuid:
             raise ValueError(f"Expected a non-empty value for `uuid` but received {uuid!r}")
         return await self._get(
-            f"/v2/gen-ai/agents/{uuid}/versions",
+            f"/v2/gen-ai/agents/{uuid}/versions"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{uuid}/versions",
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,

do_gradientai/resources/chat/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .chat import (
+    ChatResource,
+    AsyncChatResource,
+    ChatResourceWithRawResponse,
+    AsyncChatResourceWithRawResponse,
+    ChatResourceWithStreamingResponse,
+    AsyncChatResourceWithStreamingResponse,
+)
+from .completions import (
+    CompletionsResource,
+    AsyncCompletionsResource,
+    CompletionsResourceWithRawResponse,
+    AsyncCompletionsResourceWithRawResponse,
+    CompletionsResourceWithStreamingResponse,
+    AsyncCompletionsResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "CompletionsResource",
+    "AsyncCompletionsResource",
+    "CompletionsResourceWithRawResponse",
+    "AsyncCompletionsResourceWithRawResponse",
+    "CompletionsResourceWithStreamingResponse",
+    "AsyncCompletionsResourceWithStreamingResponse",
+    "ChatResource",
+    "AsyncChatResource",
+    "ChatResourceWithRawResponse",
+    "AsyncChatResourceWithRawResponse",
+    "ChatResourceWithStreamingResponse",
+    "AsyncChatResourceWithStreamingResponse",
+]

do_gradientai/resources/chat/chat.py

@@ -0,0 +1,102 @@
+# 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 .completions import (
+    CompletionsResource,
+    AsyncCompletionsResource,
+    CompletionsResourceWithRawResponse,
+    AsyncCompletionsResourceWithRawResponse,
+    CompletionsResourceWithStreamingResponse,
+    AsyncCompletionsResourceWithStreamingResponse,
+)
+
+__all__ = ["ChatResource", "AsyncChatResource"]
+
+
+class ChatResource(SyncAPIResource):
+    @cached_property
+    def completions(self) -> CompletionsResource:
+        return CompletionsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> ChatResourceWithRawResponse:
+        """
+        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/gradientai-python#accessing-raw-response-data-eg-headers
+        """
+        return ChatResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ChatResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/digitalocean/gradientai-python#with_streaming_response
+        """
+        return ChatResourceWithStreamingResponse(self)
+
+
+class AsyncChatResource(AsyncAPIResource):
+    @cached_property
+    def completions(self) -> AsyncCompletionsResource:
+        return AsyncCompletionsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncChatResourceWithRawResponse:
+        """
+        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/gradientai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncChatResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncChatResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/digitalocean/gradientai-python#with_streaming_response
+        """
+        return AsyncChatResourceWithStreamingResponse(self)
+
+
+class ChatResourceWithRawResponse:
+    def __init__(self, chat: ChatResource) -> None:
+        self._chat = chat
+
+    @cached_property
+    def completions(self) -> CompletionsResourceWithRawResponse:
+        return CompletionsResourceWithRawResponse(self._chat.completions)
+
+
+class AsyncChatResourceWithRawResponse:
+    def __init__(self, chat: AsyncChatResource) -> None:
+        self._chat = chat
+
+    @cached_property
+    def completions(self) -> AsyncCompletionsResourceWithRawResponse:
+        return AsyncCompletionsResourceWithRawResponse(self._chat.completions)
+
+
+class ChatResourceWithStreamingResponse:
+    def __init__(self, chat: ChatResource) -> None:
+        self._chat = chat
+
+    @cached_property
+    def completions(self) -> CompletionsResourceWithStreamingResponse:
+        return CompletionsResourceWithStreamingResponse(self._chat.completions)
+
+
+class AsyncChatResourceWithStreamingResponse:
+    def __init__(self, chat: AsyncChatResource) -> None:
+        self._chat = chat
+
+    @cached_property
+    def completions(self) -> AsyncCompletionsResourceWithStreamingResponse:
+        return AsyncCompletionsResourceWithStreamingResponse(self._chat.completions)

digitalocean_genai_sdk/resources/chat.py → do_gradientai/resources/chat/completions.py

@@ -6,47 +6,47 @@ from typing import Dict, List, Union, Iterable, Optional
 
 import httpx
 
-from ..types import chat_create_completion_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 (
+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.chat_create_completion_response import ChatCreateCompletionResponse
+from ...types.chat import completion_create_params
+from ..._base_client import make_request_options
+from ...types.chat.completion_create_response import CompletionCreateResponse
 
-__all__ = ["ChatResource", "AsyncChatResource"]
+__all__ = ["CompletionsResource", "AsyncCompletionsResource"]
 
 
-class ChatResource(SyncAPIResource):
+class CompletionsResource(SyncAPIResource):
     @cached_property
-    def with_raw_response(self) -> ChatResourceWithRawResponse:
+    def with_raw_response(self) -> CompletionsResourceWithRawResponse:
         """
         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
+        For more information, see https://www.github.com/digitalocean/gradientai-python#accessing-raw-response-data-eg-headers
         """
-        return ChatResourceWithRawResponse(self)
+        return CompletionsResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> ChatResourceWithStreamingResponse:
+    def with_streaming_response(self) -> CompletionsResourceWithStreamingResponse:
         """
         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
+        For more information, see https://www.github.com/digitalocean/gradientai-python#with_streaming_response
         """
-        return ChatResourceWithStreamingResponse(self)
+        return CompletionsResourceWithStreamingResponse(self)
 
-    def create_completion(
+    def create(
         self,
         *,
-        messages: Iterable[chat_create_completion_params.Message],
+        messages: Iterable[completion_create_params.Message],
         model: str,
         frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
         logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
@@ -58,7 +58,7 @@ class ChatResource(SyncAPIResource):
         presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
         stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
         stream: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[chat_create_completion_params.StreamOptions] | NotGiven = NOT_GIVEN,
+        stream_options: Optional[completion_create_params.StreamOptions] | NotGiven = NOT_GIVEN,
         temperature: Optional[float] | NotGiven = NOT_GIVEN,
         top_logprobs: Optional[int] | NotGiven = NOT_GIVEN,
         top_p: Optional[float] | NotGiven = NOT_GIVEN,
@@ -69,7 +69,7 @@ class ChatResource(SyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> ChatCreateCompletionResponse:
+    ) -> CompletionCreateResponse:
         """
         Creates a model response for the given chat conversation.
 
@@ -153,8 +153,19 @@ class ChatResource(SyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
+
+        # This method requires an inference_key to be set via client argument or environment variable
+        if not self._client.inference_key:
+            raise TypeError(
+                "Could not resolve authentication method. Expected the inference_key to be set for chat completions."
+            )
+        headers = extra_headers or {}
+        headers = {"Authorization": f"Bearer {self._client.inference_key}", **headers}
+
         return self._post(
-            "/chat/completions",
+            "/chat/completions"
+            if self._client._base_url_overridden
+            else "https://inference.do-ai.run/v1/chat/completions",
             body=maybe_transform(
                 {
                     "messages": messages,
@@ -175,39 +186,39 @@ class ChatResource(SyncAPIResource):
                     "top_p": top_p,
                     "user": user,
                 },
-                chat_create_completion_params.ChatCreateCompletionParams,
+                completion_create_params.CompletionCreateParams,
             ),
             options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                extra_headers=headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=ChatCreateCompletionResponse,
+            cast_to=CompletionCreateResponse,
         )
 
 
-class AsyncChatResource(AsyncAPIResource):
+class AsyncCompletionsResource(AsyncAPIResource):
     @cached_property
-    def with_raw_response(self) -> AsyncChatResourceWithRawResponse:
+    def with_raw_response(self) -> AsyncCompletionsResourceWithRawResponse:
         """
         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
+        For more information, see https://www.github.com/digitalocean/gradientai-python#accessing-raw-response-data-eg-headers
         """
-        return AsyncChatResourceWithRawResponse(self)
+        return AsyncCompletionsResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> AsyncChatResourceWithStreamingResponse:
+    def with_streaming_response(self) -> AsyncCompletionsResourceWithStreamingResponse:
         """
         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
+        For more information, see https://www.github.com/digitalocean/gradientai-python#with_streaming_response
         """
-        return AsyncChatResourceWithStreamingResponse(self)
+        return AsyncCompletionsResourceWithStreamingResponse(self)
 
-    async def create_completion(
+    async def create(
         self,
         *,
-        messages: Iterable[chat_create_completion_params.Message],
+        messages: Iterable[completion_create_params.Message],
         model: str,
         frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
         logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
@@ -219,7 +230,7 @@ class AsyncChatResource(AsyncAPIResource):
         presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
         stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
         stream: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[chat_create_completion_params.StreamOptions] | NotGiven = NOT_GIVEN,
+        stream_options: Optional[completion_create_params.StreamOptions] | NotGiven = NOT_GIVEN,
         temperature: Optional[float] | NotGiven = NOT_GIVEN,
         top_logprobs: Optional[int] | NotGiven = NOT_GIVEN,
         top_p: Optional[float] | NotGiven = NOT_GIVEN,
@@ -230,7 +241,7 @@ class AsyncChatResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> ChatCreateCompletionResponse:
+    ) -> CompletionCreateResponse:
         """
         Creates a model response for the given chat conversation.
 
@@ -314,8 +325,19 @@ class AsyncChatResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
+
+        # This method requires an inference_key to be set via client argument or environment variable
+        if not hasattr(self._client, "inference_key") or not self._client.inference_key:
+            raise TypeError(
+                "Could not resolve authentication method. Expected the inference_key to be set for chat completions."
+            )
+        headers = extra_headers or {}
+        headers = {"Authorization": f"Bearer {self._client.inference_key}", **headers}
+
         return await self._post(
-            "/chat/completions",
+            "/chat/completions"
+            if self._client._base_url_overridden
+            else "https://inference.do-ai.run/v1/chat/completions",
             body=await async_maybe_transform(
                 {
                     "messages": messages,
@@ -336,46 +358,46 @@ class AsyncChatResource(AsyncAPIResource):
                     "top_p": top_p,
                     "user": user,
                 },
-                chat_create_completion_params.ChatCreateCompletionParams,
+                completion_create_params.CompletionCreateParams,
             ),
             options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                extra_headers=headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=ChatCreateCompletionResponse,
+            cast_to=CompletionCreateResponse,
         )
 
 
-class ChatResourceWithRawResponse:
-    def __init__(self, chat: ChatResource) -> None:
-        self._chat = chat
+class CompletionsResourceWithRawResponse:
+    def __init__(self, completions: CompletionsResource) -> None:
+        self._completions = completions
 
-        self.create_completion = to_raw_response_wrapper(
-            chat.create_completion,
+        self.create = to_raw_response_wrapper(
+            completions.create,
         )
 
 
-class AsyncChatResourceWithRawResponse:
-    def __init__(self, chat: AsyncChatResource) -> None:
-        self._chat = chat
+class AsyncCompletionsResourceWithRawResponse:
+    def __init__(self, completions: AsyncCompletionsResource) -> None:
+        self._completions = completions
 
-        self.create_completion = async_to_raw_response_wrapper(
-            chat.create_completion,
+        self.create = async_to_raw_response_wrapper(
+            completions.create,
         )
 
 
-class ChatResourceWithStreamingResponse:
-    def __init__(self, chat: ChatResource) -> None:
-        self._chat = chat
+class CompletionsResourceWithStreamingResponse:
+    def __init__(self, completions: CompletionsResource) -> None:
+        self._completions = completions
 
-        self.create_completion = to_streamed_response_wrapper(
-            chat.create_completion,
+        self.create = to_streamed_response_wrapper(
+            completions.create,
         )
 
 
-class AsyncChatResourceWithStreamingResponse:
-    def __init__(self, chat: AsyncChatResource) -> None:
-        self._chat = chat
+class AsyncCompletionsResourceWithStreamingResponse:
+    def __init__(self, completions: AsyncCompletionsResource) -> None:
+        self._completions = completions
 
-        self.create_completion = async_to_streamed_response_wrapper(
-            chat.create_completion,
+        self.create = async_to_streamed_response_wrapper(
+            completions.create,
         )

{digitalocean_genai_sdk/resources/api_keys → do_gradientai/resources/inference}/__init__.py

@@ -8,6 +8,14 @@ from .api_keys import (
     APIKeysResourceWithStreamingResponse,
     AsyncAPIKeysResourceWithStreamingResponse,
 )
+from .inference import (
+    InferenceResource,
+    AsyncInferenceResource,
+    InferenceResourceWithRawResponse,
+    AsyncInferenceResourceWithRawResponse,
+    InferenceResourceWithStreamingResponse,
+    AsyncInferenceResourceWithStreamingResponse,
+)
 
 __all__ = [
     "APIKeysResource",
@@ -16,4 +24,10 @@ __all__ = [
     "AsyncAPIKeysResourceWithRawResponse",
     "APIKeysResourceWithStreamingResponse",
     "AsyncAPIKeysResourceWithStreamingResponse",
+    "InferenceResource",
+    "AsyncInferenceResource",
+    "InferenceResourceWithRawResponse",
+    "AsyncInferenceResourceWithRawResponse",
+    "InferenceResourceWithStreamingResponse",
+    "AsyncInferenceResourceWithStreamingResponse",
 ]