together 1.5.29__py3-none-any.whl → 1.5.31__py3-none-any.whl

together/resources/endpoints.py

@@ -13,13 +13,18 @@ class Endpoints:
         self._client = client
 
     def list(
-        self, type: Optional[Literal["dedicated", "serverless"]] = None
+        self,
+        type: Optional[Literal["dedicated", "serverless"]] = None,
+        usage_type: Optional[Literal["on-demand", "reserved"]] = None,
+        mine: Optional[bool] = None,
     ) -> List[ListEndpoint]:
         """
-        List all endpoints, can be filtered by type.
+        List all endpoints, can be filtered by endpoint type and ownership.
 
         Args:
-            type (str, optional): Filter endpoints by type ("dedicated" or "serverless"). Defaults to None.
+            type (str, optional): Filter endpoints by endpoint type ("dedicated" or "serverless"). Defaults to None.
+            usage_type (str, optional): Filter endpoints by usage type ("on-demand" or "reserved"). Defaults to None.
+            mine (bool, optional): If True, return only endpoints owned by the caller. Defaults to None.
 
         Returns:
             List[ListEndpoint]: List of endpoint objects
@@ -28,9 +33,20 @@ class Endpoints:
             client=self._client,
         )
 
-        params = {}
+        params: Dict[
+            str,
+            Union[
+                Literal["dedicated", "serverless"],
+                Literal["on-demand", "reserved"],
+                bool,
+            ],
+        ] = {}
         if type is not None:
             params["type"] = type
+        if usage_type is not None:
+            params["usage_type"] = usage_type
+        if mine is not None:
+            params["mine"] = mine
 
         response, _, _ = requestor.request(
             options=TogetherRequest(
@@ -60,6 +76,7 @@ class Endpoints:
         disable_speculative_decoding: bool = True,
         state: Literal["STARTED", "STOPPED"] = "STARTED",
         inactive_timeout: Optional[int] = None,
+        availability_zone: Optional[str] = None,
     ) -> DedicatedEndpoint:
         """
         Create a new dedicated endpoint.
@@ -74,6 +91,7 @@ class Endpoints:
             disable_speculative_decoding (bool, optional): Whether to disable speculative decoding. Defaults to False.
             state (str, optional): The desired state of the endpoint. Defaults to "STARTED".
             inactive_timeout (int, optional): The number of minutes of inactivity after which the endpoint will be automatically stopped. Set to 0 to disable automatic timeout.
+            availability_zone (str, optional): Start endpoint in specified availability zone (e.g., us-central-4b).
 
         Returns:
             DedicatedEndpoint: Object containing endpoint information
@@ -100,6 +118,9 @@ class Endpoints:
         if inactive_timeout is not None:
             data["inactive_timeout"] = inactive_timeout
 
+        if availability_zone is not None:
+            data["availability_zone"] = availability_zone
+
         response, _, _ = requestor.request(
             options=TogetherRequest(
                 method="POST",
@@ -257,19 +278,49 @@ class Endpoints:
 
         return [HardwareWithStatus(**item) for item in response.data["data"]]
 
+    def list_avzones(self) -> List[str]:
+        """
+        List all available availability zones.
+
+        Returns:
+            List[str]: List of unique availability zones
+        """
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        response, _, _ = requestor.request(
+            options=TogetherRequest(
+                method="GET",
+                url="clusters/availability-zones",
+            ),
+            stream=False,
+        )
+
+        assert isinstance(response, TogetherResponse)
+        assert isinstance(response.data, dict)
+        assert isinstance(response.data["avzones"], list)
+
+        return response.data["avzones"]
+
 
 class AsyncEndpoints:
     def __init__(self, client: TogetherClient) -> None:
         self._client = client
 
     async def list(
-        self, type: Optional[Literal["dedicated", "serverless"]] = None
+        self,
+        type: Optional[Literal["dedicated", "serverless"]] = None,
+        usage_type: Optional[Literal["on-demand", "reserved"]] = None,
+        mine: Optional[bool] = None,
     ) -> List[ListEndpoint]:
         """
-        List all endpoints, can be filtered by type.
+        List all endpoints, can be filtered by type and ownership.
 
         Args:
             type (str, optional): Filter endpoints by type ("dedicated" or "serverless"). Defaults to None.
+            usage_type (str, optional): Filter endpoints by usage type ("on-demand" or "reserved"). Defaults to None.
+            mine (bool, optional): If True, return only endpoints owned by the caller. Defaults to None.
 
         Returns:
             List[ListEndpoint]: List of endpoint objects
@@ -278,9 +329,20 @@ class AsyncEndpoints:
             client=self._client,
         )
 
-        params = {}
+        params: Dict[
+            str,
+            Union[
+                Literal["dedicated", "serverless"],
+                Literal["on-demand", "reserved"],
+                bool,
+            ],
+        ] = {}
         if type is not None:
             params["type"] = type
+        if usage_type is not None:
+            params["usage_type"] = usage_type
+        if mine is not None:
+            params["mine"] = mine
 
         response, _, _ = await requestor.arequest(
             options=TogetherRequest(
@@ -308,6 +370,7 @@ class AsyncEndpoints:
         disable_speculative_decoding: bool = True,
         state: Literal["STARTED", "STOPPED"] = "STARTED",
         inactive_timeout: Optional[int] = None,
+        availability_zone: Optional[str] = None,
     ) -> DedicatedEndpoint:
         """
         Create a new dedicated endpoint.
@@ -348,6 +411,9 @@ class AsyncEndpoints:
         if inactive_timeout is not None:
             data["inactive_timeout"] = inactive_timeout
 
+        if availability_zone is not None:
+            data["availability_zone"] = availability_zone
+
         response, _, _ = await requestor.arequest(
             options=TogetherRequest(
                 method="POST",
@@ -506,3 +572,28 @@ class AsyncEndpoints:
         assert isinstance(response.data["data"], list)
 
         return [HardwareWithStatus(**item) for item in response.data["data"]]
+
+    async def list_avzones(self) -> List[str]:
+        """
+        List all availability zones.
+
+        Returns:
+            List[str]: List of unique availability zones
+        """
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        response, _, _ = await requestor.arequest(
+            options=TogetherRequest(
+                method="GET",
+                url="clusters/availability-zones",
+            ),
+            stream=False,
+        )
+
+        assert isinstance(response, TogetherResponse)
+        assert isinstance(response.data, dict)
+        assert isinstance(response.data["avzones"], list)
+
+        return response.data["avzones"]

together/types/__init__.py

@@ -15,6 +15,8 @@ from together.types.audio_speech import (
     AudioTranslationVerboseResponse,
     AudioTranscriptionResponseFormat,
     AudioTimestampGranularities,
+    ModelVoices,
+    VoiceListResponse,
 )
 from together.types.chat_completions import (
     ChatCompletionChunk,
@@ -140,6 +142,8 @@ __all__ = [
     "AudioTranslationVerboseResponse",
     "AudioTranscriptionResponseFormat",
     "AudioTimestampGranularities",
+    "ModelVoices",
+    "VoiceListResponse",
     "DedicatedEndpoint",
     "ListEndpoint",
     "Autoscaling",

together/types/audio_speech.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 import base64
 from enum import Enum
-from typing import BinaryIO, Iterator, List, Optional, Union
+from re import S
+from typing import BinaryIO, Dict, Iterator, List, Optional, Union
 
 from pydantic import BaseModel, ConfigDict
 
@@ -82,27 +83,126 @@ class AudioSpeechStreamResponse(BaseModel):
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    def stream_to_file(self, file_path: str) -> None:
+    def stream_to_file(
+        self, file_path: str, response_format: AudioResponseFormat | str | None = None
+    ) -> None:
+        """
+        Save the audio response to a file.
+
+        For non-streaming responses, writes the complete file as received.
+        For streaming responses, collects binary chunks and constructs a valid
+        file format based on the response_format parameter.
+
+        Args:
+            file_path: Path where the audio file should be saved.
+            response_format: Format of the audio (wav, mp3, or raw). If not provided,
+                           will attempt to infer from file extension or default to wav.
+        """
+        # Determine response format
+        if response_format is None:
+            # Infer from file extension
+            ext = file_path.lower().split(".")[-1] if "." in file_path else ""
+            if ext in ["wav"]:
+                response_format = AudioResponseFormat.WAV
+            elif ext in ["mp3", "mpeg"]:
+                response_format = AudioResponseFormat.MP3
+            elif ext in ["raw", "pcm"]:
+                response_format = AudioResponseFormat.RAW
+            else:
+                # Default to WAV if unknown
+                response_format = AudioResponseFormat.WAV
+
+        if isinstance(response_format, str):
+            response_format = AudioResponseFormat(response_format)
+
         if isinstance(self.response, TogetherResponse):
-            # save response to file
+            # Non-streaming: save complete file
             with open(file_path, "wb") as f:
                 f.write(self.response.data)
 
         elif isinstance(self.response, Iterator):
+            # Streaming: collect binary chunks
+            audio_chunks = []
+            for chunk in self.response:
+                if isinstance(chunk.data, bytes):
+                    audio_chunks.append(chunk.data)
+                elif isinstance(chunk.data, dict):
+                    # SSE format with JSON/base64
+                    try:
+                        stream_event = AudioSpeechStreamEventResponse(
+                            response={"data": chunk.data}
+                        )
+                        if isinstance(stream_event.response, StreamSentinel):
+                            break
+                        audio_chunks.append(
+                            base64.b64decode(stream_event.response.data.b64)
+                        )
+                    except Exception:
+                        continue  # Skip malformed chunks
+
+            if not audio_chunks:
+                raise ValueError("No audio data received in streaming response")
+
+            # Concatenate all chunks
+            audio_data = b"".join(audio_chunks)
+
             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}
+                if response_format == AudioResponseFormat.WAV:
+                    if audio_data.startswith(b"RIFF"):
+                        # Already a valid WAV file
+                        f.write(audio_data)
+                    else:
+                        # Raw PCM - add WAV header
+                        self._write_wav_header(f, audio_data)
+                elif response_format == AudioResponseFormat.MP3:
+                    # MP3 format: Check if data is actually MP3 or raw PCM
+                    # MP3 files start with ID3 tag or sync word (0xFF 0xFB/0xFA/0xF3/0xF2)
+                    is_mp3 = audio_data.startswith(b"ID3") or (
+                        len(audio_data) > 0
+                        and audio_data[0:1] == b"\xff"
+                        and len(audio_data) > 1
+                        and audio_data[1] & 0xE0 == 0xE0
                     )
 
-                    if isinstance(stream_event_response.response, StreamSentinel):
-                        break
-
-                    # decode base64
-                    audio = base64.b64decode(stream_event_response.response.data.b64)
-
-                    f.write(audio)
+                    if is_mp3:
+                        f.write(audio_data)
+                    else:
+                        raise ValueError("Invalid MP3 data received.")
+                else:
+                    # RAW format: write PCM data as-is
+                    f.write(audio_data)
+
+    @staticmethod
+    def _write_wav_header(file_handle: BinaryIO, audio_data: bytes) -> None:
+        """
+        Write WAV file header for raw PCM audio data.
+
+        Uses default TTS parameters: 16-bit PCM, mono, 24000 Hz sample rate.
+        """
+        import struct
+
+        sample_rate = 24000
+        num_channels = 1
+        bits_per_sample = 16
+        byte_rate = sample_rate * num_channels * bits_per_sample // 8
+        block_align = num_channels * bits_per_sample // 8
+        data_size = len(audio_data)
+
+        # Write WAV header
+        file_handle.write(b"RIFF")
+        file_handle.write(struct.pack("<I", 36 + data_size))  # File size - 8
+        file_handle.write(b"WAVE")
+        file_handle.write(b"fmt ")
+        file_handle.write(struct.pack("<I", 16))  # fmt chunk size
+        file_handle.write(struct.pack("<H", 1))  # Audio format (1 = PCM)
+        file_handle.write(struct.pack("<H", num_channels))
+        file_handle.write(struct.pack("<I", sample_rate))
+        file_handle.write(struct.pack("<I", byte_rate))
+        file_handle.write(struct.pack("<H", block_align))
+        file_handle.write(struct.pack("<H", bits_per_sample))
+        file_handle.write(b"data")
+        file_handle.write(struct.pack("<I", data_size))
+        file_handle.write(audio_data)
 
 
 class AudioTranscriptionResponseFormat(str, Enum):
@@ -196,3 +296,16 @@ class AudioTranslationVerboseResponse(BaseModel):
     text: str
     segments: Optional[List[AudioTranscriptionSegment]] = None
     words: Optional[List[AudioTranscriptionWord]] = None
+
+
+class ModelVoices(BaseModel):
+    """Represents a model with its available voices."""
+
+    model: str
+    voices: List[Dict[str, str]]  # Each voice is a dict with 'name' key
+
+
+class VoiceListResponse(BaseModel):
+    """Response containing a list of models and their available voices."""
+
+    data: List[ModelVoices]

together/types/chat_completions.py

@@ -46,6 +46,7 @@ class ChatCompletionMessageContentType(str, Enum):
     TEXT = "text"
     IMAGE_URL = "image_url"
     VIDEO_URL = "video_url"
+    AUDIO_URL = "audio_url"
 
 
 class ChatCompletionMessageContentImageURL(BaseModel):
@@ -56,11 +57,16 @@ class ChatCompletionMessageContentVideoURL(BaseModel):
     url: str
 
 
+class ChatCompletionMessageContentAudioURL(BaseModel):
+    url: str
+
+
 class ChatCompletionMessageContent(BaseModel):
     type: ChatCompletionMessageContentType
     text: str | None = None
     image_url: ChatCompletionMessageContentImageURL | None = None
     video_url: ChatCompletionMessageContentVideoURL | None = None
+    audio_url: ChatCompletionMessageContentAudioURL | None = None
 
 
 class ChatCompletionMessage(BaseModel):

together/types/common.py

@@ -26,6 +26,7 @@ class UsageData(BaseModel):
 
 
 class ObjectType(str, Enum):
+    TextCompletion = "text_completion"
     Completion = "text.completion"
     CompletionChunk = "completion.chunk"
     ChatCompletion = "chat.completion"

together/types/files.py

@@ -15,6 +15,7 @@ class FilePurpose(str, Enum):
     FineTune = "fine-tune"
     BatchAPI = "batch-api"
     Eval = "eval"
+    EvalOutput = "eval-output"
 
 
 class FileType(str, Enum):