together 1.5.17__py3-none-any.whl → 2.0.0a8__py3-none-any.whl

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

together/types/code_interpreter_execute_params.py

@@ -0,0 +1,45 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["CodeInterpreterExecuteParams", "File"]
+
+
+class CodeInterpreterExecuteParams(TypedDict, total=False):
+    code: Required[str]
+    """Code snippet to execute."""
+
+    language: Required[Literal["python"]]
+    """Programming language for the code to execute.
+
+    Currently only supports Python, but more will be added.
+    """
+
+    files: Iterable[File]
+    """Files to upload to the session.
+
+    If present, files will be uploaded before executing the given code.
+    """
+
+    session_id: str
+    """Identifier of the current session.
+
+    Used to make follow-up calls. Requests will return an error if the session does
+    not belong to the caller or has expired.
+    """
+
+
+class File(TypedDict, total=False):
+    content: Required[str]
+
+    encoding: Required[Literal["string", "base64"]]
+    """Encoding of the file content.
+
+    Use `string` for text files such as code, and `base64` for binary files, such as
+    images.
+    """
+
+    name: Required[str]

together/types/completion.py

@@ -0,0 +1,42 @@
+# 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 .chat.chat_completion_usage import ChatCompletionUsage
+
+__all__ = ["Completion", "Choice", "Prompt"]
+
+
+class Choice(BaseModel):
+    finish_reason: Optional[Literal["stop", "eos", "length", "tool_calls", "function_call"]] = None
+
+    logprobs: Optional[LogProbs] = None
+
+    seed: Optional[int] = None
+
+    text: Optional[str] = None
+
+
+class Prompt(BaseModel):
+    logprobs: Optional[LogProbs] = None
+
+    text: Optional[str] = None
+
+
+class Completion(BaseModel):
+    id: str
+
+    choices: List[Choice]
+
+    created: int
+
+    model: str
+
+    object: Literal["text.completion"]
+
+    usage: Optional[ChatCompletionUsage] = None
+
+    prompt: Optional[List[Prompt]] = None

together/types/completion_chunk.py

@@ -0,0 +1,66 @@
+# 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.chat_completion_usage import ChatCompletionUsage
+
+__all__ = ["CompletionChunk", "Token", "Choice", "ChoiceDelta", "ChoiceDeltaFunctionCall"]
+
+
+class Token(BaseModel):
+    id: int
+
+    logprob: float
+
+    special: bool
+
+    text: str
+
+
+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):
+    index: int
+
+    delta: Optional[ChoiceDelta] = None
+
+    text: Optional[str] = None
+
+
+class CompletionChunk(BaseModel):
+    id: str
+
+    token: Token
+
+    choices: List[Choice]
+
+    finish_reason: Optional[Literal["stop", "eos", "length", "tool_calls", "function_call"]] = None
+
+    usage: Optional[ChatCompletionUsage] = None
+
+    created: Optional[int] = None
+
+    object: Optional[Literal["completion.chunk"]] = None
+
+    seed: Optional[int] = None

together/types/completion_create_params.py

@@ -0,0 +1,138 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union
+from typing_extensions import Literal, Required, TypedDict
+
+from .._types import SequenceNotStr
+
+__all__ = ["CompletionCreateParamsBase", "CompletionCreateParamsNonStreaming", "CompletionCreateParamsStreaming"]
+
+
+class CompletionCreateParamsBase(TypedDict, total=False):
+    model: Required[
+        Union[
+            Literal[
+                "meta-llama/Llama-2-70b-hf",
+                "mistralai/Mistral-7B-v0.1",
+                "mistralai/Mixtral-8x7B-v0.1",
+                "Meta-Llama/Llama-Guard-7b",
+            ],
+            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)
+    """
+
+    prompt: Required[str]
+    """A string providing context for the model to complete."""
+
+    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.
+    """
+
+    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.
+    """
+
+    repetition_penalty: float
+    """
+    A number that controls the diversity of generated text by reducing the
+    likelihood of repeated sequences. Higher values decrease repetition.
+    """
+
+    safety_model: Union[Literal["Meta-Llama/Llama-Guard-7b"], 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.
+    """
+
+    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 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]