dayhoff-tools 1.1.10__py3-none-any.whl → 1.13.12__py3-none-any.whl

dayhoff_tools/cli/engines_studios/simulators/engine_list_simulator.py

@@ -0,0 +1,319 @@
+#!/usr/bin/env python3
+"""Simulator for engine list output - iterate on design locally without AWS.
+
+This lets you quickly see how the list command output looks with different
+engine states and configurations.
+
+Usage:
+    python dayhoff_tools/cli/engines_studios/simulators/engine_list_simulator.py                # Show all scenarios
+    python dayhoff_tools/cli/engines_studios/simulators/engine_list_simulator.py --scenario few # Show specific scenario
+    python dayhoff_tools/cli/engines_studios/simulators/engine_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(engines: list[dict[str, Any]], env: str = "dev") -> None:
+    """Format and print engine list output matching the actual CLI."""
+
+    # Header with blue account name
+    print(f"\nEngines for AWS Account {colorize(env, '34')}")
+
+    if not engines:
+        print("No engines found\n")
+        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':<{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")
+        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:<{state_width}}", "32")  # Green
+        elif state in ["starting", "stopping", "pending"]:
+            state_display = colorize(f"{state:<{state_width}}", "33")  # Yellow
+        elif state == "stopped":
+            state_display = colorize(f"{state:<{state_width}}", "90")  # Grey (dim)
+        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_display}│"
+        )
+
+    # Table bottom border
+    print(
+        "╰"
+        + "─" * (name_width + 1)
+        + "┴"
+        + "─" * (state_width + 1)
+        + "┴"
+        + "─" * (user_width + 1)
+        + "┴"
+        + "─" * (type_width + 1)
+        + "┴"
+        + "─" * (id_width + 1)
+        + "╯"
+    )
+
+    print(f"Total: {len(engines)}\n")
+
+
+def generate_scenarios() -> dict[str, dict[str, Any]]:
+    """Generate various test scenarios for list output."""
+
+    scenarios = {}
+
+    # Scenario 1: Single running engine
+    scenarios["single"] = {
+        "name": "Single Running Engine",
+        "engines": [
+            {
+                "name": "alice-gpu",
+                "state": "running",
+                "user": "alice",
+                "engine_type": "gpu",
+                "instance_id": "i-0123456789abcdef0",
+            }
+        ],
+        "env": "dev",
+    }
+
+    # Scenario 2: Few engines with various states
+    scenarios["few"] = {
+        "name": "Few Engines - Mixed States",
+        "engines": [
+            {
+                "name": "alice-gpu",
+                "state": "running",
+                "user": "alice",
+                "engine_type": "gpu",
+                "instance_id": "i-0123456789abcdef0",
+            },
+            {
+                "name": "bob-cpu",
+                "state": "stopped",
+                "user": "bob",
+                "engine_type": "cpu",
+                "instance_id": "i-1234567890abcdef1",
+            },
+            {
+                "name": "charlie",
+                "state": "starting",
+                "user": "charlie",
+                "engine_type": "cpu",
+                "instance_id": "i-2345678901abcdef2",
+            },
+        ],
+        "env": "sand",
+    }
+
+    # Scenario 3: Many engines (production-like)
+    scenarios["many"] = {
+        "name": "Many Engines - Production",
+        "engines": [
+            {
+                "name": "alice-main",
+                "state": "running",
+                "user": "alice",
+                "engine_type": "gpu",
+                "instance_id": "i-0123456789abcdef0",
+            },
+            {
+                "name": "bob-exp1",
+                "state": "running",
+                "user": "bob",
+                "engine_type": "cpu",
+                "instance_id": "i-1234567890abcdef1",
+            },
+            {
+                "name": "bob-exp2",
+                "state": "stopped",
+                "user": "bob",
+                "engine_type": "cpu",
+                "instance_id": "i-2345678901abcdef2",
+            },
+            {
+                "name": "charlie-gpu",
+                "state": "running",
+                "user": "charlie",
+                "engine_type": "gpu",
+                "instance_id": "i-3456789012abcdef3",
+            },
+            {
+                "name": "diana-dev",
+                "state": "running",
+                "user": "diana",
+                "engine_type": "cpu",
+                "instance_id": "i-4567890123abcdef4",
+            },
+            {
+                "name": "eve-test",
+                "state": "stopping",
+                "user": "eve",
+                "engine_type": "cpu",
+                "instance_id": "i-5678901234abcdef5",
+            },
+            {
+                "name": "frank-prod",
+                "state": "running",
+                "user": "frank",
+                "engine_type": "gpu",
+                "instance_id": "i-6789012345abcdef6",
+            },
+        ],
+        "env": "prod",
+    }
+
+    # Scenario 4: Empty list
+    scenarios["empty"] = {
+        "name": "No Engines",
+        "engines": [],
+        "env": "dev",
+    }
+
+    # Scenario 5: All transitional states
+    scenarios["transitions"] = {
+        "name": "Transitional States",
+        "engines": [
+            {
+                "name": "engine1",
+                "state": "starting",
+                "user": "alice",
+                "engine_type": "cpu",
+                "instance_id": "i-0123456789abcdef0",
+            },
+            {
+                "name": "engine2",
+                "state": "stopping",
+                "user": "bob",
+                "engine_type": "cpu",
+                "instance_id": "i-1234567890abcdef1",
+            },
+            {
+                "name": "engine3",
+                "state": "pending",
+                "user": "charlie",
+                "engine_type": "gpu",
+                "instance_id": "i-2345678901abcdef2",
+            },
+        ],
+        "env": "sand",
+    }
+
+    return scenarios
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Simulate engine list output for design iteration"
+    )
+    parser.add_argument(
+        "--scenario",
+        choices=["single", "few", "many", "empty", "transitions", "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["engines"], 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["engines"], env)
+
+
+if __name__ == "__main__":
+    main()

dayhoff_tools/cli/engines_studios/simulators/engine_status_simulator.py

@@ -0,0 +1,369 @@
+#!/usr/bin/env python3
+"""Simulator for engine status output - iterate on design locally without AWS.
+
+This lets you quickly see how the status command output looks for different
+engine states and configurations.
+
+Usage:
+    python dayhoff_tools/cli/engines_studios/simulators/engine_status_simulator.py                    # Show all scenarios
+    python dayhoff_tools/cli/engines_studios/simulators/engine_status_simulator.py --scenario running # Show specific scenario
+    python dayhoff_tools/cli/engines_studios/simulators/engine_status_simulator.py --env sand         # Override environment
+"""
+
+import argparse
+import sys
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+# Import standalone utilities
+simulator_dir = Path(__file__).parent
+sys.path.insert(0, str(simulator_dir))
+from simulator_utils import format_idle_state, format_time_ago
+
+
+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_status_output(status_data: dict, env: str = "dev") -> None:
+    """Format and print engine status output matching the actual CLI."""
+
+    # Display basic info - matching engine_commands.py order
+    engine_name = status_data.get("name", status_data.get("instance_id", "unknown"))
+    print(f"Name: {colorize(engine_name, '34')}")  # Blue
+
+    # Show state with color coding
+    engine_state = status_data.get("state", "unknown")
+    state_lower = engine_state.lower()
+    if state_lower == "running":
+        print(f"State: {colorize(engine_state, '32')}")  # Green
+    elif state_lower in ["stopped", "terminated"]:
+        print(f"State: {colorize(engine_state, '31')}")  # Red
+    elif state_lower in ["stopping", "starting", "pending"]:
+        print(f"State: {colorize(engine_state, '33')}")  # Yellow
+    else:
+        print(f"State: {engine_state}")
+
+    # Show account
+    print(f"Account: {env}")
+
+    if status_data.get("launch_time"):
+        print(f"Launched: {format_time_ago(status_data['launch_time'])}")
+
+    print(f"Type: {status_data.get('instance_type', 'unknown')}")
+    print(f"Instance ID: {status_data.get('instance_id', 'unknown')}")
+
+    if status_data.get("public_ip"):
+        print(f"Public IP: {status_data['public_ip']}")
+
+    # Only show idle state and sensors for running engines
+    if state_lower != "running":
+        if state_lower in ["stopped", "terminated"]:
+            print(
+                f"\n⚠️  Engine is {engine_state.lower()} - idle detection not available"
+            )
+        return
+
+    # Display idle state
+    idle_state = status_data.get("idle_state", {})
+    if idle_state:
+        idle_display = format_idle_state(idle_state)
+        print(idle_display)
+
+    # Display attached studios
+    print(f"\nAttached Studios: {status_data.get('attached_studios', 'None')}")
+
+
+def generate_scenarios() -> dict:
+    """Generate various test scenarios for status output."""
+
+    scenarios = {}
+
+    # Scenario 1: Running engine with idle state
+    scenarios["running_idle"] = {
+        "name": "Running Engine - Idle",
+        "status_data": {
+            "name": "alice-gpu",
+            "instance_id": "i-0123456789abcdef0",
+            "instance_type": "g4dn.xlarge",
+            "state": "running",
+            "public_ip": "54.123.45.67",
+            "launch_time": (
+                datetime.now(timezone.utc) - timedelta(hours=3)
+            ).isoformat(),
+            "idle_state": {
+                "is_idle": True,
+                "reason": "All sensors report idle",
+                "idle_seconds": 450,
+                "timeout_seconds": "1800",
+                "sensors": {
+                    "coffee": {
+                        "active": False,
+                        "confidence": "HIGH",
+                        "details": {},
+                    },
+                    "ssh": {
+                        "active": False,
+                        "confidence": "HIGH",
+                        "details": {},
+                    },
+                    "ide": {
+                        "active": False,
+                        "confidence": "HIGH",
+                        "details": {},
+                    },
+                    "docker": {
+                        "active": False,
+                        "confidence": "MEDIUM",
+                        "details": {},
+                    },
+                },
+            },
+            "attached_studios": "None",
+        },
+        "env": "dev",
+    }
+
+    # Scenario 2: Running engine with active SSH
+    scenarios["running_active"] = {
+        "name": "Running Engine - Active (SSH + IDE + Coffee)",
+        "status_data": {
+            "name": "bob-cpu",
+            "instance_id": "i-1234567890abcdef1",
+            "instance_type": "t3a.xlarge",
+            "state": "running",
+            "public_ip": "54.234.56.78",
+            "launch_time": (
+                datetime.now(timezone.utc) - timedelta(minutes=45)
+            ).isoformat(),
+            "idle_state": {
+                "is_idle": False,
+                "reason": "Active connections detected",
+                "idle_seconds": 0,
+                "timeout_seconds": "1800",
+                "sensors": {
+                    "coffee": {
+                        "active": True,
+                        "confidence": "HIGH",
+                        "details": {
+                            "remaining_seconds": "13200",  # 220 minutes
+                            "timeout_seconds": "14400",
+                        },
+                    },
+                    "ssh": {
+                        "active": True,
+                        "confidence": "HIGH",
+                        "details": {
+                            "session_count": 2,
+                            "sessions": [
+                                {
+                                    "user": "bob",
+                                    "tty": "pts/0",
+                                    "from": "127.0.0.1",
+                                    "login": "2025-11-18 09:30",
+                                    "idle": "00:05",
+                                    "pid": "12345",
+                                },
+                                {
+                                    "user": "bob",
+                                    "tty": "pts/1",
+                                    "from": "127.0.0.1",
+                                    "login": "2025-11-18 09:45",
+                                    "idle": "00:02",
+                                    "pid": "12567",
+                                },
+                            ],
+                        },
+                    },
+                    "ide": {
+                        "active": True,
+                        "confidence": "HIGH",
+                        "details": {
+                            "connection_count": 1,
+                            "ide_type": "Cursor",
+                            "connections": [
+                                {
+                                    "local": "127.0.0.1:32777",
+                                    "remote": "127.0.0.1:33616",
+                                    "process": "cursor-ba90f2f8",
+                                    "pid": "24967",
+                                }
+                            ],
+                        },
+                    },
+                    "docker": {
+                        "active": False,
+                        "confidence": "MEDIUM",
+                        "details": {},
+                    },
+                },
+            },
+            "attached_studios": "vol-047e03b0647fa9d87",
+        },
+        "env": "sand",
+    }
+
+    # Scenario 3: Stopped engine
+    scenarios["stopped"] = {
+        "name": "Stopped Engine",
+        "status_data": {
+            "name": "charlie-test",
+            "instance_id": "i-2345678901abcdef2",
+            "instance_type": "t3a.medium",
+            "state": "stopped",
+            "launch_time": (datetime.now(timezone.utc) - timedelta(days=2)).isoformat(),
+            "attached_studios": "None",
+        },
+        "env": "dev",
+    }
+
+    # Scenario 4: Starting engine
+    scenarios["starting"] = {
+        "name": "Starting Engine",
+        "status_data": {
+            "name": "diana-gpu",
+            "instance_id": "i-3456789012abcdef3",
+            "instance_type": "g5.xlarge",
+            "state": "starting",
+            "launch_time": (
+                datetime.now(timezone.utc) - timedelta(minutes=2)
+            ).isoformat(),
+            "attached_studios": "None",
+        },
+        "env": "prod",
+    }
+
+    # Scenario 5: Stopping engine
+    scenarios["stopping"] = {
+        "name": "Stopping Engine",
+        "status_data": {
+            "name": "eve-dev",
+            "instance_id": "i-4567890123abcdef4",
+            "instance_type": "t3a.large",
+            "state": "stopping",
+            "public_ip": "54.123.45.89",
+            "launch_time": (
+                datetime.now(timezone.utc) - timedelta(hours=8)
+            ).isoformat(),
+            "attached_studios": "None",
+        },
+        "env": "sand",
+    }
+
+    # Scenario 6: Running with Docker activity
+    scenarios["running_docker"] = {
+        "name": "Running Engine - Docker Active",
+        "status_data": {
+            "name": "frank-ml",
+            "instance_id": "i-5678901234abcdef5",
+            "instance_type": "g4dn.2xlarge",
+            "state": "running",
+            "public_ip": "54.234.67.90",
+            "launch_time": (
+                datetime.now(timezone.utc) - timedelta(hours=12)
+            ).isoformat(),
+            "idle_state": {
+                "is_idle": False,
+                "reason": "Docker containers running",
+                "idle_seconds": 0,
+                "timeout_seconds": "1800",
+                "sensors": {
+                    "coffee": {
+                        "active": False,
+                        "confidence": "HIGH",
+                        "details": {},
+                    },
+                    "ssh": {
+                        "active": False,
+                        "confidence": "HIGH",
+                        "details": {},
+                    },
+                    "ide": {
+                        "active": False,
+                        "confidence": "HIGH",
+                        "details": {},
+                    },
+                    "docker": {
+                        "active": True,
+                        "confidence": "HIGH",
+                        "details": {
+                            "container_count": 3,
+                            "containers": [
+                                {
+                                    "name": "training-job-1",
+                                    "status": "running",
+                                    "uptime": "3 hours",
+                                },
+                                {
+                                    "name": "redis-cache",
+                                    "status": "running",
+                                    "uptime": "12 hours",
+                                },
+                                {
+                                    "name": "monitoring",
+                                    "status": "running",
+                                    "uptime": "12 hours",
+                                },
+                            ],
+                        },
+                    },
+                },
+            },
+            "attached_studios": "vol-01234567890abcdef",
+        },
+        "env": "prod",
+    }
+
+    return scenarios
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Simulate engine status output for design iteration"
+    )
+    parser.add_argument(
+        "--scenario",
+        choices=[
+            "running_idle",
+            "running_active",
+            "stopped",
+            "starting",
+            "stopping",
+            "running_docker",
+            "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_key, 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_status_output(scenario_data["status_data"], 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_status_output(scenario_data["status_data"], env)
+
+
+if __name__ == "__main__":
+    main()