truss 0.11.9rc503__tar.gz → 0.11.10__tar.gz

{truss-0.11.9rc503 → truss-0.11.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: truss
-Version: 0.11.9rc503
+Version: 0.11.10
 Summary: A seamless bridge from model development to model delivery
 Project-URL: Repository, https://github.com/basetenlabs/truss
 Project-URL: Homepage, https://truss.baseten.co
@@ -37,7 +37,7 @@ Requires-Dist: rich<14,>=13.4.2
 Requires-Dist: ruff>=0.4.8
 Requires-Dist: tenacity>=8.0.1
 Requires-Dist: tomlkit>=0.13.2
-Requires-Dist: truss-transfer<0.0.35,>=0.0.30
+Requires-Dist: truss-transfer<0.0.36,>=0.0.32
 Requires-Dist: watchfiles<0.20,>=0.19.0
 Description-Content-Type: text/markdown
 

{truss-0.11.9rc503 → truss-0.11.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "truss"
-version = "0.11.9rc503"
+version = "0.11.10"
 description = "A seamless bridge from model development to model delivery"
 authors = [
     { name = "Pankaj Gupta", email = "no-reply@baseten.co" },
@@ -43,7 +43,7 @@ dependencies = [
     "ruff>=0.4.8",
     "tenacity>=8.0.1",
     "watchfiles>=0.19.0,<0.20",
-    "truss-transfer>=0.0.30,<0.0.35",
+    "truss-transfer>=0.0.32,<0.0.36",
 ]
 
 [project.urls]

{truss-0.11.9rc503 → truss-0.11.10}/truss/base/trt_llm_config.py

@@ -577,6 +577,7 @@ class TRTLLMConfigurationV2(PydanticTrTBaseModel):
             "quantization_type",
             "quantization_config",
             "skip_build_result",
+            "num_builder_gpus",
         ]
 
         build_settings = self.build.model_dump(exclude_unset=True)

{truss-0.11.9rc503 → truss-0.11.10}/truss/cli/logs/base_watcher.py

@@ -17,7 +17,9 @@ class LogWatcher(ABC):
     # NB(nikhil): we add buffer for clock skew, so this helps us detect duplicates.
     # TODO(nikhil): clean up hashes so this doesn't grow indefinitely.
     _log_hashes: set[str] = set()
-    _last_poll_time: Optional[int] = None
+
+    _last_poll_time_ms: Optional[int] = None
+    _last_log_time_ms: Optional[int] = None
 
     def __init__(self, api: BasetenApi):
         self.api = api
@@ -26,37 +28,54 @@ class LogWatcher(ABC):
         log_str = f"{log.timestamp}-{log.message}-{log.replica}"
         return hashlib.sha256(log_str.encode("utf-8")).hexdigest()
 
-    def _poll(self) -> Iterator[ParsedLog]:
-        start_epoch: Optional[int] = None
-        now = int(time.time() * 1000)
-        if self._last_poll_time is not None:
-            start_epoch = self._last_poll_time - CLOCK_SKEW_BUFFER_MS
+    def get_start_epoch_ms(self, now_ms: int) -> Optional[int]:
+        if self._last_poll_time_ms:
+            return self._last_poll_time_ms - CLOCK_SKEW_BUFFER_MS
+
+        return None
 
+    def fetch_and_parse_logs(
+        self, start_epoch_millis: Optional[int], end_epoch_millis: Optional[int]
+    ) -> Iterator[ParsedLog]:
         api_logs = self.fetch_logs(
-            start_epoch_millis=start_epoch, end_epoch_millis=now + CLOCK_SKEW_BUFFER_MS
+            start_epoch_millis=start_epoch_millis, end_epoch_millis=end_epoch_millis
         )
 
         parsed_logs = parse_logs(api_logs)
+
         for log in parsed_logs:
-            h = self._hash_log(log)
-            if h not in self._log_hashes:
+            if (h := self._hash_log(log)) not in self._log_hashes:
                 self._log_hashes.add(h)
+
                 yield log
 
-        self._last_poll_time = now
+    def poll(self) -> Iterator[ParsedLog]:
+        now_ms = int(time.time() * 1000)
+        start_epoch_ms = self.get_start_epoch_ms(now_ms)
+
+        for log in self.fetch_and_parse_logs(
+            start_epoch_millis=start_epoch_ms,
+            end_epoch_millis=now_ms + CLOCK_SKEW_BUFFER_MS,
+        ):
+            yield log
+
+            epoch_ns = int(log.timestamp)
+            self._last_log_time_ms = int(epoch_ns / 1e6)
+
+        self._last_poll_time_ms = now_ms
 
     def watch(self) -> Iterator[ParsedLog]:
         self.before_polling()
         with console.status("Polling logs", spinner="aesthetic"):
             while True:
-                for log in self._poll():
+                for log in self.poll():
                     yield log
                 if self._log_hashes:
                     break
                 time.sleep(POLL_INTERVAL_SEC)
 
             while self.should_poll_again():
-                for log in self._poll():
+                for log in self.poll():
                     yield log
                 time.sleep(POLL_INTERVAL_SEC)
                 self.post_poll()

{truss-0.11.9rc503 → truss-0.11.10}/truss/cli/logs/model_log_watcher.py

@@ -1,9 +1,12 @@
+from functools import cached_property
 from typing import Any, List, Optional
 
 from truss.cli.logs.base_watcher import LogWatcher
 from truss.remote.baseten.api import BasetenApi
 from truss.remote.baseten.utils.status import MODEL_RUNNING_STATES
 
+MAX_LOOK_BACK_MS = 1000 * 60 * 60  # 1 hour.
+
 
 class ModelDeploymentLogWatcher(LogWatcher):
     _model_id: str
@@ -25,11 +28,31 @@ class ModelDeploymentLogWatcher(LogWatcher):
             self._model_id, self._deployment_id, start_epoch_millis, end_epoch_millis
         )
 
+    def get_start_epoch_ms(self, now_ms: int) -> Optional[int]:
+        # NOTE(Tyron): If there can be multiple replicas,
+        # we can't use a timestamp cursor to poll for logs.
+        if not self._is_development:
+            return super().get_start_epoch_ms(now_ms)
+
+        # Cursor logic.
+
+        if self._last_log_time_ms:
+            return max(self._last_log_time_ms, now_ms - MAX_LOOK_BACK_MS)
+
+        return None
+
     def should_poll_again(self) -> bool:
         return self._current_status in MODEL_RUNNING_STATES
 
+    def _get_deployment(self) -> Any:
+        return self.api.get_deployment(self._model_id, self._deployment_id)
+
     def _get_current_status(self) -> str:
-        return self.api.get_deployment(self._model_id, self._deployment_id)["status"]
+        return self._get_deployment()["status"]
+
+    @cached_property
+    def _is_development(self) -> bool:
+        return self._get_deployment()["is_development"]
 
     def post_poll(self) -> None:
         self._current_status = self._get_current_status()

{truss-0.11.9rc503 → truss-0.11.10}/truss/cli/train/core.py

@@ -16,7 +16,11 @@ from rich.text import Text
 
 from truss.cli.train import common, deploy_checkpoints
 from truss.cli.train.metrics_watcher import MetricsWatcher
-from truss.cli.train.types import DeployCheckpointArgs, DeployCheckpointsConfigComplete
+from truss.cli.train.types import (
+    DeployCheckpointArgs,
+    DeployCheckpointsConfigComplete,
+    DeploySuccessResult,
+)
 from truss.cli.utils import common as cli_common
 from truss.cli.utils.output import console
 from truss.remote.baseten.custom_types import (
@@ -244,17 +248,25 @@ def view_training_job_metrics(
 
 def create_model_version_from_inference_template(
     remote_provider: BasetenRemote, args: DeployCheckpointArgs
-) -> DeployCheckpointsConfigComplete:
+) -> DeploySuccessResult:
     if not args.deploy_config_path:
         return deploy_checkpoints.create_model_version_from_inference_template(
-            remote_provider, DeployCheckpointsConfig(), args.project_id, args.job_id
+            remote_provider,
+            DeployCheckpointsConfig(),
+            args.project_id,
+            args.job_id,
+            args.dry_run,
         )
     #### User provided a checkpoint deploy config file
     with loader.import_deploy_checkpoints_config(
         Path(args.deploy_config_path)
     ) as checkpoint_deploy:
         return deploy_checkpoints.create_model_version_from_inference_template(
-            remote_provider, checkpoint_deploy, args.project_id, args.job_id
+            remote_provider,
+            checkpoint_deploy,
+            args.project_id,
+            args.job_id,
+            args.dry_run,
         )
 
 
@@ -262,7 +274,7 @@ def _get_checkpoint_names(
     checkpoint_deploy_config: DeployCheckpointsConfigComplete,
 ) -> list[str]:
     return [
-        checkpoint.paths[0].strip("/").split("/")[-1]
+        checkpoint.checkpoint_name
         for checkpoint in checkpoint_deploy_config.checkpoint_details.checkpoints
     ]
 
@@ -299,9 +311,10 @@ def display_training_job(
     table.add_column("Value")
 
     # Basic job details
+    table.add_row("Job Name", job["name"])
+    table.add_row("Job ID", job["id"])
     table.add_row("Project ID", job["training_project"]["id"])
     table.add_row("Project Name", job["training_project"]["name"])
-    table.add_row("Job ID", job["id"])
     table.add_row("Status", job["current_status"])
     table.add_row("Instance Type", job["instance_type"]["name"])
     table.add_row("Created", cli_common.format_localized_time(job["created_at"]))

{truss-0.11.9rc503 → truss-0.11.10}/truss/cli/train/deploy_checkpoints/deploy_checkpoints.py

@@ -1,3 +1,4 @@
+import json
 import re
 from collections import OrderedDict
 from typing import List, Optional, Union
@@ -7,7 +8,11 @@ from InquirerPy import inquirer
 
 from truss.base import truss_config
 from truss.cli.train import common
-from truss.cli.train.types import DeployCheckpointsConfigComplete
+from truss.cli.train.types import (
+    DeployCheckpointsConfigComplete,
+    DeploySuccessModelVersion,
+    DeploySuccessResult,
+)
 from truss.cli.utils.output import console
 from truss.remote.baseten.remote import BasetenRemote
 from truss_train.definitions import (
@@ -35,13 +40,16 @@ def create_model_version_from_inference_template(
     checkpoint_deploy_config: DeployCheckpointsConfig,
     project_id: Optional[str],
     job_id: Optional[str],
-) -> DeployCheckpointsConfigComplete:
+    dry_run: bool,
+) -> DeploySuccessResult:
     checkpoint_deploy_config = _hydrate_deploy_config(
         checkpoint_deploy_config, remote_provider, project_id, job_id
     )
 
     request_data = _build_inference_template_request(
-        checkpoint_deploy_config, remote_provider
+        checkpoint_deploy_config=checkpoint_deploy_config,
+        remote_provider=remote_provider,
+        dry_run=dry_run,
     )
 
     # Call the GraphQL mutation to create model version from inference template
@@ -49,7 +57,9 @@ def create_model_version_from_inference_template(
         result = remote_provider.api.create_model_version_from_inference_template(
             request_data
         )
+        truss_config_result = _get_truss_config_from_result(result)
 
+        model_version = None
         if result and result.get("model_version"):
             console.print(
                 f"Successfully created model version: {result['model_version']['name']}",
@@ -58,7 +68,10 @@ def create_model_version_from_inference_template(
             console.print(
                 f"Model version ID: {result['model_version']['id']}", style="yellow"
             )
-        else:
+            model_version = DeploySuccessModelVersion.model_validate(
+                result["model_version"]
+            )
+        elif not dry_run:
             console.print(
                 "Warning: Unexpected response format from server", style="yellow"
             )
@@ -68,12 +81,31 @@ def create_model_version_from_inference_template(
         console.print(f"Error creating model version: {e}", style="red")
         raise
 
-    return checkpoint_deploy_config
+    return DeploySuccessResult(
+        deploy_config=checkpoint_deploy_config,
+        truss_config=truss_config_result,
+        model_version=model_version,
+    )
+
+
+def _get_truss_config_from_result(result: dict) -> Optional[truss_config.TrussConfig]:
+    if result and result.get("truss_config"):
+        truss_config_dict = json.loads(result["truss_config"])
+        return truss_config.TrussConfig.from_dict(truss_config_dict)
+    # Although this should never happen, we defensively allow ourselves to return None
+    # because we need a failure to handle the truss config doesn't necessarily mean we failed to deploy
+    # the model version.
+    console.print(
+        "No truss config returned. Reach out to Baseten for support if this persists.",
+        style="red",
+    )
+    return None
 
 
 def _build_inference_template_request(
     checkpoint_deploy_config: DeployCheckpointsConfigComplete,
     remote_provider: BasetenRemote,
+    dry_run: bool,
 ) -> dict:
     """
     Build the GraphQL request data structure for createModelVersionFromInferenceTemplate mutation.
@@ -83,18 +115,12 @@ def _build_inference_template_request(
     weights_sources = []
     for checkpoint in checkpoint_deploy_config.checkpoint_details.checkpoints:
         # Extract checkpoint name from the first path
-        checkpoint_name = (
-            checkpoint.paths[0].strip("/").split("/")[-1]
-            if checkpoint.paths
-            else "checkpoint"
-        )
-
         weights_source = {
             "weight_source_type": "B10_CHECKPOINTING",
             "b10_training_checkpoint_weights_source": {
                 "checkpoint": {
                     "training_job_id": checkpoint.training_job_id,
-                    "checkpoint_name": checkpoint_name,
+                    "checkpoint_name": checkpoint.checkpoint_name,
                 }
             },
         }
@@ -126,6 +152,7 @@ def _build_inference_template_request(
         "weights_sources": weights_sources,
         "inference_stack": inference_stack,
         "instance_type_id": instance_type_id,
+        "dry_run": dry_run,
     }
 
     return request_data
@@ -276,6 +303,7 @@ def _ensure_checkpoint_details(
     job_id: Optional[str],
 ) -> CheckpointList:
     if checkpoint_details and checkpoint_details.checkpoints:
+        # TODO: check here
         return _process_user_provided_checkpoints(checkpoint_details, remote_provider)
     else:
         return _prompt_user_for_checkpoint_details(

truss-0.11.10/truss/cli/train/deploy_checkpoints/deploy_full_checkpoints.py

@@ -0,0 +1,9 @@
+from truss_train.definitions import FullCheckpoint
+
+
+def hydrate_full_checkpoint(
+    job_id: str, checkpoint_id: str, checkpoint: dict
+) -> FullCheckpoint:
+    """Create a Checkpoint object for full model weights."""
+    # NOTE: Slash at the end is important since it means the checkpoint is a directory
+    return FullCheckpoint(training_job_id=job_id, checkpoint_name=checkpoint_id)

{truss-0.11.9rc503 → truss-0.11.10}/truss/cli/train/deploy_checkpoints/deploy_lora_checkpoints.py

@@ -11,11 +11,10 @@ def hydrate_lora_checkpoint(
 ) -> LoRACheckpoint:
     """Create a LoRA-specific Checkpoint object."""
     # NOTE: Slash at the end is important since it means the checkpoint is a directory
-    paths = [f"rank-0/{checkpoint_id}/"]
     return LoRACheckpoint(
         training_job_id=job_id,
-        paths=paths,
         lora_details=LoRADetails(rank=_get_lora_rank(checkpoint)),
+        checkpoint_name=checkpoint_id,
     )
 
 

{truss-0.11.9rc503 → truss-0.11.10}/truss/cli/train/deploy_checkpoints/deploy_whisper_checkpoints.py

@@ -5,6 +5,4 @@ def hydrate_whisper_checkpoint(
     job_id: str, checkpoint_id: str, checkpoint: dict
 ) -> WhisperCheckpoint:
     """Create a Checkpoint object for whisper model weights."""
-    # NOTE: Slash at the end is important since it means the checkpoint is a directory
-    paths = [f"rank-0/{checkpoint_id}/"]
-    return WhisperCheckpoint(training_job_id=job_id, paths=paths)
+    return WhisperCheckpoint(training_job_id=job_id, checkpoint_name=checkpoint_id)

{truss-0.11.9rc503 → truss-0.11.10}/truss/cli/train/types.py

@@ -1,6 +1,9 @@
 from dataclasses import dataclass
 from typing import Optional
 
+from pydantic import BaseModel
+
+from truss.base import truss_config
 from truss_train.definitions import (
     CheckpointList,
     Compute,
@@ -11,6 +14,7 @@ from truss_train.definitions import (
 
 @dataclass
 class DeployCheckpointArgs:
+    dry_run: bool
     project_id: Optional[str]
     job_id: Optional[str]
     deploy_config_path: Optional[str]
@@ -26,3 +30,18 @@ class DeployCheckpointsConfigComplete(DeployCheckpointsConfig):
     model_name: str
     runtime: DeployCheckpointsRuntime
     compute: Compute
+
+
+class DeploySuccessModelVersion(BaseModel):
+    # allow extra fields to be forwards compatible with server
+    class Config:
+        extra = "allow"
+
+    name: str
+    id: str
+
+
+class DeploySuccessResult(BaseModel):
+    deploy_config: DeployCheckpointsConfigComplete
+    truss_config: Optional[truss_config.TrussConfig]
+    model_version: Optional[DeploySuccessModelVersion]

{truss-0.11.9rc503 → truss-0.11.10}/truss/cli/train_commands.py

@@ -1,5 +1,6 @@
 import os
 import sys
+from datetime import datetime
 from pathlib import Path
 from typing import Optional, cast
 
@@ -22,6 +23,7 @@ from truss.cli.train.core import (
     SORT_ORDER_ASC,
     SORT_ORDER_DESC,
 )
+from truss.cli.train.types import DeploySuccessResult
 from truss.cli.utils import common
 from truss.cli.utils.output import console, error_console
 from truss.remote.baseten.core import get_training_job_logs_with_pagination
@@ -306,6 +308,12 @@ def get_job_metrics(
 @click.option(
     "--dry-run", is_flag=True, help="Generate a truss config without deploying"
 )
+@click.option(
+    "--truss-config-output-dir",
+    type=str,
+    required=False,
+    help="Path to output the truss config to. If not provided, will output to truss_configs/<model_version_name>_<model_version_id> or truss_configs/dry_run_<timestamp> if dry run.",
+)
 @click.option("--remote", type=str, required=False, help="Remote to use")
 @common.common_options()
 def deploy_checkpoints(
@@ -315,6 +323,7 @@ def deploy_checkpoints(
     config: Optional[str],
     remote: Optional[str],
     dry_run: bool,
+    truss_config_output_dir: Optional[str],
 ):
     """
     Deploy a LoRA checkpoint via vLLM.
@@ -332,13 +341,46 @@ def deploy_checkpoints(
     result = train_cli.create_model_version_from_inference_template(
         remote_provider,
         train_cli.DeployCheckpointArgs(
-            project_id=project_id, job_id=job_id, deploy_config_path=config
+            project_id=project_id,
+            job_id=job_id,
+            deploy_config_path=config,
+            dry_run=dry_run,
         ),
     )
 
     if dry_run:
-        console.print("--dry-run flag provided, did not deploy", style="yellow")
-    train_cli.print_deploy_checkpoints_success_message(result)
+        console.print("did not deploy because --dry-run flag provided", style="yellow")
+
+    _write_truss_config(result, truss_config_output_dir, dry_run)
+
+    if not dry_run:
+        train_cli.print_deploy_checkpoints_success_message(result.deploy_config)
+
+
+def _write_truss_config(
+    result: DeploySuccessResult, truss_config_output_dir: Optional[str], dry_run: bool
+) -> None:
+    if not result.truss_config:
+        return
+    # format: 20251006_123456
+    datestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    folder_name = (
+        f"{result.model_version.name}_{result.model_version.id}"
+        if result.model_version
+        else f"dry_run_{datestamp}"
+    )
+    output_dir_str = truss_config_output_dir or f"truss_configs/{folder_name}"
+    output_dir = Path(output_dir_str)
+    output_path = output_dir / "config.yaml"
+    os.makedirs(output_dir, exist_ok=True)
+    console.print(f"Writing truss config to {output_path}", style="yellow")
+    console.print(f"👀 Run `cat {output_path}` to view the truss config", style="green")
+    if dry_run:
+        console.print(
+            f"🚀 Run `cd {output_dir} && truss push --publish` to deploy the truss",
+            style="green",
+        )
+    result.truss_config.write_to_yaml_file(output_path)
 
 
 @train.command(name="download")

{truss-0.11.9rc503 → truss-0.11.10}/truss/contexts/image_builder/serving_image_builder.py

@@ -784,16 +784,7 @@ class ServingImageBuilder(ImageBuilder):
             config
         )
 
-        # Debug: Print the actual values
-        non_root_user_env = os.getenv("BT_USE_NON_ROOT_USER")
-        print(f"DEBUG: BT_USE_NON_ROOT_USER env var value: {repr(non_root_user_env)}")
-        print(f"DEBUG: BT_USE_NON_ROOT_USER type: {type(non_root_user_env)}")
-        
         non_root_user = os.getenv("BT_USE_NON_ROOT_USER", False)
-        print(f"DEBUG: non_root_user value: {repr(non_root_user)}")
-        print(f"DEBUG: non_root_user type: {type(non_root_user)}")
-        print(f"DEBUG: non_root_user truthiness: {bool(non_root_user)}")
-                
         dockerfile_contents = dockerfile_template.render(
             should_install_server_requirements=should_install_server_requirements,
             base_image_name_and_tag=base_image_name_and_tag,
@@ -836,5 +827,3 @@ class ServingImageBuilder(ImageBuilder):
         ).strip()
         docker_file_path = build_dir / MODEL_DOCKERFILE_NAME
         docker_file_path.write_text(dockerfile_contents)
-        import time
-        time.sleep(100000)

{truss-0.11.9rc503 → truss-0.11.10}/truss/remote/baseten/api.py

@@ -800,10 +800,10 @@ class BasetenApi:
                     id
                     name
                 }
+                truss_config
             }
         }
         """
-
         resp = self._post_graphql_query(
             query_string, variables={"request": request_data}
         )

{truss-0.11.9rc503 → truss-0.11.10}/truss/templates/control/control/application.py

@@ -38,14 +38,17 @@ class SanitizedExceptionMiddleware(BaseHTTPMiddleware):
         try:
             return await call_next(request)
         except Exception as exc:
-            sanitized_traceback = self._create_sanitized_traceback(exc)
-            request.app.state.logger.error(sanitized_traceback)
-
+            # NB(nikhil): Intentionally bypass error logging for ModelLoadFailed, since health checks
+            # are noisy. The underlying model logs for why the load failed will still be visible.
             if isinstance(exc, ModelLoadFailed):
                 return JSONResponse(
                     {"error": str(exc)}, status_code=http.HTTPStatus.BAD_GATEWAY.value
                 )
-            elif isinstance(exc, PatchApplicatonError):
+
+            sanitized_traceback = self._create_sanitized_traceback(exc)
+            request.app.state.logger.error(sanitized_traceback)
+
+            if isinstance(exc, PatchApplicatonError):
                 error_type = _camel_to_snake_case(type(exc).__name__)
                 return JSONResponse({"error": {"type": error_type, "msg": str(exc)}})
             else:
@@ -84,10 +87,9 @@ def create_app(base_config: Dict):
         base_url=f"http://localhost:{app_state.inference_server_port}", limits=limits
     )
 
-    pip_path = getattr(app_state, "pip_path", None)
-
+    uv_path = getattr(app_state, "uv_path", None)
     patch_applier = ModelContainerPatchApplier(
-        Path(app_state.inference_server_home), app_logger, pip_path
+        Path(app_state.inference_server_home), app_logger, uv_path
     )
 
     oversee_inference_server = getattr(app_state, "oversee_inference_server", True)

{truss-0.11.9rc503 → truss-0.11.10}/truss/templates/server.Dockerfile.jinja

@@ -69,7 +69,7 @@ COPY --chown={{ default_owner }} ./{{ config.data_dir }} ${APP_HOME}/data
 
 {%- if model_cache_v2 %}
 {# v0.0.9, keep synced with server_requirements.txt #}
-RUN curl -sSL --fail --retry 5 --retry-delay 2 -o /usr/local/bin/truss-transfer-cli https://github.com/basetenlabs/truss/releases/download/v0.10.11rc1/truss-transfer-cli-v0.10.11rc1-linux-x86_64-unknown-linux-musl
+RUN curl -sSL --fail --retry 5 --retry-delay 2 -o /usr/local/bin/truss-transfer-cli https://github.com/basetenlabs/truss/releases/download/v0.11.10rc5/truss-transfer-cli-v0.11.10rc5-linux-x86_64-unknown-linux-musl
 RUN chmod +x /usr/local/bin/truss-transfer-cli
 RUN mkdir /static-bptr
 RUN echo "hash {{model_cache_hash}}"

{truss-0.11.9rc503 → truss-0.11.10}/truss/tests/cli/train/test_deploy_checkpoints.py

@@ -115,8 +115,7 @@ def test_hydrate_full_checkpoint():
     assert isinstance(result, definitions.FullCheckpoint)
     assert result.training_job_id == job_id
     assert result.model_weight_format == ModelWeightsFormat.FULL
-    assert len(result.paths) == 1
-    assert result.paths[0] == f"rank-0/{checkpoint_id}/"
+    assert result.checkpoint_name == checkpoint_id
 
 
 def test_hydrate_checkpoint_dispatcher_full():
@@ -272,6 +271,6 @@ def test_hydrate_whisper_checkpoint():
     result = hydrate_whisper_checkpoint(job_id, checkpoint_id, checkpoint)
 
     assert result.training_job_id == job_id
-    assert result.paths == [f"rank-0/{checkpoint_id}/"]
+    assert result.checkpoint_name == checkpoint_id
     assert result.model_weight_format == definitions.ModelWeightsFormat.WHISPER
     assert isinstance(result, definitions.WhisperCheckpoint)

{truss-0.11.9rc503 → truss-0.11.10}/truss/tests/templates/control/control/test_server.py

@@ -53,7 +53,7 @@ def app(truss_container_fs, truss_original_hash, ports):
                 "control_server_port": ports["control_server_port"],
                 "inference_server_port": ports["inference_server_port"],
                 "oversee_inference_server": False,
-                "pip_path": "pip",
+                "uv_path": "uv",
             }
         )
         inference_server_controller = control_app.state.inference_server_controller

{truss-0.11.9rc503 → truss-0.11.10}/truss-train/truss_train/definitions.py

@@ -185,12 +185,13 @@ class TrainingProject(custom_types.SafeModelNoExtra):
 
 class Checkpoint(custom_types.ConfigModel, ABC):
     training_job_id: str
-    paths: List[str]
+    checkpoint_name: str
     model_weight_format: ModelWeightsFormat
 
     def to_truss_config(self) -> truss_config.TrainingArtifactReference:
         return truss_config.TrainingArtifactReference(
-            training_job_id=self.training_job_id, paths=self.paths
+            training_job_id=self.training_job_id,
+            paths=[f"rank-0/{self.checkpoint_name}/"],
         )
 
 

{truss-0.11.9rc503 → truss-0.11.10}/truss-transfer/README.md

@@ -284,7 +284,7 @@ The following environment variables can be used to configure truss-transfer beha
   - Number of concurrent download workers
   - Controls parallelism for file downloads
 
-- **`TRUSS_TRANSFER_USE_RANGE_DOWNLOAD`** (default: `false`)
+- **`TRUSS_TRANSFER_USE_RANGE_DOWNLOAD`** (default: `true`)
   - Enable/disable range-based downloading for large files
   - Set to `1`, `true`, `yes`, or `y` to enable