together 1.5.35__py3-none-any.whl → 2.0.0a6__py3-none-any.whl

together/{cli → lib/cli}/api/endpoints.py

@@ -1,34 +1,30 @@
 from __future__ import annotations
 
-import json
 import sys
+import json
+from typing import Any, Dict, Literal, TypeVar, Callable, cast
 from functools import wraps
-from typing import Any, Callable, Dict, List, Literal, TypeVar, Union
 
 import click
 
-from together import Together
-from together.error import InvalidRequestError
-from together.types import DedicatedEndpoint, ListEndpoint
+from together import Together, omit
+from together.types import DedicatedEndpoint
+from together._exceptions import APIError
+from together.lib.utils.serializer import datetime_serializer
+from together.types.endpoint_list_response import Data as DedicatedEndpointListItem
 
 
-def print_endpoint(
-    endpoint: Union[DedicatedEndpoint, ListEndpoint],
-) -> None:
+def print_endpoint(endpoint: DedicatedEndpoint | DedicatedEndpointListItem) -> None:
     """Print endpoint details in a Docker-like format or JSON."""
 
     # Print header info
     click.echo(f"ID:\t\t{endpoint.id}")
     click.echo(f"Name:\t\t{endpoint.name}")
 
-    # Print type-specific fields
     if isinstance(endpoint, DedicatedEndpoint):
         click.echo(f"Display Name:\t{endpoint.display_name}")
         click.echo(f"Hardware:\t{endpoint.hardware}")
-        click.echo(
-            f"Autoscaling:\tMin={endpoint.autoscaling.min_replicas}, "
-            f"Max={endpoint.autoscaling.max_replicas}"
-        )
+        click.echo(f"Autoscaling:\tMin={endpoint.autoscaling.min_replicas}, Max={endpoint.autoscaling.max_replicas}")
 
     click.echo(f"Model:\t\t{endpoint.model}")
     click.echo(f"Type:\t\t{endpoint.type}")
@@ -40,15 +36,10 @@ def print_endpoint(
 F = TypeVar("F", bound=Callable[..., Any])
 
 
-def print_api_error(
-    e: InvalidRequestError,
-) -> None:
-    error_details = e.api_response.message
+def print_api_error(e: APIError) -> None:
+    error_details = cast(Dict[str, Any], e.body)["error"]["message"]
 
-    if error_details and (
-        "credentials" in error_details.lower()
-        or "authentication" in error_details.lower()
-    ):
+    if error_details and ("credentials" in error_details.lower() or "authentication" in error_details.lower()):
         click.echo("Error: Invalid API key or authentication failed", err=True)
     else:
         click.echo(f"Error: {error_details}", err=True)
@@ -61,7 +52,7 @@ def handle_api_errors(f: F) -> F:
     def wrapper(*args: Any, **kwargs: Any) -> Any:
         try:
             return f(*args, **kwargs)
-        except InvalidRequestError as e:
+        except APIError as e:
             print_api_error(e)
             sys.exit(1)
         except Exception as e:
@@ -98,7 +89,7 @@ def endpoints(ctx: click.Context) -> None:
 )
 @click.option(
     "--gpu",
-    type=click.Choice(["b200", "h200", "h100", "a100", "l40", "l40s", "rtx-6000"]),
+    type=click.Choice(["h100", "a100", "l40", "l40s", "rtx-6000"]),
     required=True,
     help="GPU type to use for inference",
 )
@@ -137,7 +128,8 @@ def endpoints(ctx: click.Context) -> None:
     help="Start endpoint in specified availability zone (e.g., us-central-4b)",
 )
 @click.option(
-    "--wait/--no-wait",
+    "--wait",
+    is_flag=True,
     default=True,
     help="Wait for the endpoint to be ready after creation",
 )
@@ -151,8 +143,8 @@ def create(
     gpu: str,
     gpu_count: int,
     display_name: str | None,
-    no_prompt_cache: bool,
-    no_speculative_decoding: bool,
+    no_prompt_cache: bool | None,
+    no_speculative_decoding: bool | None,
     no_auto_start: bool,
     inactive_timeout: int | None,
     availability_zone: str | None,
@@ -161,8 +153,6 @@ def create(
     """Create a new dedicated inference endpoint."""
     # Map GPU types to their full hardware ID names
     gpu_map = {
-        "b200": "nvidia_b200_180gb_sxm",
-        "h200": "nvidia_h200_140gb_sxm",
         "h100": "nvidia_h100_80gb_sxm",
         "a100": "nvidia_a100_80gb_pcie" if gpu_count == 1 else "nvidia_a100_80gb_sxm",
         "l40": "nvidia_l40",
@@ -176,21 +166,21 @@ def create(
         response = client.endpoints.create(
             model=model,
             hardware=hardware_id,
-            min_replicas=min_replicas,
-            max_replicas=max_replicas,
-            display_name=display_name,
-            disable_prompt_cache=no_prompt_cache,
-            disable_speculative_decoding=no_speculative_decoding,
+            autoscaling={
+                "min_replicas": min_replicas,
+                "max_replicas": max_replicas,
+            },
+            display_name=display_name or omit,
+            disable_prompt_cache=no_prompt_cache or omit,
+            disable_speculative_decoding=no_speculative_decoding or omit,
             state="STOPPED" if no_auto_start else "STARTED",
             inactive_timeout=inactive_timeout,
-            availability_zone=availability_zone,
+            extra_query={"availability_zone": availability_zone or omit},
         )
-    except InvalidRequestError as e:
+    except APIError as e:
         print_api_error(e)
-        if "check the hardware api" in str(e).lower():
-            fetch_and_print_hardware_options(
-                client=client, model=model, print_json=False, available=True
-            )
+        if "check the hardware api" in str(e.args[0]).lower() or "invalid hardware provided" in str(e.args[0]).lower():
+            fetch_and_print_hardware_options(client=client, model=model, print_json=False, available=True)
 
         sys.exit(1)
 
@@ -219,7 +209,7 @@ def create(
         import time
 
         click.echo("Waiting for endpoint to be ready...", err=True)
-        while client.endpoints.get(response.id).state != "STARTED":
+        while client.endpoints.retrieve(response.id).state != "STARTED":
             time.sleep(1)
         click.echo("Endpoint ready", err=True)
 
@@ -234,11 +224,11 @@ def create(
 @handle_api_errors
 def get(client: Together, endpoint_id: str, json: bool) -> None:
     """Get a dedicated inference endpoint."""
-    endpoint = client.endpoints.get(endpoint_id)
+    endpoint = client.endpoints.retrieve(endpoint_id)
     if json:
         import json as json_lib
 
-        click.echo(json_lib.dumps(endpoint.model_dump(), indent=2))
+        click.echo(json_lib.dumps(endpoint.model_dump(), indent=2, default=datetime_serializer))
     else:
         print_endpoint(endpoint)
 
@@ -258,37 +248,31 @@ def hardware(client: Together, model: str | None, json: bool, available: bool) -
     fetch_and_print_hardware_options(client, model, json, available)
 
 
-def fetch_and_print_hardware_options(
-    client: Together, model: str | None, print_json: bool, available: bool
-) -> None:
+def fetch_and_print_hardware_options(client: Together, model: str | None, print_json: bool, available: bool) -> None:
     """Print hardware options for a model."""
 
     message = "Available hardware options:" if available else "All hardware options:"
     click.echo(message, err=True)
-    hardware_options = client.endpoints.list_hardware(model)
+    hardware_options = client.hardware.list(model=model or omit)
+    # hardware_options = client.endpoints.list_hardware(model)
     if available:
-        hardware_options = [
+        hardware_options.data = [
             hardware
-            for hardware in hardware_options
-            if hardware.availability is not None
-            and hardware.availability.status == "available"
+            for hardware in hardware_options.data
+            if hardware.availability is not None and hardware.availability.status == "available"
         ]
 
     if print_json:
-        json_output = [hardware.model_dump() for hardware in hardware_options]
-        click.echo(json.dumps(json_output, indent=2))
+        json_output = [hardware.model_dump() for hardware in hardware_options.data]
+        click.echo(json.dumps(json_output, default=datetime_serializer, indent=2))
     else:
-        for hardware in hardware_options:
+        for hardware in hardware_options.data:
             click.echo(f"  {hardware.id}", err=True)
 
 
 @endpoints.command()
 @click.argument("endpoint-id", required=True)
-@click.option(
-    "--wait/--no-wait",
-    default=True,
-    help="Wait for the endpoint to stop",
-)
+@click.option("--wait", is_flag=True, default=True, help="Wait for the endpoint to stop")
 @click.pass_obj
 @handle_api_errors
 def stop(client: Together, endpoint_id: str, wait: bool) -> None:
@@ -300,7 +284,7 @@ def stop(client: Together, endpoint_id: str, wait: bool) -> None:
         import time
 
         click.echo("Waiting for endpoint to stop...", err=True)
-        while client.endpoints.get(endpoint_id).state != "STOPPED":
+        while client.endpoints.retrieve(endpoint_id).state != "STOPPED":
             time.sleep(1)
         click.echo("Endpoint stopped", err=True)
 
@@ -309,11 +293,7 @@ def stop(client: Together, endpoint_id: str, wait: bool) -> None:
 
 @endpoints.command()
 @click.argument("endpoint-id", required=True)
-@click.option(
-    "--wait/--no-wait",
-    default=True,
-    help="Wait for the endpoint to start",
-)
+@click.option("--wait", is_flag=True, default=True, help="Wait for the endpoint to start")
 @click.pass_obj
 @handle_api_errors
 def start(client: Together, endpoint_id: str, wait: bool) -> None:
@@ -325,7 +305,7 @@ def start(client: Together, endpoint_id: str, wait: bool) -> None:
         import time
 
         click.echo("Waiting for endpoint to start...", err=True)
-        while client.endpoints.get(endpoint_id).state != "STARTED":
+        while client.endpoints.retrieve(endpoint_id).state != "STARTED":
             time.sleep(1)
         click.echo("Endpoint started", err=True)
 
@@ -371,8 +351,10 @@ def list(
     mine: bool | None,
 ) -> None:
     """List all inference endpoints (includes both dedicated and serverless endpoints)."""
-    endpoints: List[ListEndpoint] = client.endpoints.list(
-        type=type, usage_type=usage_type, mine=mine
+    endpoints = client.endpoints.list(
+        type=type or omit,
+        usage_type=usage_type or omit,
+        mine=mine if mine is not None else omit,
     )
 
     if not endpoints:
@@ -384,10 +366,12 @@ def list(
         import json as json_lib
 
         click.echo(
-            json_lib.dumps([endpoint.model_dump() for endpoint in endpoints], indent=2)
+            json_lib.dumps(
+                [endpoint.model_dump() for endpoint in endpoints.data], default=datetime_serializer, indent=2
+            )
         )
     else:
-        for endpoint in endpoints:
+        for endpoint in endpoints.data:
             print_endpoint(
                 endpoint,
             )
@@ -430,32 +414,30 @@ def update(
         click.echo("Error: At least one update option must be specified", err=True)
         sys.exit(1)
 
-    # If only one of min/max replicas is specified, we need both for the update
-    if (min_replicas is None) != (max_replicas is None):
-        click.echo(
-            "Error: Both --min-replicas and --max-replicas must be specified together",
-            err=True,
-        )
-        sys.exit(1)
-
     # Build kwargs for the update
     kwargs: Dict[str, Any] = {}
     if display_name is not None:
         kwargs["display_name"] = display_name
-    if min_replicas is not None and max_replicas is not None:
-        kwargs["min_replicas"] = min_replicas
-        kwargs["max_replicas"] = max_replicas
+
+    if min_replicas is not None or max_replicas is not None:
+        kwargs["autoscaling"] = {}
+        if min_replicas is not None:
+            kwargs["autoscaling"]["min_replicas"] = min_replicas
+        if max_replicas is not None:
+            kwargs["autoscaling"]["max_replicas"] = max_replicas
+
     if inactive_timeout is not None:
         kwargs["inactive_timeout"] = inactive_timeout
 
-    _response = client.endpoints.update(endpoint_id, **kwargs)
+    client.endpoints.update(endpoint_id, **kwargs)
 
     # Print what was updated
     click.echo("Updated endpoint configuration:", err=True)
     if display_name:
         click.echo(f"  Display name: {display_name}", err=True)
-    if min_replicas is not None and max_replicas is not None:
+    if min_replicas:
         click.echo(f"  Min replicas: {min_replicas}", err=True)
+    if max_replicas:
         click.echo(f"  Max replicas: {max_replicas}", err=True)
     if inactive_timeout is not None:
         click.echo(f"  Inactive timeout: {inactive_timeout} minutes", err=True)
@@ -479,8 +461,8 @@ def availability_zones(client: Together, json: bool) -> None:
     if json:
         import json as json_lib
 
-        click.echo(json_lib.dumps({"avzones": avzones}, indent=2))
+        click.echo(json_lib.dumps(avzones.model_dump(), indent=2))
     else:
         click.echo("Available zones:", err=True)
-        for availability_zone in sorted(avzones):
+        for availability_zone in sorted(avzones.avzones):
             click.echo(f"  {availability_zone}")

together/{cli/api/evaluation.py → lib/cli/api/evals.py}

@@ -1,21 +1,72 @@
+import sys
 import json
-from typing import Optional, Dict, Union, Any
+from typing import Any, Dict, List, Union, Literal, TypeVar, Callable, Optional, cast
+from functools import wraps
 
 import click
 from tabulate import tabulate
 
-from together import Together
-from together.utils import convert_unix_timestamp
+from together import APIError, Together, TogetherError
+from together._types import omit
+from together.lib.utils.serializer import datetime_serializer
+from together.types.eval_create_params import (
+    ParametersEvaluationScoreParameters,
+    ParametersEvaluationCompareParameters,
+    ParametersEvaluationClassifyParameters,
+    ParametersEvaluationScoreParametersJudge,
+    ParametersEvaluationCompareParametersJudge,
+    ParametersEvaluationClassifyParametersJudge,
+    ParametersEvaluationScoreParametersModelToEvaluate,
+    ParametersEvaluationClassifyParametersModelToEvaluate,
+    ParametersEvaluationCompareParametersModelAEvaluationModelRequest,
+    ParametersEvaluationCompareParametersModelBEvaluationModelRequest,
+)
+
+
+def print_api_error(e: Union[APIError, TogetherError]) -> None:
+    if isinstance(e, APIError):
+        error_details = cast(Dict[str, Any], e.body)["error"]["message"]
+
+        if error_details and ("credentials" in error_details.lower() or "authentication" in error_details.lower()):
+            click.echo("Error: Invalid API key or authentication failed", err=True)
+        else:
+            click.echo(f"Error: {error_details}", err=True)
+
+    click.echo(f"Error: {e}", err=True)
+    return
+
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def handle_api_errors(f: F) -> F:
+    """Decorator to handle common API errors in CLI commands."""
+
+    @wraps(f)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        try:
+            return f(*args, **kwargs)
+        except APIError as e:
+            print_api_error(e)
+            sys.exit(1)
+        except TogetherError as e:
+            print_api_error(e)
+            sys.exit(1)
+        except Exception as e:
+            click.echo(f"Error: An unexpected error occurred - {str(e)}", err=True)
+            sys.exit(1)
+
+    return wrapper  # type: ignore
 
 
 @click.group()
 @click.pass_context
-def evaluation(ctx: click.Context) -> None:
-    """Evaluation API commands"""
+def evals(ctx: click.Context) -> None:
+    """Evals API commands"""
     pass
 
 
-@evaluation.command()
+@evals.command()
 @click.pass_context
 @click.option(
     "--type",
@@ -222,11 +273,12 @@ def evaluation(ctx: click.Context) -> None:
     type=str,
     help="Input template for model B.",
 )
+@handle_api_errors
 def create(
     ctx: click.Context,
-    type: str,
+    type: Literal["classify", "score", "compare"],
     judge_model: str,
-    judge_model_source: str,
+    judge_model_source: Literal["serverless", "dedicated", "external"],
     judge_system_template: str,
     judge_external_api_token: Optional[str],
     judge_external_base_url: Optional[str],
@@ -307,13 +359,9 @@ def create(
             "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
-            )
+            model_to_evaluate_final["external_api_token"] = model_to_evaluate_external_api_token
         if model_to_evaluate_external_base_url:
-            model_to_evaluate_final["external_base_url"] = (
-                model_to_evaluate_external_base_url
-            )
+            model_to_evaluate_final["external_base_url"] = model_to_evaluate_external_base_url
 
     # Build model-a configuration
     model_a_final: Union[Dict[str, Any], None, str] = None
@@ -385,35 +433,55 @@ def create(
         if model_b_external_base_url:
             model_b_final["external_base_url"] = model_b_external_base_url
 
-    try:
-        response = client.evaluation.create(
+    judge_config = _build_judge(
+        type, judge_model, judge_model_source, judge_system_template, judge_external_api_token, judge_external_base_url
+    )
+
+    if type == "classify":
+        response = client.evals.create(
+            type=type,
+            parameters=ParametersEvaluationClassifyParameters(
+                input_data_file_path=input_data_file_path,
+                judge=judge_config,
+                labels=labels_list or [],
+                pass_labels=pass_labels_list or [],
+                model_to_evaluate=cast(ParametersEvaluationClassifyParametersModelToEvaluate, model_to_evaluate_final),
+            ),
+        )
+    elif type == "score":
+        if max_score is None or min_score is None or pass_threshold is None:
+            raise TogetherError("max_score, min_score, and pass_threshold are required for score type")
+
+        response = client.evals.create(
+            type="score",
+            parameters=ParametersEvaluationScoreParameters(
+                input_data_file_path=input_data_file_path,
+                judge=judge_config,
+                max_score=max_score,
+                min_score=min_score,
+                pass_threshold=pass_threshold,
+                model_to_evaluate=cast(ParametersEvaluationScoreParametersModelToEvaluate, model_to_evaluate_final),
+            ),
+        )
+    elif type == "compare":
+        response = client.evals.create(
             type=type,
-            judge_model=judge_model,
-            judge_model_source=judge_model_source,
-            judge_system_template=judge_system_template,
-            judge_external_api_token=judge_external_api_token,
-            judge_external_base_url=judge_external_base_url,
-            input_data_file_path=input_data_file_path,
-            model_to_evaluate=model_to_evaluate_final,
-            labels=labels_list,
-            pass_labels=pass_labels_list,
-            min_score=min_score,
-            max_score=max_score,
-            pass_threshold=pass_threshold,
-            model_a=model_a_final,
-            model_b=model_b_final,
+            parameters=ParametersEvaluationCompareParameters(
+                input_data_file_path=input_data_file_path,
+                judge=judge_config,
+                model_a=cast(ParametersEvaluationCompareParametersModelAEvaluationModelRequest, model_a_final),
+                model_b=cast(ParametersEvaluationCompareParametersModelBEvaluationModelRequest, model_b_final),
+            ),
         )
-    except ValueError as e:
-        raise click.BadParameter(str(e))
 
     click.echo(json.dumps(response.model_dump(exclude_none=True), indent=4))
 
 
-@evaluation.command()
+@evals.command()
 @click.pass_context
 @click.option(
     "--status",
-    type=str,
+    type=click.Choice(["pending", "queued", "running", "completed", "error", "user_error"]),
     help="Filter by job status.",
 )
 @click.option(
@@ -421,14 +489,18 @@ def create(
     type=int,
     help="Limit number of results (max 100).",
 )
-def list(ctx: click.Context, status: Optional[str], limit: Optional[int]) -> None:
-    """List evaluation jobs"""
+def list(
+    ctx: click.Context,
+    status: Union[Literal["pending", "queued", "running", "completed", "error", "user_error"], None],
+    limit: Union[int, None],
+) -> None:
+    """List evals"""
 
     client: Together = ctx.obj
 
-    response = client.evaluation.list(status=status, limit=limit)
+    response = client.evals.list(status=status or omit, limit=limit or omit)
 
-    display_list = []
+    display_list: List[Dict[str, Any]] = []
     for job in response:
         if job.parameters:
             model = job.parameters.get("model_to_evaluate", "")
@@ -436,6 +508,8 @@ def list(ctx: click.Context, status: Optional[str], limit: Optional[int]) -> Non
             model_b = job.parameters.get("model_b", "")
         else:
             model = ""
+            model_a = ""
+            model_b = ""
 
         display_list.append(
             {
@@ -453,7 +527,7 @@ def list(ctx: click.Context, status: Optional[str], limit: Optional[int]) -> Non
     click.echo(table)
 
 
-@evaluation.command()
+@evals.command()
 @click.pass_context
 @click.argument("evaluation_id", type=str, required=True)
 def retrieve(ctx: click.Context, evaluation_id: str) -> None:
@@ -461,12 +535,12 @@ def retrieve(ctx: click.Context, evaluation_id: str) -> None:
 
     client: Together = ctx.obj
 
-    response = client.evaluation.retrieve(evaluation_id=evaluation_id)
+    response = client.evals.retrieve(evaluation_id)
 
-    click.echo(json.dumps(response.model_dump(exclude_none=True), indent=4))
+    click.echo(json.dumps(response.model_dump(exclude_none=True), default=datetime_serializer, indent=4))
 
 
-@evaluation.command()
+@evals.command()
 @click.pass_context
 @click.argument("evaluation_id", type=str, required=True)
 def status(ctx: click.Context, evaluation_id: str) -> None:
@@ -474,6 +548,41 @@ def status(ctx: click.Context, evaluation_id: str) -> None:
 
     client: Together = ctx.obj
 
-    response = client.evaluation.status(evaluation_id=evaluation_id)
+    response = client.evals.status(evaluation_id)
 
     click.echo(json.dumps(response.model_dump(exclude_none=True), indent=4))
+
+
+def _build_judge(
+    type: Literal["classify", "score", "compare"],
+    judge_model: str,
+    judge_model_source: Literal["serverless", "dedicated", "external"],
+    judge_system_template: str,
+    judge_external_api_token: Optional[str],
+    judge_external_base_url: Optional[str],
+) -> ParametersEvaluationClassifyParametersJudge:
+    if type == "classify":
+        judge_config = ParametersEvaluationClassifyParametersJudge(
+            model=judge_model,
+            model_source=judge_model_source,
+            system_template=judge_system_template,
+        )
+    elif type == "score":
+        judge_config = ParametersEvaluationScoreParametersJudge(
+            model=judge_model,
+            model_source=judge_model_source,
+            system_template=judge_system_template,
+        )
+    elif type == "compare":
+        judge_config = ParametersEvaluationCompareParametersJudge(
+            model=judge_model,
+            model_source=judge_model_source,
+            system_template=judge_system_template,
+        )
+
+    if judge_external_api_token:
+        judge_config["external_api_token"] = judge_external_api_token
+    if judge_external_base_url:
+        judge_config["external_base_url"] = judge_external_base_url
+
+    return judge_config