dayhoff-tools 1.12.31__py3-none-any.whl → 1.12.33__py3-none-any.whl

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

@@ -321,15 +321,26 @@ dh engine2 list --env sand
 
 **Output:**
 ```
-Name                           Instance ID           Type            State     
---------------------------------------------------------------------------------
-alice-work                     i-0123456789abcdef0   cpu             running   
-bob-training                   i-0fedcba987654321   a10g            running   
-batch-worker                   i-0abc123def456789   cpumax          stopped   
+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  │
+└──────────────┴─────────────┴─────────────┴─────────────┴─────────────────────┘
 
 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
+
 ---
 
 ### Access
@@ -744,15 +755,29 @@ dh studio2 list
 
 **Output:**
 ```
-User                 Studio ID                Size       Status         
----------------------------------------------------------------------------
-alice                vol-0123456789abcdef0    100GB      attached       
-bob                  vol-0fedcba987654321     200GB      available      
-carol                vol-0abc123def456789     150GB      available      
+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: 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
+- Attached To column width adjusts dynamically to fit the longest engine name
+- Columns are ordered: User, Status, Attached To, Size, Studio ID
+
 ---
 
 ### Attachment

dayhoff_tools/cli/engines_studios/engine_commands.py

@@ -587,34 +587,69 @@ def list_engines(env: Optional[str]):
             click.echo("No engines found")
             return
 
-        # Table header - reordered per user request: Name, State, User, Type, Instance ID
+        # 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)
+        name_width = max(max_name_len + 2, len("Name") + 2)
+
+        # Fixed widths for other columns
+        state_width = 12
+        user_width = 12
+        type_width = 12
+        id_width = 20
+
+        # Calculate total width for separator line
+        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':<30} {'State':<12} {'User':<12} {'Type':<12} {'Instance ID':<20}"
+            f"│ {'Name':<{name_width}}│ {'State':<{state_width}}│ {'User':<{user_width}}│ {'Type':<{type_width}}│ {'Instance ID':<{id_width}}│"
         )
-        click.echo("-" * 90)
+
+        # 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:
-            name = engine.get("name", "unknown")[:29]
-            state = engine.get("state", "unknown")[:11]
-            user = engine.get("user", "unknown")[:11]
-            engine_type = engine.get("engine_type", "unknown")[:11]
+            name = engine.get("name", "unknown")
+            state = engine.get("state", "unknown")
+            user = engine.get("user", "unknown")
+            engine_type = engine.get("engine_type", "unknown")
             instance_id = engine.get("instance_id", "unknown")
 
-            # Color the state in the list view
+            # Truncate if needed
+            if len(name) > name_width - 1:
+                name = name[:name_width - 1]
+            if len(user) > user_width - 1:
+                user = user[:user_width - 1]
+            if len(engine_type) > type_width - 1:
+                engine_type = engine_type[:type_width - 1]
+
+            # Color the name (blue)
+            name_display = f"\033[34m{name:<{name_width}}\033[0m"
+
+            # Color the state
             if state == "running":
-                state_display = f"\033[32m{state:<12}\033[0m"  # Green
+                state_display = f"\033[32m{state:<{state_width}}\033[0m"  # Green
             elif state in ["starting", "stopping", "pending"]:
-                state_display = f"\033[33m{state:<12}\033[0m"  # Yellow
+                state_display = f"\033[33m{state:<{state_width}}\033[0m"  # Yellow
             elif state == "stopped":
-                state_display = f"\033[37m{state:<12}\033[0m"  # White
+                state_display = f"\033[90m{state:<{state_width}}\033[0m"  # Grey (dim)
             else:
-                state_display = f"{state:<12}"  # No color for other states
+                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:<30} {state_display} {user:<12} {engine_type:<12} {instance_id:<20}"
+                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

@@ -30,32 +30,104 @@ def format_list_output(engines: list[dict[str, Any]], env: str = "dev") -> None:
         print("No engines found")
         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
+    )
+    name_width = max(max_name_len + 2, len("Name") + 2)
+
+    # Fixed widths for other columns
+    state_width = 12
+    user_width = 12
+    type_width = 12
+    id_width = 20
+
+    # Table top border
+    print(
+        "┌"
+        + "─" * (name_width + 1)
+        + "┬"
+        + "─" * (state_width + 1)
+        + "┬"
+        + "─" * (user_width + 1)
+        + "┬"
+        + "─" * (type_width + 1)
+        + "┬"
+        + "─" * (id_width + 1)
+        + "┐"
+    )
+
     # Table header
-    print(f"{'Name':<12} {'State':<12} {'User':<12} {'Type':<12} {'Instance ID':<20}")
-    print("-" * 72)
+    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:
-        name = engine.get("name", "unknown")[:11]
-        state = engine.get("state", "unknown")[:11]
-        user = engine.get("user", "unknown")[:11]
-        engine_type = engine.get("engine_type", "unknown")[:11]
+        name = engine.get("name", "unknown")
+        state = engine.get("state", "unknown")
+        user = engine.get("user", "unknown")
+        engine_type = engine.get("engine_type", "unknown")
         instance_id = engine.get("instance_id", "unknown")
 
+        # Truncate if needed
+        if len(name) > name_width - 1:
+            name = name[: name_width - 1]
+        if len(user) > user_width - 1:
+            user = user[: user_width - 1]
+        if len(engine_type) > type_width - 1:
+            engine_type = engine_type[: type_width - 1]
+
+        # Color the name (blue)
+        name_display = colorize(f"{name:<{name_width}}", "34")
+
         # Color the state
         if state == "running":
-            state_display = colorize(f"{state:<12}", "32")  # Green
+            state_display = colorize(f"{state:<{state_width}}", "32")  # Green
         elif state in ["starting", "stopping", "pending"]:
-            state_display = colorize(f"{state:<12}", "33")  # Yellow
+            state_display = colorize(f"{state:<{state_width}}", "33")  # Yellow
         elif state == "stopped":
-            state_display = colorize(f"{state:<12}", "37")  # White
+            state_display = colorize(f"{state:<{state_width}}", "90")  # Grey (dim)
         else:
-            state_display = f"{state:<12}"  # No color for other states
+            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:<12} {state_display} {user:<12} {engine_type:<12} {instance_id:<20}"
+            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,18 +262,89 @@ def list_studios(env: Optional[str]):
             click.echo("No studios found")
             return
 
-        # Table header
-        click.echo(f"{'User':<20} {'Studio ID':<25} {'Size':<10} {'Status':<15}")
-        click.echo("-" * 75)
+        # 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)
+
+        # 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
+
+        # 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, Attached To, Size, Studio ID]
+        click.echo(
+            f"│ {'User':<{user_width}}│ {'Status':<{status_width}}│ {'Attached To':<{attached_width}}│ {'Size':<{size_width}}│ {'Studio ID':<{id_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:
-            user = studio.get("user", "unknown")[:19]
-            studio_id = studio.get("studio_id", "unknown")
-            size = f"{studio.get('size_gb', 0)}GB"
+            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 = f"\033[34m{user:<{user_width}}\033[0m"
+
+            # 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[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}│ {attached_display}│ {size:<{size_width}}│ {studio_id_display}│"
+            )
 
-            click.echo(f"{user:<20} {studio_id:<25} {size:<10} {status:<15}")
+        # 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)")
 

dayhoff_tools/deployment/deploy_aws.py

@@ -344,6 +344,47 @@ def create_or_update_job_definition(
             f"Adding mount points to job definition: {batch_job_config['mountPoints']}"
         )
 
+    # Auto-mount Primordial Drive if available
+    # This ensures all batch jobs have access to shared datasets at /primordial/
+    primordial_fs_id = get_primordial_fs_id(session)
+    if primordial_fs_id:
+        print(f"Adding Primordial Drive configuration (fs_id: {primordial_fs_id})")
+
+        # Add volume configuration
+        efs_volume = {
+            "name": "primordial",
+            "efsVolumeConfiguration": {
+                "fileSystemId": primordial_fs_id,
+                "rootDirectory": "/",
+            },
+        }
+
+        if "volumes" not in container_properties:
+            container_properties["volumes"] = []
+
+        # Check if already added to avoid duplicates
+        if not any(
+            v.get("name") == "primordial" for v in container_properties["volumes"]
+        ):
+            container_properties["volumes"].append(efs_volume)
+
+        # Add mount point
+        mount_point = {
+            "sourceVolume": "primordial",
+            "containerPath": "/primordial",
+            "readOnly": False,
+        }
+
+        if "mountPoints" not in container_properties:
+            container_properties["mountPoints"] = []
+
+        # Check if already added
+        if not any(
+            mp.get("containerPath") == "/primordial"
+            for mp in container_properties["mountPoints"]
+        ):
+            container_properties["mountPoints"].append(mount_point)
+
     # Check if job definition already exists using the session client
     try:
         existing = batch.describe_job_definitions(
@@ -385,6 +426,38 @@ def create_or_update_job_definition(
     return response["jobDefinitionName"]
 
 
+def get_primordial_fs_id(session: boto3.Session) -> Optional[str]:
+    """Fetch Primordial Drive EFS ID from SSM.
+
+    Args:
+        session: Boto3 session
+
+    Returns:
+        FileSystemId if found, None otherwise
+    """
+    ssm = session.client("ssm")
+
+    # Determine environment from profile name
+    # Default to dev if cannot determine
+    env = "dev"
+    if session.profile_name and "sand" in session.profile_name:
+        env = "sand"
+
+    param_name = f"/{env}/primordial/fs_id"
+
+    try:
+        response = ssm.get_parameter(Name=param_name)
+        return response["Parameter"]["Value"]
+    except ClientError as e:
+        # Silently fail if not found - Primordial might not be deployed in this env
+        # or we might not have permissions
+        # ParameterNotFound is a ClientError with error code "ParameterNotFound"
+        return None
+    except Exception as e:
+        print(f"Warning: Failed to check for Primordial Drive: {e}")
+        return None
+
+
 def submit_aws_batch_job(
     image_uri: str,
     config: dict[str, Any],

{dayhoff_tools-1.12.31.dist-info → dayhoff_tools-1.12.33.dist-info}/METADATA

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

{dayhoff_tools-1.12.31.dist-info → dayhoff_tools-1.12.33.dist-info}/RECORD

@@ -13,22 +13,23 @@ 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=jwUoMrwp8OnNcOMw128NnQib9Yn2tWmupXcLLtyfass,27613
-dayhoff_tools/cli/engines_studios/engine_commands.py,sha256=x7fif4bnc0A8sDNHv3UuilUSurWv8Qhfrv9Jlp1s_QA,32750
+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=MrfcCpg8oKZ3fpr9-J8rb7pdJ7XptKuhLcVSF07xxxU,7601
+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=fXj0Oo8BTWrORplg3V0dxZo1i9xX6-h2WSsdtbJQqbc,20575
+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
 dayhoff_tools/deployment/base.py,sha256=fM9zyhuRvIK8YqY6ooYg9j6wy_8touA_L-dkV7FA5q4,18058
-dayhoff_tools/deployment/deploy_aws.py,sha256=gfqh09hGbz0q3oPqVm0imd_CEjKF2k8moGNRIL26qqE,18614
+dayhoff_tools/deployment/deploy_aws.py,sha256=3xNuGvwDKvICfiLXVeM4Oz8MXQ363voTM-6vXHtEHZY,20987
 dayhoff_tools/deployment/deploy_gcp.py,sha256=xgaOVsUDmP6wSEMYNkm1yRNcVskfdz80qJtCulkBIAM,8860
 dayhoff_tools/deployment/deploy_utils.py,sha256=KyUFZZWn8NGT9QpR0HGqkX-huOFubvYCabko9SlC5Gg,26516
 dayhoff_tools/deployment/job_runner.py,sha256=hljvFpH2Bw96uYyUup5Ths72PZRL_X27KxlYzBMgguo,5086
@@ -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.31.dist-info/METADATA,sha256=XXc2Zu9LH0HKmDqY-uj2MlRNYrm4sOtxIHVdzRozBgg,2981
-dayhoff_tools-1.12.31.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-dayhoff_tools-1.12.31.dist-info/entry_points.txt,sha256=iAf4jteNqW3cJm6CO6czLxjW3vxYKsyGLZ8WGmxamSc,49
-dayhoff_tools-1.12.31.dist-info/RECORD,,
+dayhoff_tools-1.12.33.dist-info/METADATA,sha256=eitG3L1hL3vbXaglvoQOs25y5arWRzklHRntUTBVUR0,2981
+dayhoff_tools-1.12.33.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+dayhoff_tools-1.12.33.dist-info/entry_points.txt,sha256=iAf4jteNqW3cJm6CO6czLxjW3vxYKsyGLZ8WGmxamSc,49
+dayhoff_tools-1.12.33.dist-info/RECORD,,