together 1.5.35__py3-none-any.whl → 2.0.0a6__py3-none-any.whl

together/{utils → lib/utils}/tools.py

@@ -1,11 +1,8 @@
 from __future__ import annotations
 
-import logging
 import os
+import logging
 from datetime import datetime
-import re
-from typing import Any
-
 
 logger = logging.getLogger("together")
 
@@ -25,67 +22,18 @@ def normalize_key(key: str) -> str:
     return key.replace("/", "--").replace("_", "-").replace(" ", "-").lower()
 
 
-def parse_timestamp(timestamp: str) -> datetime | None:
-    """Parse a timestamp string into a datetime object or None if the string is empty.
-
-    Args:
-        timestamp (str): Timestamp
-
-    Returns:
-        datetime | None: Parsed datetime, or None if the string is empty
-    """
-    if timestamp == "":
-        return None
-
+def parse_timestamp(timestamp: str) -> datetime:
     formats = ["%Y-%m-%dT%H:%M:%S.%fZ", "%Y-%m-%dT%H:%M:%SZ"]
     for fmt in formats:
         try:
             return datetime.strptime(timestamp, fmt)
         except ValueError:
             continue
-
     raise ValueError("Timestamp does not match any expected format")
 
 
-def format_timestamp(timestamp_str: str) -> str:
-    """Format timestamp to a readable date string.
-
-    Args:
-        timestamp: A timestamp string
-
-    Returns:
-        str: Formatted timestamp string (MM/DD/YYYY, HH:MM AM/PM)
-    """
-    timestamp = parse_timestamp(timestamp_str)
-    if timestamp is None:
-        return ""
-    return timestamp.strftime("%m/%d/%Y, %I:%M %p")
-
-
-def get_event_step(event: Any) -> str | None:
-    """Extract the step number from a checkpoint event.
-
-    Args:
-        event: A checkpoint event object
-
-    Returns:
-        str | None: The step number as a string, or None if not found
-    """
-    step = getattr(event, "step", None)
-    if step is not None:
-        return str(step)
-    return None
-
-
+# Convert fine-tune nano-dollar price to dollars
 def finetune_price_to_dollars(price: float) -> float:
-    """Convert fine-tuning job price to dollars
-
-    Args:
-        price (float): Fine-tuning job price in billing units
-
-    Returns:
-        float: Price in dollars
-    """
     return price / NANODOLLAR
 
 
@@ -124,3 +72,19 @@ def convert_unix_timestamp(timestamp: int) -> str:
     iso_format = dt_object.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
 
     return iso_format
+
+
+def format_timestamp(timestamp_str: str) -> str:
+    """Format timestamp to a readable date string.
+
+    Args:
+        timestamp: A timestamp string
+
+    Returns:
+        str: Formatted timestamp string (MM/DD/YYYY, HH:MM AM/PM)
+    """
+    try:
+        timestamp = parse_timestamp(timestamp_str)
+        return timestamp.strftime("%m/%d/%Y, %I:%M %p")
+    except ValueError:
+        return ""

together/resources/__init__.py

@@ -1,43 +1,229 @@
-from together.resources.audio import AsyncAudio, Audio
-from together.resources.chat import AsyncChat, Chat
-from together.resources.completions import AsyncCompletions, Completions
-from together.resources.embeddings import AsyncEmbeddings, Embeddings
-from together.resources.endpoints import AsyncEndpoints, Endpoints
-from together.resources.files import AsyncFiles, Files
-from together.resources.finetune import AsyncFineTuning, FineTuning
-from together.resources.images import AsyncImages, Images
-from together.resources.models import AsyncModels, Models
-from together.resources.rerank import AsyncRerank, Rerank
-from together.resources.batch import Batches, AsyncBatches
-from together.resources.evaluation import Evaluation, AsyncEvaluation
-from together.resources.videos import AsyncVideos, Videos
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from .chat import (
+    ChatResource,
+    AsyncChatResource,
+    ChatResourceWithRawResponse,
+    AsyncChatResourceWithRawResponse,
+    ChatResourceWithStreamingResponse,
+    AsyncChatResourceWithStreamingResponse,
+)
+from .jobs import (
+    JobsResource,
+    AsyncJobsResource,
+    JobsResourceWithRawResponse,
+    AsyncJobsResourceWithRawResponse,
+    JobsResourceWithStreamingResponse,
+    AsyncJobsResourceWithStreamingResponse,
+)
+from .audio import (
+    AudioResource,
+    AsyncAudioResource,
+    AudioResourceWithRawResponse,
+    AsyncAudioResourceWithRawResponse,
+    AudioResourceWithStreamingResponse,
+    AsyncAudioResourceWithStreamingResponse,
+)
+from .evals import (
+    EvalsResource,
+    AsyncEvalsResource,
+    EvalsResourceWithRawResponse,
+    AsyncEvalsResourceWithRawResponse,
+    EvalsResourceWithStreamingResponse,
+    AsyncEvalsResourceWithStreamingResponse,
+)
+from .files import (
+    FilesResource,
+    AsyncFilesResource,
+    FilesResourceWithRawResponse,
+    AsyncFilesResourceWithRawResponse,
+    FilesResourceWithStreamingResponse,
+    AsyncFilesResourceWithStreamingResponse,
+)
+from .images import (
+    ImagesResource,
+    AsyncImagesResource,
+    ImagesResourceWithRawResponse,
+    AsyncImagesResourceWithRawResponse,
+    ImagesResourceWithStreamingResponse,
+    AsyncImagesResourceWithStreamingResponse,
+)
+from .models import (
+    ModelsResource,
+    AsyncModelsResource,
+    ModelsResourceWithRawResponse,
+    AsyncModelsResourceWithRawResponse,
+    ModelsResourceWithStreamingResponse,
+    AsyncModelsResourceWithStreamingResponse,
+)
+from .rerank import (
+    RerankResource,
+    AsyncRerankResource,
+    RerankResourceWithRawResponse,
+    AsyncRerankResourceWithRawResponse,
+    RerankResourceWithStreamingResponse,
+    AsyncRerankResourceWithStreamingResponse,
+)
+from .videos import (
+    VideosResource,
+    AsyncVideosResource,
+    VideosResourceWithRawResponse,
+    AsyncVideosResourceWithRawResponse,
+    VideosResourceWithStreamingResponse,
+    AsyncVideosResourceWithStreamingResponse,
+)
+from .batches import (
+    BatchesResource,
+    AsyncBatchesResource,
+    BatchesResourceWithRawResponse,
+    AsyncBatchesResourceWithRawResponse,
+    BatchesResourceWithStreamingResponse,
+    AsyncBatchesResourceWithStreamingResponse,
+)
+from .hardware import (
+    HardwareResource,
+    AsyncHardwareResource,
+    HardwareResourceWithRawResponse,
+    AsyncHardwareResourceWithRawResponse,
+    HardwareResourceWithStreamingResponse,
+    AsyncHardwareResourceWithStreamingResponse,
+)
+from .endpoints import (
+    EndpointsResource,
+    AsyncEndpointsResource,
+    EndpointsResourceWithRawResponse,
+    AsyncEndpointsResourceWithRawResponse,
+    EndpointsResourceWithStreamingResponse,
+    AsyncEndpointsResourceWithStreamingResponse,
+)
+from .embeddings import (
+    EmbeddingsResource,
+    AsyncEmbeddingsResource,
+    EmbeddingsResourceWithRawResponse,
+    AsyncEmbeddingsResourceWithRawResponse,
+    EmbeddingsResourceWithStreamingResponse,
+    AsyncEmbeddingsResourceWithStreamingResponse,
+)
+from .completions import (
+    CompletionsResource,
+    AsyncCompletionsResource,
+    CompletionsResourceWithRawResponse,
+    AsyncCompletionsResourceWithRawResponse,
+    CompletionsResourceWithStreamingResponse,
+    AsyncCompletionsResourceWithStreamingResponse,
+)
+from .fine_tuning import (
+    FineTuningResource,
+    AsyncFineTuningResource,
+    FineTuningResourceWithRawResponse,
+    AsyncFineTuningResourceWithRawResponse,
+    FineTuningResourceWithStreamingResponse,
+    AsyncFineTuningResourceWithStreamingResponse,
+)
+from .code_interpreter import (
+    CodeInterpreterResource,
+    AsyncCodeInterpreterResource,
+    CodeInterpreterResourceWithRawResponse,
+    AsyncCodeInterpreterResourceWithRawResponse,
+    CodeInterpreterResourceWithStreamingResponse,
+    AsyncCodeInterpreterResourceWithStreamingResponse,
+)
 
 __all__ = [
-    "AsyncCompletions",
-    "Completions",
-    "AsyncChat",
-    "Chat",
-    "AsyncEmbeddings",
-    "Embeddings",
-    "AsyncFineTuning",
-    "FineTuning",
-    "AsyncFiles",
-    "Files",
-    "AsyncImages",
-    "Images",
-    "AsyncModels",
-    "Models",
-    "AsyncRerank",
-    "Rerank",
-    "AsyncAudio",
-    "Audio",
-    "AsyncEndpoints",
-    "Endpoints",
-    "Batches",
-    "AsyncBatches",
-    "Evaluation",
-    "AsyncEvaluation",
-    "AsyncVideos",
-    "Videos",
+    "ChatResource",
+    "AsyncChatResource",
+    "ChatResourceWithRawResponse",
+    "AsyncChatResourceWithRawResponse",
+    "ChatResourceWithStreamingResponse",
+    "AsyncChatResourceWithStreamingResponse",
+    "CompletionsResource",
+    "AsyncCompletionsResource",
+    "CompletionsResourceWithRawResponse",
+    "AsyncCompletionsResourceWithRawResponse",
+    "CompletionsResourceWithStreamingResponse",
+    "AsyncCompletionsResourceWithStreamingResponse",
+    "EmbeddingsResource",
+    "AsyncEmbeddingsResource",
+    "EmbeddingsResourceWithRawResponse",
+    "AsyncEmbeddingsResourceWithRawResponse",
+    "EmbeddingsResourceWithStreamingResponse",
+    "AsyncEmbeddingsResourceWithStreamingResponse",
+    "FilesResource",
+    "AsyncFilesResource",
+    "FilesResourceWithRawResponse",
+    "AsyncFilesResourceWithRawResponse",
+    "FilesResourceWithStreamingResponse",
+    "AsyncFilesResourceWithStreamingResponse",
+    "FineTuningResource",
+    "AsyncFineTuningResource",
+    "FineTuningResourceWithRawResponse",
+    "AsyncFineTuningResourceWithRawResponse",
+    "FineTuningResourceWithStreamingResponse",
+    "AsyncFineTuningResourceWithStreamingResponse",
+    "CodeInterpreterResource",
+    "AsyncCodeInterpreterResource",
+    "CodeInterpreterResourceWithRawResponse",
+    "AsyncCodeInterpreterResourceWithRawResponse",
+    "CodeInterpreterResourceWithStreamingResponse",
+    "AsyncCodeInterpreterResourceWithStreamingResponse",
+    "ImagesResource",
+    "AsyncImagesResource",
+    "ImagesResourceWithRawResponse",
+    "AsyncImagesResourceWithRawResponse",
+    "ImagesResourceWithStreamingResponse",
+    "AsyncImagesResourceWithStreamingResponse",
+    "VideosResource",
+    "AsyncVideosResource",
+    "VideosResourceWithRawResponse",
+    "AsyncVideosResourceWithRawResponse",
+    "VideosResourceWithStreamingResponse",
+    "AsyncVideosResourceWithStreamingResponse",
+    "AudioResource",
+    "AsyncAudioResource",
+    "AudioResourceWithRawResponse",
+    "AsyncAudioResourceWithRawResponse",
+    "AudioResourceWithStreamingResponse",
+    "AsyncAudioResourceWithStreamingResponse",
+    "ModelsResource",
+    "AsyncModelsResource",
+    "ModelsResourceWithRawResponse",
+    "AsyncModelsResourceWithRawResponse",
+    "ModelsResourceWithStreamingResponse",
+    "AsyncModelsResourceWithStreamingResponse",
+    "JobsResource",
+    "AsyncJobsResource",
+    "JobsResourceWithRawResponse",
+    "AsyncJobsResourceWithRawResponse",
+    "JobsResourceWithStreamingResponse",
+    "AsyncJobsResourceWithStreamingResponse",
+    "EndpointsResource",
+    "AsyncEndpointsResource",
+    "EndpointsResourceWithRawResponse",
+    "AsyncEndpointsResourceWithRawResponse",
+    "EndpointsResourceWithStreamingResponse",
+    "AsyncEndpointsResourceWithStreamingResponse",
+    "HardwareResource",
+    "AsyncHardwareResource",
+    "HardwareResourceWithRawResponse",
+    "AsyncHardwareResourceWithRawResponse",
+    "HardwareResourceWithStreamingResponse",
+    "AsyncHardwareResourceWithStreamingResponse",
+    "RerankResource",
+    "AsyncRerankResource",
+    "RerankResourceWithRawResponse",
+    "AsyncRerankResourceWithRawResponse",
+    "RerankResourceWithStreamingResponse",
+    "AsyncRerankResourceWithStreamingResponse",
+    "BatchesResource",
+    "AsyncBatchesResource",
+    "BatchesResourceWithRawResponse",
+    "AsyncBatchesResourceWithRawResponse",
+    "BatchesResourceWithStreamingResponse",
+    "AsyncBatchesResourceWithStreamingResponse",
+    "EvalsResource",
+    "AsyncEvalsResource",
+    "EvalsResourceWithRawResponse",
+    "AsyncEvalsResourceWithRawResponse",
+    "EvalsResourceWithStreamingResponse",
+    "AsyncEvalsResourceWithStreamingResponse",
 ]

together/resources/audio/__init__.py

@@ -1,51 +1,75 @@
-from functools import cached_property
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from together.resources.audio.speech import AsyncSpeech, Speech
-from together.resources.audio.transcriptions import AsyncTranscriptions, Transcriptions
-from together.resources.audio.translations import AsyncTranslations, Translations
-from together.resources.audio.voices import AsyncVoices, Voices
-from together.types import (
-    TogetherClient,
+from .audio import (
+    AudioResource,
+    AsyncAudioResource,
+    AudioResourceWithRawResponse,
+    AsyncAudioResourceWithRawResponse,
+    AudioResourceWithStreamingResponse,
+    AsyncAudioResourceWithStreamingResponse,
+)
+from .speech import (
+    SpeechResource,
+    AsyncSpeechResource,
+    SpeechResourceWithRawResponse,
+    AsyncSpeechResourceWithRawResponse,
+    SpeechResourceWithStreamingResponse,
+    AsyncSpeechResourceWithStreamingResponse,
+)
+from .voices import (
+    VoicesResource,
+    AsyncVoicesResource,
+    VoicesResourceWithRawResponse,
+    AsyncVoicesResourceWithRawResponse,
+    VoicesResourceWithStreamingResponse,
+    AsyncVoicesResourceWithStreamingResponse,
+)
+from .translations import (
+    TranslationsResource,
+    AsyncTranslationsResource,
+    TranslationsResourceWithRawResponse,
+    AsyncTranslationsResourceWithRawResponse,
+    TranslationsResourceWithStreamingResponse,
+    AsyncTranslationsResourceWithStreamingResponse,
+)
+from .transcriptions import (
+    TranscriptionsResource,
+    AsyncTranscriptionsResource,
+    TranscriptionsResourceWithRawResponse,
+    AsyncTranscriptionsResourceWithRawResponse,
+    TranscriptionsResourceWithStreamingResponse,
+    AsyncTranscriptionsResourceWithStreamingResponse,
 )
 
-
-class Audio:
-    def __init__(self, client: TogetherClient) -> None:
-        self._client = client
-
-    @cached_property
-    def speech(self) -> Speech:
-        return Speech(self._client)
-
-    @cached_property
-    def transcriptions(self) -> Transcriptions:
-        return Transcriptions(self._client)
-
-    @cached_property
-    def translations(self) -> Translations:
-        return Translations(self._client)
-
-    @cached_property
-    def voices(self) -> Voices:
-        return Voices(self._client)
-
-
-class AsyncAudio:
-    def __init__(self, client: TogetherClient) -> None:
-        self._client = client
-
-    @cached_property
-    def speech(self) -> AsyncSpeech:
-        return AsyncSpeech(self._client)
-
-    @cached_property
-    def transcriptions(self) -> AsyncTranscriptions:
-        return AsyncTranscriptions(self._client)
-
-    @cached_property
-    def translations(self) -> AsyncTranslations:
-        return AsyncTranslations(self._client)
-
-    @cached_property
-    def voices(self) -> AsyncVoices:
-        return AsyncVoices(self._client)
+__all__ = [
+    "SpeechResource",
+    "AsyncSpeechResource",
+    "SpeechResourceWithRawResponse",
+    "AsyncSpeechResourceWithRawResponse",
+    "SpeechResourceWithStreamingResponse",
+    "AsyncSpeechResourceWithStreamingResponse",
+    "VoicesResource",
+    "AsyncVoicesResource",
+    "VoicesResourceWithRawResponse",
+    "AsyncVoicesResourceWithRawResponse",
+    "VoicesResourceWithStreamingResponse",
+    "AsyncVoicesResourceWithStreamingResponse",
+    "TranscriptionsResource",
+    "AsyncTranscriptionsResource",
+    "TranscriptionsResourceWithRawResponse",
+    "AsyncTranscriptionsResourceWithRawResponse",
+    "TranscriptionsResourceWithStreamingResponse",
+    "AsyncTranscriptionsResourceWithStreamingResponse",
+    "TranslationsResource",
+    "AsyncTranslationsResource",
+    "TranslationsResourceWithRawResponse",
+    "AsyncTranslationsResourceWithRawResponse",
+    "TranslationsResourceWithStreamingResponse",
+    "AsyncTranslationsResourceWithStreamingResponse",
+    "AudioResource",
+    "AsyncAudioResource",
+    "AudioResourceWithRawResponse",
+    "AsyncAudioResourceWithRawResponse",
+    "AudioResourceWithStreamingResponse",
+    "AsyncAudioResourceWithStreamingResponse",
+]

together/resources/audio/audio.py

@@ -0,0 +1,198 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .speech import (
+    SpeechResource,
+    AsyncSpeechResource,
+    SpeechResourceWithRawResponse,
+    AsyncSpeechResourceWithRawResponse,
+    SpeechResourceWithStreamingResponse,
+    AsyncSpeechResourceWithStreamingResponse,
+)
+from .voices import (
+    VoicesResource,
+    AsyncVoicesResource,
+    VoicesResourceWithRawResponse,
+    AsyncVoicesResourceWithRawResponse,
+    VoicesResourceWithStreamingResponse,
+    AsyncVoicesResourceWithStreamingResponse,
+)
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from .translations import (
+    TranslationsResource,
+    AsyncTranslationsResource,
+    TranslationsResourceWithRawResponse,
+    AsyncTranslationsResourceWithRawResponse,
+    TranslationsResourceWithStreamingResponse,
+    AsyncTranslationsResourceWithStreamingResponse,
+)
+from .transcriptions import (
+    TranscriptionsResource,
+    AsyncTranscriptionsResource,
+    TranscriptionsResourceWithRawResponse,
+    AsyncTranscriptionsResourceWithRawResponse,
+    TranscriptionsResourceWithStreamingResponse,
+    AsyncTranscriptionsResourceWithStreamingResponse,
+)
+
+__all__ = ["AudioResource", "AsyncAudioResource"]
+
+
+class AudioResource(SyncAPIResource):
+    @cached_property
+    def speech(self) -> SpeechResource:
+        return SpeechResource(self._client)
+
+    @cached_property
+    def voices(self) -> VoicesResource:
+        return VoicesResource(self._client)
+
+    @cached_property
+    def transcriptions(self) -> TranscriptionsResource:
+        return TranscriptionsResource(self._client)
+
+    @cached_property
+    def translations(self) -> TranslationsResource:
+        return TranslationsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AudioResourceWithRawResponse:
+        """
+        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/togethercomputer/together-py#accessing-raw-response-data-eg-headers
+        """
+        return AudioResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AudioResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/togethercomputer/together-py#with_streaming_response
+        """
+        return AudioResourceWithStreamingResponse(self)
+
+
+class AsyncAudioResource(AsyncAPIResource):
+    @cached_property
+    def speech(self) -> AsyncSpeechResource:
+        return AsyncSpeechResource(self._client)
+
+    @cached_property
+    def voices(self) -> AsyncVoicesResource:
+        return AsyncVoicesResource(self._client)
+
+    @cached_property
+    def transcriptions(self) -> AsyncTranscriptionsResource:
+        return AsyncTranscriptionsResource(self._client)
+
+    @cached_property
+    def translations(self) -> AsyncTranslationsResource:
+        return AsyncTranslationsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncAudioResourceWithRawResponse:
+        """
+        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/togethercomputer/together-py#accessing-raw-response-data-eg-headers
+        """
+        return AsyncAudioResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncAudioResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/togethercomputer/together-py#with_streaming_response
+        """
+        return AsyncAudioResourceWithStreamingResponse(self)
+
+
+class AudioResourceWithRawResponse:
+    def __init__(self, audio: AudioResource) -> None:
+        self._audio = audio
+
+    @cached_property
+    def speech(self) -> SpeechResourceWithRawResponse:
+        return SpeechResourceWithRawResponse(self._audio.speech)
+
+    @cached_property
+    def voices(self) -> VoicesResourceWithRawResponse:
+        return VoicesResourceWithRawResponse(self._audio.voices)
+
+    @cached_property
+    def transcriptions(self) -> TranscriptionsResourceWithRawResponse:
+        return TranscriptionsResourceWithRawResponse(self._audio.transcriptions)
+
+    @cached_property
+    def translations(self) -> TranslationsResourceWithRawResponse:
+        return TranslationsResourceWithRawResponse(self._audio.translations)
+
+
+class AsyncAudioResourceWithRawResponse:
+    def __init__(self, audio: AsyncAudioResource) -> None:
+        self._audio = audio
+
+    @cached_property
+    def speech(self) -> AsyncSpeechResourceWithRawResponse:
+        return AsyncSpeechResourceWithRawResponse(self._audio.speech)
+
+    @cached_property
+    def voices(self) -> AsyncVoicesResourceWithRawResponse:
+        return AsyncVoicesResourceWithRawResponse(self._audio.voices)
+
+    @cached_property
+    def transcriptions(self) -> AsyncTranscriptionsResourceWithRawResponse:
+        return AsyncTranscriptionsResourceWithRawResponse(self._audio.transcriptions)
+
+    @cached_property
+    def translations(self) -> AsyncTranslationsResourceWithRawResponse:
+        return AsyncTranslationsResourceWithRawResponse(self._audio.translations)
+
+
+class AudioResourceWithStreamingResponse:
+    def __init__(self, audio: AudioResource) -> None:
+        self._audio = audio
+
+    @cached_property
+    def speech(self) -> SpeechResourceWithStreamingResponse:
+        return SpeechResourceWithStreamingResponse(self._audio.speech)
+
+    @cached_property
+    def voices(self) -> VoicesResourceWithStreamingResponse:
+        return VoicesResourceWithStreamingResponse(self._audio.voices)
+
+    @cached_property
+    def transcriptions(self) -> TranscriptionsResourceWithStreamingResponse:
+        return TranscriptionsResourceWithStreamingResponse(self._audio.transcriptions)
+
+    @cached_property
+    def translations(self) -> TranslationsResourceWithStreamingResponse:
+        return TranslationsResourceWithStreamingResponse(self._audio.translations)
+
+
+class AsyncAudioResourceWithStreamingResponse:
+    def __init__(self, audio: AsyncAudioResource) -> None:
+        self._audio = audio
+
+    @cached_property
+    def speech(self) -> AsyncSpeechResourceWithStreamingResponse:
+        return AsyncSpeechResourceWithStreamingResponse(self._audio.speech)
+
+    @cached_property
+    def voices(self) -> AsyncVoicesResourceWithStreamingResponse:
+        return AsyncVoicesResourceWithStreamingResponse(self._audio.voices)
+
+    @cached_property
+    def transcriptions(self) -> AsyncTranscriptionsResourceWithStreamingResponse:
+        return AsyncTranscriptionsResourceWithStreamingResponse(self._audio.transcriptions)
+
+    @cached_property
+    def translations(self) -> AsyncTranslationsResourceWithStreamingResponse:
+        return AsyncTranslationsResourceWithStreamingResponse(self._audio.translations)