together 1.5.31__tar.gz → 1.5.33__tar.gz

{together-1.5.31 → together-1.5.33}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: together
-Version: 1.5.31
-Summary: Python client for Together's Cloud Platform!
+Version: 1.5.33
+Summary: Python client for Together's Cloud Platform! Note: SDK 2.0 is now available at https://github.com/togethercomputer/together-py
 License: Apache-2.0
 License-File: LICENSE
 Author: Together AI
@@ -42,6 +42,34 @@ Description-Content-Type: text/markdown
   </a>
 </div>
 
+> [!NOTE]
+> ## 🚀 Together Python SDK 2.0 is now available!
+>
+> Check out the new SDK: **[together-py](https://github.com/togethercomputer/together-py)**
+>
+> 📖 **Migration Guide:** [https://docs.together.ai/docs/pythonv2-migration-guide](https://docs.together.ai/docs/pythonv2-migration-guide)
+>
+> ### Install the Beta
+>
+> **Using uv (Recommended):**
+> ```bash
+> # Install uv if you haven't already
+> curl -LsSf https://astral.sh/uv/install.sh | sh
+>
+> # Install together python SDK
+> uv add together --prerelease allow
+>
+> # Or upgrade an existing installation
+> uv sync --upgrade-package together --prerelease allow
+> ```
+>
+> **Using pip:**
+> ```bash
+> pip install --pre together
+> ```
+>
+> This package will be maintained until January 2026.
+
 # Together Python API library
 
 [![PyPI version](https://img.shields.io/pypi/v/together.svg)](https://pypi.org/project/together/)

{together-1.5.31 → together-1.5.33}/README.md

@@ -4,6 +4,34 @@
   </a>
 </div>
 
+> [!NOTE]
+> ## 🚀 Together Python SDK 2.0 is now available!
+>
+> Check out the new SDK: **[together-py](https://github.com/togethercomputer/together-py)**
+>
+> 📖 **Migration Guide:** [https://docs.together.ai/docs/pythonv2-migration-guide](https://docs.together.ai/docs/pythonv2-migration-guide)
+>
+> ### Install the Beta
+>
+> **Using uv (Recommended):**
+> ```bash
+> # Install uv if you haven't already
+> curl -LsSf https://astral.sh/uv/install.sh | sh
+>
+> # Install together python SDK
+> uv add together --prerelease allow
+>
+> # Or upgrade an existing installation
+> uv sync --upgrade-package together --prerelease allow
+> ```
+>
+> **Using pip:**
+> ```bash
+> pip install --pre together
+> ```
+>
+> This package will be maintained until January 2026.
+
 # Together Python API library
 
 [![PyPI version](https://img.shields.io/pypi/v/together.svg)](https://pypi.org/project/together/)

{together-1.5.31 → together-1.5.33}/pyproject.toml

@@ -12,9 +12,9 @@ build-backend = "poetry.masonry.api"
 
 [tool.poetry]
 name = "together"
-version = "1.5.31"
+version = "1.5.33"
 authors = ["Together AI <support@together.ai>"]
-description = "Python client for Together's Cloud Platform!"
+description = "Python client for Together's Cloud Platform! Note: SDK 2.0 is now available at https://github.com/togethercomputer/together-py"
 readme = "README.md"
 license = "Apache-2.0"
 classifiers = [

together-1.5.33/src/together/__init__.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import os
+import sys
+
+# =============================================================================
+# SDK 2.0 ANNOUNCEMENT
+# =============================================================================
+_ANNOUNCEMENT_MESSAGE = """
+================================================================================
+Together Python SDK 2.0 is now available!
+
+Install: pip install --pre together
+New SDK: https://github.com/togethercomputer/together-py
+Migration guide: https://docs.together.ai/docs/pythonv2-migration-guide
+
+This package will be maintained until January 2026.
+================================================================================
+"""
+
+# Show info banner (unless suppressed)
+if not os.environ.get("TOGETHER_NO_BANNER"):
+    try:
+        from rich.console import Console
+        from rich.panel import Panel
+
+        console = Console(stderr=True)
+        console.print(
+            Panel(
+                "[bold cyan]Together Python SDK 2.0 is now available![/bold cyan]\n\n"
+                "Install the beta:\n"
+                "[green]pip install --pre together[/green]  or  "
+                "[green]uv add together --prerelease allow[/green]\n\n"
+                "New SDK: [link=https://github.com/togethercomputer/together-py]"
+                "https://github.com/togethercomputer/together-py[/link]\n"
+                "Migration guide: [link=https://docs.together.ai/docs/pythonv2-migration-guide]"
+                "https://docs.together.ai/docs/pythonv2-migration-guide[/link]\n\n"
+                "[dim]This package will be maintained until January 2026.\n"
+                "Set TOGETHER_NO_BANNER=1 to hide this message.[/dim]",
+                title="🚀 New SDK Available",
+                border_style="cyan",
+            )
+        )
+    except Exception:
+        # Fallback for any error (ImportError, OSError in daemons, rich errors, etc.)
+        # Banner display should never break module imports
+        try:
+            print(_ANNOUNCEMENT_MESSAGE, file=sys.stderr)
+        except Exception:
+            pass  # Silently ignore if even stderr is unavailable
+
+# =============================================================================
+
+from contextvars import ContextVar
+from typing import TYPE_CHECKING, Callable
+
+from together import (
+    abstract,
+    client,
+    constants,
+    error,
+    filemanager,
+    resources,
+    together_response,
+    types,
+    utils,
+)
+from together.version import VERSION
+
+from together.legacy.complete import AsyncComplete, Complete, Completion
+from together.legacy.embeddings import Embeddings
+from together.legacy.files import Files
+from together.legacy.finetune import Finetune
+from together.legacy.images import Image
+from together.legacy.models import Models
+
+version = VERSION
+
+log: str | None = None  # Set to either 'debug' or 'info', controls console logging
+
+if TYPE_CHECKING:
+    import requests
+    from aiohttp import ClientSession
+
+requestssession: "requests.Session" | Callable[[], "requests.Session"] | None = None
+
+aiosession: ContextVar["ClientSession" | None] = ContextVar(
+    "aiohttp-session", default=None
+)
+
+from together.client import AsyncClient, AsyncTogether, Client, Together
+
+
+api_key: str | None = None  # To be deprecated in the next major release
+
+# Legacy functions
+
+
+__all__ = [
+    "aiosession",
+    "constants",
+    "version",
+    "Together",
+    "AsyncTogether",
+    "Client",
+    "AsyncClient",
+    "resources",
+    "types",
+    "abstract",
+    "filemanager",
+    "error",
+    "together_response",
+    "client",
+    "utils",
+    "Complete",
+    "AsyncComplete",
+    "Completion",
+    "Embeddings",
+    "Files",
+    "Finetune",
+    "Image",
+    "Models",
+]

{together-1.5.31 → together-1.5.33}/src/together/cli/api/finetune.py

@@ -9,14 +9,17 @@ from typing import Any, Literal
 import click
 from click.core import ParameterSource  # type: ignore[attr-defined]
 from rich import print as rprint
+from rich.json import JSON
 from tabulate import tabulate
 
 from together import Together
-from together.cli.api.utils import BOOL_WITH_AUTO, INT_WITH_MAX
+from together.cli.api.utils import BOOL_WITH_AUTO, INT_WITH_MAX, generate_progress_bar
 from together.types.finetune import (
     DownloadCheckpointType,
     FinetuneEventType,
     FinetuneTrainingLimits,
+    FullTrainingType,
+    LoRATrainingType,
 )
 from together.utils import (
     finetune_price_to_dollars,
@@ -29,13 +32,21 @@ from together.utils import (
 
 _CONFIRMATION_MESSAGE = (
     "You are about to create a fine-tuning job. "
-    "The cost of your job will be determined by the model size, the number of tokens "
+    "The estimated price of this job is {price}. "
+    "The actual cost of your job will be determined by the model size, the number of tokens "
     "in the training file, the number of tokens in the validation file, the number of epochs, and "
-    "the number of evaluations. Visit https://www.together.ai/pricing to get a price estimate.\n"
+    "the number of evaluations. Visit https://www.together.ai/pricing to learn more about fine-tuning pricing.\n"
+    "{warning}"
     "You can pass `-y` or `--confirm` to your command to skip this message.\n\n"
     "Do you want to proceed?"
 )
 
+_WARNING_MESSAGE_INSUFFICIENT_FUNDS = (
+    "The estimated price of this job is significantly greater than your current credit limit and balance combined. "
+    "It will likely get cancelled due to insufficient funds. "
+    "Consider increasing your credit limit at https://api.together.xyz/settings/profile\n"
+)
+
 
 class DownloadCheckpointTypeChoice(click.Choice):
     def __init__(self) -> None:
@@ -357,12 +368,36 @@ def create(
             "You have specified a number of evaluation loops but no validation file."
         )
 
-    if confirm or click.confirm(_CONFIRMATION_MESSAGE, default=True, show_default=True):
+    finetune_price_estimation_result = client.fine_tuning.estimate_price(
+        training_file=training_file,
+        validation_file=validation_file,
+        model=model,
+        n_epochs=n_epochs,
+        n_evals=n_evals,
+        training_type="lora" if lora else "full",
+        training_method=training_method,
+    )
+
+    price = click.style(
+        f"${finetune_price_estimation_result.estimated_total_price:.2f}",
+        bold=True,
+    )
+
+    if not finetune_price_estimation_result.allowed_to_proceed:
+        warning = click.style(_WARNING_MESSAGE_INSUFFICIENT_FUNDS, fg="red", bold=True)
+    else:
+        warning = ""
+
+    confirmation_message = _CONFIRMATION_MESSAGE.format(
+        price=price,
+        warning=warning,
+    )
+
+    if confirm or click.confirm(confirmation_message, default=True, show_default=True):
         response = client.fine_tuning.create(
             **training_args,
             verbose=True,
         )
-
         report_string = f"Successfully submitted a fine-tuning job {response.id}"
         if response.created_at is not None:
             created_time = datetime.strptime(
@@ -401,6 +436,9 @@ def list(ctx: click.Context) -> None:
                 "Price": f"""${
                     finetune_price_to_dollars(float(str(i.total_price)))
                 }""",  # convert to string for mypy typing
+                "Progress": generate_progress_bar(
+                    i, datetime.now().astimezone(), use_rich=False
+                ),
             }
         )
     table = tabulate(display_list, headers="keys", tablefmt="grid", showindex=True)
@@ -420,7 +458,15 @@ def retrieve(ctx: click.Context, fine_tune_id: str) -> None:
     # remove events from response for cleaner output
     response.events = None
 
-    click.echo(json.dumps(response.model_dump(exclude_none=True), indent=4))
+    rprint(JSON.from_data(response.model_dump(exclude_none=True)))
+    progress_text = generate_progress_bar(
+        response, datetime.now().astimezone(), use_rich=True
+    )
+    status = "Unknown"
+    if response.status is not None:
+        status = response.status.value
+    prefix = f"Status: [bold]{status}[/bold],"
+    rprint(f"{prefix} {progress_text}")
 
 
 @fine_tuning.command()

together-1.5.33/src/together/cli/api/utils.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import math
+import re
+from gettext import gettext as _
+from typing import Literal
+from datetime import datetime
+
+import click
+
+from together.types.finetune import FinetuneResponse, COMPLETED_STATUSES
+
+_PROGRESS_BAR_WIDTH = 40
+
+
+class AutoIntParamType(click.ParamType):
+    name = "integer_or_max"
+    _number_class = int
+
+    def convert(
+        self, value: str, param: click.Parameter | None, ctx: click.Context | None
+    ) -> int | Literal["max"] | None:
+        if value == "max":
+            return "max"
+        try:
+            return int(value)
+        except ValueError:
+            self.fail(
+                _("{value!r} is not a valid {number_type}.").format(
+                    value=value, number_type=self.name
+                ),
+                param,
+                ctx,
+            )
+
+
+class BooleanWithAutoParamType(click.ParamType):
+    name = "boolean_or_auto"
+
+    def convert(
+        self, value: str, param: click.Parameter | None, ctx: click.Context | None
+    ) -> bool | Literal["auto"] | None:
+        if value == "auto":
+            return "auto"
+        try:
+            return bool(value)
+        except ValueError:
+            self.fail(
+                _("{value!r} is not a valid {type}.").format(
+                    value=value, type=self.name
+                ),
+                param,
+                ctx,
+            )
+
+
+INT_WITH_MAX = AutoIntParamType()
+BOOL_WITH_AUTO = BooleanWithAutoParamType()
+
+
+def _human_readable_time(timedelta: float) -> str:
+    """Convert a timedelta to a compact human-readble string
+    Examples:
+        00:00:10 -> 10s
+        01:23:45 -> 1h 23min 45s
+        1 Month 23 days 04:56:07 -> 1month 23d 4h 56min 7s
+    Args:
+        timedelta (float): The timedelta in seconds to convert.
+    Returns:
+        A string representing the timedelta in a human-readable format.
+    """
+    units = [
+        (30 * 24 * 60 * 60, "month"),  # 30 days
+        (24 * 60 * 60, "d"),
+        (60 * 60, "h"),
+        (60, "min"),
+        (1, "s"),
+    ]
+
+    total_seconds = int(timedelta)
+    parts = []
+
+    for unit_seconds, unit_name in units:
+        if total_seconds >= unit_seconds:
+            value = total_seconds // unit_seconds
+            total_seconds %= unit_seconds
+            parts.append(f"{value}{unit_name}")
+
+    return " ".join(parts) if parts else "0s"
+
+
+def generate_progress_bar(
+    finetune_job: FinetuneResponse, current_time: datetime, use_rich: bool = False
+) -> str:
+    """Generate a progress bar for a finetune job.
+    Args:
+        finetune_job: The finetune job to generate a progress bar for.
+        current_time: The current time.
+        use_rich: Whether to use rich formatting.
+    Returns:
+        A string representing the progress bar.
+    """
+    progress = "Progress: [bold red]unavailable[/bold red]"
+    if finetune_job.status in COMPLETED_STATUSES:
+        progress = "Progress: [bold green]completed[/bold green]"
+    elif finetune_job.updated_at is not None:
+        # Replace 'Z' with '+00:00' for Python 3.10 compatibility
+        updated_at_str = finetune_job.updated_at.replace("Z", "+00:00")
+        update_at = datetime.fromisoformat(updated_at_str).astimezone()
+
+        if finetune_job.progress is not None:
+            if current_time < update_at:
+                return progress
+
+            if not finetune_job.progress.estimate_available:
+                return progress
+
+            if finetune_job.progress.seconds_remaining <= 0:
+                return progress
+
+            elapsed_time = (current_time - update_at).total_seconds()
+            ratio_filled = min(
+                elapsed_time / finetune_job.progress.seconds_remaining, 1.0
+            )
+            percentage = ratio_filled * 100
+            filled = math.ceil(ratio_filled * _PROGRESS_BAR_WIDTH)
+            bar = "█" * filled + "░" * (_PROGRESS_BAR_WIDTH - filled)
+            time_left = "N/A"
+            if finetune_job.progress.seconds_remaining > elapsed_time:
+                time_left = _human_readable_time(
+                    finetune_job.progress.seconds_remaining - elapsed_time
+                )
+            time_text = f"{time_left} left"
+            progress = f"Progress: {bar} [bold]{percentage:>3.0f}%[/bold] [yellow]{time_text}[/yellow]"
+
+    if use_rich:
+        return progress
+
+    return re.sub(r"\[/?[^\]]+\]", "", progress)

{together-1.5.31 → together-1.5.33}/src/together/resources/finetune.py

@@ -20,6 +20,8 @@ from together.types import (
     FinetuneLRScheduler,
     FinetuneRequest,
     FinetuneResponse,
+    FinetunePriceEstimationRequest,
+    FinetunePriceEstimationResponse,
     FinetuneTrainingLimits,
     FullTrainingType,
     LinearLRScheduler,
@@ -31,7 +33,7 @@ from together.types import (
     TrainingMethodSFT,
     TrainingType,
 )
-from together.types.finetune import DownloadCheckpointType
+from together.types.finetune import DownloadCheckpointType, TrainingMethod
 from together.utils import log_warn_once, normalize_key
 
 
@@ -42,6 +44,12 @@ AVAILABLE_TRAINING_METHODS = {
     TrainingMethodSFT().method,
     TrainingMethodDPO().method,
 }
+_WARNING_MESSAGE_INSUFFICIENT_FUNDS = (
+    "The estimated price of the fine-tuning job is {} which is significantly "
+    "greater than your current credit limit and balance combined. "
+    "It will likely get cancelled due to insufficient funds. "
+    "Proceed at your own risk."
+)
 
 
 def create_finetune_request(
@@ -473,12 +481,34 @@ class FineTuning:
             hf_api_token=hf_api_token,
             hf_output_repo_name=hf_output_repo_name,
         )
+        if from_checkpoint is None and from_hf_model is None:
+            price_estimation_result = self.estimate_price(
+                training_file=training_file,
+                validation_file=validation_file,
+                model=model_name,
+                n_epochs=finetune_request.n_epochs,
+                n_evals=finetune_request.n_evals,
+                training_type="lora" if lora else "full",
+                training_method=training_method,
+            )
+            price_limit_passed = price_estimation_result.allowed_to_proceed
+        else:
+            # unsupported case
+            price_limit_passed = True
 
         if verbose:
             rprint(
                 "Submitting a fine-tuning job with the following parameters:",
                 finetune_request,
             )
+            if not price_limit_passed:
+                rprint(
+                    "[red]"
+                    + _WARNING_MESSAGE_INSUFFICIENT_FUNDS.format(
+                        price_estimation_result.estimated_total_price
+                    )
+                    + "[/red]",
+                )
         parameter_payload = finetune_request.model_dump(exclude_none=True)
 
         response, _, _ = requestor.request(
@@ -493,6 +523,81 @@ class FineTuning:
 
         return FinetuneResponse(**response.data)
 
+    def estimate_price(
+        self,
+        *,
+        training_file: str,
+        model: str,
+        validation_file: str | None = None,
+        n_epochs: int | None = 1,
+        n_evals: int | None = 0,
+        training_type: str = "lora",
+        training_method: str = "sft",
+    ) -> FinetunePriceEstimationResponse:
+        """
+        Estimates the price of a fine-tuning job
+
+        Args:
+            training_file (str): File-ID of a file uploaded to the Together API
+            model (str): Name of the base model to run fine-tune job on
+            validation_file (str, optional): File ID of a file uploaded to the Together API for validation.
+            n_epochs (int, optional): Number of epochs for fine-tuning. Defaults to 1.
+            n_evals (int, optional): Number of evaluation loops to run. Defaults to 0.
+            training_type (str, optional): Training type. Defaults to "lora".
+            training_method (str, optional): Training method. Defaults to "sft".
+
+        Returns:
+            FinetunePriceEstimationResponse: Object containing the price estimation result.
+        """
+        training_type_cls: TrainingType
+        training_method_cls: TrainingMethod
+
+        if training_method == "sft":
+            training_method_cls = TrainingMethodSFT(method="sft")
+        elif training_method == "dpo":
+            training_method_cls = TrainingMethodDPO(method="dpo")
+        else:
+            raise ValueError(f"Unknown training method: {training_method}")
+
+        if training_type.lower() == "lora":
+            # parameters of lora are unused in price estimation
+            # but we need to set them to valid values
+            training_type_cls = LoRATrainingType(
+                type="Lora",
+                lora_r=16,
+                lora_alpha=16,
+                lora_dropout=0.0,
+                lora_trainable_modules="all-linear",
+            )
+        elif training_type.lower() == "full":
+            training_type_cls = FullTrainingType(type="Full")
+        else:
+            raise ValueError(f"Unknown training type: {training_type}")
+
+        request = FinetunePriceEstimationRequest(
+            training_file=training_file,
+            validation_file=validation_file,
+            model=model,
+            n_epochs=n_epochs,
+            n_evals=n_evals,
+            training_type=training_type_cls,
+            training_method=training_method_cls,
+        )
+        parameter_payload = request.model_dump(exclude_none=True)
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        response, _, _ = requestor.request(
+            options=TogetherRequest(
+                method="POST", url="fine-tunes/estimate-price", params=parameter_payload
+            ),
+            stream=False,
+        )
+        assert isinstance(response, TogetherResponse)
+
+        return FinetunePriceEstimationResponse(**response.data)
+
     def list(self) -> FinetuneList:
         """
         Lists fine-tune job history
@@ -941,11 +1046,34 @@ class AsyncFineTuning:
             hf_output_repo_name=hf_output_repo_name,
         )
 
+        if from_checkpoint is None and from_hf_model is None:
+            price_estimation_result = await self.estimate_price(
+                training_file=training_file,
+                validation_file=validation_file,
+                model=model_name,
+                n_epochs=finetune_request.n_epochs,
+                n_evals=finetune_request.n_evals,
+                training_type="lora" if lora else "full",
+                training_method=training_method,
+            )
+            price_limit_passed = price_estimation_result.allowed_to_proceed
+        else:
+            # unsupported case
+            price_limit_passed = True
+
         if verbose:
             rprint(
                 "Submitting a fine-tuning job with the following parameters:",
                 finetune_request,
             )
+            if not price_limit_passed:
+                rprint(
+                    "[red]"
+                    + _WARNING_MESSAGE_INSUFFICIENT_FUNDS.format(
+                        price_estimation_result.estimated_total_price
+                    )
+                    + "[/red]",
+                )
         parameter_payload = finetune_request.model_dump(exclude_none=True)
 
         response, _, _ = await requestor.arequest(
@@ -961,6 +1089,81 @@ class AsyncFineTuning:
 
         return FinetuneResponse(**response.data)
 
+    async def estimate_price(
+        self,
+        *,
+        training_file: str,
+        model: str,
+        validation_file: str | None = None,
+        n_epochs: int | None = 1,
+        n_evals: int | None = 0,
+        training_type: str = "lora",
+        training_method: str = "sft",
+    ) -> FinetunePriceEstimationResponse:
+        """
+        Estimates the price of a fine-tuning job
+
+        Args:
+            training_file (str): File-ID of a file uploaded to the Together API
+            model (str): Name of the base model to run fine-tune job on
+            validation_file (str, optional): File ID of a file uploaded to the Together API for validation.
+            n_epochs (int, optional): Number of epochs for fine-tuning. Defaults to 1.
+            n_evals (int, optional): Number of evaluation loops to run. Defaults to 0.
+            training_type (str, optional): Training type. Defaults to "lora".
+            training_method (str, optional): Training method. Defaults to "sft".
+
+        Returns:
+            FinetunePriceEstimationResponse: Object containing the price estimation result.
+        """
+        training_type_cls: TrainingType
+        training_method_cls: TrainingMethod
+
+        if training_method == "sft":
+            training_method_cls = TrainingMethodSFT(method="sft")
+        elif training_method == "dpo":
+            training_method_cls = TrainingMethodDPO(method="dpo")
+        else:
+            raise ValueError(f"Unknown training method: {training_method}")
+
+        if training_type.lower() == "lora":
+            # parameters of lora are unused in price estimation
+            # but we need to set them to valid values
+            training_type_cls = LoRATrainingType(
+                type="Lora",
+                lora_r=16,
+                lora_alpha=16,
+                lora_dropout=0.0,
+                lora_trainable_modules="all-linear",
+            )
+        elif training_type.lower() == "full":
+            training_type_cls = FullTrainingType(type="Full")
+        else:
+            raise ValueError(f"Unknown training type: {training_type}")
+
+        request = FinetunePriceEstimationRequest(
+            training_file=training_file,
+            validation_file=validation_file,
+            model=model,
+            n_epochs=n_epochs,
+            n_evals=n_evals,
+            training_type=training_type_cls,
+            training_method=training_method_cls,
+        )
+        parameter_payload = request.model_dump(exclude_none=True)
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        response, _, _ = await requestor.arequest(
+            options=TogetherRequest(
+                method="POST", url="fine-tunes/estimate-price", params=parameter_payload
+            ),
+            stream=False,
+        )
+        assert isinstance(response, TogetherResponse)
+
+        return FinetunePriceEstimationResponse(**response.data)
+
     async def list(self) -> FinetuneList:
         """
         Async method to list fine-tune job history

{together-1.5.31 → together-1.5.33}/src/together/types/__init__.py

@@ -54,6 +54,8 @@ from together.types.finetune import (
     FinetuneListEvents,
     FinetuneRequest,
     FinetuneResponse,
+    FinetunePriceEstimationRequest,
+    FinetunePriceEstimationResponse,
     FinetuneDeleteResponse,
     FinetuneTrainingLimits,
     FullTrainingType,
@@ -103,6 +105,8 @@ __all__ = [
     "FinetuneDeleteResponse",
     "FinetuneDownloadResult",
     "FinetuneLRScheduler",
+    "FinetunePriceEstimationRequest",
+    "FinetunePriceEstimationResponse",
     "LinearLRScheduler",
     "LinearLRSchedulerArgs",
     "CosineLRScheduler",

{together-1.5.31 → together-1.5.33}/src/together/types/finetune.py

@@ -28,6 +28,14 @@ class FinetuneJobStatus(str, Enum):
     STATUS_COMPLETED = "completed"
 
 
+COMPLETED_STATUSES = [
+    FinetuneJobStatus.STATUS_ERROR,
+    FinetuneJobStatus.STATUS_USER_ERROR,
+    FinetuneJobStatus.STATUS_COMPLETED,
+    FinetuneJobStatus.STATUS_CANCELLED,
+]
+
+
 class FinetuneEventLevels(str, Enum):
     """
     Fine-tune job event status levels
@@ -167,6 +175,15 @@ class TrainingMethodDPO(TrainingMethod):
     simpo_gamma: float | None = None
 
 
+class FinetuneProgress(BaseModel):
+    """
+    Fine-tune job progress
+    """
+
+    estimate_available: bool = False
+    seconds_remaining: float = 0
+
+
 class FinetuneRequest(BaseModel):
     """
     Fine-tune request type
@@ -297,6 +314,8 @@ class FinetuneResponse(BaseModel):
     train_on_inputs: StrictBool | Literal["auto"] | None = "auto"
     from_checkpoint: str | None = None
 
+    progress: FinetuneProgress | None = None
+
     @field_validator("training_type")
     @classmethod
     def validate_training_type(cls, v: TrainingType) -> TrainingType:
@@ -308,6 +327,32 @@ class FinetuneResponse(BaseModel):
             raise ValueError("Unknown training type")
 
 
+class FinetunePriceEstimationRequest(BaseModel):
+    """
+    Fine-tune price estimation request type
+    """
+
+    training_file: str
+    validation_file: str | None = None
+    model: str
+    n_epochs: int
+    n_evals: int
+    training_type: LoRATrainingType | FullTrainingType
+    training_method: TrainingMethodSFT | TrainingMethodDPO
+
+
+class FinetunePriceEstimationResponse(BaseModel):
+    """
+    Fine-tune price estimation response type
+    """
+
+    estimated_total_price: float
+    user_limit: float
+    estimated_train_token_count: int
+    estimated_eval_token_count: int
+    allowed_to_proceed: bool
+
+
 class FinetuneList(BaseModel):
     # object type
     object: Literal["list"] | None = None

together-1.5.31/src/together/__init__.py

@@ -1,72 +0,0 @@
-from __future__ import annotations
-
-from contextvars import ContextVar
-from typing import TYPE_CHECKING, Callable
-
-from together import (
-    abstract,
-    client,
-    constants,
-    error,
-    filemanager,
-    resources,
-    together_response,
-    types,
-    utils,
-)
-from together.version import VERSION
-
-from together.legacy.complete import AsyncComplete, Complete, Completion
-from together.legacy.embeddings import Embeddings
-from together.legacy.files import Files
-from together.legacy.finetune import Finetune
-from together.legacy.images import Image
-from together.legacy.models import Models
-
-version = VERSION
-
-log: str | None = None  # Set to either 'debug' or 'info', controls console logging
-
-if TYPE_CHECKING:
-    import requests
-    from aiohttp import ClientSession
-
-requestssession: "requests.Session" | Callable[[], "requests.Session"] | None = None
-
-aiosession: ContextVar["ClientSession" | None] = ContextVar(
-    "aiohttp-session", default=None
-)
-
-from together.client import AsyncClient, AsyncTogether, Client, Together
-
-
-api_key: str | None = None  # To be deprecated in the next major release
-
-# Legacy functions
-
-
-__all__ = [
-    "aiosession",
-    "constants",
-    "version",
-    "Together",
-    "AsyncTogether",
-    "Client",
-    "AsyncClient",
-    "resources",
-    "types",
-    "abstract",
-    "filemanager",
-    "error",
-    "together_response",
-    "client",
-    "utils",
-    "Complete",
-    "AsyncComplete",
-    "Completion",
-    "Embeddings",
-    "Files",
-    "Finetune",
-    "Image",
-    "Models",
-]

together-1.5.31/src/together/cli/api/utils.py

@@ -1,51 +0,0 @@
-from __future__ import annotations
-
-from gettext import gettext as _
-from typing import Literal
-
-import click
-
-
-class AutoIntParamType(click.ParamType):
-    name = "integer_or_max"
-    _number_class = int
-
-    def convert(
-        self, value: str, param: click.Parameter | None, ctx: click.Context | None
-    ) -> int | Literal["max"] | None:
-        if value == "max":
-            return "max"
-        try:
-            return int(value)
-        except ValueError:
-            self.fail(
-                _("{value!r} is not a valid {number_type}.").format(
-                    value=value, number_type=self.name
-                ),
-                param,
-                ctx,
-            )
-
-
-class BooleanWithAutoParamType(click.ParamType):
-    name = "boolean_or_auto"
-
-    def convert(
-        self, value: str, param: click.Parameter | None, ctx: click.Context | None
-    ) -> bool | Literal["auto"] | None:
-        if value == "auto":
-            return "auto"
-        try:
-            return bool(value)
-        except ValueError:
-            self.fail(
-                _("{value!r} is not a valid {type}.").format(
-                    value=value, type=self.name
-                ),
-                param,
-                ctx,
-            )
-
-
-INT_WITH_MAX = AutoIntParamType()
-BOOL_WITH_AUTO = BooleanWithAutoParamType()