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

together/types/batch_create_params.py

@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["BatchCreateParams"]
+
+
+class BatchCreateParams(TypedDict, total=False):
+    endpoint: Required[str]
+    """The endpoint to use for batch processing"""
+
+    input_file_id: Required[str]
+    """ID of the uploaded input file containing batch requests"""
+
+    completion_window: str
+    """Time window for batch completion (optional)"""
+
+    model_id: str
+    """Model to use for processing batch requests"""
+
+    priority: int
+    """Priority for batch processing (optional)"""

together/types/batch_create_response.py

@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from .._models import BaseModel
+from .batch_job import BatchJob
+
+__all__ = ["BatchCreateResponse"]
+
+
+class BatchCreateResponse(BaseModel):
+    job: Optional[BatchJob] = None
+
+    warning: Optional[str] = None

together/types/batch_job.py

@@ -0,0 +1,45 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["BatchJob"]
+
+
+class BatchJob(BaseModel):
+    id: Optional[str] = None
+
+    completed_at: Optional[datetime] = None
+
+    created_at: Optional[datetime] = None
+
+    endpoint: Optional[str] = None
+
+    error: Optional[str] = None
+
+    error_file_id: Optional[str] = None
+
+    file_size_bytes: Optional[int] = None
+    """Size of input file in bytes"""
+
+    input_file_id: Optional[str] = None
+
+    job_deadline: Optional[datetime] = None
+
+    x_model_id: Optional[str] = FieldInfo(alias="model_id", default=None)
+    """Model used for processing requests"""
+
+    output_file_id: Optional[str] = None
+
+    progress: Optional[float] = None
+    """Completion progress (0.0 to 100)"""
+
+    status: Optional[Literal["VALIDATING", "IN_PROGRESS", "COMPLETED", "FAILED", "EXPIRED", "CANCELLED"]] = None
+    """Current status of the batch job"""
+
+    user_id: Optional[str] = None

together/types/batch_list_response.py

@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+from typing_extensions import TypeAlias
+
+from .batch_job import BatchJob
+
+__all__ = ["BatchListResponse"]
+
+BatchListResponse: TypeAlias = List[BatchJob]

together/types/chat/__init__.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .chat_completion import ChatCompletion as ChatCompletion
+from .chat_completion_chunk import ChatCompletionChunk as ChatCompletionChunk
+from .chat_completion_usage import ChatCompletionUsage as ChatCompletionUsage
+from .chat_completion_warning import ChatCompletionWarning as ChatCompletionWarning
+from .completion_create_params import CompletionCreateParams as CompletionCreateParams
+from .chat_completion_structured_message_text_param import (
+    ChatCompletionStructuredMessageTextParam as ChatCompletionStructuredMessageTextParam,
+)
+from .chat_completion_structured_message_image_url_param import (
+    ChatCompletionStructuredMessageImageURLParam as ChatCompletionStructuredMessageImageURLParam,
+)
+from .chat_completion_structured_message_video_url_param import (
+    ChatCompletionStructuredMessageVideoURLParam as ChatCompletionStructuredMessageVideoURLParam,
+)

together/types/chat/chat_completion.py

@@ -0,0 +1,60 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from ..log_probs import LogProbs
+from ..tool_choice import ToolChoice
+from .chat_completion_usage import ChatCompletionUsage
+from .chat_completion_warning import ChatCompletionWarning
+
+__all__ = ["ChatCompletion", "Choice", "ChoiceMessage", "ChoiceMessageFunctionCall"]
+
+
+class ChoiceMessageFunctionCall(BaseModel):
+    arguments: str
+
+    name: str
+
+
+class ChoiceMessage(BaseModel):
+    content: Optional[str] = None
+
+    role: Literal["assistant"]
+
+    function_call: Optional[ChoiceMessageFunctionCall] = None
+
+    reasoning: Optional[str] = None
+
+    tool_calls: Optional[List[ToolChoice]] = None
+
+
+class Choice(BaseModel):
+    finish_reason: Optional[Literal["stop", "eos", "length", "tool_calls", "function_call"]] = None
+
+    index: Optional[int] = None
+
+    logprobs: Optional[LogProbs] = None
+
+    message: Optional[ChoiceMessage] = None
+
+    seed: Optional[int] = None
+
+    text: Optional[str] = None
+
+
+class ChatCompletion(BaseModel):
+    id: str
+
+    choices: List[Choice]
+
+    created: int
+
+    model: str
+
+    object: Literal["chat.completion"]
+
+    usage: Optional[ChatCompletionUsage] = None
+
+    warnings: Optional[List[ChatCompletionWarning]] = None

together/types/chat/chat_completion_chunk.py

@@ -0,0 +1,61 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from ..tool_choice import ToolChoice
+from .chat_completion_usage import ChatCompletionUsage
+from .chat_completion_warning import ChatCompletionWarning
+
+__all__ = ["ChatCompletionChunk", "Choice", "ChoiceDelta", "ChoiceDeltaFunctionCall"]
+
+
+class ChoiceDeltaFunctionCall(BaseModel):
+    arguments: str
+
+    name: str
+
+
+class ChoiceDelta(BaseModel):
+    role: Literal["system", "user", "assistant", "function", "tool"]
+
+    content: Optional[str] = None
+
+    function_call: Optional[ChoiceDeltaFunctionCall] = None
+
+    reasoning: Optional[str] = None
+
+    token_id: Optional[int] = None
+
+    tool_calls: Optional[List[ToolChoice]] = None
+
+
+class Choice(BaseModel):
+    delta: ChoiceDelta
+
+    finish_reason: Optional[Literal["stop", "eos", "length", "tool_calls", "function_call"]] = None
+
+    index: int
+
+    logprobs: Optional[float] = None
+
+    seed: Optional[int] = None
+
+
+class ChatCompletionChunk(BaseModel):
+    id: str
+
+    choices: List[Choice]
+
+    created: int
+
+    model: str
+
+    object: Literal["chat.completion.chunk"]
+
+    system_fingerprint: Optional[str] = None
+
+    usage: Optional[ChatCompletionUsage] = None
+
+    warnings: Optional[List[ChatCompletionWarning]] = None

together/types/chat/chat_completion_structured_message_image_url_param.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ChatCompletionStructuredMessageImageURLParam", "ImageURL"]
+
+
+class ImageURL(TypedDict, total=False):
+    url: Required[str]
+    """The URL of the image"""
+
+
+class ChatCompletionStructuredMessageImageURLParam(TypedDict, total=False):
+    image_url: ImageURL
+
+    type: Literal["image_url"]

together/types/chat/chat_completion_structured_message_text_param.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ChatCompletionStructuredMessageTextParam"]
+
+
+class ChatCompletionStructuredMessageTextParam(TypedDict, total=False):
+    text: Required[str]
+
+    type: Required[Literal["text"]]

together/types/chat/chat_completion_structured_message_video_url_param.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ChatCompletionStructuredMessageVideoURLParam", "VideoURL"]
+
+
+class VideoURL(TypedDict, total=False):
+    url: Required[str]
+    """The URL of the video"""
+
+
+class ChatCompletionStructuredMessageVideoURLParam(TypedDict, total=False):
+    type: Required[Literal["video_url"]]
+
+    video_url: Required[VideoURL]

together/types/chat/chat_completion_usage.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..._models import BaseModel
+
+__all__ = ["ChatCompletionUsage"]
+
+
+class ChatCompletionUsage(BaseModel):
+    completion_tokens: int
+
+    prompt_tokens: int
+
+    total_tokens: int

together/types/chat/chat_completion_warning.py

@@ -0,0 +1,9 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..._models import BaseModel
+
+__all__ = ["ChatCompletionWarning"]
+
+
+class ChatCompletionWarning(BaseModel):
+    message: str

together/types/chat/completion_create_params.py

@@ -0,0 +1,329 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Iterable, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from ..._types import SequenceNotStr
+from ..tools_param import ToolsParam
+from ..tool_choice_param import ToolChoiceParam
+from .chat_completion_structured_message_text_param import ChatCompletionStructuredMessageTextParam
+from .chat_completion_structured_message_image_url_param import ChatCompletionStructuredMessageImageURLParam
+from .chat_completion_structured_message_video_url_param import ChatCompletionStructuredMessageVideoURLParam
+
+__all__ = [
+    "CompletionCreateParamsBase",
+    "Message",
+    "MessageChatCompletionSystemMessageParam",
+    "MessageChatCompletionUserMessageParam",
+    "MessageChatCompletionUserMessageParamContentChatCompletionUserMessageContentMultimodal",
+    "MessageChatCompletionUserMessageParamContentChatCompletionUserMessageContentMultimodalAudio",
+    "MessageChatCompletionUserMessageParamContentChatCompletionUserMessageContentMultimodalAudioAudioURL",
+    "MessageChatCompletionUserMessageParamContentChatCompletionUserMessageContentMultimodalInputAudio",
+    "MessageChatCompletionUserMessageParamContentChatCompletionUserMessageContentMultimodalInputAudioInputAudio",
+    "MessageChatCompletionAssistantMessageParam",
+    "MessageChatCompletionAssistantMessageParamFunctionCall",
+    "MessageChatCompletionToolMessageParam",
+    "MessageChatCompletionFunctionMessageParam",
+    "FunctionCall",
+    "FunctionCallName",
+    "ResponseFormat",
+    "ToolChoice",
+    "CompletionCreateParamsNonStreaming",
+    "CompletionCreateParamsStreaming",
+]
+
+
+class CompletionCreateParamsBase(TypedDict, total=False):
+    messages: Required[Iterable[Message]]
+    """A list of messages comprising the conversation so far."""
+
+    model: Required[
+        Union[
+            Literal[
+                "Qwen/Qwen2.5-72B-Instruct-Turbo",
+                "Qwen/Qwen2.5-7B-Instruct-Turbo",
+                "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo",
+                "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
+                "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+            ],
+            str,
+        ]
+    ]
+    """The name of the model to query.
+
+    [See all of Together AI's chat models](https://docs.together.ai/docs/serverless-models#chat-models)
+    """
+
+    context_length_exceeded_behavior: Literal["truncate", "error"]
+    """
+    Defined the behavior of the API when max_tokens exceed the maximum context
+    length of the model. When set to 'error', API will return 400 with appropriate
+    error message. When set to 'truncate', override the max_tokens with maximum
+    context length of the model.
+    """
+
+    echo: bool
+    """If true, the response will contain the prompt.
+
+    Can be used with `logprobs` to return prompt logprobs.
+    """
+
+    frequency_penalty: float
+    """
+    A number between -2.0 and 2.0 where a positive value decreases the likelihood of
+    repeating tokens that have already been mentioned.
+    """
+
+    function_call: FunctionCall
+
+    logit_bias: Dict[str, float]
+    """Adjusts the likelihood of specific tokens appearing in the generated output."""
+
+    logprobs: int
+    """
+    An integer between 0 and 20 of the top k tokens to return log probabilities for
+    at each generation step, instead of just the sampled token. Log probabilities
+    help assess model confidence in token predictions.
+    """
+
+    max_tokens: int
+    """The maximum number of tokens to generate."""
+
+    min_p: float
+    """A number between 0 and 1 that can be used as an alternative to top_p and top-k."""
+
+    n: int
+    """The number of completions to generate for each prompt."""
+
+    presence_penalty: float
+    """
+    A number between -2.0 and 2.0 where a positive value increases the likelihood of
+    a model talking about new topics.
+    """
+
+    reasoning_effort: Literal["low", "medium", "high"]
+    """
+    Controls the level of reasoning effort the model should apply when generating
+    responses. Higher values may result in more thoughtful and detailed responses
+    but may take longer to generate.
+    """
+
+    repetition_penalty: float
+    """
+    A number that controls the diversity of generated text by reducing the
+    likelihood of repeated sequences. Higher values decrease repetition.
+    """
+
+    response_format: ResponseFormat
+    """An object specifying the format that the model must output."""
+
+    safety_model: str
+    """The name of the moderation model used to validate tokens.
+
+    Choose from the available moderation models found
+    [here](https://docs.together.ai/docs/inference-models#moderation-models).
+    """
+
+    seed: int
+    """Seed value for reproducibility."""
+
+    stop: SequenceNotStr[str]
+    """A list of string sequences that will truncate (stop) inference text output.
+
+    For example, "</s>" will stop generation as soon as the model generates the
+    given token.
+    """
+
+    temperature: float
+    """
+    A decimal number from 0-1 that determines the degree of randomness in the
+    response. A temperature less than 1 favors more correctness and is appropriate
+    for question answering or summarization. A value closer to 1 introduces more
+    randomness in the output.
+    """
+
+    tool_choice: ToolChoice
+    """Controls which (if any) function is called by the model.
+
+    By default uses `auto`, which lets the model pick between generating a message
+    or calling a function.
+    """
+
+    tools: Iterable[ToolsParam]
+    """A list of tools the model may call.
+
+    Currently, only functions are supported as a tool. Use this to provide a list of
+    functions the model may generate JSON inputs for.
+    """
+
+    top_k: int
+    """
+    An integer that's used to limit the number of choices for the next predicted
+    word or token. It specifies the maximum number of tokens to consider at each
+    step, based on their probability of occurrence. This technique helps to speed up
+    the generation process and can improve the quality of the generated text by
+    focusing on the most likely options.
+    """
+
+    top_p: float
+    """
+    A percentage (also called the nucleus parameter) that's used to dynamically
+    adjust the number of choices for each predicted token based on the cumulative
+    probabilities. It specifies a probability threshold below which all less likely
+    tokens are filtered out. This technique helps maintain diversity and generate
+    more fluent and natural-sounding text.
+    """
+
+
+class MessageChatCompletionSystemMessageParam(TypedDict, total=False):
+    content: Required[str]
+
+    role: Required[Literal["system"]]
+
+    name: str
+
+
+class MessageChatCompletionUserMessageParamContentChatCompletionUserMessageContentMultimodalAudioAudioURL(
+    TypedDict, total=False
+):
+    url: Required[str]
+    """The URL of the audio"""
+
+
+class MessageChatCompletionUserMessageParamContentChatCompletionUserMessageContentMultimodalAudio(
+    TypedDict, total=False
+):
+    audio_url: Required[
+        MessageChatCompletionUserMessageParamContentChatCompletionUserMessageContentMultimodalAudioAudioURL
+    ]
+
+    type: Required[Literal["audio_url"]]
+
+
+class MessageChatCompletionUserMessageParamContentChatCompletionUserMessageContentMultimodalInputAudioInputAudio(
+    TypedDict, total=False
+):
+    data: Required[str]
+    """The base64 encoded audio data"""
+
+    format: Required[Literal["wav"]]
+    """The format of the audio data"""
+
+
+class MessageChatCompletionUserMessageParamContentChatCompletionUserMessageContentMultimodalInputAudio(
+    TypedDict, total=False
+):
+    input_audio: Required[
+        MessageChatCompletionUserMessageParamContentChatCompletionUserMessageContentMultimodalInputAudioInputAudio
+    ]
+
+    type: Required[Literal["input_audio"]]
+
+
+MessageChatCompletionUserMessageParamContentChatCompletionUserMessageContentMultimodal: TypeAlias = Union[
+    ChatCompletionStructuredMessageTextParam,
+    ChatCompletionStructuredMessageImageURLParam,
+    ChatCompletionStructuredMessageVideoURLParam,
+    MessageChatCompletionUserMessageParamContentChatCompletionUserMessageContentMultimodalAudio,
+    MessageChatCompletionUserMessageParamContentChatCompletionUserMessageContentMultimodalInputAudio,
+]
+
+
+class MessageChatCompletionUserMessageParam(TypedDict, total=False):
+    content: Required[
+        Union[str, Iterable[MessageChatCompletionUserMessageParamContentChatCompletionUserMessageContentMultimodal]]
+    ]
+    """
+    The content of the message, which can either be a simple string or a structured
+    format.
+    """
+
+    role: Required[Literal["user"]]
+
+    name: str
+
+
+class MessageChatCompletionAssistantMessageParamFunctionCall(TypedDict, total=False):
+    arguments: Required[str]
+
+    name: Required[str]
+
+
+class MessageChatCompletionAssistantMessageParam(TypedDict, total=False):
+    role: Required[Literal["assistant"]]
+
+    content: Optional[str]
+
+    function_call: MessageChatCompletionAssistantMessageParamFunctionCall
+
+    name: str
+
+    tool_calls: Iterable[ToolChoiceParam]
+
+
+class MessageChatCompletionToolMessageParam(TypedDict, total=False):
+    content: Required[str]
+
+    role: Required[Literal["tool"]]
+
+    tool_call_id: Required[str]
+
+    name: str
+
+
+class MessageChatCompletionFunctionMessageParam(TypedDict, total=False):
+    content: Required[str]
+
+    name: Required[str]
+
+    role: Required[Literal["function"]]
+
+
+Message: TypeAlias = Union[
+    MessageChatCompletionSystemMessageParam,
+    MessageChatCompletionUserMessageParam,
+    MessageChatCompletionAssistantMessageParam,
+    MessageChatCompletionToolMessageParam,
+    MessageChatCompletionFunctionMessageParam,
+]
+
+
+class FunctionCallName(TypedDict, total=False):
+    name: Required[str]
+
+
+FunctionCall: TypeAlias = Union[Literal["none", "auto"], FunctionCallName]
+
+
+class ResponseFormat(TypedDict, total=False):
+    schema: Dict[str, object]
+    """The schema of the response format."""
+
+    type: str
+    """The type of the response format."""
+
+
+ToolChoice: TypeAlias = Union[str, ToolChoiceParam]
+
+
+class CompletionCreateParamsNonStreaming(CompletionCreateParamsBase, total=False):
+    stream: Literal[False]
+    """
+    If true, stream tokens as Server-Sent Events as the model generates them instead
+    of waiting for the full model response. The stream terminates with
+    `data: [DONE]`. If false, return a single JSON object containing the results.
+    """
+
+
+class CompletionCreateParamsStreaming(CompletionCreateParamsBase):
+    stream: Required[Literal[True]]
+    """
+    If true, stream tokens as Server-Sent Events as the model generates them instead
+    of waiting for the full model response. The stream terminates with
+    `data: [DONE]`. If false, return a single JSON object containing the results.
+    """
+
+
+CompletionCreateParams = Union[CompletionCreateParamsNonStreaming, CompletionCreateParamsStreaming]

together/types/code_interpreter/__init__.py

@@ -0,0 +1,5 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .session_list_response import SessionListResponse as SessionListResponse

together/types/code_interpreter/session_list_response.py

@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from datetime import datetime
+
+from ..._models import BaseModel
+
+__all__ = ["SessionListResponse", "Data", "DataSession"]
+
+
+class DataSession(BaseModel):
+    id: str
+    """Session Identifier. Used to make follow-up calls."""
+
+    execute_count: int
+
+    expires_at: datetime
+
+    last_execute_at: datetime
+
+    started_at: datetime
+
+
+class Data(BaseModel):
+    sessions: List[DataSession]
+
+
+class SessionListResponse(BaseModel):
+    data: Optional[Data] = None
+
+    errors: Optional[List[Union[str, Dict[str, object]]]] = None