truss 0.11.18rc500__py3-none-any.whl → 0.11.24rc2__py3-none-any.whl

truss/cli/train/cache.py

@@ -0,0 +1,332 @@
+import csv
+import json
+import os
+import sys
+from abc import ABC, abstractmethod
+from typing import Any, Callable, Optional
+
+import rich
+
+from truss.cli.train import common
+from truss.cli.utils import common as cli_common
+from truss.cli.utils.output import console
+from truss.remote.baseten.custom_types import (
+    FileSummary,
+    FileSummaryWithTotalSize,
+    GetCacheSummaryResponseV1,
+)
+from truss.remote.baseten.remote import BasetenRemote
+
+# Sort constants
+SORT_BY_FILEPATH = "filepath"
+SORT_BY_SIZE = "size"
+SORT_BY_MODIFIED = "modified"
+SORT_BY_TYPE = "type"
+SORT_BY_PERMISSIONS = "permissions"
+SORT_ORDER_ASC = "asc"
+SORT_ORDER_DESC = "desc"
+
+# Output format constants
+OUTPUT_FORMAT_CLI_TABLE = "cli-table"
+OUTPUT_FORMAT_CSV = "csv"
+OUTPUT_FORMAT_JSON = "json"
+
+
+def calculate_directory_sizes(
+    files: list[FileSummary], max_depth: int = 100
+) -> dict[str, int]:
+    """Calculate total sizes for directories based on their file contents."""
+    directory_sizes = {}
+
+    for file_info in files:
+        if file_info.file_type == "directory":
+            directory_sizes[file_info.path] = 0
+
+    for file_info in files:
+        current_path = file_info.path
+        for i in range(max_depth):
+            if current_path is None:
+                break
+            if current_path in directory_sizes:
+                directory_sizes[current_path] += file_info.size_bytes
+            # Move to parent directory
+            parent = os.path.dirname(current_path)
+            if parent == current_path:  # Reached root
+                break
+            current_path = parent
+
+    return directory_sizes
+
+
+def create_file_summary_with_directory_sizes(
+    files: list[FileSummary],
+) -> list[FileSummaryWithTotalSize]:
+    """Create file summaries with total sizes including directory sizes."""
+    directory_sizes = calculate_directory_sizes(files)
+    return [
+        FileSummaryWithTotalSize(
+            file_summary=file_info,
+            total_size=directory_sizes.get(file_info.path, file_info.size_bytes),
+        )
+        for file_info in files
+    ]
+
+
+def _get_sort_key(sort_by: str) -> Callable[[FileSummaryWithTotalSize], Any]:
+    """Get the sort key function for the given sort option."""
+    if sort_by == SORT_BY_FILEPATH:
+        return lambda x: x.file_summary.path
+    elif sort_by == SORT_BY_SIZE:
+        return lambda x: x.total_size
+    elif sort_by == SORT_BY_MODIFIED:
+        return lambda x: x.file_summary.modified
+    elif sort_by == SORT_BY_TYPE:
+        return lambda x: x.file_summary.file_type or ""
+    elif sort_by == SORT_BY_PERMISSIONS:
+        return lambda x: x.file_summary.permissions or ""
+    else:
+        raise ValueError(f"Invalid --sort argument: {sort_by}")
+
+
+class CacheSummaryViewer(ABC):
+    """Base class for cache summary viewers that output in different formats."""
+
+    @abstractmethod
+    def output_cache_summary(
+        self,
+        cache_data: Optional[GetCacheSummaryResponseV1],
+        files_with_total_sizes: list[FileSummaryWithTotalSize],
+        total_size: int,
+        total_size_str: str,
+        project_id: str,
+    ) -> None:
+        """Output the cache summary in the viewer's format."""
+        pass
+
+    @abstractmethod
+    def output_no_cache_message(self, project_id: str) -> None:
+        """Output message when no cache summary is found."""
+        pass
+
+
+class CLITableViewer(CacheSummaryViewer):
+    """Viewer that outputs cache summary as a styled CLI table."""
+
+    def output_cache_summary(
+        self,
+        cache_data: Optional[GetCacheSummaryResponseV1],
+        files_with_total_sizes: list[FileSummaryWithTotalSize],
+        total_size: int,
+        total_size_str: str,
+        project_id: str,
+    ) -> None:
+        """Output cache summary as a styled CLI table."""
+        if not cache_data:
+            return
+
+        table = rich.table.Table(title=f"Cache summary for project: {project_id}")
+        table.add_column("File Path", style="cyan", overflow="fold")
+        table.add_column("Size", style="green")
+        table.add_column("Modified", style="yellow")
+        table.add_column("Type")
+        table.add_column("Permissions", style="magenta")
+
+        console.print(
+            f"📅 Cache captured at: {cache_data.timestamp}", style="bold blue"
+        )
+        console.print(f"📁 Project ID: {cache_data.project_id}", style="bold blue")
+        console.print()
+        console.print(
+            f"📊 Total files: {len(files_with_total_sizes)}", style="bold green"
+        )
+        console.print(f"💾 Total size: {total_size_str}", style="bold green")
+        console.print()
+        # Note: Long file paths wrap across multiple lines. To copy full paths easily,
+        # use --output-format csv or --output-format json
+        if any(len(f.file_summary.path) > 60 for f in files_with_total_sizes):
+            console.print(
+                "💡 Tip: Use -o csv or -o json to output paths on single lines for easier copying",
+                style="dim",
+            )
+            console.print()
+
+        for file_info in files_with_total_sizes:
+            total_size = file_info.total_size
+
+            size_str = cli_common.format_bytes_to_human_readable(int(total_size))
+
+            modified_str = cli_common.format_localized_time(
+                file_info.file_summary.modified
+            )
+
+            table.add_row(
+                file_info.file_summary.path,
+                size_str,
+                modified_str,
+                file_info.file_summary.file_type or "Unknown",
+                file_info.file_summary.permissions or "Unknown",
+            )
+
+        console.print(table)
+
+    def output_no_cache_message(self, project_id: str) -> None:
+        """Output message when no cache summary is found."""
+        console.print("No cache summary found for this project.", style="yellow")
+
+
+class CSVViewer(CacheSummaryViewer):
+    """Viewer that outputs cache summary in CSV format."""
+
+    def output_cache_summary(
+        self,
+        cache_data: Optional[GetCacheSummaryResponseV1],
+        files_with_total_sizes: list[FileSummaryWithTotalSize],
+        total_size: int,
+        total_size_str: str,
+        project_id: str,
+    ) -> None:
+        """Output cache summary in CSV format."""
+        writer = csv.writer(sys.stdout)
+        # Write header
+        writer.writerow(
+            [
+                "File Path",
+                "Size (bytes)",
+                "Size (human readable)",
+                "Modified",
+                "Type",
+                "Permissions",
+            ]
+        )
+        # Write data rows
+        for file_info in files_with_total_sizes:
+            size_str = cli_common.format_bytes_to_human_readable(
+                int(file_info.total_size)
+            )
+            modified_str = cli_common.format_localized_time(
+                file_info.file_summary.modified
+            )
+            writer.writerow(
+                [
+                    file_info.file_summary.path,
+                    str(file_info.total_size),
+                    size_str,
+                    modified_str,
+                    file_info.file_summary.file_type or "Unknown",
+                    file_info.file_summary.permissions or "Unknown",
+                ]
+            )
+
+    def output_no_cache_message(self, project_id: str) -> None:
+        """Output empty CSV with headers when no cache summary is found."""
+        self.output_cache_summary(None, [], 0, "0 B", project_id)
+
+
+class JSONViewer(CacheSummaryViewer):
+    """Viewer that outputs cache summary in JSON format."""
+
+    def output_cache_summary(
+        self,
+        cache_data: Optional[GetCacheSummaryResponseV1],
+        files_with_total_sizes: list[FileSummaryWithTotalSize],
+        total_size: int,
+        total_size_str: str,
+        project_id: str,
+    ) -> None:
+        """Output cache summary in JSON format."""
+        files_data = []
+        for file_info in files_with_total_sizes:
+            size_str = cli_common.format_bytes_to_human_readable(
+                int(file_info.total_size)
+            )
+            modified_str = cli_common.format_localized_time(
+                file_info.file_summary.modified
+            )
+            files_data.append(
+                {
+                    "path": file_info.file_summary.path,
+                    "size_bytes": file_info.total_size,
+                    "size_human_readable": size_str,
+                    "modified": modified_str,
+                    "type": file_info.file_summary.file_type or "Unknown",
+                    "permissions": file_info.file_summary.permissions or "Unknown",
+                }
+            )
+
+        output = {
+            "timestamp": cache_data.timestamp if cache_data else "",
+            "project_id": cache_data.project_id if cache_data else project_id,
+            "total_files": len(files_with_total_sizes),
+            "total_size_bytes": total_size,
+            "total_size_human_readable": total_size_str,
+            "files": files_data,
+        }
+
+        print(json.dumps(output, indent=2))
+
+    def output_no_cache_message(self, project_id: str) -> None:
+        """Output empty JSON structure when no cache summary is found."""
+        self.output_cache_summary(None, [], 0, "0 B", project_id)
+
+
+def _get_cache_summary_viewer(output_format: str) -> CacheSummaryViewer:
+    """Factory function to get the appropriate viewer for the output format."""
+    if output_format == OUTPUT_FORMAT_CSV:
+        return CSVViewer()
+    elif output_format == OUTPUT_FORMAT_JSON:
+        return JSONViewer()
+    else:
+        return CLITableViewer()
+
+
+def view_cache_summary(
+    remote_provider: BasetenRemote,
+    project_id: str,
+    sort_by: str = SORT_BY_FILEPATH,
+    order: str = SORT_ORDER_ASC,
+    output_format: str = OUTPUT_FORMAT_CLI_TABLE,
+):
+    """View cache summary for a training project."""
+    viewer_factories = {
+        OUTPUT_FORMAT_CSV: lambda: CSVViewer(),
+        OUTPUT_FORMAT_JSON: lambda: JSONViewer(),
+        OUTPUT_FORMAT_CLI_TABLE: lambda: CLITableViewer(),
+    }
+    viewer_factory = viewer_factories.get(output_format)
+    if not viewer_factory:
+        raise ValueError(f"Invalid output format: {output_format}")
+    viewer = viewer_factory()
+    try:
+        raw_cache_data = remote_provider.api.get_cache_summary(project_id)
+
+        if not raw_cache_data:
+            viewer.output_no_cache_message(project_id)
+            return
+
+        cache_data = GetCacheSummaryResponseV1.model_validate(raw_cache_data)
+
+        files = cache_data.file_summaries
+        files_with_total_sizes = (
+            create_file_summary_with_directory_sizes(files) if files else []
+        )
+
+        reverse = order == SORT_ORDER_DESC
+        sort_key = _get_sort_key(sort_by)
+        files_with_total_sizes.sort(key=sort_key, reverse=reverse)
+
+        total_size = sum(
+            file_info.file_summary.size_bytes for file_info in files_with_total_sizes
+        )
+        total_size_str = common.format_bytes_to_human_readable(total_size)
+
+        viewer.output_cache_summary(
+            cache_data, files_with_total_sizes, total_size, total_size_str, project_id
+        )
+
+    except Exception as e:
+        # For CSV/JSON formats, print to stderr to keep stdout clean for piping
+        if output_format in (OUTPUT_FORMAT_CSV, OUTPUT_FORMAT_JSON):
+            print(f"Error fetching cache summary: {str(e)}", file=sys.stderr)
+        else:
+            console.print(f"Error fetching cache summary: {str(e)}", style="red")
+        raise

truss/cli/train/core.py

@@ -23,23 +23,10 @@ from truss.cli.train.types import (
 )
 from truss.cli.utils import common as cli_common
 from truss.cli.utils.output import console
-from truss.remote.baseten.custom_types import (
-    FileSummary,
-    FileSummaryWithTotalSize,
-    GetCacheSummaryResponseV1,
-)
 from truss.remote.baseten.remote import BasetenRemote
 from truss_train import loader
 from truss_train.definitions import DeployCheckpointsConfig
 
-SORT_BY_FILEPATH = "filepath"
-SORT_BY_SIZE = "size"
-SORT_BY_MODIFIED = "modified"
-SORT_BY_TYPE = "type"
-SORT_BY_PERMISSIONS = "permissions"
-SORT_ORDER_ASC = "asc"
-SORT_ORDER_DESC = "desc"
-
 ACTIVE_JOB_STATUSES = [
     "TRAINING_JOB_RUNNING",
     "TRAINING_JOB_CREATED",
@@ -630,139 +617,28 @@ def fetch_project_by_name_or_id(
         raise click.ClickException(f"Error fetching project: {str(e)}")
 
 
-def create_file_summary_with_directory_sizes(
-    files: list[FileSummary],
-) -> list[FileSummaryWithTotalSize]:
-    directory_sizes = calculate_directory_sizes(files)
-    return [
-        FileSummaryWithTotalSize(
-            file_summary=file_info,
-            total_size=directory_sizes.get(file_info.path, file_info.size_bytes),
-        )
-        for file_info in files
-    ]
-
-
-def calculate_directory_sizes(
-    files: list[FileSummary], max_depth: int = 100
-) -> dict[str, int]:
-    directory_sizes = {}
-
-    for file_info in files:
-        if file_info.file_type == "directory":
-            directory_sizes[file_info.path] = 0
-
-    for file_info in files:
-        current_path = file_info.path
-        for i in range(max_depth):
-            if current_path is None:
-                break
-            if current_path in directory_sizes:
-                directory_sizes[current_path] += file_info.size_bytes
-            # Move to parent directory
-            parent = os.path.dirname(current_path)
-            if parent == current_path:  # Reached root
-                break
-            current_path = parent
-
-    return directory_sizes
-
-
-def view_cache_summary(
-    remote_provider: BasetenRemote,
-    project_id: str,
-    sort_by: str = SORT_BY_FILEPATH,
-    order: str = SORT_ORDER_ASC,
-):
-    """View cache summary for a training project."""
-    try:
-        raw_cache_data = remote_provider.api.get_cache_summary(project_id)
-
-        if not raw_cache_data:
-            console.print("No cache summary found for this project.", style="yellow")
-            return
-
-        cache_data = GetCacheSummaryResponseV1.model_validate(raw_cache_data)
-
-        table = rich.table.Table(title=f"Cache summary for project: {project_id}")
-        table.add_column("File Path", style="cyan")
-        table.add_column("Size", style="green")
-        table.add_column("Modified", style="yellow")
-        table.add_column("Type")
-        table.add_column("Permissions", style="magenta")
-
-        files = cache_data.file_summaries
-        if not files:
-            console.print("No files found in cache.", style="yellow")
-            return
-
-        files_with_total_sizes = create_file_summary_with_directory_sizes(files)
-
-        reverse = order == SORT_ORDER_DESC
-        sort_key = _get_sort_key(sort_by)
-        files_with_total_sizes.sort(key=sort_key, reverse=reverse)
-
-        total_size = sum(
-            file_info.file_summary.size_bytes for file_info in files_with_total_sizes
-        )
-        total_size_str = common.format_bytes_to_human_readable(total_size)
-
-        console.print(
-            f"📅 Cache captured at: {cache_data.timestamp}", style="bold blue"
-        )
-        console.print(f"📁 Project ID: {cache_data.project_id}", style="bold blue")
-        console.print()
-        console.print(
-            f"📊 Total files: {len(files_with_total_sizes)}", style="bold green"
-        )
-        console.print(f"💾 Total size: {total_size_str}", style="bold green")
-        console.print()
-
-        for file_info in files_with_total_sizes:
-            total_size = file_info.total_size
-
-            size_str = cli_common.format_bytes_to_human_readable(int(total_size))
-
-            modified_str = cli_common.format_localized_time(
-                file_info.file_summary.modified
-            )
-
-            table.add_row(
-                file_info.file_summary.path,
-                size_str,
-                modified_str,
-                file_info.file_summary.file_type or "Unknown",
-                file_info.file_summary.permissions or "Unknown",
-            )
-
-        console.print(table)
-
-    except Exception as e:
-        console.print(f"Error fetching cache summary: {str(e)}", style="red")
-        raise
-
-
-def _get_sort_key(sort_by: str) -> Callable[[FileSummaryWithTotalSize], Any]:
-    if sort_by == SORT_BY_FILEPATH:
-        return lambda x: x.file_summary.path
-    elif sort_by == SORT_BY_SIZE:
-        return lambda x: x.total_size
-    elif sort_by == SORT_BY_MODIFIED:
-        return lambda x: x.file_summary.modified
-    elif sort_by == SORT_BY_TYPE:
-        return lambda x: x.file_summary.file_type or ""
-    elif sort_by == SORT_BY_PERMISSIONS:
-        return lambda x: x.file_summary.permissions or ""
-    else:
-        raise ValueError(f"Invalid --sort argument: {sort_by}")
-
-
 def view_cache_summary_by_project(
     remote_provider: BasetenRemote,
     project_identifier: str,
-    sort_by: str = SORT_BY_FILEPATH,
-    order: str = SORT_ORDER_ASC,
+    sort_by: Optional[str] = None,
+    order: Optional[str] = None,
+    output_format: Optional[str] = None,
 ):
     """View cache summary for a training project by ID or name."""
+    from truss.cli.train.cache import (
+        OUTPUT_FORMAT_CLI_TABLE,
+        SORT_BY_FILEPATH,
+        SORT_ORDER_ASC,
+        view_cache_summary,
+    )
+
+    # Use constants for defaults if not provided
+    if sort_by is None:
+        sort_by = SORT_BY_FILEPATH
+    if order is None:
+        order = SORT_ORDER_ASC
+    if output_format is None:
+        output_format = OUTPUT_FORMAT_CLI_TABLE
+
     project = fetch_project_by_name_or_id(remote_provider, project_identifier)
-    view_cache_summary(remote_provider, project["id"], sort_by, order)
+    view_cache_summary(remote_provider, project["id"], sort_by, order, output_format)

truss/cli/train_commands.py

@@ -12,9 +12,15 @@ from truss.cli import remote_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,
@@ -108,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.
@@ -556,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()
@@ -566,7 +622,9 @@ 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(

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")