together 1.5.3__tar.gz → 1.5.5__tar.gz

{together-1.5.3 → together-1.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: together
-Version: 1.5.3
+Version: 1.5.5
 Summary: Python client for Together's Cloud Platform!
 License: Apache-2.0
 Author: Together AI

{together-1.5.3 → together-1.5.5}/pyproject.toml

@@ -12,10 +12,8 @@ build-backend = "poetry.masonry.api"
 
 [tool.poetry]
 name = "together"
-version = "1.5.3"
-authors = [
-    "Together AI <support@together.ai>"
-]
+version = "1.5.5"
+authors = ["Together AI <support@together.ai>"]
 description = "Python client for Together's Cloud Platform!"
 readme = "README.md"
 license = "Apache-2.0"
@@ -65,6 +63,7 @@ optional = true
 [tool.poetry.group.tests.dependencies]
 pytest = ">=7.4.2,<9.0.0"
 pytest-watch = "^4.2.0"
+pytest-mock = "^3.14.0"
 tox = "^4.14.1"
 
 [tool.poetry.group.examples]

{together-1.5.3 → together-1.5.5}/src/together/client.py

@@ -7,6 +7,7 @@ from typing import Dict, TYPE_CHECKING
 from together import resources
 from together.constants import BASE_URL, MAX_RETRIES, TIMEOUT_SECS
 from together.error import AuthenticationError
+from together.resources.code_interpreter import CodeInterpreter
 from together.types import TogetherClient
 from together.utils import enforce_trailing_slash
 from together.utils.api_helpers import get_google_colab_secret
@@ -22,6 +23,7 @@ class Together:
     fine_tuning: resources.FineTuning
     rerank: resources.Rerank
     audio: resources.Audio
+    code_interpreter: CodeInterpreter
 
     # client options
     client: TogetherClient
@@ -87,6 +89,7 @@ class Together:
         self.rerank = resources.Rerank(self.client)
         self.audio = resources.Audio(self.client)
         self.endpoints = resources.Endpoints(self.client)
+        self.code_interpreter = CodeInterpreter(self.client)
 
 
 class AsyncTogether:
@@ -98,6 +101,7 @@ class AsyncTogether:
     models: resources.AsyncModels
     fine_tuning: resources.AsyncFineTuning
     rerank: resources.AsyncRerank
+    code_interpreter: CodeInterpreter
 
     # client options
     client: TogetherClient
@@ -161,6 +165,7 @@ class AsyncTogether:
         self.models = resources.AsyncModels(self.client)
         self.fine_tuning = resources.AsyncFineTuning(self.client)
         self.rerank = resources.AsyncRerank(self.client)
+        self.code_interpreter = CodeInterpreter(self.client)
 
 
 Client = Together

{together-1.5.3 → together-1.5.5}/src/together/filemanager.py

@@ -378,7 +378,8 @@ class UploadManager:
 
             if not callback_response.status_code == 200:
                 raise APIError(
-                    f"Error code: {callback_response.status_code} - Failed to process uploaded file"
+                    f"Error during file upload: {callback_response.content.decode()}, headers: {callback_response.headers}",
+                    http_status=callback_response.status_code,
                 )
 
             response = self.callback(f"{url}/{file_id}/preprocess")

together-1.5.5/src/together/resources/code_interpreter.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import Dict, Literal, Optional
+
+from together.abstract import api_requestor
+from together.together_response import TogetherResponse
+from together.types import TogetherClient, TogetherRequest
+from together.types.code_interpreter import ExecuteResponse
+
+
+class CodeInterpreter:
+    """Code Interpreter resource for executing code snippets."""
+
+    def __init__(self, client: TogetherClient) -> None:
+        self._client = client
+
+    def run(
+        self,
+        code: str,
+        language: Literal["python"],
+        session_id: Optional[str] = None,
+    ) -> ExecuteResponse:
+        """Execute a code snippet.
+
+        Args:
+            code (str): Code snippet to execute
+            language (str): Programming language for the code to execute. Currently only supports Python.
+            session_id (str, optional): Identifier of the current session. Used to make follow-up calls.
+
+        Returns:
+            ExecuteResponse: Object containing execution results and outputs
+        """
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        data: Dict[str, str] = {
+            "code": code,
+            "language": language,
+        }
+
+        if session_id is not None:
+            data["session_id"] = session_id
+
+        # Use absolute URL to bypass the /v1 prefix
+        response, _, _ = requestor.request(
+            options=TogetherRequest(
+                method="POST",
+                url="/tci/execute",
+                params=data,
+            ),
+            stream=False,
+        )
+
+        assert isinstance(response, TogetherResponse)
+
+        # Return the response data directly since our types match the API structure
+        return ExecuteResponse(**response.data)

{together-1.5.3 → together-1.5.5}/src/together/resources/finetune.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import re
 from pathlib import Path
-from typing import Literal, List
+from typing import List, Literal
 
 from rich import print as rprint
 
@@ -10,37 +10,38 @@ from together.abstract import api_requestor
 from together.filemanager import DownloadManager
 from together.together_response import TogetherResponse
 from together.types import (
+    CosineLRScheduler,
+    CosineLRSchedulerArgs,
+    FinetuneCheckpoint,
     FinetuneDownloadResult,
     FinetuneList,
     FinetuneListEvents,
+    FinetuneLRScheduler,
     FinetuneRequest,
     FinetuneResponse,
     FinetuneTrainingLimits,
     FullTrainingType,
+    LinearLRScheduler,
+    LinearLRSchedulerArgs,
     LoRATrainingType,
     TogetherClient,
     TogetherRequest,
-    TrainingType,
-    FinetuneLRScheduler,
-    FinetuneLinearLRScheduler,
-    FinetuneCosineLRScheduler,
-    FinetuneLinearLRSchedulerArgs,
-    FinetuneCosineLRSchedulerArgs,
     TrainingMethodDPO,
     TrainingMethodSFT,
-    FinetuneCheckpoint,
+    TrainingType,
 )
 from together.types.finetune import (
     DownloadCheckpointType,
-    FinetuneEventType,
     FinetuneEvent,
+    FinetuneEventType,
 )
 from together.utils import (
+    get_event_step,
     log_warn_once,
     normalize_key,
-    get_event_step,
 )
 
+
 _FT_JOB_WITH_STEP_REGEX = r"^ft-[\dabcdef-]+:\d+$"
 
 
@@ -50,7 +51,7 @@ AVAILABLE_TRAINING_METHODS = {
 }
 
 
-def createFinetuneRequest(
+def create_finetune_request(
     model_limits: FinetuneTrainingLimits,
     training_file: str,
     model: str | None = None,
@@ -63,7 +64,7 @@ def createFinetuneRequest(
     lr_scheduler_type: Literal["linear", "cosine"] = "linear",
     min_lr_ratio: float = 0.0,
     scheduler_num_cycles: float = 0.5,
-    warmup_ratio: float = 0.0,
+    warmup_ratio: float | None = None,
     max_grad_norm: float = 1.0,
     weight_decay: float = 0.0,
     lora: bool = False,
@@ -81,7 +82,6 @@ def createFinetuneRequest(
     dpo_beta: float | None = None,
     from_checkpoint: str | None = None,
 ) -> FinetuneRequest:
-
     if model is not None and from_checkpoint is not None:
         raise ValueError(
             "You must specify either a model or a checkpoint to start a job from, not both"
@@ -90,6 +90,8 @@ def createFinetuneRequest(
     if model is None and from_checkpoint is None:
         raise ValueError("You must specify either a model or a checkpoint")
 
+    model_or_checkpoint = model or from_checkpoint
+
     if batch_size == "max":
         log_warn_once(
             "Starting from together>=1.3.0, "
@@ -103,7 +105,9 @@ def createFinetuneRequest(
     min_batch_size: int = 0
     if lora:
         if model_limits.lora_training is None:
-            raise ValueError("LoRA adapters are not supported for the selected model.")
+            raise ValueError(
+                f"LoRA adapters are not supported for the selected model ({model_or_checkpoint})."
+            )
         lora_r = lora_r if lora_r is not None else model_limits.lora_training.max_rank
         lora_alpha = lora_alpha if lora_alpha is not None else lora_r * 2
         training_type = LoRATrainingType(
@@ -118,7 +122,9 @@ def createFinetuneRequest(
 
     else:
         if model_limits.full_training is None:
-            raise ValueError("Full training is not supported for the selected model.")
+            raise ValueError(
+                f"Full training is not supported for the selected model ({model_or_checkpoint})."
+            )
 
         max_batch_size = model_limits.full_training.max_batch_size
         min_batch_size = model_limits.full_training.min_batch_size
@@ -127,46 +133,50 @@ def createFinetuneRequest(
 
     if batch_size > max_batch_size:
         raise ValueError(
-            "Requested batch size is higher that the maximum allowed value."
+            f"Requested batch size of {batch_size} is higher that the maximum allowed value of {max_batch_size}."
         )
 
     if batch_size < min_batch_size:
         raise ValueError(
-            "Requested batch size is lower that the minimum allowed value."
+            f"Requested batch size of {batch_size} is lower that the minimum allowed value of {min_batch_size}."
         )
 
     if warmup_ratio > 1 or warmup_ratio < 0:
-        raise ValueError("Warmup ratio should be between 0 and 1")
+        raise ValueError(f"Warmup ratio should be between 0 and 1 (got {warmup_ratio})")
 
     if min_lr_ratio is not None and (min_lr_ratio > 1 or min_lr_ratio < 0):
-        raise ValueError("Min learning rate ratio should be between 0 and 1")
+        raise ValueError(
+            f"Min learning rate ratio should be between 0 and 1 (got {min_lr_ratio})"
+        )
 
     if max_grad_norm < 0:
-        raise ValueError("Max gradient norm should be non-negative")
+        raise ValueError(
+            f"Max gradient norm should be non-negative (got {max_grad_norm})"
+        )
 
     if weight_decay is not None and (weight_decay < 0):
-        raise ValueError("Weight decay should be non-negative")
+        raise ValueError(f"Weight decay should be non-negative (got {weight_decay})")
 
     if training_method not in AVAILABLE_TRAINING_METHODS:
         raise ValueError(
             f"training_method must be one of {', '.join(AVAILABLE_TRAINING_METHODS)}"
         )
 
-    # Default to generic lr scheduler
-    lrScheduler: FinetuneLRScheduler = FinetuneLRScheduler(lr_scheduler_type="linear")
-
+    lr_scheduler: FinetuneLRScheduler
     if lr_scheduler_type == "cosine":
         if scheduler_num_cycles <= 0.0:
-            raise ValueError("Number of cycles should be greater than 0")
+            raise ValueError(
+                f"Number of cycles should be greater than 0 (got {scheduler_num_cycles})"
+            )
 
-        lrScheduler = FinetuneCosineLRScheduler(
-            lr_scheduler_args=FinetuneCosineLRSchedulerArgs(
+        lr_scheduler = CosineLRScheduler(
+            lr_scheduler_args=CosineLRSchedulerArgs(
                 min_lr_ratio=min_lr_ratio, num_cycles=scheduler_num_cycles
             ),
         )
     else:
-        lrScheduler = FinetuneLinearLRScheduler(
-            lr_scheduler_args=FinetuneLinearLRSchedulerArgs(min_lr_ratio=min_lr_ratio),
+        lr_scheduler = LinearLRScheduler(
+            lr_scheduler_args=LinearLRSchedulerArgs(min_lr_ratio=min_lr_ratio),
         )
 
     training_method_cls: TrainingMethodSFT | TrainingMethodDPO = TrainingMethodSFT()
@@ -182,7 +192,7 @@ def createFinetuneRequest(
         n_checkpoints=n_checkpoints,
         batch_size=batch_size,
         learning_rate=learning_rate,
-        lr_scheduler=lrScheduler,
+        lr_scheduler=lr_scheduler,
         warmup_ratio=warmup_ratio,
         max_grad_norm=max_grad_norm,
         weight_decay=weight_decay,
@@ -374,7 +384,7 @@ class FineTuning:
                 pass
             model_limits = self.get_model_limits(model=model_name)
 
-        finetune_request = createFinetuneRequest(
+        finetune_request = create_finetune_request(
             model_limits=model_limits,
             training_file=training_file,
             model=model,
@@ -762,7 +772,7 @@ class AsyncFineTuning:
                 pass
             model_limits = await self.get_model_limits(model=model_name)
 
-        finetune_request = createFinetuneRequest(
+        finetune_request = create_finetune_request(
             model_limits=model_limits,
             training_file=training_file,
             model=model,

{together-1.5.3 → together-1.5.5}/src/together/types/__init__.py

@@ -34,11 +34,11 @@ from together.types.finetune import (
     TrainingMethodDPO,
     TrainingMethodSFT,
     FinetuneCheckpoint,
-    FinetuneCosineLRScheduler,
-    FinetuneCosineLRSchedulerArgs,
+    CosineLRScheduler,
+    CosineLRSchedulerArgs,
     FinetuneDownloadResult,
-    FinetuneLinearLRScheduler,
-    FinetuneLinearLRSchedulerArgs,
+    LinearLRScheduler,
+    LinearLRSchedulerArgs,
     FinetuneLRScheduler,
     FinetuneList,
     FinetuneListEvents,
@@ -72,10 +72,10 @@ __all__ = [
     "FinetuneListEvents",
     "FinetuneDownloadResult",
     "FinetuneLRScheduler",
-    "FinetuneLinearLRScheduler",
-    "FinetuneLinearLRSchedulerArgs",
-    "FinetuneCosineLRScheduler",
-    "FinetuneCosineLRSchedulerArgs",
+    "LinearLRScheduler",
+    "LinearLRSchedulerArgs",
+    "CosineLRScheduler",
+    "CosineLRSchedulerArgs",
     "FileRequest",
     "FileResponse",
     "FileList",

together-1.5.5/src/together/types/code_interpreter.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Literal, Union
+
+from pydantic import Field
+
+from together.types.endpoints import TogetherJSONModel
+
+
+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__ = [
+    "InterpreterOutput",
+    "ExecuteResponseData",
+    "ExecuteResponse",
+]

{together-1.5.3 → together-1.5.5}/src/together/types/finetune.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import List, Literal, Union
+from typing import List, Literal
 
-from pydantic import StrictBool, Field, validator, field_validator, ValidationInfo
+from pydantic import StrictBool, Field, field_validator
 
 from together.types.abstract import BaseModel
 from together.types.common import (
@@ -176,7 +176,7 @@ class FinetuneRequest(BaseModel):
     # training learning rate
     learning_rate: float
     # learning rate scheduler type and args
-    lr_scheduler: FinetuneLinearLRScheduler | FinetuneCosineLRScheduler | None = None
+    lr_scheduler: LinearLRScheduler | CosineLRScheduler | None = None
     # learning rate warmup ratio
     warmup_ratio: float
     # max gradient norm
@@ -239,7 +239,7 @@ class FinetuneResponse(BaseModel):
     # training learning rate
     learning_rate: float | None = None
     # learning rate scheduler type and args
-    lr_scheduler: FinetuneLinearLRScheduler | FinetuneCosineLRScheduler | None = None
+    lr_scheduler: LinearLRScheduler | CosineLRScheduler | EmptyLRScheduler | None = None
     # learning rate warmup ratio
     warmup_ratio: float | None = None
     # max gradient norm
@@ -345,11 +345,11 @@ class FinetuneTrainingLimits(BaseModel):
     lora_training: FinetuneLoraTrainingLimits | None = None
 
 
-class FinetuneLinearLRSchedulerArgs(BaseModel):
+class LinearLRSchedulerArgs(BaseModel):
     min_lr_ratio: float | None = 0.0
 
 
-class FinetuneCosineLRSchedulerArgs(BaseModel):
+class CosineLRSchedulerArgs(BaseModel):
     min_lr_ratio: float | None = 0.0
     num_cycles: float | None = 0.5
 
@@ -358,14 +358,20 @@ class FinetuneLRScheduler(BaseModel):
     lr_scheduler_type: str
 
 
-class FinetuneLinearLRScheduler(FinetuneLRScheduler):
+class LinearLRScheduler(FinetuneLRScheduler):
     lr_scheduler_type: Literal["linear"] = "linear"
-    lr_scheduler: FinetuneLinearLRSchedulerArgs | None = None
+    lr_scheduler_args: LinearLRSchedulerArgs | None = None
 
 
-class FinetuneCosineLRScheduler(FinetuneLRScheduler):
+class CosineLRScheduler(FinetuneLRScheduler):
     lr_scheduler_type: Literal["cosine"] = "cosine"
-    lr_scheduler: FinetuneCosineLRSchedulerArgs | None = None
+    lr_scheduler_args: CosineLRSchedulerArgs | None = None
+
+
+# placeholder for old fine-tuning jobs with no lr_scheduler_type specified
+class EmptyLRScheduler(FinetuneLRScheduler):
+    lr_scheduler_type: Literal[""]
+    lr_scheduler_args: None = None
 
 
 class FinetuneCheckpoint(BaseModel):