together 1.5.17__py3-none-any.whl → 2.0.0a8__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,110 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import Iterator
-import threading
-
-from pydantic import BaseModel, ConfigDict
-
-from together.together_response import TogetherResponse
-import base64
-
-
-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) -> None:
-
-        if isinstance(self.response, TogetherResponse):
-            # save response to file
-            with open(file_path, "wb") as f:
-                f.write(self.response.data)
-
-        elif isinstance(self.response, Iterator):
-
-            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 isinstance(stream_event_response.response, StreamSentinel):
-                        break
-
-                    # decode base64
-                    audio = base64.b64decode(stream_event_response.response.data.b64)
-
-                    f.write(audio)

together/types/batch.py

@@ -1,53 +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"
-
-
-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,197 +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"
-
-
-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"
-
-
-class ChatCompletionMessageContentImageURL(BaseModel):
-    url: str
-
-
-class ChatCompletionMessageContentVideoURL(BaseModel):
-    url: str
-
-
-class ChatCompletionMessageContent(BaseModel):
-    type: ChatCompletionMessageContentType
-    text: str | None = None
-    image_url: ChatCompletionMessageContentImageURL | None = None
-    video_url: ChatCompletionMessageContentVideoURL | 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
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {"schema": self.schema_, "type": self.type}
-
-
-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",
-]

together/types/common.py

@@ -1,66 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import Any, Dict, List
-
-from pydantic import ConfigDict
-from tqdm.utils import CallbackIOWrapper
-
-from together.types.abstract import BaseModel
-
-
-# Generation finish reason
-class FinishReason(str, Enum):
-    Length = "length"
-    StopSequence = "stop"
-    EOS = "eos"
-    ToolCalls = "tool_calls"
-    Error = "error"
-    Null = ""
-
-
-class UsageData(BaseModel):
-    prompt_tokens: int
-    completion_tokens: int
-    total_tokens: int
-
-
-class ObjectType(str, Enum):
-    Completion = "text.completion"
-    CompletionChunk = "completion.chunk"
-    ChatCompletion = "chat.completion"
-    ChatCompletionChunk = "chat.completion.chunk"
-    Embedding = "embedding"
-    FinetuneEvent = "fine-tune-event"
-    File = "file"
-    Model = "model"
-
-
-class LogprobsPart(BaseModel):
-    # token list
-    tokens: List[str | None] | None = None
-    # token logprob list
-    token_logprobs: List[float | None] | None = None
-
-
-class PromptPart(BaseModel):
-    # prompt string
-    text: str | None = None
-    # list of prompt logprobs
-    logprobs: LogprobsPart | None = None
-
-
-class DeltaContent(BaseModel):
-    content: str | None = None
-
-
-class TogetherRequest(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    method: str
-    url: str
-    headers: Dict[str, str] | None = None
-    params: Dict[str, Any] | CallbackIOWrapper | None = None
-    files: Dict[str, Any] | None = None
-    allow_redirects: bool = True
-    override_headers: bool = False

together/types/completions.py

@@ -1,107 +0,0 @@
-from __future__ import annotations
-
-import warnings
-from typing import 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 CompletionRequest(BaseModel):
-    # prompt to complete
-    prompt: str
-    # query model
-    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
-
-    # 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 CompletionChoicesData(BaseModel):
-    index: int
-    logprobs: LogprobsPart | None = None
-    seed: int | None = None
-    finish_reason: FinishReason
-    text: str
-
-
-class CompletionChoicesChunk(BaseModel):
-    index: int | None = None
-    logprobs: float | None = None
-    seed: int | None = None
-    finish_reason: FinishReason | None = None
-    delta: DeltaContent | None = None
-
-
-class CompletionResponse(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[CompletionChoicesData] | None = None
-    # prompt list
-    prompt: List[PromptPart] | None = None
-    # token usage data
-    usage: UsageData | None = None
-
-
-class CompletionChunk(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[CompletionChoicesChunk] | None = None
-    # token usage data
-    usage: UsageData | None = None

together/types/embeddings.py

@@ -1,35 +0,0 @@
-from __future__ import annotations
-
-from typing import List, Literal
-
-from together.types.abstract import BaseModel
-from together.types.common import (
-    ObjectType,
-)
-
-
-class EmbeddingRequest(BaseModel):
-    # input or list of inputs
-    input: str | List[str]
-    # model to query
-    model: str
-
-
-class EmbeddingChoicesData(BaseModel):
-    # response index
-    index: int
-    # object type
-    object: ObjectType
-    # embedding response
-    embedding: List[float] | None = None
-
-
-class EmbeddingResponse(BaseModel):
-    # job id
-    id: str | None = None
-    # query model
-    model: str | None = None
-    # object type
-    object: Literal["list"] | None = None
-    # list of embedding choices
-    data: List[EmbeddingChoicesData] | None = None