together 1.5.25__py3-none-any.whl → 1.5.27__py3-none-any.whl

together/filemanager.py

@@ -1,28 +1,40 @@
 from __future__ import annotations
 
+import math
 import os
 import shutil
 import stat
 import tempfile
 import uuid
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from functools import partial
 from pathlib import Path
-from typing import Tuple
+from typing import Any, Dict, List, Tuple
 
 import requests
 from filelock import FileLock
 from requests.structures import CaseInsensitiveDict
 from tqdm import tqdm
-from tqdm.utils import CallbackIOWrapper
 
-import together.utils
 from together.abstract import api_requestor
-from together.constants import DISABLE_TQDM, DOWNLOAD_BLOCK_SIZE, MAX_RETRIES
+from together.constants import (
+    DISABLE_TQDM,
+    DOWNLOAD_BLOCK_SIZE,
+    MAX_CONCURRENT_PARTS,
+    MAX_FILE_SIZE_GB,
+    MAX_RETRIES,
+    MIN_PART_SIZE_MB,
+    NUM_BYTES_IN_GB,
+    TARGET_PART_SIZE_MB,
+    MAX_MULTIPART_PARTS,
+    MULTIPART_UPLOAD_TIMEOUT,
+)
 from together.error import (
     APIError,
     AuthenticationError,
     DownloadError,
     FileTypeError,
+    ResponseError,
 )
 from together.together_response import TogetherResponse
 from together.types import (
@@ -32,6 +44,8 @@ from together.types import (
     TogetherClient,
     TogetherRequest,
 )
+from tqdm.utils import CallbackIOWrapper
+import together.utils
 
 
 def chmod_and_replace(src: Path, dst: Path) -> None:
@@ -339,7 +353,7 @@ class UploadManager:
                 )
             redirect_url, file_id = self.get_upload_url(url, file, purpose, filetype)
 
-        file_size = os.stat(file.as_posix()).st_size
+        file_size = os.stat(file).st_size
 
         with tqdm(
             total=file_size,
@@ -385,3 +399,214 @@ class UploadManager:
         assert isinstance(response, TogetherResponse)
 
         return FileResponse(**response.data)
+
+
+class MultipartUploadManager:
+    """Handles multipart uploads for large files"""
+
+    def __init__(self, client: TogetherClient) -> None:
+        self._client = client
+        self.max_concurrent_parts = MAX_CONCURRENT_PARTS
+
+    def upload(
+        self,
+        url: str,
+        file: Path,
+        purpose: FilePurpose,
+    ) -> FileResponse:
+        """Upload large file using multipart upload"""
+
+        file_size = os.stat(file).st_size
+
+        file_size_gb = file_size / NUM_BYTES_IN_GB
+        if file_size_gb > MAX_FILE_SIZE_GB:
+            raise FileTypeError(
+                f"File size {file_size_gb:.1f}GB exceeds maximum supported size of {MAX_FILE_SIZE_GB}GB"
+            )
+
+        part_size, num_parts = self._calculate_parts(file_size)
+
+        file_type = self._get_file_type(file)
+        upload_info = None
+
+        try:
+            upload_info = self._initiate_upload(
+                url, file, file_size, num_parts, purpose, file_type
+            )
+
+            completed_parts = self._upload_parts_concurrent(
+                file, upload_info, part_size
+            )
+
+            return self._complete_upload(
+                url, upload_info["upload_id"], upload_info["file_id"], completed_parts
+            )
+
+        except Exception as e:
+            # Cleanup on failure
+            if upload_info is not None:
+                self._abort_upload(
+                    url, upload_info["upload_id"], upload_info["file_id"]
+                )
+            raise e
+
+    def _get_file_type(self, file: Path) -> str:
+        """Get file type from extension, raising ValueError for unsupported extensions"""
+        if file.suffix == ".jsonl":
+            return "jsonl"
+        elif file.suffix == ".parquet":
+            return "parquet"
+        elif file.suffix == ".csv":
+            return "csv"
+        else:
+            raise ValueError(
+                f"Unsupported file extension: '{file.suffix}'. "
+                f"Supported extensions: .jsonl, .parquet, .csv"
+            )
+
+    def _calculate_parts(self, file_size: int) -> tuple[int, int]:
+        """Calculate optimal part size and count"""
+        min_part_size = MIN_PART_SIZE_MB * 1024 * 1024  # 5MB
+        target_part_size = TARGET_PART_SIZE_MB * 1024 * 1024  # 100MB
+
+        if file_size <= target_part_size:
+            return file_size, 1
+
+        num_parts = min(MAX_MULTIPART_PARTS, math.ceil(file_size / target_part_size))
+        part_size = math.ceil(file_size / num_parts)
+
+        if part_size < min_part_size:
+            part_size = min_part_size
+            num_parts = math.ceil(file_size / part_size)
+
+        return part_size, num_parts
+
+    def _initiate_upload(
+        self,
+        url: str,
+        file: Path,
+        file_size: int,
+        num_parts: int,
+        purpose: FilePurpose,
+        file_type: str,
+    ) -> Any:
+        """Initiate multipart upload with backend"""
+
+        requestor = api_requestor.APIRequestor(client=self._client)
+
+        payload = {
+            "file_name": file.name,
+            "file_size": file_size,
+            "num_parts": num_parts,
+            "purpose": purpose.value,
+            "file_type": file_type,
+        }
+
+        response, _, _ = requestor.request(
+            options=TogetherRequest(
+                method="POST",
+                url="files/multipart/initiate",
+                params=payload,
+            ),
+        )
+
+        return response.data
+
+    def _upload_parts_concurrent(
+        self, file: Path, upload_info: Dict[str, Any], part_size: int
+    ) -> List[Dict[str, Any]]:
+        """Upload file parts concurrently with progress tracking"""
+
+        parts = upload_info["parts"]
+        completed_parts = []
+
+        with ThreadPoolExecutor(max_workers=self.max_concurrent_parts) as executor:
+            with tqdm(total=len(parts), desc="Uploading parts", unit="part") as pbar:
+                future_to_part = {}
+
+                with open(file, "rb") as f:
+                    for part_info in parts:
+                        f.seek((part_info["PartNumber"] - 1) * part_size)
+                        part_data = f.read(part_size)
+
+                        future = executor.submit(
+                            self._upload_single_part, part_info, part_data
+                        )
+                        future_to_part[future] = part_info["PartNumber"]
+
+                # Collect results
+                for future in as_completed(future_to_part):
+                    part_number = future_to_part[future]
+                    try:
+                        etag = future.result()
+                        completed_parts.append(
+                            {"part_number": part_number, "etag": etag}
+                        )
+                        pbar.update(1)
+                    except Exception as e:
+                        raise Exception(f"Failed to upload part {part_number}: {e}")
+
+        completed_parts.sort(key=lambda x: x["part_number"])
+        return completed_parts
+
+    def _upload_single_part(self, part_info: Dict[str, Any], part_data: bytes) -> str:
+        """Upload a single part and return ETag"""
+
+        response = requests.put(
+            part_info["URL"],
+            data=part_data,
+            headers=part_info.get("Headers", {}),
+            timeout=MULTIPART_UPLOAD_TIMEOUT,
+        )
+        response.raise_for_status()
+
+        etag = response.headers.get("ETag", "").strip('"')
+        if not etag:
+            raise ResponseError(f"No ETag returned for part {part_info['PartNumber']}")
+
+        return etag
+
+    def _complete_upload(
+        self,
+        url: str,
+        upload_id: str,
+        file_id: str,
+        completed_parts: List[Dict[str, Any]],
+    ) -> FileResponse:
+        """Complete the multipart upload"""
+
+        requestor = api_requestor.APIRequestor(client=self._client)
+
+        payload = {
+            "upload_id": upload_id,
+            "file_id": file_id,
+            "parts": completed_parts,
+        }
+
+        response, _, _ = requestor.request(
+            options=TogetherRequest(
+                method="POST",
+                url="files/multipart/complete",
+                params=payload,
+            ),
+        )
+
+        return FileResponse(**response.data.get("file", response.data))
+
+    def _abort_upload(self, url: str, upload_id: str, file_id: str) -> None:
+        """Abort the multipart upload"""
+
+        requestor = api_requestor.APIRequestor(client=self._client)
+
+        payload = {
+            "upload_id": upload_id,
+            "file_id": file_id,
+        }
+
+        requestor.request(
+            options=TogetherRequest(
+                method="POST",
+                url="files/multipart/abort",
+                params=payload,
+            ),
+        )

together/resources/__init__.py

@@ -10,6 +10,7 @@ from together.resources.models import AsyncModels, Models
 from together.resources.rerank import AsyncRerank, Rerank
 from together.resources.batch import Batches, AsyncBatches
 from together.resources.evaluation import Evaluation, AsyncEvaluation
+from together.resources.videos import AsyncVideos, Videos
 
 
 __all__ = [
@@ -37,4 +38,6 @@ __all__ = [
     "AsyncBatches",
     "Evaluation",
     "AsyncEvaluation",
+    "AsyncVideos",
+    "Videos",
 ]

together/resources/audio/transcriptions.py

@@ -104,7 +104,12 @@ class Transcriptions:
             )
 
         # Add any additional kwargs
-        params_data.update(kwargs)
+        # Convert boolean values to lowercase strings for proper form encoding
+        for key, value in kwargs.items():
+            if isinstance(value, bool):
+                params_data[key] = str(value).lower()
+            else:
+                params_data[key] = value
 
         try:
             response, _, _ = requestor.request(
@@ -131,7 +136,8 @@ class Transcriptions:
             response_format == "verbose_json"
             or response_format == AudioTranscriptionResponseFormat.VERBOSE_JSON
         ):
-            return AudioTranscriptionVerboseResponse(**response.data)
+            # Create response with model validation that preserves extra fields
+            return AudioTranscriptionVerboseResponse.model_validate(response.data)
         else:
             return AudioTranscriptionResponse(**response.data)
 
@@ -234,7 +240,12 @@ class AsyncTranscriptions:
             )
 
         # Add any additional kwargs
-        params_data.update(kwargs)
+        # Convert boolean values to lowercase strings for proper form encoding
+        for key, value in kwargs.items():
+            if isinstance(value, bool):
+                params_data[key] = str(value).lower()
+            else:
+                params_data[key] = value
 
         try:
             response, _, _ = await requestor.arequest(
@@ -261,6 +272,7 @@ class AsyncTranscriptions:
             response_format == "verbose_json"
             or response_format == AudioTranscriptionResponseFormat.VERBOSE_JSON
         ):
-            return AudioTranscriptionVerboseResponse(**response.data)
+            # Create response with model validation that preserves extra fields
+            return AudioTranscriptionVerboseResponse.model_validate(response.data)
         else:
             return AudioTranscriptionResponse(**response.data)

together/resources/endpoints.py

@@ -56,8 +56,8 @@ class Endpoints:
         min_replicas: int,
         max_replicas: int,
         display_name: Optional[str] = None,
-        disable_prompt_cache: bool = False,
-        disable_speculative_decoding: bool = False,
+        disable_prompt_cache: bool = True,
+        disable_speculative_decoding: bool = True,
         state: Literal["STARTED", "STOPPED"] = "STARTED",
         inactive_timeout: Optional[int] = None,
     ) -> DedicatedEndpoint:
@@ -304,8 +304,8 @@ class AsyncEndpoints:
         min_replicas: int,
         max_replicas: int,
         display_name: Optional[str] = None,
-        disable_prompt_cache: bool = False,
-        disable_speculative_decoding: bool = False,
+        disable_prompt_cache: bool = True,
+        disable_speculative_decoding: bool = True,
         state: Literal["STARTED", "STOPPED"] = "STARTED",
         inactive_timeout: Optional[int] = None,
     ) -> DedicatedEndpoint:

together/resources/evaluation.py

@@ -27,9 +27,12 @@ class Evaluation:
     def create(
         self,
         type: str,
-        judge_model_name: str,
+        judge_model: str,
+        judge_model_source: str,
         judge_system_template: str,
         input_data_file_path: str,
+        judge_external_api_token: Optional[str] = None,
+        judge_external_base_url: Optional[str] = None,
         # Classify-specific parameters
         labels: Optional[List[str]] = None,
         pass_labels: Optional[List[str]] = None,
@@ -48,9 +51,12 @@ class Evaluation:
 
         Args:
             type: The type of evaluation ("classify", "score", or "compare")
-            judge_model_name: Name of the judge model
+            judge_model: Name or URL of the judge model
+            judge_model_source: Source of the judge model ("serverless", "dedicated", or "external")
             judge_system_template: System template for the judge
             input_data_file_path: Path to input data file
+            judge_external_api_token: Optional external API token for the judge model
+            judge_external_base_url: Optional external base URLs for the judge model
             labels: List of classification labels (required for classify)
             pass_labels: List of labels considered as passing (required for classify)
             min_score: Minimum score value (required for score)
@@ -67,10 +73,18 @@ class Evaluation:
             client=self._client,
         )
 
+        if judge_model_source == "external" and not judge_external_api_token:
+            raise ValueError(
+                "judge_external_api_token is required when judge_model_source is 'external'"
+            )
+
         # Build judge config
         judge_config = JudgeModelConfig(
-            model_name=judge_model_name,
+            model=judge_model,
+            model_source=judge_model_source,
             system_template=judge_system_template,
+            external_api_token=judge_external_api_token,
+            external_base_url=judge_external_base_url,
         )
         parameters: Union[ClassifyParameters, ScoreParameters, CompareParameters]
         # Build parameters based on type
@@ -112,7 +126,8 @@ class Evaluation:
                 elif isinstance(model_to_evaluate, dict):
                     # Validate that all required fields are present for model config
                     required_fields = [
-                        "model_name",
+                        "model",
+                        "model_source",
                         "max_tokens",
                         "temperature",
                         "system_template",
@@ -128,6 +143,12 @@ class Evaluation:
                             f"All model config parameters are required when using detailed configuration. "
                             f"Missing: {', '.join(missing_fields)}"
                         )
+                    if model_to_evaluate.get(
+                        "model_source"
+                    ) == "external" and not model_to_evaluate.get("external_api_token"):
+                        raise ValueError(
+                            "external_api_token is required when model_source is 'external' for model_to_evaluate"
+                        )
                     parameters.model_to_evaluate = ModelRequest(**model_to_evaluate)
 
         elif type == "score":
@@ -163,7 +184,8 @@ class Evaluation:
                 elif isinstance(model_to_evaluate, dict):
                     # Validate that all required fields are present for model config
                     required_fields = [
-                        "model_name",
+                        "model",
+                        "model_source",
                         "max_tokens",
                         "temperature",
                         "system_template",
@@ -179,6 +201,12 @@ class Evaluation:
                             f"All model config parameters are required when using detailed configuration. "
                             f"Missing: {', '.join(missing_fields)}"
                         )
+                    if model_to_evaluate.get(
+                        "model_source"
+                    ) == "external" and not model_to_evaluate.get("external_api_token"):
+                        raise ValueError(
+                            "external_api_token is required when model_source is 'external' for model_to_evaluate"
+                        )
                     parameters.model_to_evaluate = ModelRequest(**model_to_evaluate)
 
         elif type == "compare":
@@ -223,7 +251,8 @@ class Evaluation:
             elif isinstance(model_a, dict):
                 # Validate that all required fields are present for model config
                 required_fields = [
-                    "model_name",
+                    "model",
+                    "model_source",
                     "max_tokens",
                     "temperature",
                     "system_template",
@@ -237,6 +266,12 @@ class Evaluation:
                         f"All model config parameters are required for model_a when using detailed configuration. "
                         f"Missing: {', '.join(missing_fields)}"
                     )
+                if model_a.get("model_source") == "external" and not model_a.get(
+                    "external_api_token"
+                ):
+                    raise ValueError(
+                        "external_api_token is required when model_source is 'external' for model_a"
+                    )
                 parameters.model_a = ModelRequest(**model_a)
 
             # Handle model_b
@@ -245,7 +280,8 @@ class Evaluation:
             elif isinstance(model_b, dict):
                 # Validate that all required fields are present for model config
                 required_fields = [
-                    "model_name",
+                    "model",
+                    "model_source",
                     "max_tokens",
                     "temperature",
                     "system_template",
@@ -259,6 +295,12 @@ class Evaluation:
                         f"All model config parameters are required for model_b when using detailed configuration. "
                         f"Missing: {', '.join(missing_fields)}"
                     )
+                if model_b.get("model_source") == "external" and not model_b.get(
+                    "external_api_token"
+                ):
+                    raise ValueError(
+                        "external_api_token is required when model_source is 'external' for model_b"
+                    )
                 parameters.model_b = ModelRequest(**model_b)
 
         else:
@@ -379,9 +421,12 @@ class AsyncEvaluation:
     async def create(
         self,
         type: str,
-        judge_model_name: str,
+        judge_model: str,
+        judge_model_source: str,
         judge_system_template: str,
         input_data_file_path: str,
+        judge_external_api_token: Optional[str] = None,
+        judge_external_base_url: Optional[str] = None,
         # Classify-specific parameters
         labels: Optional[List[str]] = None,
         pass_labels: Optional[List[str]] = None,
@@ -400,9 +445,12 @@ class AsyncEvaluation:
 
         Args:
             type: The type of evaluation ("classify", "score", or "compare")
-            judge_model_name: Name of the judge model
+            judge_model: Name or URL of the judge model
+            judge_model_source: Source of the judge model ("serverless", "dedicated", or "external")
             judge_system_template: System template for the judge
             input_data_file_path: Path to input data file
+            judge_external_api_token: Optional external API token for the judge model
+            judge_external_base_url: Optional external base URLs for the judge model
             labels: List of classification labels (required for classify)
             pass_labels: List of labels considered as passing (required for classify)
             min_score: Minimum score value (required for score)
@@ -419,10 +467,18 @@ class AsyncEvaluation:
             client=self._client,
         )
 
+        if judge_model_source == "external" and not judge_external_api_token:
+            raise ValueError(
+                "judge_external_api_token is required when judge_model_source is 'external'"
+            )
+
         # Build judge config
         judge_config = JudgeModelConfig(
-            model_name=judge_model_name,
+            model=judge_model,
+            model_source=judge_model_source,
             system_template=judge_system_template,
+            external_api_token=judge_external_api_token,
+            external_base_url=judge_external_base_url,
         )
         parameters: Union[ClassifyParameters, ScoreParameters, CompareParameters]
         # Build parameters based on type
@@ -464,7 +520,8 @@ class AsyncEvaluation:
                 elif isinstance(model_to_evaluate, dict):
                     # Validate that all required fields are present for model config
                     required_fields = [
-                        "model_name",
+                        "model",
+                        "model_source",
                         "max_tokens",
                         "temperature",
                         "system_template",
@@ -480,6 +537,12 @@ class AsyncEvaluation:
                             f"All model config parameters are required when using detailed configuration. "
                             f"Missing: {', '.join(missing_fields)}"
                         )
+                    if model_to_evaluate.get(
+                        "model_source"
+                    ) == "external" and not model_to_evaluate.get("external_api_token"):
+                        raise ValueError(
+                            "external_api_token is required when model_source is 'external' for model_to_evaluate"
+                        )
                     parameters.model_to_evaluate = ModelRequest(**model_to_evaluate)
 
         elif type == "score":
@@ -515,7 +578,8 @@ class AsyncEvaluation:
                 elif isinstance(model_to_evaluate, dict):
                     # Validate that all required fields are present for model config
                     required_fields = [
-                        "model_name",
+                        "model",
+                        "model_source",
                         "max_tokens",
                         "temperature",
                         "system_template",
@@ -531,6 +595,12 @@ class AsyncEvaluation:
                             f"All model config parameters are required when using detailed configuration. "
                             f"Missing: {', '.join(missing_fields)}"
                         )
+                    if model_to_evaluate.get(
+                        "model_source"
+                    ) == "external" and not model_to_evaluate.get("external_api_token"):
+                        raise ValueError(
+                            "external_api_token is required when model_source is 'external' for model_to_evaluate"
+                        )
                     parameters.model_to_evaluate = ModelRequest(**model_to_evaluate)
 
         elif type == "compare":
@@ -575,7 +645,8 @@ class AsyncEvaluation:
             elif isinstance(model_a, dict):
                 # Validate that all required fields are present for model config
                 required_fields = [
-                    "model_name",
+                    "model",
+                    "model_source",
                     "max_tokens",
                     "temperature",
                     "system_template",
@@ -589,6 +660,12 @@ class AsyncEvaluation:
                         f"All model config parameters are required for model_a when using detailed configuration. "
                         f"Missing: {', '.join(missing_fields)}"
                     )
+                if model_a.get("model_source") == "external" and not model_a.get(
+                    "external_api_token"
+                ):
+                    raise ValueError(
+                        "external_api_token is required when model_source is 'external' for model_a"
+                    )
                 parameters.model_a = ModelRequest(**model_a)
 
             # Handle model_b
@@ -597,7 +674,8 @@ class AsyncEvaluation:
             elif isinstance(model_b, dict):
                 # Validate that all required fields are present for model config
                 required_fields = [
-                    "model_name",
+                    "model",
+                    "model_source",
                     "max_tokens",
                     "temperature",
                     "system_template",
@@ -611,6 +689,12 @@ class AsyncEvaluation:
                         f"All model config parameters are required for model_b when using detailed configuration. "
                         f"Missing: {', '.join(missing_fields)}"
                     )
+                if model_b.get("model_source") == "external" and not model_b.get(
+                    "external_api_token"
+                ):
+                    raise ValueError(
+                        "external_api_token is required when model_source is 'external' for model_b"
+                    )
                 parameters.model_b = ModelRequest(**model_b)
 
         else:

together/resources/files.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
+import os
 from pathlib import Path
 from pprint import pformat
 
 from together.abstract import api_requestor
+from together.constants import MULTIPART_THRESHOLD_GB, NUM_BYTES_IN_GB
 from together.error import FileTypeError
-from together.filemanager import DownloadManager, UploadManager
+from together.filemanager import DownloadManager, UploadManager, MultipartUploadManager
 from together.together_response import TogetherResponse
 from together.types import (
     FileDeleteResponse,
@@ -30,7 +32,6 @@ class Files:
         purpose: FilePurpose | str = FilePurpose.FineTune,
         check: bool = True,
     ) -> FileResponse:
-        upload_manager = UploadManager(self._client)
 
         if check and purpose == FilePurpose.FineTune:
             report_dict = check_file(file)
@@ -47,7 +48,15 @@ class Files:
 
         assert isinstance(purpose, FilePurpose)
 
-        return upload_manager.upload("files", file, purpose=purpose, redirect=True)
+        file_size = os.stat(file).st_size
+        file_size_gb = file_size / NUM_BYTES_IN_GB
+
+        if file_size_gb > MULTIPART_THRESHOLD_GB:
+            multipart_manager = MultipartUploadManager(self._client)
+            return multipart_manager.upload("files", file, purpose)
+        else:
+            upload_manager = UploadManager(self._client)
+            return upload_manager.upload("files", file, purpose=purpose, redirect=True)
 
     def list(self) -> FileList:
         requestor = api_requestor.APIRequestor(