together 1.5.19__tar.gz → 1.5.21__tar.gz

{together-1.5.19 → together-1.5.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: together
-Version: 1.5.19
+Version: 1.5.21
 Summary: Python client for Together's Cloud Platform!
 License: Apache-2.0
 Author: Together AI

{together-1.5.19 → together-1.5.21}/pyproject.toml

@@ -12,7 +12,7 @@ build-backend = "poetry.masonry.api"
 
 [tool.poetry]
 name = "together"
-version = "1.5.19"
+version = "1.5.21"
 authors = ["Together AI <support@together.ai>"]
 description = "Python client for Together's Cloud Platform!"
 readme = "README.md"

{together-1.5.19 → together-1.5.21}/src/together/client.py

@@ -103,6 +103,7 @@ class AsyncTogether:
     models: resources.AsyncModels
     fine_tuning: resources.AsyncFineTuning
     rerank: resources.AsyncRerank
+    audio: resources.AsyncAudio
     code_interpreter: CodeInterpreter
     batches: resources.AsyncBatches
     # client options
@@ -167,6 +168,7 @@ class AsyncTogether:
         self.models = resources.AsyncModels(self.client)
         self.fine_tuning = resources.AsyncFineTuning(self.client)
         self.rerank = resources.AsyncRerank(self.client)
+        self.audio = resources.AsyncAudio(self.client)
         self.code_interpreter = CodeInterpreter(self.client)
         self.batches = resources.AsyncBatches(self.client)
 

together-1.5.21/src/together/resources/audio/__init__.py

@@ -0,0 +1,42 @@
+from functools import cached_property
+
+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.types import (
+    TogetherClient,
+)
+
+
+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)
+
+
+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)

together-1.5.21/src/together/resources/audio/transcriptions.py

@@ -0,0 +1,266 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, BinaryIO, Dict, Optional, Tuple, Union
+
+from together.abstract import api_requestor
+from together.types import (
+    AudioTimestampGranularities,
+    AudioTranscriptionResponse,
+    AudioTranscriptionResponseFormat,
+    AudioTranscriptionVerboseResponse,
+    TogetherClient,
+    TogetherRequest,
+)
+
+
+class Transcriptions:
+    def __init__(self, client: TogetherClient) -> None:
+        self._client = client
+
+    def create(
+        self,
+        *,
+        file: Union[str, BinaryIO, Path],
+        model: str = "openai/whisper-large-v3",
+        language: Optional[str] = None,
+        prompt: Optional[str] = None,
+        response_format: Union[str, AudioTranscriptionResponseFormat] = "json",
+        temperature: float = 0.0,
+        timestamp_granularities: Optional[
+            Union[str, AudioTimestampGranularities]
+        ] = None,
+        **kwargs: Any,
+    ) -> Union[AudioTranscriptionResponse, AudioTranscriptionVerboseResponse]:
+        """
+        Transcribes audio into the input language.
+
+        Args:
+            file: The audio file object (not file name) to transcribe, in one of these formats:
+                flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
+                Can be a file path (str/Path), file object (BinaryIO), or URL (str).
+            model: ID of the model to use. Defaults to "openai/whisper-large-v3".
+            language: The language of the input audio. Supplying the input language in
+                ISO-639-1 format will improve accuracy and latency.
+            prompt: An optional text to guide the model's style or continue a previous
+                audio segment. The prompt should match the audio language.
+            response_format: The format of the transcript output, in one of these options:
+                json, verbose_json.
+            temperature: The sampling temperature, between 0 and 1. Higher values like 0.8
+                will make the output more random, while lower values like 0.2 will make it
+                more focused and deterministic.
+            timestamp_granularities: The timestamp granularities to populate for this
+                transcription. response_format must be set verbose_json to use timestamp
+                granularities. Either or both of these options are supported: word, or segment.
+
+        Returns:
+            The transcribed text in the requested format.
+        """
+
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        # Handle file input - could be a path, URL, or file object
+        files_data: Dict[str, Union[Tuple[None, str], BinaryIO]] = {}
+        params_data = {}
+
+        if isinstance(file, (str, Path)):
+            if isinstance(file, str) and file.startswith(("http://", "https://")):
+                # URL string - send as multipart field
+                files_data["file"] = (None, file)
+            else:
+                # Local file path
+                file_path = Path(file)
+                files_data["file"] = open(file_path, "rb")
+        else:
+            # File object
+            files_data["file"] = file
+
+        # Build request parameters
+        params_data.update(
+            {
+                "model": model,
+                "response_format": (
+                    response_format.value
+                    if hasattr(response_format, "value")
+                    else response_format
+                ),
+                "temperature": temperature,
+            }
+        )
+
+        if language is not None:
+            params_data["language"] = language
+
+        if prompt is not None:
+            params_data["prompt"] = prompt
+
+        if timestamp_granularities is not None:
+            params_data["timestamp_granularities"] = (
+                timestamp_granularities.value
+                if hasattr(timestamp_granularities, "value")
+                else timestamp_granularities
+            )
+
+        # Add any additional kwargs
+        params_data.update(kwargs)
+
+        try:
+            response, _, _ = requestor.request(
+                options=TogetherRequest(
+                    method="POST",
+                    url="audio/transcriptions",
+                    params=params_data,
+                    files=files_data,
+                ),
+            )
+        finally:
+            # Close file if we opened it
+            if files_data and "file" in files_data:
+                try:
+                    # Only close if it's a file object (not a tuple for URL)
+                    file_obj = files_data["file"]
+                    if hasattr(file_obj, "close") and not isinstance(file_obj, tuple):
+                        file_obj.close()
+                except:
+                    pass
+
+        # Parse response based on format
+        if (
+            response_format == "verbose_json"
+            or response_format == AudioTranscriptionResponseFormat.VERBOSE_JSON
+        ):
+            return AudioTranscriptionVerboseResponse(**response.data)
+        else:
+            return AudioTranscriptionResponse(**response.data)
+
+
+class AsyncTranscriptions:
+    def __init__(self, client: TogetherClient) -> None:
+        self._client = client
+
+    async def create(
+        self,
+        *,
+        file: Union[str, BinaryIO, Path],
+        model: str = "openai/whisper-large-v3",
+        language: Optional[str] = None,
+        prompt: Optional[str] = None,
+        response_format: Union[str, AudioTranscriptionResponseFormat] = "json",
+        temperature: float = 0.0,
+        timestamp_granularities: Optional[
+            Union[str, AudioTimestampGranularities]
+        ] = None,
+        **kwargs: Any,
+    ) -> Union[AudioTranscriptionResponse, AudioTranscriptionVerboseResponse]:
+        """
+        Async version of transcribe audio into the input language.
+
+        Args:
+            file: The audio file object (not file name) to transcribe, in one of these formats:
+                flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
+                Can be a file path (str/Path), file object (BinaryIO), or URL (str).
+            model: ID of the model to use. Defaults to "openai/whisper-large-v3".
+            language: The language of the input audio. Supplying the input language in
+                ISO-639-1 format will improve accuracy and latency.
+            prompt: An optional text to guide the model's style or continue a previous
+                audio segment. The prompt should match the audio language.
+            response_format: The format of the transcript output, in one of these options:
+                json, verbose_json.
+            temperature: The sampling temperature, between 0 and 1. Higher values like 0.8
+                will make the output more random, while lower values like 0.2 will make it
+                more focused and deterministic.
+            timestamp_granularities: The timestamp granularities to populate for this
+                transcription. response_format must be set verbose_json to use timestamp
+                granularities. Either or both of these options are supported: word, or segment.
+
+        Returns:
+            The transcribed text in the requested format.
+        """
+
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        # Handle file input - could be a path, URL, or file object
+        files_data: Dict[str, Union[Tuple[None, str], BinaryIO]] = {}
+        params_data = {}
+
+        if isinstance(file, (str, Path)):
+            if isinstance(file, str) and file.startswith(("http://", "https://")):
+                # URL string - send as multipart field
+                files_data["file"] = (None, file)
+            else:
+                # Local file path
+                file_path = Path(file)
+                files_data["file"] = open(file_path, "rb")
+        else:
+            # File object
+            files_data["file"] = file
+
+        # Build request parameters
+        params_data.update(
+            {
+                "model": model,
+                "response_format": (
+                    response_format
+                    if isinstance(response_format, str)
+                    else (
+                        response_format.value
+                        if hasattr(response_format, "value")
+                        else response_format
+                    )
+                ),
+                "temperature": temperature,
+            }
+        )
+
+        if language is not None:
+            params_data["language"] = language
+
+        if prompt is not None:
+            params_data["prompt"] = prompt
+
+        if timestamp_granularities is not None:
+            params_data["timestamp_granularities"] = (
+                timestamp_granularities
+                if isinstance(timestamp_granularities, str)
+                else (
+                    timestamp_granularities.value
+                    if hasattr(timestamp_granularities, "value")
+                    else timestamp_granularities
+                )
+            )
+
+        # Add any additional kwargs
+        params_data.update(kwargs)
+
+        try:
+            response, _, _ = await requestor.arequest(
+                options=TogetherRequest(
+                    method="POST",
+                    url="audio/transcriptions",
+                    params=params_data,
+                    files=files_data,
+                ),
+            )
+        finally:
+            # Close file if we opened it
+            if files_data and "file" in files_data:
+                try:
+                    # Only close if it's a file object (not a tuple for URL)
+                    file_obj = files_data["file"]
+                    if hasattr(file_obj, "close") and not isinstance(file_obj, tuple):
+                        file_obj.close()
+                except:
+                    pass
+
+        # Parse response based on format
+        if (
+            response_format == "verbose_json"
+            or response_format == AudioTranscriptionResponseFormat.VERBOSE_JSON
+        ):
+            return AudioTranscriptionVerboseResponse(**response.data)
+        else:
+            return AudioTranscriptionResponse(**response.data)

together-1.5.21/src/together/resources/audio/translations.py

@@ -0,0 +1,276 @@
+from __future__ import annotations
+
+from typing import Any, Union, BinaryIO, Optional, Dict, Tuple
+from pathlib import Path
+
+from together.abstract import api_requestor
+from together.together_response import TogetherResponse
+from together.types import (
+    AudioTranslationRequest,
+    AudioTranslationResponse,
+    AudioTranslationVerboseResponse,
+    AudioTranscriptionResponseFormat,
+    AudioTimestampGranularities,
+    TogetherClient,
+    TogetherRequest,
+)
+
+
+class Translations:
+    def __init__(self, client: TogetherClient) -> None:
+        self._client = client
+
+    def create(
+        self,
+        *,
+        file: Union[str, BinaryIO, Path],
+        model: str = "openai/whisper-large-v3",
+        language: Optional[str] = None,
+        prompt: Optional[str] = None,
+        response_format: Union[str, AudioTranscriptionResponseFormat] = "json",
+        temperature: float = 0.0,
+        timestamp_granularities: Optional[
+            Union[str, AudioTimestampGranularities]
+        ] = None,
+        **kwargs: Any,
+    ) -> Union[AudioTranslationResponse, AudioTranslationVerboseResponse]:
+        """
+        Translates audio into English.
+
+        Args:
+            file: The audio file object (not file name) to translate, in one of these formats:
+                flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
+                Can be a file path (str/Path), file object (BinaryIO), or URL (str).
+            model: ID of the model to use. Defaults to "openai/whisper-large-v3".
+            language: The language of the input audio. Optional ISO-639-1 language code.
+                If omitted, language is set to English.
+            prompt: An optional text to guide the model's style or continue a previous
+                audio segment. The prompt should be in English.
+            response_format: The format of the transcript output, in one of these options:
+                json, verbose_json.
+            temperature: The sampling temperature, between 0 and 1. Higher values like 0.8
+                will make the output more random, while lower values like 0.2 will make it
+                more focused and deterministic.
+            timestamp_granularities: The timestamp granularities to populate for this
+                translation. response_format must be set verbose_json to use timestamp
+                granularities. Either or both of these options are supported: word, or segment.
+
+        Returns:
+            The translated text in the requested format.
+        """
+
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        # Handle file input - could be a path, URL, or file object
+        files_data: Dict[str, Union[Tuple[None, str], BinaryIO]] = {}
+        params_data = {}
+
+        if isinstance(file, (str, Path)):
+            if isinstance(file, str) and file.startswith(("http://", "https://")):
+                # URL string - send as multipart field
+                files_data["file"] = (None, file)
+            else:
+                # Local file path
+                file_path = Path(file)
+                files_data["file"] = open(file_path, "rb")
+        else:
+            # File object
+            files_data["file"] = file
+
+        # Build request parameters
+        params_data.update(
+            {
+                "model": model,
+                "response_format": (
+                    response_format
+                    if isinstance(response_format, str)
+                    else (
+                        response_format.value
+                        if hasattr(response_format, "value")
+                        else response_format
+                    )
+                ),
+                "temperature": temperature,
+            }
+        )
+
+        if language is not None:
+            params_data["language"] = language
+
+        if prompt is not None:
+            params_data["prompt"] = prompt
+
+        if timestamp_granularities is not None:
+            params_data["timestamp_granularities"] = (
+                timestamp_granularities
+                if isinstance(timestamp_granularities, str)
+                else (
+                    timestamp_granularities.value
+                    if hasattr(timestamp_granularities, "value")
+                    else timestamp_granularities
+                )
+            )
+
+        # Add any additional kwargs
+        params_data.update(kwargs)
+
+        try:
+            response, _, _ = requestor.request(
+                options=TogetherRequest(
+                    method="POST",
+                    url="audio/translations",
+                    params=params_data,
+                    files=files_data,
+                ),
+            )
+        finally:
+            # Close file if we opened it
+            if files_data and "file" in files_data:
+                try:
+                    # Only close if it's a file object (not a tuple for URL)
+                    file_obj = files_data["file"]
+                    if hasattr(file_obj, "close") and not isinstance(file_obj, tuple):
+                        file_obj.close()
+                except:
+                    pass
+
+        # Parse response based on format
+        if (
+            response_format == "verbose_json"
+            or response_format == AudioTranscriptionResponseFormat.VERBOSE_JSON
+        ):
+            return AudioTranslationVerboseResponse(**response.data)
+        else:
+            return AudioTranslationResponse(**response.data)
+
+
+class AsyncTranslations:
+    def __init__(self, client: TogetherClient) -> None:
+        self._client = client
+
+    async def create(
+        self,
+        *,
+        file: Union[str, BinaryIO, Path],
+        model: str = "openai/whisper-large-v3",
+        language: Optional[str] = None,
+        prompt: Optional[str] = None,
+        response_format: Union[str, AudioTranscriptionResponseFormat] = "json",
+        temperature: float = 0.0,
+        timestamp_granularities: Optional[
+            Union[str, AudioTimestampGranularities]
+        ] = None,
+        **kwargs: Any,
+    ) -> Union[AudioTranslationResponse, AudioTranslationVerboseResponse]:
+        """
+        Async version of translate audio into English.
+
+        Args:
+            file: The audio file object (not file name) to translate, in one of these formats:
+                flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
+                Can be a file path (str/Path), file object (BinaryIO), or URL (str).
+            model: ID of the model to use. Defaults to "openai/whisper-large-v3".
+            language: The language of the input audio. Optional ISO-639-1 language code.
+                If omitted, language is set to English.
+            prompt: An optional text to guide the model's style or continue a previous
+                audio segment. The prompt should be in English.
+            response_format: The format of the transcript output, in one of these options:
+                json, verbose_json.
+            temperature: The sampling temperature, between 0 and 1. Higher values like 0.8
+                will make the output more random, while lower values like 0.2 will make it
+                more focused and deterministic.
+            timestamp_granularities: The timestamp granularities to populate for this
+                translation. response_format must be set verbose_json to use timestamp
+                granularities. Either or both of these options are supported: word, or segment.
+
+        Returns:
+            The translated text in the requested format.
+        """
+
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        # Handle file input - could be a path, URL, or file object
+        files_data: Dict[str, Union[Tuple[None, str], BinaryIO]] = {}
+        params_data = {}
+
+        if isinstance(file, (str, Path)):
+            if isinstance(file, str) and file.startswith(("http://", "https://")):
+                # URL string - send as multipart field
+                files_data["file"] = (None, file)
+            else:
+                # Local file path
+                file_path = Path(file)
+                files_data["file"] = open(file_path, "rb")
+        else:
+            # File object
+            files_data["file"] = file
+
+        # Build request parameters
+        params_data.update(
+            {
+                "model": model,
+                "response_format": (
+                    response_format
+                    if isinstance(response_format, str)
+                    else (
+                        response_format.value
+                        if hasattr(response_format, "value")
+                        else response_format
+                    )
+                ),
+                "temperature": temperature,
+            }
+        )
+
+        if language is not None:
+            params_data["language"] = language
+
+        if prompt is not None:
+            params_data["prompt"] = prompt
+
+        if timestamp_granularities is not None:
+            params_data["timestamp_granularities"] = (
+                timestamp_granularities
+                if isinstance(timestamp_granularities, str)
+                else (
+                    timestamp_granularities.value
+                    if hasattr(timestamp_granularities, "value")
+                    else timestamp_granularities
+                )
+            )
+
+        # Add any additional kwargs
+        params_data.update(kwargs)
+
+        try:
+            response, _, _ = await requestor.arequest(
+                options=TogetherRequest(
+                    method="POST",
+                    url="audio/translations",
+                    params=params_data,
+                    files=files_data,
+                ),
+            )
+        finally:
+            # Close file if we opened it
+            if files_data and "file" in files_data:
+                try:
+                    # Only close if it's a file object (not a tuple for URL)
+                    file_obj = files_data["file"]
+                    if hasattr(file_obj, "close") and not isinstance(file_obj, tuple):
+                        file_obj.close()
+                except:
+                    pass
+
+        # Parse response based on format
+        if (
+            response_format == "verbose_json"
+            or response_format == AudioTranscriptionResponseFormat.VERBOSE_JSON
+        ):
+            return AudioTranslationVerboseResponse(**response.data)
+        else:
+            return AudioTranslationResponse(**response.data)

{together-1.5.19 → together-1.5.21}/src/together/types/__init__.py

@@ -7,6 +7,14 @@ from together.types.audio_speech import (
     AudioSpeechStreamChunk,
     AudioSpeechStreamEvent,
     AudioSpeechStreamResponse,
+    AudioTranscriptionRequest,
+    AudioTranslationRequest,
+    AudioTranscriptionResponse,
+    AudioTranscriptionVerboseResponse,
+    AudioTranslationResponse,
+    AudioTranslationVerboseResponse,
+    AudioTranscriptionResponseFormat,
+    AudioTimestampGranularities,
 )
 from together.types.chat_completions import (
     ChatCompletionChunk,
@@ -102,6 +110,14 @@ __all__ = [
     "AudioSpeechStreamChunk",
     "AudioSpeechStreamEvent",
     "AudioSpeechStreamResponse",
+    "AudioTranscriptionRequest",
+    "AudioTranslationRequest",
+    "AudioTranscriptionResponse",
+    "AudioTranscriptionVerboseResponse",
+    "AudioTranslationResponse",
+    "AudioTranslationVerboseResponse",
+    "AudioTranscriptionResponseFormat",
+    "AudioTimestampGranularities",
     "DedicatedEndpoint",
     "ListEndpoint",
     "Autoscaling",

{together-1.5.19 → together-1.5.21}/src/together/types/audio_speech.py

@@ -1,13 +1,12 @@
 from __future__ import annotations
 
+import base64
 from enum import Enum
-from typing import Iterator
-import threading
+from typing import BinaryIO, Iterator, List, Optional, Union
 
 from pydantic import BaseModel, ConfigDict
 
 from together.together_response import TogetherResponse
-import base64
 
 
 class AudioResponseFormat(str, Enum):
@@ -79,23 +78,19 @@ class AudioSpeechStreamEventResponse(BaseModel):
 
 
 class AudioSpeechStreamResponse(BaseModel):
-
     response: TogetherResponse | Iterator[TogetherResponse]
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     def stream_to_file(self, file_path: str) -> None:
-
         if isinstance(self.response, TogetherResponse):
             # save response to file
             with open(file_path, "wb") as f:
                 f.write(self.response.data)
 
         elif isinstance(self.response, Iterator):
-
             with open(file_path, "wb") as f:
                 for chunk in self.response:
-
                     # Try to parse as stream chunk
                     stream_event_response = AudioSpeechStreamEventResponse(
                         response={"data": chunk.data}
@@ -108,3 +103,83 @@ class AudioSpeechStreamResponse(BaseModel):
                     audio = base64.b64decode(stream_event_response.response.data.b64)
 
                     f.write(audio)
+
+
+class AudioTranscriptionResponseFormat(str, Enum):
+    JSON = "json"
+    VERBOSE_JSON = "verbose_json"
+
+
+class AudioTimestampGranularities(str, Enum):
+    SEGMENT = "segment"
+    WORD = "word"
+
+
+class AudioTranscriptionRequest(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    file: Union[str, BinaryIO]
+    model: str = "openai/whisper-large-v3"
+    language: Optional[str] = None
+    prompt: Optional[str] = None
+    response_format: AudioTranscriptionResponseFormat = (
+        AudioTranscriptionResponseFormat.JSON
+    )
+    temperature: float = 0.0
+    timestamp_granularities: Optional[AudioTimestampGranularities] = (
+        AudioTimestampGranularities.SEGMENT
+    )
+
+
+class AudioTranslationRequest(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    file: Union[str, BinaryIO]
+    model: str = "openai/whisper-large-v3"
+    language: Optional[str] = None
+    prompt: Optional[str] = None
+    response_format: AudioTranscriptionResponseFormat = (
+        AudioTranscriptionResponseFormat.JSON
+    )
+    temperature: float = 0.0
+    timestamp_granularities: Optional[AudioTimestampGranularities] = (
+        AudioTimestampGranularities.SEGMENT
+    )
+
+
+class AudioTranscriptionSegment(BaseModel):
+    id: int
+    start: float
+    end: float
+    text: str
+
+
+class AudioTranscriptionWord(BaseModel):
+    word: str
+    start: float
+    end: float
+
+
+class AudioTranscriptionResponse(BaseModel):
+    text: str
+
+
+class AudioTranscriptionVerboseResponse(BaseModel):
+    language: Optional[str] = None
+    duration: Optional[float] = None
+    text: str
+    segments: Optional[List[AudioTranscriptionSegment]] = None
+    words: Optional[List[AudioTranscriptionWord]] = None
+
+
+class AudioTranslationResponse(BaseModel):
+    text: str
+
+
+class AudioTranslationVerboseResponse(BaseModel):
+    task: Optional[str] = None
+    language: Optional[str] = None
+    duration: Optional[float] = None
+    text: str
+    segments: Optional[List[AudioTranscriptionSegment]] = None
+    words: Optional[List[AudioTranscriptionWord]] = None

{together-1.5.19 → together-1.5.21}/src/together/types/models.py

@@ -16,6 +16,7 @@ class ModelType(str, Enum):
     MODERATION = "moderation"
     RERANK = "rerank"
     AUDIO = "audio"
+    TRANSCRIBE = "transcribe"
 
 
 class PricingObject(BaseModel):

together-1.5.19/src/together/resources/audio/__init__.py

@@ -1,24 +0,0 @@
-from functools import cached_property
-
-from together.resources.audio.speech import AsyncSpeech, Speech
-from together.types import (
-    TogetherClient,
-)
-
-
-class Audio:
-    def __init__(self, client: TogetherClient) -> None:
-        self._client = client
-
-    @cached_property
-    def speech(self) -> Speech:
-        return Speech(self._client)
-
-
-class AsyncAudio:
-    def __init__(self, client: TogetherClient) -> None:
-        self._client = client
-
-    @cached_property
-    def speech(self) -> AsyncSpeech:
-        return AsyncSpeech(self._client)