dayhoff-tools 1.12.32__py3-none-any.whl → 1.13.0__py3-none-any.whl

dayhoff_tools/cli/engines_studios/engine-studio-cli.md

@@ -323,18 +323,22 @@ dh engine2 list --env sand
 ```
 Engines for AWS Account dev
 
-Name            State        User         Type         Instance ID         
-───────────────────────────────────────────────────────────────────────────
-alice-work      running      alice        cpu          i-0123456789abcdef0 
-bob-training    running      bob          a10g         i-0fedcba987654321  
-batch-worker    stopped      charlie      cpumax       i-0abc123def456789  
+┌──────────────┬─────────────┬─────────────┬─────────────┬─────────────────────┐
+│ Name         │ State       │ User        │ Type        │ Instance ID         │
+├──────────────┼─────────────┼─────────────┼─────────────┼─────────────────────┤
+│ alice-work   │ running     │ alice       │ cpu         │ i-0123456789abcdef0 │
+│ bob-training │ running     │ bob         │ a10g        │ i-0fedcba987654321  │
+│ batch-worker │ stopped     │ charlie     │ cpumax      │ i-0abc123def456789  │
+└──────────────┴─────────────┴─────────────┴─────────────┴─────────────────────┘
 
 Total: 3 engine(s)
 ```
 
 **Formatting:**
+- Full table borders with Unicode box-drawing characters
 - Engine names are displayed in blue
 - State is color-coded: green for "running", yellow for "starting/stopping", grey for "stopped"
+- Instance IDs are displayed in grey
 - Name column width adjusts dynamically to fit the longest engine name
 
 ---
@@ -751,20 +755,28 @@ dh studio2 list
 
 **Output:**
 ```
-User         Status       Size       Studio ID                
-──────────────────────────────────────────────────────────────
-alice        attached     100GB      vol-0123456789abcdef0    
-bob          available    200GB      vol-0fedcba987654321     
-carol        available    150GB      vol-0abc123def456789     
+Studios for AWS Account dev
+
+┌────────┬──────────────┬──────────────┬───────────┬───────────────────────────┐
+│ User   │ Status       │ Attached To  │ Size      │ Studio ID                 │
+├────────┼──────────────┼──────────────┼───────────┼───────────────────────────┤
+│ alice  │ attached     │ alice-work   │ 100GB     │ vol-0123456789abcdef0     │
+│ bob    │ available    │ -            │ 200GB     │ vol-0fedcba987654321      │
+│ carol  │ attaching    │ carol-gpu    │ 150GB     │ vol-0abc123def456789      │
+└────────┴──────────────┴──────────────┴───────────┴───────────────────────────┘
 
 Total: 3 studio(s)
 ```
 
 **Formatting:**
+- Full table borders with Unicode box-drawing characters
 - User names are displayed in blue
-- Status is color-coded: green for "available/attached", yellow for "attaching/detaching", red for "error"
+- Status is color-coded: purple for "attached", green for "available", yellow for "attaching/detaching", red for "error"
+- "Attached To" shows engine name, or "-" if not attached
+- Studio IDs are displayed in grey
 - User column width adjusts dynamically to fit the longest username
-- Columns are ordered: User, Status, Size, Studio ID
+- Attached To column width adjusts dynamically to fit the longest engine name
+- Columns are ordered: User, Status, Attached To, Size, Studio ID
 
 ---
 

dayhoff_tools/cli/engines_studios/engine_commands.py

@@ -598,13 +598,18 @@ def list_engines(env: Optional[str]):
         id_width = 20
 
         # Calculate total width for separator line
-        total_width = name_width + state_width + user_width + type_width + id_width + 4  # +4 for spaces
+        total_width = name_width + state_width + user_width + type_width + id_width + 9  # +9 for separators and spaces
+
+        # Table top border
+        click.echo("┌" + "─" * (name_width + 1) + "┬" + "─" * (state_width + 1) + "┬" + "─" * (user_width + 1) + "┬" + "─" * (type_width + 1) + "┬" + "─" * (id_width + 1) + "┐")
 
         # Table header
         click.echo(
-            f"{'Name':<{name_width}} {'State':<{state_width}} {'User':<{user_width}} {'Type':<{type_width}} {'Instance ID':<{id_width}}"
+            f"│ {'Name':<{name_width}}│ {'State':<{state_width}}│ {'User':<{user_width}}│ {'Type':<{type_width}}│ {'Instance ID':<{id_width}}│"
         )
-        click.echo("─" * total_width)
+
+        # Header separator
+        click.echo("├" + "─" * (name_width + 1) + "┼" + "─" * (state_width + 1) + "┼" + "─" * (user_width + 1) + "┼" + "─" * (type_width + 1) + "┼" + "─" * (id_width + 1) + "┤")
 
         # Table rows
         for engine in engines:
@@ -635,10 +640,16 @@ def list_engines(env: Optional[str]):
             else:
                 state_display = f"{state:<{state_width}}"  # No color for other states
 
+            # Color the instance ID (grey)
+            instance_id_display = f"\033[90m{instance_id:<{id_width}}\033[0m"
+
             click.echo(
-                f"{name_display} {state_display} {user:<{user_width}} {engine_type:<{type_width}} {instance_id:<{id_width}}"
+                f"│ {name_display}│ {state_display}│ {user:<{user_width}}│ {engine_type:<{type_width}}│ {instance_id_display}│"
             )
 
+        # Table bottom border
+        click.echo("└" + "─" * (name_width + 1) + "┴" + "─" * (state_width + 1) + "┴" + "─" * (user_width + 1) + "┴" + "─" * (type_width + 1) + "┴" + "─" * (id_width + 1) + "┘")
+
         click.echo(f"\nTotal: {len(engines)} engine(s)")
 
     except Exception as e:

dayhoff_tools/cli/engines_studios/simulators/engine_list_simulator.py

@@ -31,7 +31,9 @@ def format_list_output(engines: list[dict[str, Any]], env: str = "dev") -> None:
         return
 
     # Calculate dynamic width for Name column (longest name + 2 for padding)
-    max_name_len = max((len(engine.get("name", "unknown")) for engine in engines), default=4)
+    max_name_len = max(
+        (len(engine.get("name", "unknown")) for engine in engines), default=4
+    )
     name_width = max(max_name_len + 2, len("Name") + 2)
 
     # Fixed widths for other columns
@@ -40,12 +42,40 @@ def format_list_output(engines: list[dict[str, Any]], env: str = "dev") -> None:
     type_width = 12
     id_width = 20
 
-    # Calculate total width for separator line
-    total_width = name_width + state_width + user_width + type_width + id_width + 4  # +4 for spaces
+    # Table top border
+    print(
+        "┌"
+        + "─" * (name_width + 1)
+        + "┬"
+        + "─" * (state_width + 1)
+        + "┬"
+        + "─" * (user_width + 1)
+        + "┬"
+        + "─" * (type_width + 1)
+        + "┬"
+        + "─" * (id_width + 1)
+        + "┐"
+    )
 
     # Table header
-    print(f"{'Name':<{name_width}} {'State':<{state_width}} {'User':<{user_width}} {'Type':<{type_width}} {'Instance ID':<{id_width}}")
-    print("─" * total_width)
+    print(
+        f"│ {'Name':<{name_width}}│ {'State':<{state_width}}│ {'User':<{user_width}}│ {'Type':<{type_width}}│ {'Instance ID':<{id_width}}│"
+    )
+
+    # Header separator
+    print(
+        "├"
+        + "─" * (name_width + 1)
+        + "┼"
+        + "─" * (state_width + 1)
+        + "┼"
+        + "─" * (user_width + 1)
+        + "┼"
+        + "─" * (type_width + 1)
+        + "┼"
+        + "─" * (id_width + 1)
+        + "┤"
+    )
 
     # Table rows
     for engine in engines:
@@ -57,11 +87,11 @@ def format_list_output(engines: list[dict[str, Any]], env: str = "dev") -> None:
 
         # Truncate if needed
         if len(name) > name_width - 1:
-            name = name[:name_width - 1]
+            name = name[: name_width - 1]
         if len(user) > user_width - 1:
-            user = user[:user_width - 1]
+            user = user[: user_width - 1]
         if len(engine_type) > type_width - 1:
-            engine_type = engine_type[:type_width - 1]
+            engine_type = engine_type[: type_width - 1]
 
         # Color the name (blue)
         name_display = colorize(f"{name:<{name_width}}", "34")
@@ -76,10 +106,28 @@ def format_list_output(engines: list[dict[str, Any]], env: str = "dev") -> None:
         else:
             state_display = f"{state:<{state_width}}"  # No color for other states
 
+        # Color the instance ID (grey)
+        instance_id_display = colorize(f"{instance_id:<{id_width}}", "90")
+
         print(
-            f"{name_display} {state_display} {user:<{user_width}} {engine_type:<{type_width}} {instance_id:<{id_width}}"
+            f"│ {name_display}│ {state_display}│ {user:<{user_width}}│ {engine_type:<{type_width}}│ {instance_id_display}│"
         )
 
+    # Table bottom border
+    print(
+        "└"
+        + "─" * (name_width + 1)
+        + "┴"
+        + "─" * (state_width + 1)
+        + "┴"
+        + "─" * (user_width + 1)
+        + "┴"
+        + "─" * (type_width + 1)
+        + "┴"
+        + "─" * (id_width + 1)
+        + "┘"
+    )
+
     print(f"\nTotal: {len(engines)} engine(s)")
 
 

dayhoff_tools/cli/engines_studios/simulators/studio_list_simulator.py

@@ -0,0 +1,325 @@
+#!/usr/bin/env python3
+"""Simulator for studio list output - iterate on design locally without AWS.
+
+This lets you quickly see how the list command output looks with different
+studio states and configurations.
+
+Usage:
+    python dayhoff_tools/cli/engines_studios/simulators/studio_list_simulator.py                # Show all scenarios
+    python dayhoff_tools/cli/engines_studios/simulators/studio_list_simulator.py --scenario few # Show specific scenario
+    python dayhoff_tools/cli/engines_studios/simulators/studio_list_simulator.py --env prod     # Simulate different environment
+"""
+
+import argparse
+import sys
+from typing import Any
+
+
+def colorize(text: str, color_code: str) -> str:
+    """Apply ANSI color code to text."""
+    return f"\033[{color_code}m{text}\033[0m"
+
+
+def format_list_output(studios: list[dict[str, Any]], engines_map: dict[str, str], env: str = "dev") -> None:
+    """Format and print studio list output matching the actual CLI."""
+
+    # Header with blue account name
+    print(f"Studios for AWS Account {colorize(env, '34')}\n")
+
+    if not studios:
+        print("No studios found")
+        return
+
+    # Calculate dynamic width for User column (longest user + 2 for padding)
+    max_user_len = max((len(studio.get("user", "unknown")) for studio in studios), default=4)
+    user_width = max(max_user_len + 2, len("User") + 2)
+
+    # Calculate dynamic width for Attached To column
+    max_attached_len = 0
+    for studio in studios:
+        if studio.get("attached_to"):
+            instance_id = studio["attached_to"]
+            engine_name = engines_map.get(instance_id, "unknown")
+            max_attached_len = max(max_attached_len, len(engine_name))
+    attached_width = max(max_attached_len + 2, len("Attached To") + 2, 3)  # At least 3 for "-"
+
+    # Fixed widths for other columns
+    status_width = 12
+    size_width = 10
+    id_width = 25
+
+    # Table top border
+    print("┌" + "─" * (user_width + 1) + "┬" + "─" * (status_width + 1) + "┬" + "─" * (attached_width + 1) + "┬" + "─" * (size_width + 1) + "┬" + "─" * (id_width + 1) + "┐")
+
+    # Table header
+    print(f"│ {'User':<{user_width}}│ {'Status':<{status_width}}│ {'Attached To':<{attached_width}}│ {'Size':<{size_width}}│ {'Studio ID':<{id_width}}│")
+
+    # Header separator
+    print("├" + "─" * (user_width + 1) + "┼" + "─" * (status_width + 1) + "┼" + "─" * (attached_width + 1) + "┼" + "─" * (size_width + 1) + "┼" + "─" * (id_width + 1) + "┤")
+
+    # Table rows
+    for studio in studios:
+        user = studio.get("user", "unknown")
+        status = studio.get("status", "unknown")
+        size = f"{studio.get('size_gb', 0)}GB"
+        studio_id = studio.get("studio_id", "unknown")
+        attached_to = studio.get("attached_to")
+
+        # Truncate if needed
+        if len(user) > user_width - 1:
+            user = user[:user_width - 1]
+
+        # Color the user (blue)
+        user_display = colorize(f"{user:<{user_width}}", "34")
+
+        # Format status - display "in-use" as "attached" in purple
+        if status == "in-use":
+            display_status = "attached"
+            status_display = colorize(f"{display_status:<{status_width}}", "35")  # Purple
+        elif status == "available":
+            status_display = colorize(f"{status:<{status_width}}", "32")  # Green
+        elif status in ["attaching", "detaching"]:
+            status_display = colorize(f"{status:<{status_width}}", "33")  # Yellow
+        elif status == "attached":
+            status_display = colorize(f"{status:<{status_width}}", "35")  # Purple
+        elif status == "error":
+            status_display = colorize(f"{status:<{status_width}}", "31")  # Red
+        else:
+            status_display = f"{status:<{status_width}}"  # No color for other states
+
+        # Format Attached To column
+        if attached_to:
+            instance_id = attached_to
+            engine_name = engines_map.get(instance_id, "unknown")
+            # Engine name in white (no color)
+            attached_display = f"{engine_name:<{attached_width}}"
+        else:
+            attached_display = f"{'-':<{attached_width}}"
+
+        # Color the studio ID (grey)
+        studio_id_display = colorize(f"{studio_id:<{id_width}}", "90")
+
+        print(f"│ {user_display}│ {status_display}│ {attached_display}│ {size:<{size_width}}│ {studio_id_display}│")
+
+    # Table bottom border
+    print("└" + "─" * (user_width + 1) + "┴" + "─" * (status_width + 1) + "┴" + "─" * (attached_width + 1) + "┴" + "─" * (size_width + 1) + "┴" + "─" * (id_width + 1) + "┘")
+
+    print(f"\nTotal: {len(studios)} studio(s)")
+
+
+def generate_scenarios() -> dict[str, dict[str, Any]]:
+    """Generate various test scenarios for studio list output."""
+
+    scenarios = {}
+
+    # Create a consistent engines map for all scenarios
+    engines_map = {
+        "i-0123456789abcdef0": "alice-gpu",
+        "i-1234567890abcdef1": "bob-cpu",
+        "i-2345678901abcdef2": "charlie-work",
+        "i-3456789012abcdef3": "diana-dev",
+    }
+
+    # Scenario 1: Single available studio
+    scenarios["single"] = {
+        "name": "Single Available Studio",
+        "studios": [
+            {
+                "user": "alice",
+                "status": "available",
+                "size_gb": 100,
+                "studio_id": "vol-0abc123def456789a",
+                "attached_to": None,
+            }
+        ],
+        "engines_map": engines_map,
+        "env": "dev",
+    }
+
+    # Scenario 2: Few studios with various states
+    scenarios["few"] = {
+        "name": "Few Studios - Mixed States",
+        "studios": [
+            {
+                "user": "alice",
+                "status": "in-use",  # Will be displayed as "attached" in purple
+                "size_gb": 100,
+                "studio_id": "vol-0abc123def456789a",
+                "attached_to": "i-0123456789abcdef0",
+            },
+            {
+                "user": "bob",
+                "status": "available",
+                "size_gb": 200,
+                "studio_id": "vol-0abc123def456789b",
+                "attached_to": None,
+            },
+            {
+                "user": "charlie",
+                "status": "attaching",
+                "size_gb": 150,
+                "studio_id": "vol-0abc123def456789c",
+                "attached_to": "i-2345678901abcdef2",
+            },
+        ],
+        "engines_map": engines_map,
+        "env": "sand",
+    }
+
+    # Scenario 3: Many studios (production-like)
+    scenarios["many"] = {
+        "name": "Many Studios - Production",
+        "studios": [
+            {
+                "user": "alice",
+                "status": "attached",
+                "size_gb": 100,
+                "studio_id": "vol-0abc123def456789a",
+                "attached_to": "i-0123456789abcdef0",
+            },
+            {
+                "user": "bob",
+                "status": "attached",
+                "size_gb": 200,
+                "studio_id": "vol-0abc123def456789b",
+                "attached_to": "i-1234567890abcdef1",
+            },
+            {
+                "user": "charlie",
+                "status": "available",
+                "size_gb": 150,
+                "studio_id": "vol-0abc123def456789c",
+                "attached_to": None,
+            },
+            {
+                "user": "diana",
+                "status": "attached",
+                "size_gb": 250,
+                "studio_id": "vol-0abc123def456789d",
+                "attached_to": "i-3456789012abcdef3",
+            },
+            {
+                "user": "eve",
+                "status": "available",
+                "size_gb": 100,
+                "studio_id": "vol-0abc123def456789e",
+                "attached_to": None,
+            },
+            {
+                "user": "frank",
+                "status": "detaching",
+                "size_gb": 300,
+                "studio_id": "vol-0abc123def456789f",
+                "attached_to": None,
+            },
+        ],
+        "engines_map": engines_map,
+        "env": "prod",
+    }
+
+    # Scenario 4: Empty list
+    scenarios["empty"] = {
+        "name": "No Studios",
+        "studios": [],
+        "engines_map": engines_map,
+        "env": "dev",
+    }
+
+    # Scenario 5: All transitional states
+    scenarios["transitions"] = {
+        "name": "Transitional States",
+        "studios": [
+            {
+                "user": "alice",
+                "status": "attaching",
+                "size_gb": 100,
+                "studio_id": "vol-0abc123def456789a",
+                "attached_to": "i-0123456789abcdef0",
+            },
+            {
+                "user": "bob",
+                "status": "detaching",
+                "size_gb": 200,
+                "studio_id": "vol-0abc123def456789b",
+                "attached_to": None,
+            },
+            {
+                "user": "charlie",
+                "status": "error",
+                "size_gb": 150,
+                "studio_id": "vol-0abc123def456789c",
+                "attached_to": None,
+            },
+        ],
+        "engines_map": engines_map,
+        "env": "sand",
+    }
+
+    # Scenario 6: Long names
+    scenarios["long_names"] = {
+        "name": "Long User Names",
+        "studios": [
+            {
+                "user": "alice-with-very-long-username",
+                "status": "attached",
+                "size_gb": 100,
+                "studio_id": "vol-0abc123def456789a",
+                "attached_to": "i-0123456789abcdef0",
+            },
+            {
+                "user": "bob",
+                "status": "available",
+                "size_gb": 200,
+                "studio_id": "vol-0abc123def456789b",
+                "attached_to": None,
+            },
+        ],
+        "engines_map": engines_map,
+        "env": "dev",
+    }
+
+    return scenarios
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Simulate studio list output for design iteration"
+    )
+    parser.add_argument(
+        "--scenario",
+        choices=["single", "few", "many", "empty", "transitions", "long_names", "all"],
+        default="all",
+        help="Which scenario to display (default: all)",
+    )
+    parser.add_argument(
+        "--env",
+        choices=["dev", "sand", "prod"],
+        help="Override environment for display",
+    )
+
+    args = parser.parse_args()
+
+    scenarios = generate_scenarios()
+
+    if args.scenario == "all":
+        # Show all scenarios
+        for _, scenario_data in scenarios.items():
+            print("\n" + "=" * 80)
+            print(f"SCENARIO: {scenario_data['name']}")
+            print("=" * 80 + "\n")
+
+            env = args.env if args.env else scenario_data["env"]
+            format_list_output(scenario_data["studios"], scenario_data["engines_map"], env)
+            print()  # Extra newline between scenarios
+    else:
+        # Show specific scenario
+        scenario_data = scenarios[args.scenario]
+        print(f"\nSCENARIO: {scenario_data['name']}\n")
+
+        env = args.env if args.env else scenario_data["env"]
+        format_list_output(scenario_data["studios"], scenario_data["engines_map"], env)
+
+
+if __name__ == "__main__":
+    main()
+

dayhoff_tools/cli/engines_studios/studio_commands.py

@@ -262,23 +262,40 @@ def list_studios(env: Optional[str]):
             click.echo("No studios found")
             return
 
+        # Get all engines to map instance IDs to names
+        engines_result = client.list_engines()
+        engines_map = {}
+        for engine in engines_result.get("engines", []):
+            engines_map[engine["instance_id"]] = engine["name"]
+
         # Calculate dynamic width for User column (longest user + 2 for padding)
         max_user_len = max((len(studio.get("user", "unknown")) for studio in studios), default=4)
         user_width = max(max_user_len + 2, len("User") + 2)
 
-        # Fixed widths for other columns - reordered to [User, Status, Size, Studio ID]
+        # Calculate dynamic width for Attached To column
+        max_attached_len = 0
+        for studio in studios:
+            if studio.get("attached_to"):
+                instance_id = studio["attached_to"]
+                engine_name = engines_map.get(instance_id, "unknown")
+                max_attached_len = max(max_attached_len, len(engine_name))
+        attached_width = max(max_attached_len + 2, len("Attached To") + 2, 3)  # At least 3 for "-"
+
+        # Fixed widths for other columns - reordered to [User, Status, Attached To, Size, Studio ID]
         status_width = 12
         size_width = 10
         id_width = 25
 
-        # Calculate total width for separator line
-        total_width = user_width + status_width + size_width + id_width + 3  # +3 for spaces
+        # Table top border
+        click.echo("┌" + "─" * (user_width + 1) + "┬" + "─" * (status_width + 1) + "┬" + "─" * (attached_width + 1) + "┬" + "─" * (size_width + 1) + "┬" + "─" * (id_width + 1) + "┐")
 
-        # Table header - reordered to [User, Status, Size, Studio ID]
+        # Table header - reordered to [User, Status, Attached To, Size, Studio ID]
         click.echo(
-            f"{'User':<{user_width}} {'Status':<{status_width}} {'Size':<{size_width}} {'Studio ID':<{id_width}}"
+            f"│ {'User':<{user_width}}│ {'Status':<{status_width}}│ {'Attached To':<{attached_width}}│ {'Size':<{size_width}}│ {'Studio ID':<{id_width}}│"
         )
-        click.echo("─" * total_width)
+
+        # Header separator
+        click.echo("├" + "─" * (user_width + 1) + "┼" + "─" * (status_width + 1) + "┼" + "─" * (attached_width + 1) + "┼" + "─" * (size_width + 1) + "┼" + "─" * (id_width + 1) + "┤")
 
         # Table rows
         for studio in studios:
@@ -286,6 +303,7 @@ def list_studios(env: Optional[str]):
             status = studio.get("status", "unknown")
             size = f"{studio.get('size_gb', 0)}GB"
             studio_id = studio.get("studio_id", "unknown")
+            attached_to = studio.get("attached_to")
 
             # Truncate if needed
             if len(user) > user_width - 1:
@@ -294,26 +312,40 @@ def list_studios(env: Optional[str]):
             # Color the user (blue)
             user_display = f"\033[34m{user:<{user_width}}\033[0m"
 
-            # Color the status
-            if status == "available":
+            # Format status - display "in-use" as "attached" in purple
+            if status == "in-use":
+                display_status = "attached"
+                status_display = f"\033[35m{display_status:<{status_width}}\033[0m"  # Purple
+            elif status == "available":
                 status_display = f"\033[32m{status:<{status_width}}\033[0m"  # Green
             elif status in ["attaching", "detaching"]:
                 status_display = f"\033[33m{status:<{status_width}}\033[0m"  # Yellow
             elif status == "attached":
-                status_display = f"\033[32m{status:<{status_width}}\033[0m"  # Green
-            elif status in ["error", "in-use"]:
-                # "in-use" is the old status name, treat as attached (green)
-                if status == "in-use":
-                    status_display = f"\033[32m{status:<{status_width}}\033[0m"  # Green
-                else:
-                    status_display = f"\033[31m{status:<{status_width}}\033[0m"  # Red for error
+                status_display = f"\033[35m{status:<{status_width}}\033[0m"  # Purple
+            elif status == "error":
+                status_display = f"\033[31m{status:<{status_width}}\033[0m"  # Red for error
             else:
                 status_display = f"{status:<{status_width}}"  # No color for other states
 
+            # Format Attached To column
+            if attached_to:
+                instance_id = attached_to
+                engine_name = engines_map.get(instance_id, "unknown")
+                # Engine name in white (no color)
+                attached_display = f"{engine_name:<{attached_width}}"
+            else:
+                attached_display = f"{'-':<{attached_width}}"
+
+            # Color the studio ID (grey)
+            studio_id_display = f"\033[90m{studio_id:<{id_width}}\033[0m"
+
             click.echo(
-                f"{user_display} {status_display} {size:<{size_width}} {studio_id:<{id_width}}"
+                f"│ {user_display}│ {status_display}│ {attached_display}│ {size:<{size_width}}│ {studio_id_display}│"
             )
 
+        # Table bottom border
+        click.echo("└" + "─" * (user_width + 1) + "┴" + "─" * (status_width + 1) + "┴" + "─" * (attached_width + 1) + "┴" + "─" * (size_width + 1) + "┴" + "─" * (id_width + 1) + "┘")
+
         click.echo(f"\nTotal: {len(studios)} studio(s)")
 
     except Exception as e:

{dayhoff_tools-1.12.32.dist-info → dayhoff_tools-1.13.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dayhoff-tools
-Version: 1.12.32
+Version: 1.13.0
 Summary: Common tools for all the repos at Dayhoff Labs
 Author: Daniel Martin-Alarcon
 Author-email: dma@dayhofflabs.com

{dayhoff_tools-1.12.32.dist-info → dayhoff_tools-1.13.0.dist-info}/RECORD

@@ -13,17 +13,18 @@ dayhoff_tools/cli/engine1/studio_commands.py,sha256=VwTQujz32-uMcYusDRE73SdzRpgv
 dayhoff_tools/cli/engines_studios/__init__.py,sha256=E6aG0C6qjJnJuClemSKRFlYvLUL49MQZOvfqNQ7SDKs,159
 dayhoff_tools/cli/engines_studios/api_client.py,sha256=9I55_Ns8VHxndGjvSt_c5ZohSqMOeywQlLjyuoDEqCQ,13039
 dayhoff_tools/cli/engines_studios/auth.py,sha256=rwetV5hp4jSvK8FyvKgXCnezLOZx1aW8oiSDc6U83iE,5189
-dayhoff_tools/cli/engines_studios/engine-studio-cli.md,sha256=uWi6MMZwlIc1PiNQ8iRtRZSVTSOmBkwWY1s2wpuRbgk,28345
-dayhoff_tools/cli/engines_studios/engine_commands.py,sha256=zhkKsXj6LzpfJ2MnNsmir-pByKOuGSXLeJU14pVJfaQ,33743
+dayhoff_tools/cli/engines_studios/engine-studio-cli.md,sha256=TYnoJUxuTsnsvUAbn0oxlp0nCru9eYElL1_LLCvtqw4,29944
+dayhoff_tools/cli/engines_studios/engine_commands.py,sha256=Kmt9lo5bEmLDbIqNX6ivqWIgoTH9XrbOsXmHpqeVaqs,34561
 dayhoff_tools/cli/engines_studios/progress.py,sha256=SMahdG2YmO5bEPSONrfAXVTdS6m_69Ep02t3hc2DdKQ,9264
 dayhoff_tools/cli/engines_studios/simulators/cli-simulators.md,sha256=FZJl6nehdr2Duht2cx3yijcak0yKyOaHTrTzvFTAfZs,4976
 dayhoff_tools/cli/engines_studios/simulators/demo.sh,sha256=8tYABSCxLNXqGs-4r071V9mpKNZ5DTQ34WZ-v3d5s94,5364
-dayhoff_tools/cli/engines_studios/simulators/engine_list_simulator.py,sha256=hkuZMkCfnAD8giMVS04TeqGWMiRKhjhCmKCPRWcdPZA,8603
+dayhoff_tools/cli/engines_studios/simulators/engine_list_simulator.py,sha256=ldPA6D4EqnCn6zjcbDX2AWRtVZ3SXCyUTfFbVStabvc,9533
 dayhoff_tools/cli/engines_studios/simulators/engine_status_simulator.py,sha256=KUm3gA2MiRgGrQV7KURhb5zabM18-30z_ugRjiq5iso,13024
 dayhoff_tools/cli/engines_studios/simulators/idle_status_simulator.py,sha256=F_MfEXdPKNVDCKgJV72QyU2oMG8hLt-Bwic4yFadRXE,17570
 dayhoff_tools/cli/engines_studios/simulators/simulator_utils.py,sha256=HA08pIMJWV3OFrWj3Ca8GldvgJZfFoTOloyLK0UWMgA,6729
+dayhoff_tools/cli/engines_studios/simulators/studio_list_simulator.py,sha256=kOoON4_V5DwPRBlCuFqOEEjH535a_SyDAFoK5wKlYaY,11205
 dayhoff_tools/cli/engines_studios/simulators/studio_status_simulator.py,sha256=6WvpnRawJVaQf_H81zuR1_66igRRVxPxjAt8e69xjp4,5394
-dayhoff_tools/cli/engines_studios/studio_commands.py,sha256=DX--3p15yrKC5eB86dc5m_MTb-5SB7b-kPsqW42ykaI,22417
+dayhoff_tools/cli/engines_studios/studio_commands.py,sha256=V7yltLuwN67xGOCj6S8DyfyQDQtjJbANq7G6gY5P08s,24275
 dayhoff_tools/cli/main.py,sha256=Nz_jtbppmvWKHZydQ0nkt_eejccJE90ces8xCGrerdY,7086
 dayhoff_tools/cli/swarm_commands.py,sha256=5EyKj8yietvT5lfoz8Zx0iQvVaNgc3SJX1z2zQR6o6M,5614
 dayhoff_tools/cli/utility_commands.py,sha256=e2P4dCCtoqMUGNyb0lFBZ6GZpl5Zslm1qqE5qIvsy38,50765
@@ -47,7 +48,7 @@ dayhoff_tools/intake/uniprot.py,sha256=BZYJQF63OtPcBBnQ7_P9gulxzJtqyorgyuDiPeOJq
 dayhoff_tools/logs.py,sha256=DKdeP0k0kliRcilwvX0mUB2eipO5BdWUeHwh-VnsICs,838
 dayhoff_tools/sqlite.py,sha256=jV55ikF8VpTfeQqqlHSbY8OgfyfHj8zgHNpZjBLos_E,18672
 dayhoff_tools/warehouse.py,sha256=UETBtZD3r7WgvURqfGbyHlT7cxoiVq8isjzMuerKw8I,24475
-dayhoff_tools-1.12.32.dist-info/METADATA,sha256=wg00QqtusBsm7HGPud5mkObekKEuyJoa-IYpRRquZ5k,2981
-dayhoff_tools-1.12.32.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-dayhoff_tools-1.12.32.dist-info/entry_points.txt,sha256=iAf4jteNqW3cJm6CO6czLxjW3vxYKsyGLZ8WGmxamSc,49
-dayhoff_tools-1.12.32.dist-info/RECORD,,
+dayhoff_tools-1.13.0.dist-info/METADATA,sha256=J7tfJUuPi4-ncz_TgTx4tZqbkpEey8KxwdSM8M3mvCg,2980
+dayhoff_tools-1.13.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+dayhoff_tools-1.13.0.dist-info/entry_points.txt,sha256=iAf4jteNqW3cJm6CO6czLxjW3vxYKsyGLZ8WGmxamSc,49
+dayhoff_tools-1.13.0.dist-info/RECORD,,