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

together/together_response.py

@@ -1,50 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Dict
-
-
-class TogetherResponse:
-    """
-    API Response class. Stores headers and response data.
-    """
-
-    def __init__(self, data: Any, headers: Dict[str, Any]):
-        self._headers = headers
-        self.data = data
-
-    @property
-    def request_id(self) -> str | None:
-        """
-        Fetches request id from headers
-        """
-        if "cf-ray" in self._headers:
-            return str(self._headers["cf-ray"])
-        return None
-
-    @property
-    def requests_remaining(self) -> int | None:
-        """
-        Number of requests remaining at current rate limit
-        """
-        if "x-ratelimit-remaining" in self._headers:
-            return int(self._headers["x-ratelimit-remaining"])
-        return None
-
-    @property
-    def processed_by(self) -> str | None:
-        """
-        Processing host server name
-        """
-        if "x-hostname" in self._headers:
-            return str(self._headers["x-hostname"])
-        return None
-
-    @property
-    def response_ms(self) -> int | None:
-        """
-        Server request completion time
-        """
-        if "x-total-time" in self._headers:
-            h = self._headers["x-total-time"]
-            return None if h is None else round(float(h))
-        return None

together/types/abstract.py

@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Dict
-
-import pydantic
-from pydantic import ConfigDict
-from typing_extensions import ClassVar
-
-from together.constants import BASE_URL, MAX_RETRIES, TIMEOUT_SECS
-
-
-PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
-
-
-@dataclass
-class TogetherClient:
-    api_key: str | None = None
-    base_url: str | None = BASE_URL
-    timeout: float | None = TIMEOUT_SECS
-    max_retries: int | None = MAX_RETRIES
-    supplied_headers: Dict[str, str] | None = None
-
-
-class BaseModel(pydantic.BaseModel):
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="allow")

together/types/audio_speech.py

@@ -1,311 +0,0 @@
-from __future__ import annotations
-
-import base64
-from enum import Enum
-from re import S
-from typing import BinaryIO, Dict, Iterator, List, Optional, Union
-
-from pydantic import BaseModel, ConfigDict
-
-from together.together_response import TogetherResponse
-
-
-class AudioResponseFormat(str, Enum):
-    MP3 = "mp3"
-    WAV = "wav"
-    RAW = "raw"
-
-
-class AudioLanguage(str, Enum):
-    EN = "en"
-    DE = "de"
-    FR = "fr"
-    ES = "es"
-    HI = "hi"
-    IT = "it"
-    JA = "ja"
-    KO = "ko"
-    NL = "nl"
-    PL = "pl"
-    PT = "pt"
-    RU = "ru"
-    SV = "sv"
-    TR = "tr"
-    ZH = "zh"
-
-
-class AudioResponseEncoding(str, Enum):
-    PCM_F32LE = "pcm_f32le"
-    PCM_S16LE = "pcm_s16le"
-    PCM_MULAW = "pcm_mulaw"
-    PCM_ALAW = "pcm_alaw"
-
-
-class AudioObjectType(str, Enum):
-    AUDIO_TTS_CHUNK = "audio.tts.chunk"
-
-
-class StreamSentinelType(str, Enum):
-    DONE = "[DONE]"
-
-
-class AudioSpeechRequest(BaseModel):
-    model: str
-    input: str
-    voice: str | None = None
-    response_format: AudioResponseFormat = AudioResponseFormat.MP3
-    language: AudioLanguage = AudioLanguage.EN
-    response_encoding: AudioResponseEncoding = AudioResponseEncoding.PCM_F32LE
-    sample_rate: int = 44100
-    stream: bool = False
-
-
-class AudioSpeechStreamChunk(BaseModel):
-    object: AudioObjectType = AudioObjectType.AUDIO_TTS_CHUNK
-    model: str
-    b64: str
-
-
-class AudioSpeechStreamEvent(BaseModel):
-    data: AudioSpeechStreamChunk
-
-
-class StreamSentinel(BaseModel):
-    data: StreamSentinelType = StreamSentinelType.DONE
-
-
-class AudioSpeechStreamEventResponse(BaseModel):
-    response: AudioSpeechStreamEvent | StreamSentinel
-
-
-class AudioSpeechStreamResponse(BaseModel):
-    response: TogetherResponse | Iterator[TogetherResponse]
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    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):
-            # 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:
-                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 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):
-    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
-    id: Optional[int] = None
-    speaker_id: Optional[str] = None
-
-
-class AudioSpeakerSegment(BaseModel):
-    id: int
-    speaker_id: str
-    start: float
-    end: float
-    text: str
-    words: List[AudioTranscriptionWord]
-
-
-class AudioTranscriptionResponse(BaseModel):
-    text: str
-
-
-class AudioTranscriptionVerboseResponse(BaseModel):
-    id: Optional[str] = None
-    language: Optional[str] = None
-    duration: Optional[float] = None
-    text: str
-    segments: Optional[List[AudioTranscriptionSegment]] = None
-    words: Optional[List[AudioTranscriptionWord]] = None
-    speaker_segments: Optional[List[AudioSpeakerSegment]] = 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
-
-
-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/batch.py

@@ -1,54 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import Optional
-from datetime import datetime
-
-from pydantic import Field
-
-from together.types.abstract import BaseModel
-
-
-class BatchJobStatus(str, Enum):
-    """
-    The status of a batch job
-    """
-
-    VALIDATING = "VALIDATING"
-    IN_PROGRESS = "IN_PROGRESS"
-    COMPLETED = "COMPLETED"
-    FAILED = "FAILED"
-    EXPIRED = "EXPIRED"
-    CANCELLED = "CANCELLED"
-    CANCELING = "CANCELING"
-
-
-class BatchEndpoint(str, Enum):
-    """
-    The endpoint of a batch job
-    """
-
-    COMPLETIONS = "/v1/completions"
-    CHAT_COMPLETIONS = "/v1/chat/completions"
-    # More endpoints can be added here as needed
-
-
-class BatchJob(BaseModel):
-    """
-    A batch job object
-    """
-
-    id: str
-    user_id: str
-    input_file_id: str
-    file_size_bytes: int
-    status: BatchJobStatus
-    job_deadline: datetime
-    created_at: datetime
-    endpoint: str
-    progress: float = 0.0
-    model_id: Optional[str] = None
-    output_file_id: Optional[str] = None
-    error_file_id: Optional[str] = None
-    error: Optional[str] = None
-    completed_at: Optional[datetime] = None

together/types/chat_completions.py

@@ -1,210 +0,0 @@
-from __future__ import annotations
-
-import warnings
-from enum import Enum
-from typing import Any, Dict, List
-
-from pydantic import model_validator
-from typing_extensions import Self
-
-from together.types.abstract import BaseModel
-from together.types.common import (
-    DeltaContent,
-    FinishReason,
-    LogprobsPart,
-    ObjectType,
-    PromptPart,
-    UsageData,
-)
-
-
-class MessageRole(str, Enum):
-    ASSISTANT = "assistant"
-    SYSTEM = "system"
-    USER = "user"
-    TOOL = "tool"
-
-
-class ResponseFormatType(str, Enum):
-    JSON_OBJECT = "json_object"
-    JSON_SCHEMA = "json_schema"
-    REGEX = "regex"
-
-
-class FunctionCall(BaseModel):
-    name: str | None = None
-    arguments: str | None = None
-
-
-class ToolCalls(BaseModel):
-    id: str | None = None
-    type: str | None = None
-    function: FunctionCall | None = None
-
-
-class ChatCompletionMessageContentType(str, Enum):
-    TEXT = "text"
-    IMAGE_URL = "image_url"
-    VIDEO_URL = "video_url"
-    AUDIO_URL = "audio_url"
-
-
-class ChatCompletionMessageContentImageURL(BaseModel):
-    url: str
-
-
-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):
-    role: MessageRole
-    content: str | List[ChatCompletionMessageContent] | None = None
-    tool_calls: List[ToolCalls] | None = None
-
-
-class ResponseFormat(BaseModel):
-    type: ResponseFormatType
-    schema_: Dict[str, Any] | None = None
-    pattern: str | None = None
-
-    def to_dict(self) -> Dict[str, Any]:
-        result: Dict[str, Any] = {"type": self.type.value}
-        if self.schema_ is not None:
-            result["schema"] = self.schema_
-        if self.pattern is not None:
-            result["pattern"] = self.pattern
-        return result
-
-
-class FunctionTool(BaseModel):
-    description: str | None = None
-    name: str
-    parameters: Dict[str, Any] | None = None
-
-
-class FunctionToolChoice(BaseModel):
-    name: str
-
-
-class Tools(BaseModel):
-    type: str
-    function: FunctionTool
-
-
-class ToolChoice(BaseModel):
-    type: str
-    function: FunctionToolChoice
-
-
-class ToolChoiceEnum(str, Enum):
-    Auto = "auto"
-    Required = "required"
-
-
-class ChatCompletionRequest(BaseModel):
-    # list of messages
-    messages: List[ChatCompletionMessage]
-    # model name
-    model: str
-    # stopping criteria: max tokens to generate
-    max_tokens: int | None = None
-    # stopping criteria: list of strings to stop generation
-    stop: List[str] | None = None
-    # sampling hyperparameters
-    temperature: float | None = None
-    top_p: float | None = None
-    top_k: int | None = None
-    repetition_penalty: float | None = None
-    presence_penalty: float | None = None
-    frequency_penalty: float | None = None
-    min_p: float | None = None
-    logit_bias: Dict[str, float] | None = None
-    seed: int | None = None
-    # stream SSE token chunks
-    stream: bool = False
-    # return logprobs
-    logprobs: int | None = None
-    # echo prompt.
-    # can be used with logprobs to return prompt logprobs
-    echo: bool | None = None
-    # number of output generations
-    n: int | None = None
-    # moderation model
-    safety_model: str | None = None
-    # constraints
-    response_format: ResponseFormat | None = None
-    tools: List[Tools] | None = None
-    tool_choice: ToolChoice | ToolChoiceEnum | None = None
-
-    # Raise warning if repetition_penalty is used with presence_penalty or frequency_penalty
-    @model_validator(mode="after")
-    def verify_parameters(self) -> Self:
-        if self.repetition_penalty:
-            if self.presence_penalty or self.frequency_penalty:
-                warnings.warn(
-                    "repetition_penalty is not advisable to be used alongside presence_penalty or frequency_penalty"
-                )
-        return self
-
-
-class ChatCompletionChoicesData(BaseModel):
-    index: int | None = None
-    logprobs: LogprobsPart | None = None
-    seed: int | None = None
-    finish_reason: FinishReason | None = None
-    message: ChatCompletionMessage | None = None
-
-
-class ChatCompletionResponse(BaseModel):
-    # request id
-    id: str | None = None
-    # object type
-    object: ObjectType | None = None
-    # created timestamp
-    created: int | None = None
-    # model name
-    model: str | None = None
-    # choices list
-    choices: List[ChatCompletionChoicesData] | None = None
-    # prompt list
-    prompt: List[PromptPart] | List[None] | None = None
-    # token usage data
-    usage: UsageData | None = None
-
-
-class ChatCompletionChoicesChunk(BaseModel):
-    index: int | None = None
-    logprobs: float | None = None
-    seed: int | None = None
-    finish_reason: FinishReason | None = None
-    delta: DeltaContent | None = None
-
-
-class ChatCompletionChunk(BaseModel):
-    # request id
-    id: str | None = None
-    # object type
-    object: ObjectType | None = None
-    # created timestamp
-    created: int | None = None
-    # model name
-    model: str | None = None
-    # delta content
-    choices: List[ChatCompletionChoicesChunk] | None = None
-    # finish reason
-    finish_reason: FinishReason | None = None
-    # token usage data
-    usage: UsageData | None = None

together/types/code_interpreter.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Dict, Literal, Union
-
-from pydantic import Field
-
-from together.types.endpoints import TogetherJSONModel
-
-
-class FileInput(TogetherJSONModel):
-    """File input to be uploaded to the code interpreter session."""
-
-    name: str = Field(description="The name of the file.")
-    encoding: Literal["string", "base64"] = Field(
-        description="Encoding of the file content. Use 'string' for text files and 'base64' for binary files."
-    )
-    content: str = Field(description="The content of the file, encoded as specified.")
-
-
-class InterpreterOutput(TogetherJSONModel):
-    """Base class for interpreter output types."""
-
-    type: Literal["stdout", "stderr", "error", "display_data", "execute_result"] = (
-        Field(description="The type of output")
-    )
-    data: Union[str, Dict[str, Any]] = Field(description="The output data")
-
-
-class ExecuteResponseData(TogetherJSONModel):
-    """Data from code execution response."""
-
-    outputs: list[InterpreterOutput] = Field(
-        description="List of outputs from execution", default_factory=list
-    )
-    errors: Union[str, None] = Field(
-        description="Any errors that occurred during execution", default=None
-    )
-    session_id: str = Field(
-        description="Identifier of the current session. Used to make follow-up calls."
-    )
-    status: str = Field(description="Status of the execution", default="completed")
-
-
-class ExecuteResponse(TogetherJSONModel):
-    """Response from code execution."""
-
-    data: ExecuteResponseData = Field(
-        description="The response data containing outputs and session information"
-    )
-
-
-__all__ = [
-    "FileInput",
-    "InterpreterOutput",
-    "ExecuteResponseData",
-    "ExecuteResponse",
-]