together 1.5.24__py3-none-any.whl → 1.5.26__py3-none-any.whl

together/cli/api/evaluation.py

@@ -24,10 +24,22 @@ def evaluation(ctx: click.Context) -> None:
     help="Type of evaluation to create.",
 )
 @click.option(
-    "--judge-model-name",
+    "--judge-model",
     type=str,
     required=True,
-    help="Name of the judge model to use for evaluation.",
+    help="Name or URL of the judge model to use for evaluation.",
+)
+@click.option(
+    "--judge-model-source",
+    type=click.Choice(["serverless", "dedicated", "external"]),
+    required=True,
+    help="Source of the judge model.",
+)
+@click.option(
+    "--judge-external-api-token",
+    type=str,
+    required=False,
+    help="Optional external API token for the judge model.",
 )
 @click.option(
     "--judge-system-template",
@@ -48,10 +60,20 @@ def evaluation(ctx: click.Context) -> None:
     "Can not be used when model-a-name and other model config parameters are specified",
 )
 @click.option(
-    "--model-to-evaluate-name",
+    "--model-to-evaluate",
     type=str,
     help="Model name when using the detailed config",
 )
+@click.option(
+    "--model-to-evaluate-source",
+    type=click.Choice(["serverless", "dedicated", "external"]),
+    help="Source of the model to evaluate.",
+)
+@click.option(
+    "--model-to-evaluate-external-api-token",
+    type=str,
+    help="Optional external API token for the model to evaluate.",
+)
 @click.option(
     "--model-to-evaluate-max-tokens",
     type=int,
@@ -104,9 +126,19 @@ def evaluation(ctx: click.Context) -> None:
         Can not be used when model-a-name and other model config parameters are specified",
 )
 @click.option(
-    "--model-a-name",
+    "--model-a",
     type=str,
-    help="Model name for model A when using detailed config.",
+    help="Model name or URL for model A when using detailed config.",
+)
+@click.option(
+    "--model-a-source",
+    type=click.Choice(["serverless", "dedicated", "external"]),
+    help="Source of model A.",
+)
+@click.option(
+    "--model-a-external-api-token",
+    type=str,
+    help="Optional external API token for model A.",
 )
 @click.option(
     "--model-a-max-tokens",
@@ -135,9 +167,19 @@ def evaluation(ctx: click.Context) -> None:
           Can not be used when model-b-name and other model config parameters are specified",
 )
 @click.option(
-    "--model-b-name",
+    "--model-b",
     type=str,
-    help="Model name for model B when using detailed config.",
+    help="Model name or URL for model B when using detailed config.",
+)
+@click.option(
+    "--model-b-source",
+    type=click.Choice(["serverless", "dedicated", "external"]),
+    help="Source of model B.",
+)
+@click.option(
+    "--model-b-external-api-token",
+    type=str,
+    help="Optional external API token for model B.",
 )
 @click.option(
     "--model-b-max-tokens",
@@ -162,11 +204,15 @@ def evaluation(ctx: click.Context) -> None:
 def create(
     ctx: click.Context,
     type: str,
-    judge_model_name: str,
+    judge_model: str,
+    judge_model_source: str,
     judge_system_template: str,
+    judge_external_api_token: Optional[str],
     input_data_file_path: str,
     model_field: Optional[str],
-    model_to_evaluate_name: Optional[str],
+    model_to_evaluate: Optional[str],
+    model_to_evaluate_source: Optional[str],
+    model_to_evaluate_external_api_token: Optional[str],
     model_to_evaluate_max_tokens: Optional[int],
     model_to_evaluate_temperature: Optional[float],
     model_to_evaluate_system_template: Optional[str],
@@ -177,13 +223,17 @@ def create(
     max_score: Optional[float],
     pass_threshold: Optional[float],
     model_a_field: Optional[str],
-    model_a_name: Optional[str],
+    model_a: Optional[str],
+    model_a_source: Optional[str],
+    model_a_external_api_token: Optional[str],
     model_a_max_tokens: Optional[int],
     model_a_temperature: Optional[float],
     model_a_system_template: Optional[str],
     model_a_input_template: Optional[str],
     model_b_field: Optional[str],
-    model_b_name: Optional[str],
+    model_b: Optional[str],
+    model_b_source: Optional[str],
+    model_b_external_api_token: Optional[str],
     model_b_max_tokens: Optional[int],
     model_b_temperature: Optional[float],
     model_b_system_template: Optional[str],
@@ -203,7 +253,8 @@ def create(
     # Check if any config parameters are provided
     config_params_provided = any(
         [
-            model_to_evaluate_name,
+            model_to_evaluate,
+            model_to_evaluate_source,
             model_to_evaluate_max_tokens,
             model_to_evaluate_temperature,
             model_to_evaluate_system_template,
@@ -223,17 +274,23 @@ def create(
     elif config_params_provided:
         # Config mode: config parameters are provided
         model_to_evaluate_final = {
-            "model_name": model_to_evaluate_name,
+            "model": model_to_evaluate,
+            "model_source": model_to_evaluate_source,
             "max_tokens": model_to_evaluate_max_tokens,
             "temperature": model_to_evaluate_temperature,
             "system_template": model_to_evaluate_system_template,
             "input_template": model_to_evaluate_input_template,
         }
+        if model_to_evaluate_external_api_token:
+            model_to_evaluate_final["external_api_token"] = (
+                model_to_evaluate_external_api_token
+            )
 
     # Build model-a configuration
     model_a_final: Union[Dict[str, Any], None, str] = None
     model_a_config_params = [
-        model_a_name,
+        model_a,
+        model_a_source,
         model_a_max_tokens,
         model_a_temperature,
         model_a_system_template,
@@ -252,17 +309,21 @@ def create(
     elif any(model_a_config_params):
         # Config mode: config parameters are provided
         model_a_final = {
-            "model_name": model_a_name,
+            "model": model_a,
+            "model_source": model_a_source,
             "max_tokens": model_a_max_tokens,
             "temperature": model_a_temperature,
             "system_template": model_a_system_template,
             "input_template": model_a_input_template,
         }
+        if model_a_external_api_token:
+            model_a_final["external_api_token"] = model_a_external_api_token
 
     # Build model-b configuration
     model_b_final: Union[Dict[str, Any], None, str] = None
     model_b_config_params = [
-        model_b_name,
+        model_b,
+        model_b_source,
         model_b_max_tokens,
         model_b_temperature,
         model_b_system_template,
@@ -281,18 +342,23 @@ def create(
     elif any(model_b_config_params):
         # Config mode: config parameters are provided
         model_b_final = {
-            "model_name": model_b_name,
+            "model": model_b,
+            "model_source": model_b_source,
             "max_tokens": model_b_max_tokens,
             "temperature": model_b_temperature,
             "system_template": model_b_system_template,
             "input_template": model_b_input_template,
         }
+        if model_b_external_api_token:
+            model_b_final["external_api_token"] = model_b_external_api_token
 
     try:
         response = client.evaluation.create(
             type=type,
-            judge_model_name=judge_model_name,
+            judge_model=judge_model,
+            judge_model_source=judge_model_source,
             judge_system_template=judge_system_template,
+            judge_external_api_token=judge_external_api_token,
             input_data_file_path=input_data_file_path,
             model_to_evaluate=model_to_evaluate_final,
             labels=labels_list,

together/cli/api/finetune.py

@@ -543,3 +543,30 @@ def download(
     )
 
     click.echo(json.dumps(response.model_dump(exclude_none=True), indent=4))
+
+
+@fine_tuning.command()
+@click.pass_context
+@click.argument("fine_tune_id", type=str, required=True)
+@click.option("--force", is_flag=True, help="Force deletion without confirmation")
+@click.option(
+    "--quiet", is_flag=True, help="Do not prompt for confirmation before deleting job"
+)
+def delete(
+    ctx: click.Context, fine_tune_id: str, force: bool = False, quiet: bool = False
+) -> None:
+    """Delete fine-tuning job"""
+    client: Together = ctx.obj
+
+    if not quiet:
+        confirm_response = input(
+            f"Are you sure you want to delete fine-tuning job {fine_tune_id}? "
+            "This action cannot be undone. [y/N] "
+        )
+        if confirm_response.lower() != "y":
+            click.echo("Deletion cancelled")
+            return
+
+    response = client.fine_tuning.delete(fine_tune_id, force=force)
+
+    click.echo(json.dumps(response.model_dump(exclude_none=True), indent=4))

together/cli/api/models.py

@@ -4,7 +4,7 @@ import click
 from tabulate import tabulate
 
 from together import Together
-from together.types.models import ModelObject
+from together.types.models import ModelObject, ModelUploadResponse
 
 
 @click.group()
@@ -53,3 +53,81 @@ def list(ctx: click.Context, type: str | None, json: bool) -> None:
         click.echo(json_lib.dumps(display_list, indent=2))
     else:
         click.echo(tabulate(display_list, headers="keys", tablefmt="plain"))
+
+
+@models.command()
+@click.option(
+    "--model-name",
+    required=True,
+    help="The name to give to your uploaded model",
+)
+@click.option(
+    "--model-source",
+    required=True,
+    help="The source location of the model (Hugging Face repo or S3 path)",
+)
+@click.option(
+    "--model-type",
+    type=click.Choice(["model", "adapter"]),
+    default="model",
+    help="Whether the model is a full model or an adapter",
+)
+@click.option(
+    "--hf-token",
+    help="Hugging Face token (if uploading from Hugging Face)",
+)
+@click.option(
+    "--description",
+    help="A description of your model",
+)
+@click.option(
+    "--base-model",
+    help="The base model to use for an adapter if setting it to run against a serverless pool. Only used for model_type 'adapter'.",
+)
+@click.option(
+    "--lora-model",
+    help="The lora pool to use for an adapter if setting it to run against, say, a dedicated pool. Only used for model_type 'adapter'.",
+)
+@click.option(
+    "--json",
+    is_flag=True,
+    help="Output in JSON format",
+)
+@click.pass_context
+def upload(
+    ctx: click.Context,
+    model_name: str,
+    model_source: str,
+    model_type: str,
+    hf_token: str | None,
+    description: str | None,
+    base_model: str | None,
+    lora_model: str | None,
+    json: bool,
+) -> None:
+    """Upload a custom model or adapter from Hugging Face or S3"""
+    client: Together = ctx.obj
+
+    response: ModelUploadResponse = client.models.upload(
+        model_name=model_name,
+        model_source=model_source,
+        model_type=model_type,
+        hf_token=hf_token,
+        description=description,
+        base_model=base_model,
+        lora_model=lora_model,
+    )
+
+    if json:
+        click.echo(json_lib.dumps(response.model_dump(), indent=2))
+    else:
+        click.echo(f"Model upload job created successfully!")
+        if response.job_id:
+            click.echo(f"Job ID: {response.job_id}")
+        if response.model_name:
+            click.echo(f"Model Name: {response.model_name}")
+        if response.model_id:
+            click.echo(f"Model ID: {response.model_id}")
+        if response.model_source:
+            click.echo(f"Model Source: {response.model_source}")
+        click.echo(f"Message: {response.message}")

together/constants.py

@@ -15,6 +15,20 @@ BASE_URL = "https://api.together.xyz/v1"
 DOWNLOAD_BLOCK_SIZE = 10 * 1024 * 1024  # 10 MB
 DISABLE_TQDM = False
 
+# Upload defaults
+MAX_CONCURRENT_PARTS = 4  # Maximum concurrent parts for multipart upload
+
+# Multipart upload constants
+MIN_PART_SIZE_MB = 5  # Minimum part size (S3 requirement)
+TARGET_PART_SIZE_MB = 100  # Target part size for optimal performance
+MAX_MULTIPART_PARTS = 250  # Maximum parts per upload (S3 limit)
+MULTIPART_UPLOAD_TIMEOUT = 300  # Timeout in seconds for uploading each part
+MULTIPART_THRESHOLD_GB = 5.0  # threshold for switching to multipart upload
+
+# maximum number of GB sized files we support finetuning for
+MAX_FILE_SIZE_GB = 25.0
+
+
 # Messages
 MISSING_API_KEY_MESSAGE = """TOGETHER_API_KEY not found.
 Please set it as an environment variable or set it as together.api_key
@@ -26,8 +40,6 @@ MIN_SAMPLES = 1
 # the number of bytes in a gigabyte, used to convert bytes to GB for readable comparison
 NUM_BYTES_IN_GB = 2**30
 
-# maximum number of GB sized files we support finetuning for
-MAX_FILE_SIZE_GB = 4.9
 
 # expected columns for Parquet files
 PARQUET_EXPECTED_COLUMNS = ["input_ids", "attention_mask", "labels"]

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/batch.py

@@ -72,6 +72,21 @@ class Batches:
         jobs = response.data or []
         return [BatchJob(**job) for job in jobs]
 
+    def cancel_batch(self, batch_job_id: str) -> BatchJob:
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        response, _, _ = requestor.request(
+            options=TogetherRequest(
+                method="POST",
+                url=f"batches/{batch_job_id}/cancel",
+            ),
+            stream=False,
+        )
+
+        return BatchJob(**response.data)
+
 
 class AsyncBatches:
     def __init__(self, client: TogetherClient) -> None:
@@ -133,3 +148,18 @@ class AsyncBatches:
         assert isinstance(response, TogetherResponse)
         jobs = response.data or []
         return [BatchJob(**job) for job in jobs]
+
+    async def cancel_batch(self, batch_job_id: str) -> BatchJob:
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        response, _, _ = await requestor.arequest(
+            options=TogetherRequest(
+                method="POST",
+                url=f"batches/{batch_job_id}/cancel",
+            ),
+            stream=False,
+        )
+
+        return BatchJob(**response.data)