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

gradientai/resources/{providers → model_providers}/anthropic/keys.py

@@ -15,13 +15,18 @@ from ...._response import (
     async_to_streamed_response_wrapper,
 )
 from ...._base_client import make_request_options
-from ....types.providers.anthropic import key_list_params, key_create_params, key_update_params, key_list_agents_params
-from ....types.providers.anthropic.key_list_response import KeyListResponse
-from ....types.providers.anthropic.key_create_response import KeyCreateResponse
-from ....types.providers.anthropic.key_delete_response import KeyDeleteResponse
-from ....types.providers.anthropic.key_update_response import KeyUpdateResponse
-from ....types.providers.anthropic.key_retrieve_response import KeyRetrieveResponse
-from ....types.providers.anthropic.key_list_agents_response import KeyListAgentsResponse
+from ....types.model_providers.anthropic import (
+    key_list_params,
+    key_create_params,
+    key_update_params,
+    key_list_agents_params,
+)
+from ....types.model_providers.anthropic.key_list_response import KeyListResponse
+from ....types.model_providers.anthropic.key_create_response import KeyCreateResponse
+from ....types.model_providers.anthropic.key_delete_response import KeyDeleteResponse
+from ....types.model_providers.anthropic.key_update_response import KeyUpdateResponse
+from ....types.model_providers.anthropic.key_retrieve_response import KeyRetrieveResponse
+from ....types.model_providers.anthropic.key_list_agents_response import KeyListAgentsResponse
 
 __all__ = ["KeysResource", "AsyncKeysResource"]
 

gradientai/resources/{providers/providers.py → model_providers/model_providers.py}

@@ -21,10 +21,10 @@ from .anthropic.anthropic import (
     AsyncAnthropicResourceWithStreamingResponse,
 )
 
-__all__ = ["ProvidersResource", "AsyncProvidersResource"]
+__all__ = ["ModelProvidersResource", "AsyncModelProvidersResource"]
 
 
-class ProvidersResource(SyncAPIResource):
+class ModelProvidersResource(SyncAPIResource):
     @cached_property
     def anthropic(self) -> AnthropicResource:
         return AnthropicResource(self._client)
@@ -34,26 +34,26 @@ class ProvidersResource(SyncAPIResource):
         return OpenAIResource(self._client)
 
     @cached_property
-    def with_raw_response(self) -> ProvidersResourceWithRawResponse:
+    def with_raw_response(self) -> ModelProvidersResourceWithRawResponse:
         """
         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 ProvidersResourceWithRawResponse(self)
+        return ModelProvidersResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> ProvidersResourceWithStreamingResponse:
+    def with_streaming_response(self) -> ModelProvidersResourceWithStreamingResponse:
         """
         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 ProvidersResourceWithStreamingResponse(self)
+        return ModelProvidersResourceWithStreamingResponse(self)
 
 
-class AsyncProvidersResource(AsyncAPIResource):
+class AsyncModelProvidersResource(AsyncAPIResource):
     @cached_property
     def anthropic(self) -> AsyncAnthropicResource:
         return AsyncAnthropicResource(self._client)
@@ -63,72 +63,72 @@ class AsyncProvidersResource(AsyncAPIResource):
         return AsyncOpenAIResource(self._client)
 
     @cached_property
-    def with_raw_response(self) -> AsyncProvidersResourceWithRawResponse:
+    def with_raw_response(self) -> AsyncModelProvidersResourceWithRawResponse:
         """
         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 AsyncProvidersResourceWithRawResponse(self)
+        return AsyncModelProvidersResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> AsyncProvidersResourceWithStreamingResponse:
+    def with_streaming_response(self) -> AsyncModelProvidersResourceWithStreamingResponse:
         """
         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 AsyncProvidersResourceWithStreamingResponse(self)
+        return AsyncModelProvidersResourceWithStreamingResponse(self)
 
 
-class ProvidersResourceWithRawResponse:
-    def __init__(self, providers: ProvidersResource) -> None:
-        self._providers = providers
+class ModelProvidersResourceWithRawResponse:
+    def __init__(self, model_providers: ModelProvidersResource) -> None:
+        self._model_providers = model_providers
 
     @cached_property
     def anthropic(self) -> AnthropicResourceWithRawResponse:
-        return AnthropicResourceWithRawResponse(self._providers.anthropic)
+        return AnthropicResourceWithRawResponse(self._model_providers.anthropic)
 
     @cached_property
     def openai(self) -> OpenAIResourceWithRawResponse:
-        return OpenAIResourceWithRawResponse(self._providers.openai)
+        return OpenAIResourceWithRawResponse(self._model_providers.openai)
 
 
-class AsyncProvidersResourceWithRawResponse:
-    def __init__(self, providers: AsyncProvidersResource) -> None:
-        self._providers = providers
+class AsyncModelProvidersResourceWithRawResponse:
+    def __init__(self, model_providers: AsyncModelProvidersResource) -> None:
+        self._model_providers = model_providers
 
     @cached_property
     def anthropic(self) -> AsyncAnthropicResourceWithRawResponse:
-        return AsyncAnthropicResourceWithRawResponse(self._providers.anthropic)
+        return AsyncAnthropicResourceWithRawResponse(self._model_providers.anthropic)
 
     @cached_property
     def openai(self) -> AsyncOpenAIResourceWithRawResponse:
-        return AsyncOpenAIResourceWithRawResponse(self._providers.openai)
+        return AsyncOpenAIResourceWithRawResponse(self._model_providers.openai)
 
 
-class ProvidersResourceWithStreamingResponse:
-    def __init__(self, providers: ProvidersResource) -> None:
-        self._providers = providers
+class ModelProvidersResourceWithStreamingResponse:
+    def __init__(self, model_providers: ModelProvidersResource) -> None:
+        self._model_providers = model_providers
 
     @cached_property
     def anthropic(self) -> AnthropicResourceWithStreamingResponse:
-        return AnthropicResourceWithStreamingResponse(self._providers.anthropic)
+        return AnthropicResourceWithStreamingResponse(self._model_providers.anthropic)
 
     @cached_property
     def openai(self) -> OpenAIResourceWithStreamingResponse:
-        return OpenAIResourceWithStreamingResponse(self._providers.openai)
+        return OpenAIResourceWithStreamingResponse(self._model_providers.openai)
 
 
-class AsyncProvidersResourceWithStreamingResponse:
-    def __init__(self, providers: AsyncProvidersResource) -> None:
-        self._providers = providers
+class AsyncModelProvidersResourceWithStreamingResponse:
+    def __init__(self, model_providers: AsyncModelProvidersResource) -> None:
+        self._model_providers = model_providers
 
     @cached_property
     def anthropic(self) -> AsyncAnthropicResourceWithStreamingResponse:
-        return AsyncAnthropicResourceWithStreamingResponse(self._providers.anthropic)
+        return AsyncAnthropicResourceWithStreamingResponse(self._model_providers.anthropic)
 
     @cached_property
     def openai(self) -> AsyncOpenAIResourceWithStreamingResponse:
-        return AsyncOpenAIResourceWithStreamingResponse(self._providers.openai)
+        return AsyncOpenAIResourceWithStreamingResponse(self._model_providers.openai)

gradientai/resources/{providers → model_providers}/openai/keys.py

@@ -15,13 +15,18 @@ from ...._response import (
     async_to_streamed_response_wrapper,
 )
 from ...._base_client import make_request_options
-from ....types.providers.openai import key_list_params, key_create_params, key_update_params, key_retrieve_agents_params
-from ....types.providers.openai.key_list_response import KeyListResponse
-from ....types.providers.openai.key_create_response import KeyCreateResponse
-from ....types.providers.openai.key_delete_response import KeyDeleteResponse
-from ....types.providers.openai.key_update_response import KeyUpdateResponse
-from ....types.providers.openai.key_retrieve_response import KeyRetrieveResponse
-from ....types.providers.openai.key_retrieve_agents_response import KeyRetrieveAgentsResponse
+from ....types.model_providers.openai import (
+    key_list_params,
+    key_create_params,
+    key_update_params,
+    key_retrieve_agents_params,
+)
+from ....types.model_providers.openai.key_list_response import KeyListResponse
+from ....types.model_providers.openai.key_create_response import KeyCreateResponse
+from ....types.model_providers.openai.key_delete_response import KeyDeleteResponse
+from ....types.model_providers.openai.key_update_response import KeyUpdateResponse
+from ....types.model_providers.openai.key_retrieve_response import KeyRetrieveResponse
+from ....types.model_providers.openai.key_retrieve_agents_response import KeyRetrieveAgentsResponse
 
 __all__ = ["KeysResource", "AsyncKeysResource"]
 

gradientai/resources/models.py

@@ -2,14 +2,9 @@
 
 from __future__ import annotations
 
-from typing import List
-from typing_extensions import Literal
-
 import httpx
 
-from ..types import model_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 (
@@ -18,6 +13,7 @@ from .._response import (
     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
 
@@ -44,52 +40,22 @@ class ModelsResource(SyncAPIResource):
         """
         return ModelsResourceWithStreamingResponse(self)
 
-    def list(
+    def retrieve(
         self,
+        model: str,
         *,
-        page: int | NotGiven = NOT_GIVEN,
-        per_page: int | NotGiven = NOT_GIVEN,
-        public_only: bool | NotGiven = NOT_GIVEN,
-        usecases: List[
-            Literal[
-                "MODEL_USECASE_UNKNOWN",
-                "MODEL_USECASE_AGENT",
-                "MODEL_USECASE_FINETUNED",
-                "MODEL_USECASE_KNOWLEDGEBASE",
-                "MODEL_USECASE_GUARDRAIL",
-                "MODEL_USECASE_REASONING",
-                "MODEL_USECASE_SERVERLESS",
-            ]
-        ]
-        | 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,
-    ) -> ModelListResponse:
+    ) -> Model:
         """
-        To list all models, send a GET request to `/v2/gen-ai/models`.
+        Retrieves a model instance, providing basic information about the model such as
+        the owner and permissioning.
 
         Args:
-          page: page number.
-
-          per_page: items per page.
-
-          public_only: only include models that are publicly available.
-
-          usecases: include only models defined for the listed usecases.
-
-              - MODEL_USECASE_UNKNOWN: The use case of the model is unknown
-              - MODEL_USECASE_AGENT: The model maybe used in an agent
-              - MODEL_USECASE_FINETUNED: The model maybe used for fine tuning
-              - MODEL_USECASE_KNOWLEDGEBASE: The model maybe used for knowledge bases
-                (embedding models)
-              - MODEL_USECASE_GUARDRAIL: The model maybe used for guardrails
-              - MODEL_USECASE_REASONING: The model usecase for reasoning
-              - MODEL_USECASE_SERVERLESS: The model usecase for serverless inference
-
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -98,24 +64,36 @@ class ModelsResource(SyncAPIResource):
 
           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(
-            "/v2/gen-ai/models"
+            f"/models/{model}"
             if self._client._base_url_overridden
-            else "https://api.digitalocean.com/v2/gen-ai/models",
+            else f"https://inference.do-ai.run/v1/models/{model}",
             options=make_request_options(
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
-                query=maybe_transform(
-                    {
-                        "page": page,
-                        "per_page": per_page,
-                        "public_only": public_only,
-                        "usecases": usecases,
-                    },
-                    model_list_params.ModelListParams,
-                ),
+                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" if self._client._base_url_overridden else "https://inference.do-ai.run/v1/models",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
             cast_to=ModelListResponse,
         )
@@ -141,52 +119,22 @@ class AsyncModelsResource(AsyncAPIResource):
         """
         return AsyncModelsResourceWithStreamingResponse(self)
 
-    async def list(
+    async def retrieve(
         self,
+        model: str,
         *,
-        page: int | NotGiven = NOT_GIVEN,
-        per_page: int | NotGiven = NOT_GIVEN,
-        public_only: bool | NotGiven = NOT_GIVEN,
-        usecases: List[
-            Literal[
-                "MODEL_USECASE_UNKNOWN",
-                "MODEL_USECASE_AGENT",
-                "MODEL_USECASE_FINETUNED",
-                "MODEL_USECASE_KNOWLEDGEBASE",
-                "MODEL_USECASE_GUARDRAIL",
-                "MODEL_USECASE_REASONING",
-                "MODEL_USECASE_SERVERLESS",
-            ]
-        ]
-        | 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,
-    ) -> ModelListResponse:
+    ) -> Model:
         """
-        To list all models, send a GET request to `/v2/gen-ai/models`.
+        Retrieves a model instance, providing basic information about the model such as
+        the owner and permissioning.
 
         Args:
-          page: page number.
-
-          per_page: items per page.
-
-          public_only: only include models that are publicly available.
-
-          usecases: include only models defined for the listed usecases.
-
-              - MODEL_USECASE_UNKNOWN: The use case of the model is unknown
-              - MODEL_USECASE_AGENT: The model maybe used in an agent
-              - MODEL_USECASE_FINETUNED: The model maybe used for fine tuning
-              - MODEL_USECASE_KNOWLEDGEBASE: The model maybe used for knowledge bases
-                (embedding models)
-              - MODEL_USECASE_GUARDRAIL: The model maybe used for guardrails
-              - MODEL_USECASE_REASONING: The model usecase for reasoning
-              - MODEL_USECASE_SERVERLESS: The model usecase for serverless inference
-
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -195,24 +143,36 @@ class AsyncModelsResource(AsyncAPIResource):
 
           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(
-            "/v2/gen-ai/models"
+            f"/models/{model}"
             if self._client._base_url_overridden
-            else "https://api.digitalocean.com/v2/gen-ai/models",
+            else f"https://inference.do-ai.run/v1/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" if self._client._base_url_overridden else "https://inference.do-ai.run/v1/models",
             options=make_request_options(
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
-                query=await async_maybe_transform(
-                    {
-                        "page": page,
-                        "per_page": per_page,
-                        "public_only": public_only,
-                        "usecases": usecases,
-                    },
-                    model_list_params.ModelListParams,
-                ),
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
             cast_to=ModelListResponse,
         )
@@ -222,6 +182,9 @@ 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,
         )
@@ -231,6 +194,9 @@ 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,
         )
@@ -240,6 +206,9 @@ 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,
         )
@@ -249,6 +218,9 @@ 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,
         )

gradientai/resources/regions.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 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/gradientai-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/gradientai-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/gen-ai/regions"
+            if self._client._base_url_overridden
+            else "https://api.digitalocean.com/v2/gen-ai/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/gradientai-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/gradientai-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/gen-ai/regions"
+            if self._client._base_url_overridden
+            else "https://api.digitalocean.com/v2/gen-ai/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,
+        )