truss 0.11.6rc102__py3-none-any.whl → 0.11.24rc2__py3-none-any.whl

truss/cli/train/deploy_checkpoints/deploy_lora_checkpoints.py

@@ -1,12 +1,3 @@
-from pathlib import Path
-
-from jinja2 import Template
-
-from truss.base import truss_config
-from truss.cli.train.deploy_checkpoints.deploy_checkpoints_helpers import (
-    START_COMMAND_ENVVAR_NAME,
-)
-from truss.cli.train.types import DeployCheckpointsConfigComplete
 from truss_train.definitions import (
     ALLOWED_LORA_RANKS,
     DEFAULT_LORA_RANK,
@@ -14,78 +5,19 @@ from truss_train.definitions import (
     LoRADetails,
 )
 
-from .deploy_checkpoints_helpers import (
-    setup_base_truss_config,
-    setup_environment_variables_and_secrets,
-)
-
-VLLM_LORA_START_COMMAND = Template(
-    'sh -c "{%if envvars %}{{ envvars }} {% endif %}vllm serve {{ base_model_id }}'
-    + " --port 8000"
-    + "{{ specify_tensor_parallelism }}"
-    + " --enable-lora"
-    + " --max-lora-rank {{ max_lora_rank }}"
-    + " --dtype bfloat16"
-    + ' --lora-modules {{ lora_modules }}"'
-)
-
 
 def hydrate_lora_checkpoint(
     job_id: str, checkpoint_id: str, checkpoint: dict
 ) -> 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,
     )
 
 
-def render_vllm_lora_truss_config(
-    checkpoint_deploy: DeployCheckpointsConfigComplete,
-) -> truss_config.TrussConfig:
-    """Render truss config specifically for LoRA checkpoints using vLLM."""
-    truss_deploy_config = setup_base_truss_config(checkpoint_deploy)
-    start_command_envvars = setup_environment_variables_and_secrets(
-        truss_deploy_config, checkpoint_deploy
-    )
-
-    checkpoint_str = _build_lora_checkpoint_string(truss_deploy_config)
-
-    max_lora_rank = max(
-        [
-            checkpoint.lora_details.rank or DEFAULT_LORA_RANK
-            for checkpoint in checkpoint_deploy.checkpoint_details.checkpoints
-            if hasattr(checkpoint, "lora_details") and checkpoint.lora_details
-        ]
-    )
-    accelerator = checkpoint_deploy.compute.accelerator
-    if accelerator:
-        specify_tensor_parallelism = f" --tensor-parallel-size {accelerator.count}"
-    else:
-        specify_tensor_parallelism = ""
-
-    start_command_args = {
-        "base_model_id": checkpoint_deploy.checkpoint_details.base_model_id,
-        "lora_modules": checkpoint_str,
-        "envvars": start_command_envvars,
-        "max_lora_rank": max_lora_rank,
-        "specify_tensor_parallelism": specify_tensor_parallelism,
-    }
-    start_command = VLLM_LORA_START_COMMAND.render(**start_command_args)
-    # Note: we set the start command as an environment variable in supervisord config.
-    # This is so that we don't have to change the supervisord config when the start command changes.
-    # Our goal is to reduce the number of times we need to rebuild the image, and allow us to deploy faster.
-    truss_deploy_config.environment_variables[START_COMMAND_ENVVAR_NAME] = start_command
-    # Note: supervisord uses the convention %(ENV_VAR_NAME)s to access environment variable VAR_NAME
-    truss_deploy_config.docker_server.start_command = (  # type: ignore[union-attr]
-        f"%(ENV_{START_COMMAND_ENVVAR_NAME})s"
-    )
-    return truss_deploy_config
-
-
 def _get_lora_rank(checkpoint_resp: dict) -> int:
     """Extract and validate LoRA rank from checkpoint response."""
     lora_adapter_config = checkpoint_resp.get("lora_adapter_config") or {}
@@ -99,19 +31,3 @@ def _get_lora_rank(checkpoint_resp: dict) -> int:
         )
 
     return lora_rank
-
-
-def _build_lora_checkpoint_string(truss_deploy_config) -> str:
-    """Build the checkpoint string for LoRA modules from truss deploy config."""
-    checkpoint_parts = []
-    for (
-        truss_checkpoint
-    ) in truss_deploy_config.training_checkpoints.artifact_references:  # type: ignore
-        ckpt_path = Path(
-            truss_deploy_config.training_checkpoints.download_folder,  # type: ignore
-            truss_checkpoint.training_job_id,
-            truss_checkpoint.paths[0],
-        )
-        checkpoint_parts.append(f"{truss_checkpoint.training_job_id}={ckpt_path}")
-
-    return " ".join(checkpoint_parts)

truss/cli/train/deploy_checkpoints/deploy_whisper_checkpoints.py

@@ -1,63 +1,8 @@
-from jinja2 import Template
-
-from truss.base import truss_config
-from truss.cli.train.deploy_checkpoints.deploy_checkpoints_helpers import (
-    START_COMMAND_ENVVAR_NAME,
-)
-from truss.cli.train.deploy_checkpoints.deploy_full_checkpoints import (
-    build_full_checkpoint_string,
-)
-from truss.cli.train.types import DeployCheckpointsConfigComplete
 from truss_train.definitions import WhisperCheckpoint
 
-from .deploy_checkpoints_helpers import (
-    setup_base_truss_config,
-    setup_environment_variables_and_secrets,
-)
-
-VLLM_WHISPER_START_COMMAND = Template(
-    "sh -c '{% if envvars %}{{ envvars }} {% endif %}"
-    'HF_TOKEN="$$(cat /secrets/hf_access_token)" && export HF_TOKEN && '
-    "vllm serve {{ model_path }} --port 8000 --tensor-parallel-size {{ specify_tensor_parallelism }}'"
-)
-
-
-def render_vllm_whisper_truss_config(
-    checkpoint_deploy: DeployCheckpointsConfigComplete,
-) -> truss_config.TrussConfig:
-    """Render truss config specifically for whisper checkpoints using vLLM."""
-    truss_deploy_config = setup_base_truss_config(checkpoint_deploy)
-
-    start_command_envvars = setup_environment_variables_and_secrets(
-        truss_deploy_config, checkpoint_deploy
-    )
-
-    checkpoint_str = build_full_checkpoint_string(truss_deploy_config)
-
-    accelerator = checkpoint_deploy.compute.accelerator
-
-    start_command_args = {
-        "model_path": checkpoint_str,
-        "envvars": start_command_envvars,
-        "specify_tensor_parallelism": accelerator.count if accelerator else 1,
-    }
-    # Note: we set the start command as an environment variable in supervisord config.
-    # This is so that we don't have to change the supervisord config when the start command changes.
-    # Our goal is to reduce the number of times we need to rebuild the image, and allow us to deploy faster.
-    start_command = VLLM_WHISPER_START_COMMAND.render(**start_command_args)
-    truss_deploy_config.environment_variables[START_COMMAND_ENVVAR_NAME] = start_command
-    # Note: supervisord uses the convention %(ENV_VAR_NAME)s to access environment variable VAR_NAME
-    truss_deploy_config.docker_server.start_command = (  # type: ignore[union-attr]
-        f"%(ENV_{START_COMMAND_ENVVAR_NAME})s"
-    )
-
-    return truss_deploy_config
-
 
 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/cli/train/types.py

@@ -1,18 +1,20 @@
 from dataclasses import dataclass
-from pathlib import Path
 from typing import Optional
 
+from pydantic import BaseModel
+
+from truss.base import truss_config
 from truss_train.definitions import (
     CheckpointList,
     Compute,
     DeployCheckpointsConfig,
     DeployCheckpointsRuntime,
-    ModelWeightsFormat,
 )
 
 
 @dataclass
-class PrepareCheckpointArgs:
+class DeployCheckpointArgs:
+    dry_run: bool
     project_id: Optional[str]
     job_id: Optional[str]
     deploy_config_path: Optional[str]
@@ -26,13 +28,20 @@ class DeployCheckpointsConfigComplete(DeployCheckpointsConfig):
 
     checkpoint_details: CheckpointList
     model_name: str
-    deployment_name: str
     runtime: DeployCheckpointsRuntime
     compute: Compute
-    model_weight_format: ModelWeightsFormat
 
 
-@dataclass
-class PrepareCheckpointResult:
-    truss_directory: Path
-    checkpoint_deploy_config: DeployCheckpointsConfigComplete
+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/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
 
@@ -8,12 +9,18 @@ import rich_click as click
 import truss.cli.train.core as train_cli
 from truss.base.constants import TRAINING_TEMPLATE_DIR
 from truss.cli import remote_cli
-from truss.cli.cli import push, truss_cli
+from truss.cli.cli import truss_cli
 from truss.cli.logs import utils as cli_log_utils
 from truss.cli.logs.training_log_watcher import TrainingLogWatcher
+from truss.cli.resolvers.training_project_team_resolver import (
+    resolve_training_project_team_name,
+)
 from truss.cli.train import common as train_common
 from truss.cli.train import core
-from truss.cli.train.core import (
+from truss.cli.train.cache import (
+    OUTPUT_FORMAT_CLI_TABLE,
+    OUTPUT_FORMAT_CSV,
+    OUTPUT_FORMAT_JSON,
     SORT_BY_FILEPATH,
     SORT_BY_MODIFIED,
     SORT_BY_PERMISSIONS,
@@ -22,6 +29,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
@@ -41,13 +49,14 @@ truss_cli.add_command(train)
 
 def _print_training_job_success_message(
     job_id: str,
+    project_id: str,
     project_name: str,
-    job_object: TrainingJob,
+    job_object: Optional[TrainingJob],
     remote_provider: BasetenRemote,
 ) -> None:
     """Print success message and helpful commands for a training job."""
     console.print("✨ Training job successfully created!", style="green")
-    should_print_cache_summary = (
+    should_print_cache_summary = job_object and (
         job_object.runtime.enable_cache
         or job_object.runtime.cache_config
         and job_object.runtime.cache_config.enabled
@@ -64,7 +73,7 @@ def _print_training_job_success_message(
         f"🔍 View metrics for your job via "
         f"[cyan]'truss train metrics --job-id {job_id}'[/cyan]\n"
         f"{cache_summary_snippet}"
-        f"🌐 Status page: {common.format_link(core.status_page_url(remote_provider.remote_url, job_id))}"
+        f"🌐 View job in the UI: {common.format_link(core.status_page_url(remote_provider.remote_url, project_id, job_id))}"
     )
 
 
@@ -80,8 +89,13 @@ def _handle_post_create_logic(
             style="green",
         )
     else:
+        # recreate currently doesn't pass back a job object.
         _print_training_job_success_message(
-            job_id, project_name, job_resp["job_object"], remote_provider
+            job_id,
+            project_id,
+            project_name,
+            job_resp.get("job_object"),
+            remote_provider,
         )
 
     if tail:
@@ -100,29 +114,70 @@ def _prepare_click_context(f: click.Command, params: dict) -> click.Context:
     return ctx
 
 
+def _resolve_team_name(
+    remote_provider: BasetenRemote,
+    provided_team_name: Optional[str],
+    existing_project_name: Optional[str] = None,
+    existing_teams: Optional[dict[str, dict[str, str]]] = None,
+) -> tuple[Optional[str], Optional[str]]:
+    return resolve_training_project_team_name(
+        remote_provider=remote_provider,
+        provided_team_name=provided_team_name,
+        existing_project_name=existing_project_name,
+        existing_teams=existing_teams,
+    )
+
+
 @train.command(name="push")
 @click.argument("config", type=Path, required=True)
 @click.option("--remote", type=str, required=False, help="Remote to use")
 @click.option("--tail", is_flag=True, help="Tail for status + logs after push.")
 @click.option("--job-name", type=str, required=False, help="Name of the training job.")
+@click.option(
+    "--team",
+    "provided_team_name",
+    type=str,
+    required=False,
+    help="Team name for the training project",
+)
 @common.common_options()
 def push_training_job(
-    config: Path, remote: Optional[str], tail: bool, job_name: Optional[str]
+    config: Path,
+    remote: Optional[str],
+    tail: bool,
+    job_name: Optional[str],
+    provided_team_name: Optional[str],
 ):
     """Run a training job"""
-    from truss_train import deployment
+    from truss_train import deployment, loader
 
     if not remote:
         remote = remote_cli.inquire_remote_name()
 
-    with console.status("Creating training job...", spinner="dots"):
-        remote_provider: BasetenRemote = cast(
-            BasetenRemote, RemoteFactory.create(remote=remote)
-        )
-        job_resp = deployment.create_training_job_from_file(
-            remote_provider, config, job_name
+    remote_provider: BasetenRemote = cast(
+        BasetenRemote, RemoteFactory.create(remote=remote)
+    )
+
+    existing_teams = remote_provider.api.get_teams()
+
+    with loader.import_training_project(config) as training_project:
+        team_name, team_id = _resolve_team_name(
+            remote_provider,
+            provided_team_name,
+            existing_project_name=training_project.name,
+            existing_teams=existing_teams,
         )
 
+        with console.status("Creating training job...", spinner="dots"):
+            job_resp = deployment.create_training_job(
+                remote_provider,
+                config,
+                training_project,
+                job_name_from_cli=job_name,
+                team_name=team_name,
+                team_id=team_id,
+            )
+
     # Note: This post create logic needs to happen outside the context
     # of the above context manager, as only one console session can be active
     # at a time.
@@ -156,11 +211,16 @@ def recreate_training_job(job_id: Optional[str], remote: Optional[str], tail: bo
 @train.command(name="logs")
 @click.option("--remote", type=str, required=False, help="Remote to use")
 @click.option("--project-id", type=str, required=False, help="Project ID.")
+@click.option("--project", type=str, required=False, help="Project name or project id.")
 @click.option("--job-id", type=str, required=False, help="Job ID.")
 @click.option("--tail", is_flag=True, help="Tail for ongoing logs.")
 @common.common_options()
 def get_job_logs(
-    remote: Optional[str], project_id: Optional[str], job_id: Optional[str], tail: bool
+    remote: Optional[str],
+    project_id: Optional[str],
+    project: Optional[str],
+    job_id: Optional[str],
+    tail: bool,
 ):
     """Fetch logs for a training job"""
 
@@ -170,6 +230,10 @@ def get_job_logs(
     remote_provider: BasetenRemote = cast(
         BasetenRemote, RemoteFactory.create(remote=remote)
     )
+    project_id = _maybe_resolve_project_id_from_id_or_name(
+        remote_provider, project_id=project_id, project=project
+    )
+
     project_id, job_id = train_common.get_most_recent_job(
         remote_provider, project_id, job_id
     )
@@ -188,12 +252,17 @@ def get_job_logs(
 
 @train.command(name="stop")
 @click.option("--project-id", type=str, required=False, help="Project ID.")
+@click.option("--project", type=str, required=False, help="Project name or project id.")
 @click.option("--job-id", type=str, required=False, help="Job ID.")
 @click.option("--all", is_flag=True, help="Stop all running jobs.")
 @click.option("--remote", type=str, required=False, help="Remote to use")
 @common.common_options()
 def stop_job(
-    project_id: Optional[str], job_id: Optional[str], all: bool, remote: Optional[str]
+    project_id: Optional[str],
+    project: Optional[str],
+    job_id: Optional[str],
+    all: bool,
+    remote: Optional[str],
 ):
     """Stop a training job"""
 
@@ -203,6 +272,9 @@ def stop_job(
     remote_provider: BasetenRemote = cast(
         BasetenRemote, RemoteFactory.create(remote=remote)
     )
+    project_id = _maybe_resolve_project_id_from_id_or_name(
+        remote_provider, project_id=project_id, project=project
+    )
     if all:
         train_cli.stop_all_jobs(remote_provider, project_id)
     else:
@@ -217,13 +289,17 @@ def stop_job(
 @click.option(
     "--project-id", type=str, required=False, help="View training jobs for a project."
 )
+@click.option("--project", type=str, required=False, help="Project name or project id.")
 @click.option(
     "--job-id", type=str, required=False, help="View a specific training job."
 )
 @click.option("--remote", type=str, required=False, help="Remote to use")
 @common.common_options()
 def view_training(
-    project_id: Optional[str], job_id: Optional[str], remote: Optional[str]
+    project_id: Optional[str],
+    project: Optional[str],
+    job_id: Optional[str],
+    remote: Optional[str],
 ):
     """List all training jobs for a project"""
 
@@ -233,16 +309,24 @@ def view_training(
     remote_provider: BasetenRemote = cast(
         BasetenRemote, RemoteFactory.create(remote=remote)
     )
+    project_id = _maybe_resolve_project_id_from_id_or_name(
+        remote_provider, project_id=project_id, project=project
+    )
+
     train_cli.view_training_details(remote_provider, project_id, job_id)
 
 
 @train.command(name="metrics")
 @click.option("--project-id", type=str, required=False, help="Project ID.")
+@click.option("--project", type=str, required=False, help="Project name or project id.")
 @click.option("--job-id", type=str, required=False, help="Job ID.")
 @click.option("--remote", type=str, required=False, help="Remote to use")
 @common.common_options()
 def get_job_metrics(
-    project_id: Optional[str], job_id: Optional[str], remote: Optional[str]
+    project_id: Optional[str],
+    project: Optional[str],
+    job_id: Optional[str],
+    remote: Optional[str],
 ):
     """Get metrics for a training job"""
 
@@ -252,11 +336,15 @@ def get_job_metrics(
     remote_provider: BasetenRemote = cast(
         BasetenRemote, RemoteFactory.create(remote=remote)
     )
+    project_id = _maybe_resolve_project_id_from_id_or_name(
+        remote_provider, project_id=project_id, project=project
+    )
     train_cli.view_training_job_metrics(remote_provider, project_id, job_id)
 
 
 @train.command(name="deploy_checkpoints")
 @click.option("--project-id", type=str, required=False, help="Project ID.")
+@click.option("--project", type=str, required=False, help="Project name or project id.")
 @click.option("--job-id", type=str, required=False, help="Job ID.")
 @click.option(
     "--config",
@@ -267,14 +355,22 @@ 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(
     project_id: Optional[str],
+    project: Optional[str],
     job_id: Optional[str],
     config: Optional[str],
     remote: Optional[str],
     dry_run: bool,
+    truss_config_output_dir: Optional[str],
 ):
     """
     Deploy a LoRA checkpoint via vLLM.
@@ -286,26 +382,52 @@ def deploy_checkpoints(
     remote_provider: BasetenRemote = cast(
         BasetenRemote, RemoteFactory.create(remote=remote)
     )
-    prepare_checkpoint_result = train_cli.prepare_checkpoint_deploy(
+    project_id = _maybe_resolve_project_id_from_id_or_name(
+        remote_provider, project_id=project_id, project=project
+    )
+    result = train_cli.create_model_version_from_inference_template(
         remote_provider,
-        train_cli.PrepareCheckpointArgs(
-            project_id=project_id, job_id=job_id, deploy_config_path=config
+        train_cli.DeployCheckpointArgs(
+            project_id=project_id,
+            job_id=job_id,
+            deploy_config_path=config,
+            dry_run=dry_run,
         ),
     )
 
-    params = {
-        "target_directory": prepare_checkpoint_result.truss_directory,
-        "remote": remote,
-        "model_name": prepare_checkpoint_result.checkpoint_deploy_config.model_name,
-        "publish": True,
-        "deployment_name": prepare_checkpoint_result.checkpoint_deploy_config.deployment_name,
-    }
-    ctx = _prepare_click_context(push, params)
     if dry_run:
-        console.print("--dry-run flag provided, not deploying", style="yellow")
-    else:
-        push.invoke(ctx)
-    train_cli.print_deploy_checkpoints_success_message(prepare_checkpoint_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")
@@ -481,8 +603,17 @@ def cache():
     default=SORT_ORDER_ASC,
     help="Sort order: ascending or descending.",
 )
+@click.option(
+    "-o",
+    "--output-format",
+    type=click.Choice([OUTPUT_FORMAT_CLI_TABLE, OUTPUT_FORMAT_CSV, OUTPUT_FORMAT_JSON]),
+    default=OUTPUT_FORMAT_CLI_TABLE,
+    help="Output format: cli-table (default), csv, or json.",
+)
 @common.common_options()
-def view_cache_summary(project: str, remote: Optional[str], sort: str, order: str):
+def view_cache_summary(
+    project: str, remote: Optional[str], sort: str, order: str, output_format: str
+):
     """View cache summary for a training project"""
     if not remote:
         remote = remote_cli.inquire_remote_name()
@@ -491,4 +622,18 @@ def view_cache_summary(project: str, remote: Optional[str], sort: str, order: st
         BasetenRemote, RemoteFactory.create(remote=remote)
     )
 
-    train_cli.view_cache_summary_by_project(remote_provider, project, sort, order)
+    train_cli.view_cache_summary_by_project(
+        remote_provider, project, sort, order, output_format
+    )
+
+
+def _maybe_resolve_project_id_from_id_or_name(
+    remote_provider: BasetenRemote, project_id: Optional[str], project: Optional[str]
+) -> Optional[str]:
+    """resolve the project_id or project. `project` can be name or id"""
+    if project and project_id:
+        console.print("Both `project-id` and `project` provided. Using `project`.")
+    project_str = project or project_id
+    if not project_str:
+        return None
+    return train_cli.fetch_project_by_name_or_id(remote_provider, project_str)["id"]

truss/cli/utils/common.py

@@ -1,5 +1,6 @@
 import datetime
 import logging
+import re
 import sys
 import warnings
 from functools import wraps
@@ -20,6 +21,8 @@ from truss.cli.utils import self_upgrade
 from truss.cli.utils.output import console
 from truss.util import user_config
 
+logger = logging.getLogger(__name__)
+
 INCLUDE_GIT_INFO_DOC = (
     "Whether to attach git versioning info (sha, branch, tag) to deployments made from "
     "within a git repo. If set to True in `.trussrc`, it will always be attached."
@@ -181,10 +184,44 @@ def is_human_log_level(ctx: click.Context) -> bool:
     return get_required_option(ctx, "log") != _HUMANFRIENDLY_LOG_LEVEL
 
 
-def format_localized_time(iso_timestamp: str) -> str:
+def _normalize_iso_timestamp(iso_timestamp: str) -> str:
+    iso_timestamp = iso_timestamp.strip()
     if iso_timestamp.endswith("Z"):
-        iso_timestamp = iso_timestamp.replace("Z", "+00:00")
-    utc_time = datetime.datetime.fromisoformat(iso_timestamp)
+        iso_timestamp = iso_timestamp[:-1] + "+00:00"
+
+    tz_part = ""
+    tz_match = re.search(r"([+-]\d{2}:\d{2}|[+-]\d{4})$", iso_timestamp)
+    if tz_match:
+        tz_part = tz_match.group(0)
+        iso_timestamp = iso_timestamp[: tz_match.start()]
+
+    iso_timestamp = iso_timestamp.rstrip()
+
+    if tz_part and ":" not in tz_part:
+        tz_part = f"{tz_part[:3]}:{tz_part[3:]}"
+
+    fractional_match = re.search(r"\.(\d+)$", iso_timestamp)
+    if fractional_match:
+        fractional_digits = fractional_match.group(1)
+        if len(fractional_digits) > 6:
+            iso_timestamp = (
+                iso_timestamp[: fractional_match.start()] + "." + fractional_digits[:6]
+            )
+
+    return f"{iso_timestamp}{tz_part}"
+
+
+# NOTE: `pyproject.toml` declares support down to Python 3.9, whose
+# `datetime.fromisoformat` cannot parse nanosecond fractions or colonless offsets,
+# so normalize timestamps before parsing.
+def format_localized_time(iso_timestamp: str) -> str:
+    try:
+        utc_time = datetime.datetime.fromisoformat(iso_timestamp)
+    except ValueError:
+        # Handle non-standard formats (nanoseconds, Z suffix, colonless offsets)
+        normalized_timestamp = _normalize_iso_timestamp(iso_timestamp)
+        utc_time = datetime.datetime.fromisoformat(normalized_timestamp)
+
     local_time = utc_time.astimezone()
     return local_time.strftime("%Y-%m-%d %H:%M:%S")