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

together/types/__init__.py

@@ -1,169 +1,68 @@
-from together.types.abstract import TogetherClient
-from together.types.audio_speech import (
-    AudioLanguage,
-    AudioResponseEncoding,
-    AudioResponseFormat,
-    AudioSpeechRequest,
-    AudioSpeechStreamChunk,
-    AudioSpeechStreamEvent,
-    AudioSpeechStreamResponse,
-    AudioTimestampGranularities,
-    AudioTranscriptionRequest,
-    AudioTranscriptionResponse,
-    AudioTranscriptionResponseFormat,
-    AudioTranscriptionVerboseResponse,
-    AudioTranslationRequest,
-    AudioTranslationResponse,
-    AudioTranslationVerboseResponse,
-    ModelVoices,
-    VoiceListResponse,
-)
-from together.types.batch import BatchEndpoint, BatchJob, BatchJobStatus
-from together.types.chat_completions import (
-    ChatCompletionChunk,
-    ChatCompletionRequest,
-    ChatCompletionResponse,
-)
-from together.types.common import TogetherRequest
-from together.types.completions import (
-    CompletionChunk,
-    CompletionRequest,
-    CompletionResponse,
-)
-from together.types.embeddings import EmbeddingRequest, EmbeddingResponse
-from together.types.endpoints import Autoscaling, DedicatedEndpoint, ListEndpoint
-from together.types.evaluation import (
-    ClassifyParameters,
-    CompareParameters,
-    EvaluationCreateResponse,
-    EvaluationJob,
-    EvaluationRequest,
-    EvaluationStatus,
-    EvaluationStatusResponse,
-    EvaluationType,
-    JudgeModelConfig,
-    ModelRequest,
-    ScoreParameters,
-)
-from together.types.files import (
-    FileDeleteResponse,
-    FileList,
-    FileObject,
-    FilePurpose,
-    FileRequest,
-    FileResponse,
-    FileType,
-)
-from together.types.finetune import (
-    CosineLRScheduler,
-    CosineLRSchedulerArgs,
-    FinetuneCheckpoint,
-    FinetuneDeleteResponse,
-    FinetuneDownloadResult,
-    FinetuneList,
-    FinetuneListEvents,
-    FinetuneLRScheduler,
-    FinetuneMultimodalParams,
-    FinetunePriceEstimationRequest,
-    FinetunePriceEstimationResponse,
-    FinetuneRequest,
-    FinetuneResponse,
-    FinetuneTrainingLimits,
-    FullTrainingType,
-    LinearLRScheduler,
-    LinearLRSchedulerArgs,
-    LoRATrainingType,
-    TrainingMethodDPO,
-    TrainingMethodSFT,
-    TrainingType,
-)
-from together.types.images import ImageRequest, ImageResponse
-from together.types.models import ModelObject, ModelUploadRequest, ModelUploadResponse
-from together.types.rerank import RerankRequest, RerankResponse
-from together.types.videos import CreateVideoBody, CreateVideoResponse, VideoJob
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from __future__ import annotations
 
-__all__ = [
-    "TogetherClient",
-    "TogetherRequest",
-    "CompletionChunk",
-    "CompletionRequest",
-    "CompletionResponse",
-    "ChatCompletionChunk",
-    "ChatCompletionRequest",
-    "ChatCompletionResponse",
-    "EmbeddingRequest",
-    "EmbeddingResponse",
-    "FinetuneCheckpoint",
-    "FinetuneRequest",
-    "FinetuneResponse",
-    "FinetuneList",
-    "FinetuneListEvents",
-    "FinetuneDeleteResponse",
-    "FinetuneDownloadResult",
-    "FinetuneLRScheduler",
-    "FinetunePriceEstimationRequest",
-    "FinetunePriceEstimationResponse",
-    "LinearLRScheduler",
-    "LinearLRSchedulerArgs",
-    "CosineLRScheduler",
-    "CosineLRSchedulerArgs",
-    "FileRequest",
-    "FileResponse",
-    "FileList",
-    "FileDeleteResponse",
-    "FileObject",
-    "FilePurpose",
-    "FileType",
-    "ImageRequest",
-    "ImageResponse",
-    "ModelObject",
-    "ModelUploadRequest",
-    "ModelUploadResponse",
-    "TrainingType",
-    "FullTrainingType",
-    "LoRATrainingType",
-    "TrainingMethodDPO",
-    "TrainingMethodSFT",
-    "RerankRequest",
-    "RerankResponse",
-    "FinetuneTrainingLimits",
-    "FinetuneMultimodalParams",
-    "AudioSpeechRequest",
-    "AudioResponseFormat",
-    "AudioLanguage",
-    "AudioResponseEncoding",
-    "AudioSpeechStreamChunk",
-    "AudioSpeechStreamEvent",
-    "AudioSpeechStreamResponse",
-    "AudioTranscriptionRequest",
-    "AudioTranslationRequest",
-    "AudioTranscriptionResponse",
-    "AudioTranscriptionVerboseResponse",
-    "AudioTranslationResponse",
-    "AudioTranslationVerboseResponse",
-    "AudioTranscriptionResponseFormat",
-    "AudioTimestampGranularities",
-    "ModelVoices",
-    "VoiceListResponse",
-    "DedicatedEndpoint",
-    "ListEndpoint",
-    "Autoscaling",
-    "BatchJob",
-    "BatchJobStatus",
-    "BatchEndpoint",
-    "EvaluationType",
-    "EvaluationStatus",
-    "JudgeModelConfig",
-    "ModelRequest",
-    "ClassifyParameters",
-    "ScoreParameters",
-    "CompareParameters",
-    "EvaluationRequest",
-    "EvaluationCreateResponse",
-    "EvaluationJob",
-    "EvaluationStatusResponse",
-    "CreateVideoBody",
-    "CreateVideoResponse",
-    "VideoJob",
-]
+from .batch_job import BatchJob as BatchJob
+from .embedding import Embedding as Embedding
+from .file_list import FileList as FileList
+from .file_type import FileType as FileType
+from .log_probs import LogProbs as LogProbs
+from .video_job import VideoJob as VideoJob
+from .completion import Completion as Completion
+from .image_file import ImageFile as ImageFile
+from .autoscaling import Autoscaling as Autoscaling
+from .tool_choice import ToolChoice as ToolChoice
+from .tools_param import ToolsParam as ToolsParam
+from .file_purpose import FilePurpose as FilePurpose
+from .model_object import ModelObject as ModelObject
+from .file_response import FileResponse as FileResponse
+from .evaluation_job import EvaluationJob as EvaluationJob
+from .finetune_event import FinetuneEvent as FinetuneEvent
+from .image_data_b64 import ImageDataB64 as ImageDataB64
+from .image_data_url import ImageDataURL as ImageDataURL
+from .completion_chunk import CompletionChunk as CompletionChunk
+from .eval_list_params import EvalListParams as EvalListParams
+from .execute_response import ExecuteResponse as ExecuteResponse
+from .autoscaling_param import AutoscalingParam as AutoscalingParam
+from .finetune_response import FinetuneResponse as FinetuneResponse
+from .job_list_response import JobListResponse as JobListResponse
+from .tool_choice_param import ToolChoiceParam as ToolChoiceParam
+from .dedicated_endpoint import DedicatedEndpoint as DedicatedEndpoint
+from .eval_create_params import EvalCreateParams as EvalCreateParams
+from .eval_list_response import EvalListResponse as EvalListResponse
+from .batch_create_params import BatchCreateParams as BatchCreateParams
+from .batch_list_response import BatchListResponse as BatchListResponse
+from .finetune_event_type import FinetuneEventType as FinetuneEventType
+from .model_list_response import ModelListResponse as ModelListResponse
+from .model_upload_params import ModelUploadParams as ModelUploadParams
+from .video_create_params import VideoCreateParams as VideoCreateParams
+from .endpoint_list_params import EndpointListParams as EndpointListParams
+from .eval_create_response import EvalCreateResponse as EvalCreateResponse
+from .eval_status_response import EvalStatusResponse as EvalStatusResponse
+from .file_delete_response import FileDeleteResponse as FileDeleteResponse
+from .hardware_list_params import HardwareListParams as HardwareListParams
+from .rerank_create_params import RerankCreateParams as RerankCreateParams
+from .batch_create_response import BatchCreateResponse as BatchCreateResponse
+from .image_generate_params import ImageGenerateParams as ImageGenerateParams
+from .job_retrieve_response import JobRetrieveResponse as JobRetrieveResponse
+from .model_upload_response import ModelUploadResponse as ModelUploadResponse
+from .video_create_response import VideoCreateResponse as VideoCreateResponse
+from .endpoint_create_params import EndpointCreateParams as EndpointCreateParams
+from .endpoint_list_response import EndpointListResponse as EndpointListResponse
+from .endpoint_update_params import EndpointUpdateParams as EndpointUpdateParams
+from .hardware_list_response import HardwareListResponse as HardwareListResponse
+from .rerank_create_response import RerankCreateResponse as RerankCreateResponse
+from .embedding_create_params import EmbeddingCreateParams as EmbeddingCreateParams
+from .completion_create_params import CompletionCreateParams as CompletionCreateParams
+from .audio_speech_stream_chunk import AudioSpeechStreamChunk as AudioSpeechStreamChunk
+from .fine_tuning_delete_params import FineTuningDeleteParams as FineTuningDeleteParams
+from .fine_tuning_list_response import FineTuningListResponse as FineTuningListResponse
+from .fine_tuning_content_params import FineTuningContentParams as FineTuningContentParams
+from .fine_tuning_cancel_response import FineTuningCancelResponse as FineTuningCancelResponse
+from .fine_tuning_delete_response import FineTuningDeleteResponse as FineTuningDeleteResponse
+from .endpoint_list_avzones_response import EndpointListAvzonesResponse as EndpointListAvzonesResponse
+from .code_interpreter_execute_params import CodeInterpreterExecuteParams as CodeInterpreterExecuteParams
+from .fine_tuning_list_events_response import FineTuningListEventsResponse as FineTuningListEventsResponse
+from .fine_tuning_list_checkpoints_response import (
+    FineTuningListCheckpointsResponse as FineTuningListCheckpointsResponse,
+)

together/types/audio/__init__.py

@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .voice_list_response import VoiceListResponse as VoiceListResponse
+from .speech_create_params import SpeechCreateParams as SpeechCreateParams
+from .translation_create_params import TranslationCreateParams as TranslationCreateParams
+from .transcription_create_params import TranscriptionCreateParams as TranscriptionCreateParams
+from .translation_create_response import TranslationCreateResponse as TranslationCreateResponse
+from .transcription_create_response import TranscriptionCreateResponse as TranscriptionCreateResponse

together/types/audio/speech_create_params.py

@@ -0,0 +1,75 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["SpeechCreateParamsBase", "SpeechCreateParamsNonStreaming", "SpeechCreateParamsStreaming"]
+
+
+class SpeechCreateParamsBase(TypedDict, total=False):
+    input: Required[str]
+    """Input text to generate the audio for"""
+
+    model: Required[Union[Literal["cartesia/sonic", "hexgrad/Kokoro-82M", "canopylabs/orpheus-3b-0.1-ft"], str]]
+    """The name of the model to query.
+
+    [See all of Together AI's chat models](https://docs.together.ai/docs/serverless-models#audio-models)
+    The current supported tts models are: - cartesia/sonic - hexgrad/Kokoro-82M -
+    canopylabs/orpheus-3b-0.1-ft
+    """
+
+    voice: Required[str]
+    """The voice to use for generating the audio.
+
+    The voices supported are different for each model. For eg - for
+    canopylabs/orpheus-3b-0.1-ft, one of the voices supported is tara, for
+    hexgrad/Kokoro-82M, one of the voices supported is af_alloy and for
+    cartesia/sonic, one of the voices supported is "friendly sidekick".
+
+    You can view the voices supported for each model using the /v1/voices endpoint
+    sending the model name as the query parameter.
+    [View all supported voices here](https://docs.together.ai/docs/text-to-speech#voices-available).
+    """
+
+    language: Literal["en", "de", "fr", "es", "hi", "it", "ja", "ko", "nl", "pl", "pt", "ru", "sv", "tr", "zh"]
+    """Language of input text."""
+
+    response_encoding: Literal["pcm_f32le", "pcm_s16le", "pcm_mulaw", "pcm_alaw"]
+    """Audio encoding of response"""
+
+    response_format: Literal["mp3", "wav", "raw"]
+    """The format of audio output.
+
+    Supported formats are mp3, wav, raw if streaming is false. If streaming is true,
+    the only supported format is raw.
+    """
+
+    sample_rate: int
+    """Sampling rate to use for the output audio.
+
+    The default sampling rate for canopylabs/orpheus-3b-0.1-ft and
+    hexgrad/Kokoro-82M is 24000 and for cartesia/sonic is 44100.
+    """
+
+
+class SpeechCreateParamsNonStreaming(SpeechCreateParamsBase, total=False):
+    stream: Literal[False]
+    """
+    If true, output is streamed for several characters at a time instead of waiting
+    for the full response. The stream terminates with `data: [DONE]`. If false,
+    return the encoded audio as octet stream
+    """
+
+
+class SpeechCreateParamsStreaming(SpeechCreateParamsBase):
+    stream: Required[Literal[True]]
+    """
+    If true, output is streamed for several characters at a time instead of waiting
+    for the full response. The stream terminates with `data: [DONE]`. If false,
+    return the encoded audio as octet stream
+    """
+
+
+SpeechCreateParams = Union[SpeechCreateParamsNonStreaming, SpeechCreateParamsStreaming]

together/types/audio/transcription_create_params.py

@@ -0,0 +1,54 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union
+from typing_extensions import Literal, Required, TypedDict
+
+from ..._types import FileTypes
+
+__all__ = ["TranscriptionCreateParams"]
+
+
+class TranscriptionCreateParams(TypedDict, total=False):
+    file: Required[FileTypes]
+    """Audio file to transcribe"""
+
+    diarize: bool
+    """Whether to enable speaker diarization.
+
+    When enabled, you will get the speaker id for each word in the transcription. In
+    the response, in the words array, you will get the speaker id for each word. In
+    addition, we also return the speaker_segments array which contains the speaker
+    id for each speaker segment along with the start and end time of the segment
+    along with all the words in the segment.
+
+    For eg - ... "speaker_segments": [ "speaker_id": "SPEAKER_00", "start": 0,
+    "end": 30.02, "words": [ { "id": 0, "word": "Tijana", "start": 0, "end": 11.475,
+    "speaker_id": "SPEAKER_00" }, ...
+    """
+
+    language: str
+    """Optional ISO 639-1 language code.
+
+    If `auto` is provided, language is auto-detected.
+    """
+
+    model: Literal["openai/whisper-large-v3"]
+    """Model to use for transcription"""
+
+    prompt: str
+    """Optional text to bias decoding."""
+
+    response_format: Literal["json", "verbose_json"]
+    """The format of the response"""
+
+    temperature: float
+    """Sampling temperature between 0.0 and 1.0"""
+
+    timestamp_granularities: Union[Literal["segment", "word"], List[Literal["segment", "word"]]]
+    """Controls level of timestamp detail in verbose_json.
+
+    Only used when response_format is verbose_json. Can be a single granularity or
+    an array to get multiple levels.
+    """

together/types/audio/transcription_create_response.py

@@ -0,0 +1,111 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from ..._models import BaseModel
+
+__all__ = [
+    "TranscriptionCreateResponse",
+    "AudioTranscriptionJsonResponse",
+    "AudioTranscriptionVerboseJsonResponse",
+    "AudioTranscriptionVerboseJsonResponseSegment",
+    "AudioTranscriptionVerboseJsonResponseSpeakerSegment",
+    "AudioTranscriptionVerboseJsonResponseSpeakerSegmentWord",
+    "AudioTranscriptionVerboseJsonResponseWord",
+]
+
+
+class AudioTranscriptionJsonResponse(BaseModel):
+    text: str
+    """The transcribed text"""
+
+
+class AudioTranscriptionVerboseJsonResponseSegment(BaseModel):
+    id: int
+    """Unique identifier for the segment"""
+
+    end: float
+    """End time of the segment in seconds"""
+
+    start: float
+    """Start time of the segment in seconds"""
+
+    text: str
+    """The text content of the segment"""
+
+
+class AudioTranscriptionVerboseJsonResponseSpeakerSegmentWord(BaseModel):
+    end: float
+    """End time of the word in seconds"""
+
+    start: float
+    """Start time of the word in seconds"""
+
+    word: str
+    """The word"""
+
+    speaker_id: Optional[str] = None
+    """The speaker id for the word (only when diarize is enabled)"""
+
+
+class AudioTranscriptionVerboseJsonResponseSpeakerSegment(BaseModel):
+    id: int
+    """Unique identifier for the speaker segment"""
+
+    end: float
+    """End time of the speaker segment in seconds"""
+
+    speaker_id: str
+    """The speaker identifier"""
+
+    start: float
+    """Start time of the speaker segment in seconds"""
+
+    text: str
+    """The full text spoken by this speaker in this segment"""
+
+    words: List[AudioTranscriptionVerboseJsonResponseSpeakerSegmentWord]
+    """Array of words spoken by this speaker in this segment"""
+
+
+class AudioTranscriptionVerboseJsonResponseWord(BaseModel):
+    end: float
+    """End time of the word in seconds"""
+
+    start: float
+    """Start time of the word in seconds"""
+
+    word: str
+    """The word"""
+
+    speaker_id: Optional[str] = None
+    """The speaker id for the word (only when diarize is enabled)"""
+
+
+class AudioTranscriptionVerboseJsonResponse(BaseModel):
+    duration: float
+    """The duration of the audio in seconds"""
+
+    language: str
+    """The language of the audio"""
+
+    segments: List[AudioTranscriptionVerboseJsonResponseSegment]
+    """Array of transcription segments"""
+
+    task: Literal["transcribe", "translate"]
+    """The task performed"""
+
+    text: str
+    """The transcribed text"""
+
+    speaker_segments: Optional[List[AudioTranscriptionVerboseJsonResponseSpeakerSegment]] = None
+    """Array of transcription speaker segments (only when diarize is enabled)"""
+
+    words: Optional[List[AudioTranscriptionVerboseJsonResponseWord]] = None
+    """
+    Array of transcription words (only when timestamp_granularities includes 'word')
+    """
+
+
+TranscriptionCreateResponse: TypeAlias = Union[AudioTranscriptionJsonResponse, AudioTranscriptionVerboseJsonResponse]

together/types/audio/translation_create_params.py

@@ -0,0 +1,40 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union
+from typing_extensions import Literal, Required, TypedDict
+
+from ..._types import FileTypes
+
+__all__ = ["TranslationCreateParams"]
+
+
+class TranslationCreateParams(TypedDict, total=False):
+    file: Required[FileTypes]
+    """Audio file to translate"""
+
+    language: str
+    """Target output language.
+
+    Optional ISO 639-1 language code. If omitted, language is set to English.
+    """
+
+    model: Literal["openai/whisper-large-v3"]
+    """Model to use for translation"""
+
+    prompt: str
+    """Optional text to bias decoding."""
+
+    response_format: Literal["json", "verbose_json"]
+    """The format of the response"""
+
+    temperature: float
+    """Sampling temperature between 0.0 and 1.0"""
+
+    timestamp_granularities: Union[Literal["segment", "word"], List[Literal["segment", "word"]]]
+    """Controls level of timestamp detail in verbose_json.
+
+    Only used when response_format is verbose_json. Can be a single granularity or
+    an array to get multiple levels.
+    """

together/types/audio/translation_create_response.py

@@ -0,0 +1,70 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from ..._models import BaseModel
+
+__all__ = [
+    "TranslationCreateResponse",
+    "AudioTranslationJsonResponse",
+    "AudioTranslationVerboseJsonResponse",
+    "AudioTranslationVerboseJsonResponseSegment",
+    "AudioTranslationVerboseJsonResponseWord",
+]
+
+
+class AudioTranslationJsonResponse(BaseModel):
+    text: str
+    """The translated text"""
+
+
+class AudioTranslationVerboseJsonResponseSegment(BaseModel):
+    id: int
+    """Unique identifier for the segment"""
+
+    end: float
+    """End time of the segment in seconds"""
+
+    start: float
+    """Start time of the segment in seconds"""
+
+    text: str
+    """The text content of the segment"""
+
+
+class AudioTranslationVerboseJsonResponseWord(BaseModel):
+    end: float
+    """End time of the word in seconds"""
+
+    start: float
+    """Start time of the word in seconds"""
+
+    word: str
+    """The word"""
+
+    speaker_id: Optional[str] = None
+    """The speaker id for the word (only when diarize is enabled)"""
+
+
+class AudioTranslationVerboseJsonResponse(BaseModel):
+    duration: float
+    """The duration of the audio in seconds"""
+
+    language: str
+    """The target language of the translation"""
+
+    segments: List[AudioTranslationVerboseJsonResponseSegment]
+    """Array of translation segments"""
+
+    task: Literal["transcribe", "translate"]
+    """The task performed"""
+
+    text: str
+    """The translated text"""
+
+    words: Optional[List[AudioTranslationVerboseJsonResponseWord]] = None
+    """Array of translation words (only when timestamp_granularities includes 'word')"""
+
+
+TranslationCreateResponse: TypeAlias = Union[AudioTranslationJsonResponse, AudioTranslationVerboseJsonResponse]

together/types/audio/voice_list_response.py

@@ -0,0 +1,23 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from ..._models import BaseModel
+
+__all__ = ["VoiceListResponse", "Data", "DataVoice"]
+
+
+class DataVoice(BaseModel):
+    id: str
+
+    name: str
+
+
+class Data(BaseModel):
+    model: str
+
+    voices: List[DataVoice]
+
+
+class VoiceListResponse(BaseModel):
+    data: List[Data]

together/types/audio_speech_stream_chunk.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["AudioSpeechStreamChunk"]
+
+
+class AudioSpeechStreamChunk(BaseModel):
+    b64: str
+    """base64 encoded audio stream"""
+
+    model: str
+
+    object: Literal["audio.tts.chunk"]

together/types/autoscaling.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .._models import BaseModel
+
+__all__ = ["Autoscaling"]
+
+
+class Autoscaling(BaseModel):
+    max_replicas: int
+    """The maximum number of replicas to scale up to under load"""
+
+    min_replicas: int
+    """The minimum number of replicas to maintain, even when there is no load"""

together/types/autoscaling_param.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["AutoscalingParam"]
+
+
+class AutoscalingParam(TypedDict, total=False):
+    max_replicas: Required[int]
+    """The maximum number of replicas to scale up to under load"""
+
+    min_replicas: Required[int]
+    """The minimum number of replicas to maintain, even when there is no load"""