feat(api): update via SDK Studio

Author: stainless-app[bot]

.stats.yml

@@ -1,4 +1,4 @@
 configured_endpoints: 174
 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/digitalocean%2Fgradient-40c154e2fdc4fef9ca1cf8329c29b7102bf324acfc9589571d6f3452d1ca579c.yml
 openapi_spec_hash: 83a3d092965fde776b29b61f785459f9
-config_hash: ddab0a714b26eb4a0ed28df928df0b05
+config_hash: 3752c9f438752ab61938a8921bb3befd

api.md

@@ -18,6 +18,9 @@ from gradient.types import (
     GarbageCollection,
     GPUInfo,
     Image,
+    ImageGenCompletedEvent,
+    ImageGenPartialImageEvent,
+    ImageGenStreamEvent,
     Kernel,
     MetaProperties,
     NetworkV4,

src/gradient/resources/images/generations.py

@@ -41,8 +41,11 @@
     GarbageCollection as GarbageCollection,
     FirewallRuleTarget as FirewallRuleTarget,
     ChatCompletionChunk as ChatCompletionChunk,
+    ImageGenStreamEvent as ImageGenStreamEvent,
     SubscriptionTierBase as SubscriptionTierBase,
+    ImageGenCompletedEvent as ImageGenCompletedEvent,
     DropletNextBackupWindow as DropletNextBackupWindow,
+    ImageGenPartialImageEvent as ImageGenPartialImageEvent,
     ChatCompletionTokenLogprob as ChatCompletionTokenLogprob,
 )
 from .api_agent import APIAgent as APIAgent

src/gradient/types/__init__.py

@@ -2,13 +2,13 @@
 
 from __future__ import annotations
 
-from typing import Optional
-from typing_extensions import Required, TypedDict
+from typing import Union, Optional
+from typing_extensions import Literal, Required, TypedDict
 
-__all__ = ["GenerationCreateParams"]
+__all__ = ["GenerationCreateParamsBase", "GenerationCreateParamsNonStreaming", "GenerationCreateParamsStreaming"]
 
 
-class GenerationCreateParams(TypedDict, total=False):
+class GenerationCreateParamsBase(TypedDict, total=False):
     prompt: Required[str]
     """A text description of the desired image(s).
 
@@ -70,16 +70,31 @@ class GenerationCreateParams(TypedDict, total=False):
     (landscape), 1024x1536 (portrait).
     """
 
-    stream: Optional[bool]
+    user: Optional[str]
+    """
+    A unique identifier representing your end-user, which can help DigitalOcean to
+    monitor and detect abuse.
+    """
+
+
+class GenerationCreateParamsNonStreaming(GenerationCreateParamsBase, total=False):
+    stream: Optional[Literal[False]]
     """
     If set to true, partial image data will be streamed as the image is being
     generated. When streaming, the response will be sent as server-sent events with
     partial image chunks. When stream is true, partial_images must be greater
     than 0.
     """
 
-    user: Optional[str]
+
+class GenerationCreateParamsStreaming(GenerationCreateParamsBase):
+    stream: Required[Literal[True]]
     """
-    A unique identifier representing your end-user, which can help DigitalOcean to
-    monitor and detect abuse.
+    If set to true, partial image data will be streamed as the image is being
+    generated. When streaming, the response will be sent as server-sent events with
+    partial image chunks. When stream is true, partial_images must be greater
+    than 0.
     """
+
+
+GenerationCreateParams = Union[GenerationCreateParamsNonStreaming, GenerationCreateParamsStreaming]

src/gradient/types/images/generation_create_params.py

@@ -24,6 +24,9 @@
 from .garbage_collection import GarbageCollection as GarbageCollection
 from .firewall_rule_target import FirewallRuleTarget as FirewallRuleTarget
 from .chat_completion_chunk import ChatCompletionChunk as ChatCompletionChunk
+from .image_gen_stream_event import ImageGenStreamEvent as ImageGenStreamEvent
 from .subscription_tier_base import SubscriptionTierBase as SubscriptionTierBase
+from .image_gen_completed_event import ImageGenCompletedEvent as ImageGenCompletedEvent
 from .droplet_next_backup_window import DropletNextBackupWindow as DropletNextBackupWindow
 from .chat_completion_token_logprob import ChatCompletionTokenLogprob as ChatCompletionTokenLogprob
+from .image_gen_partial_image_event import ImageGenPartialImageEvent as ImageGenPartialImageEvent

src/gradient/types/shared/__init__.py

@@ -0,0 +1,55 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ImageGenCompletedEvent", "Usage", "UsageInputTokensDetails"]
+
+
+class UsageInputTokensDetails(BaseModel):
+    image_tokens: int
+    """The number of image tokens in the input prompt."""
+
+    text_tokens: int
+    """The number of text tokens in the input prompt."""
+
+
+class Usage(BaseModel):
+    input_tokens: int
+    """The number of tokens (images and text) in the input prompt."""
+
+    input_tokens_details: UsageInputTokensDetails
+    """The input tokens detailed information for the image generation."""
+
+    output_tokens: int
+    """The number of image tokens in the output image."""
+
+    total_tokens: int
+    """The total number of tokens (images and text) used for the image generation."""
+
+
+class ImageGenCompletedEvent(BaseModel):
+    b64_json: str
+    """Base64-encoded image data, suitable for rendering as an image."""
+
+    background: Literal["transparent", "opaque", "auto"]
+    """The background setting for the generated image."""
+
+    created_at: int
+    """The Unix timestamp when the event was created."""
+
+    output_format: Literal["png", "webp", "jpeg"]
+    """The output format for the generated image."""
+
+    quality: Literal["low", "medium", "high", "auto"]
+    """The quality setting for the generated image."""
+
+    size: Literal["1024x1024", "1024x1536", "1536x1024", "auto"]
+    """The size of the generated image."""
+
+    type: Literal["image_generation.completed"]
+    """The type of the event. Always `image_generation.completed`."""
+
+    usage: Usage
+    """For `gpt-image-1` only, the token usage information for the image generation."""

src/gradient/types/shared/image_gen_completed_event.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ImageGenPartialImageEvent"]
+
+
+class ImageGenPartialImageEvent(BaseModel):
+    b64_json: str
+    """Base64-encoded partial image data, suitable for rendering as an image."""
+
+    background: Literal["transparent", "opaque", "auto"]
+    """The background setting for the requested image."""
+
+    created_at: int
+    """The Unix timestamp when the event was created."""
+
+    output_format: Literal["png", "webp", "jpeg"]
+    """The output format for the requested image."""
+
+    partial_image_index: int
+    """0-based index for the partial image (streaming)."""
+
+    quality: Literal["low", "medium", "high", "auto"]
+    """The quality setting for the requested image."""
+
+    size: Literal["1024x1024", "1024x1536", "1536x1024", "auto"]
+    """The size of the requested image."""
+
+    type: Literal["image_generation.partial_image"]
+    """The type of the event. Always `image_generation.partial_image`."""

src/gradient/types/shared/image_gen_partial_image_event.py

@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from .image_gen_completed_event import ImageGenCompletedEvent
+from .image_gen_partial_image_event import ImageGenPartialImageEvent
+
+__all__ = ["ImageGenStreamEvent"]
+
+ImageGenStreamEvent: TypeAlias = Annotated[
+    Union[ImageGenPartialImageEvent, ImageGenCompletedEvent], PropertyInfo(discriminator="type")
+]

src/gradient/types/shared/image_gen_stream_event.py

@@ -19,15 +19,15 @@ class TestGenerations:
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
-    def test_method_create(self, client: Gradient) -> None:
+    def test_method_create_overload_1(self, client: Gradient) -> None:
         generation = client.images.generations.create(
             prompt="A cute baby sea otter floating on its back in calm blue water",
         )
         assert_matches_type(GenerationCreateResponse, generation, path=["response"])
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
-    def test_method_create_with_all_params(self, client: Gradient) -> None:
+    def test_method_create_with_all_params_overload_1(self, client: Gradient) -> None:
         generation = client.images.generations.create(
             prompt="A cute baby sea otter floating on its back in calm blue water",
             background="auto",
@@ -46,7 +46,7 @@ def test_method_create_with_all_params(self, client: Gradient) -> None:
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
-    def test_raw_response_create(self, client: Gradient) -> None:
+    def test_raw_response_create_overload_1(self, client: Gradient) -> None:
         response = client.images.generations.with_raw_response.create(
             prompt="A cute baby sea otter floating on its back in calm blue water",
         )
@@ -58,7 +58,7 @@ def test_raw_response_create(self, client: Gradient) -> None:
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
-    def test_streaming_response_create(self, client: Gradient) -> None:
+    def test_streaming_response_create_overload_1(self, client: Gradient) -> None:
         with client.images.generations.with_streaming_response.create(
             prompt="A cute baby sea otter floating on its back in calm blue water",
         ) as response:
@@ -70,6 +70,61 @@ def test_streaming_response_create(self, client: Gradient) -> None:
 
         assert cast(Any, response.is_closed) is True
 
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    def test_method_create_overload_2(self, client: Gradient) -> None:
+        generation_stream = client.images.generations.create(
+            prompt="A cute baby sea otter floating on its back in calm blue water",
+            stream=True,
+        )
+        generation_stream.response.close()
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    def test_method_create_with_all_params_overload_2(self, client: Gradient) -> None:
+        generation_stream = client.images.generations.create(
+            prompt="A cute baby sea otter floating on its back in calm blue water",
+            stream=True,
+            background="auto",
+            model="openai-gpt-image-1",
+            moderation="auto",
+            n=1,
+            output_compression=100,
+            output_format="png",
+            partial_images=1,
+            quality="auto",
+            size="auto",
+            user="user-1234",
+        )
+        generation_stream.response.close()
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    def test_raw_response_create_overload_2(self, client: Gradient) -> None:
+        response = client.images.generations.with_raw_response.create(
+            prompt="A cute baby sea otter floating on its back in calm blue water",
+            stream=True,
+        )
+
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        stream = response.parse()
+        stream.close()
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    def test_streaming_response_create_overload_2(self, client: Gradient) -> None:
+        with client.images.generations.with_streaming_response.create(
+            prompt="A cute baby sea otter floating on its back in calm blue water",
+            stream=True,
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            stream = response.parse()
+            stream.close()
+
+        assert cast(Any, response.is_closed) is True
+
 
 class TestAsyncGenerations:
     parametrize = pytest.mark.parametrize(
@@ -78,15 +133,15 @@ class TestAsyncGenerations:
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
-    async def test_method_create(self, async_client: AsyncGradient) -> None:
+    async def test_method_create_overload_1(self, async_client: AsyncGradient) -> None:
         generation = await async_client.images.generations.create(
             prompt="A cute baby sea otter floating on its back in calm blue water",
         )
         assert_matches_type(GenerationCreateResponse, generation, path=["response"])
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
-    async def test_method_create_with_all_params(self, async_client: AsyncGradient) -> None:
+    async def test_method_create_with_all_params_overload_1(self, async_client: AsyncGradient) -> None:
         generation = await async_client.images.generations.create(
             prompt="A cute baby sea otter floating on its back in calm blue water",
             background="auto",
@@ -105,7 +160,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncGradient)
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
-    async def test_raw_response_create(self, async_client: AsyncGradient) -> None:
+    async def test_raw_response_create_overload_1(self, async_client: AsyncGradient) -> None:
         response = await async_client.images.generations.with_raw_response.create(
             prompt="A cute baby sea otter floating on its back in calm blue water",
         )
@@ -117,7 +172,7 @@ async def test_raw_response_create(self, async_client: AsyncGradient) -> None:
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
-    async def test_streaming_response_create(self, async_client: AsyncGradient) -> None:
+    async def test_streaming_response_create_overload_1(self, async_client: AsyncGradient) -> None:
         async with async_client.images.generations.with_streaming_response.create(
             prompt="A cute baby sea otter floating on its back in calm blue water",
         ) as response:
@@ -128,3 +183,58 @@ async def test_streaming_response_create(self, async_client: AsyncGradient) -> N
             assert_matches_type(GenerationCreateResponse, generation, path=["response"])
 
         assert cast(Any, response.is_closed) is True
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    async def test_method_create_overload_2(self, async_client: AsyncGradient) -> None:
+        generation_stream = await async_client.images.generations.create(
+            prompt="A cute baby sea otter floating on its back in calm blue water",
+            stream=True,
+        )
+        await generation_stream.response.aclose()
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    async def test_method_create_with_all_params_overload_2(self, async_client: AsyncGradient) -> None:
+        generation_stream = await async_client.images.generations.create(
+            prompt="A cute baby sea otter floating on its back in calm blue water",
+            stream=True,
+            background="auto",
+            model="openai-gpt-image-1",
+            moderation="auto",
+            n=1,
+            output_compression=100,
+            output_format="png",
+            partial_images=1,
+            quality="auto",
+            size="auto",
+            user="user-1234",
+        )
+        await generation_stream.response.aclose()
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    async def test_raw_response_create_overload_2(self, async_client: AsyncGradient) -> None:
+        response = await async_client.images.generations.with_raw_response.create(
+            prompt="A cute baby sea otter floating on its back in calm blue water",
+            stream=True,
+        )
+
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        stream = await response.parse()
+        await stream.close()
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    async def test_streaming_response_create_overload_2(self, async_client: AsyncGradient) -> None:
+        async with async_client.images.generations.with_streaming_response.create(
+            prompt="A cute baby sea otter floating on its back in calm blue water",
+            stream=True,
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            stream = await response.parse()
+            await stream.close()
+
+        assert cast(Any, response.is_closed) is True