dayhoff-tools 1.10.1__tar.gz → 1.10.3__tar.gz

{dayhoff_tools-1.10.1 → dayhoff_tools-1.10.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: dayhoff-tools
-Version: 1.10.1
+Version: 1.10.3
 Summary: Common tools for all the repos at Dayhoff Labs
 Author: Daniel Martin-Alarcon
 Author-email: dma@dayhofflabs.com
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Provides-Extra: embedders
 Provides-Extra: full
 Requires-Dist: biopython (>=1.84) ; extra == "full"

dayhoff_tools-1.10.1/dayhoff_tools/cli/engine_studio_commands.py → dayhoff_tools-1.10.3/dayhoff_tools/cli/engine/__init__.py

@@ -36,7 +36,7 @@ def launch_engine_cmd(
     ),
 ):
     """Launch a new engine instance."""
-    from .engine.launch import launch_engine
+    from .engine_core import launch_engine
 
     return launch_engine(name, engine_type, user, boot_disk_size, availability_zone)
 
@@ -55,7 +55,7 @@ def list_engines_cmd(
     ),
 ):
     """List engines (shows all engines by default)."""
-    from .engine.list import list_engines
+    from .engine_core import list_engines
 
     return list_engines(user, running_only, stopped_only, detailed)
 
@@ -71,7 +71,7 @@ def engine_status_cmd(
     ),
 ):
     """Show engine status and information."""
-    from .engine.status import engine_status
+    from .engine_core import engine_status
 
     return engine_status(name_or_id, detailed, show_log)
 
@@ -81,7 +81,7 @@ def start_engine_cmd(
     name_or_id: str = typer.Argument(help="Engine name or instance ID"),
 ):
     """Start a stopped engine."""
-    from .engine.lifecycle import start_engine
+    from .engine_lifecycle import start_engine
 
     return start_engine(name_or_id)
 
@@ -94,7 +94,7 @@ def stop_engine_cmd(
     ),
 ):
     """Stop an engine."""
-    from .engine.lifecycle import stop_engine
+    from .engine_lifecycle import stop_engine
 
     return stop_engine(name_or_id, force)
 
@@ -104,7 +104,7 @@ def terminate_engine_cmd(
     name_or_id: str = typer.Argument(help="Engine name or instance ID"),
 ):
     """Permanently terminate an engine."""
-    from .engine.lifecycle import terminate_engine
+    from .engine_lifecycle import terminate_engine
 
     return terminate_engine(name_or_id)
 
@@ -122,7 +122,7 @@ def ssh_engine_cmd(
     ),
 ):
     """Connect to an engine via SSH."""
-    from .engine.ssh import ssh_engine
+    from .engine_management import ssh_engine
 
     return ssh_engine(name_or_id, admin, idle_timeout)
 
@@ -140,7 +140,7 @@ def config_ssh_cmd(
     ),
 ):
     """Update SSH config with available engines."""
-    from .engine.config_ssh import config_ssh
+    from .engine_management import config_ssh
 
     return config_ssh(clean, all_engines, admin)
 
@@ -159,7 +159,7 @@ def resize_engine_cmd(
     ),
 ):
     """Resize an engine's boot disk."""
-    from .engine.resize import resize_engine
+    from .engine_management import resize_engine
 
     return resize_engine(name_or_id, size, online, force)
 
@@ -171,7 +171,7 @@ def create_ami_cmd(
     ),
 ):
     """Create a 'Golden AMI' from a running engine."""
-    from .engine.gami import create_ami
+    from .engine_management import create_ami
 
     return create_ami(name_or_id)
 
@@ -185,7 +185,7 @@ def coffee_cmd(
     ),
 ):
     """Pour ☕ for an engine: keeps it awake for the given duration (or cancel)."""
-    from .engine.coffee import coffee
+    from .engine_maintenance import coffee
 
     return coffee(name_or_id, duration, cancel)
 
@@ -201,7 +201,7 @@ def idle_timeout_cmd_wrapper(
     ),
 ):
     """Show or set engine idle-detector settings."""
-    from .engine.idle import idle_timeout_cmd
+    from .engine_maintenance import idle_timeout_cmd
 
     return idle_timeout_cmd(name_or_id=name_or_id, set=set, slack=slack)
 
@@ -211,7 +211,7 @@ def debug_engine_cmd(
     name_or_id: str = typer.Argument(help="Engine name or instance ID"),
 ):
     """Debug engine bootstrap status and files."""
-    from .engine.debug import debug_engine
+    from .engine_maintenance import debug_engine
 
     return debug_engine(name_or_id)
 
@@ -221,7 +221,7 @@ def repair_engine_cmd(
     name_or_id: str = typer.Argument(help="Engine name or instance ID"),
 ):
     """Repair an engine that's stuck in a bad state (e.g., after GAMI creation)."""
-    from .engine.repair import repair_engine
+    from .engine_maintenance import repair_engine
 
     return repair_engine(name_or_id)
 
@@ -232,7 +232,7 @@ def create_studio_cmd(
     size_gb: int = typer.Option(50, "--size", "-s", help="Studio size in GB"),
 ):
     """Create a new studio for the current user."""
-    from .studio.create import create_studio
+    from .studio_commands import create_studio
 
     return create_studio(size_gb)
 
@@ -244,7 +244,7 @@ def studio_status_cmd(
     ),
 ):
     """Show status of your studio."""
-    from .studio.status import studio_status
+    from .studio_commands import studio_status
 
     return studio_status(user)
 
@@ -257,7 +257,7 @@ def attach_studio_cmd(
     ),
 ):
     """Attach your studio to an engine."""
-    from .studio.attach import attach_studio
+    from .studio_commands import attach_studio
 
     return attach_studio(engine_name_or_id, user)
 
@@ -269,7 +269,7 @@ def detach_studio_cmd(
     ),
 ):
     """Detach your studio from its current engine."""
-    from .studio.detach import detach_studio
+    from .studio_commands import detach_studio
 
     return detach_studio(user)
 
@@ -281,7 +281,7 @@ def delete_studio_cmd(
     ),
 ):
     """Delete your studio permanently."""
-    from .studio.delete import delete_studio
+    from .studio_commands import delete_studio
 
     return delete_studio(user)
 
@@ -293,7 +293,7 @@ def list_studios_cmd(
     ),
 ):
     """List studios."""
-    from .studio.list import list_studios
+    from .studio_commands import list_studios
 
     return list_studios(all_users)
 
@@ -305,7 +305,7 @@ def reset_studio_cmd(
     ),
 ):
     """Reset a stuck studio (admin operation)."""
-    from .studio.reset import reset_studio
+    from .studio_commands import reset_studio
 
     return reset_studio(user)
 
@@ -318,6 +318,6 @@ def resize_studio_cmd(
     ),
 ):
     """Resize your studio volume (requires detachment)."""
-    from .studio.resize import resize_studio
+    from .studio_commands import resize_studio
 
     return resize_studio(size, user)

dayhoff_tools-1.10.1/dayhoff_tools/cli/engine/status.py → dayhoff_tools-1.10.3/dayhoff_tools/cli/engine/engine_core.py

@@ -1,4 +1,4 @@
-"""Engine status command."""
+"""Core engine commands: launch, list, and status."""
 
 import json
 import time
@@ -7,19 +7,214 @@ from typing import Any, Dict, Optional
 
 import boto3
 import typer
+from rich import box
 from rich.panel import Panel
-
-from ..engine_studio_utils.api_utils import make_api_request
-from ..engine_studio_utils.aws_utils import _fetch_init_stages, check_aws_sso
-from ..engine_studio_utils.constants import HOURLY_COSTS, console
-from ..engine_studio_utils.formatting import (
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+from .shared import (
+    HOURLY_COSTS,
+    _fetch_init_stages,
+    check_aws_sso,
+    console,
     format_duration,
+    format_status,
     get_disk_usage_via_ssm,
+    make_api_request,
     parse_launch_time,
     resolve_engine,
 )
 
 
+def launch_engine(
+    name: str = typer.Argument(help="Name for the new engine"),
+    engine_type: str = typer.Option(
+        "cpu",
+        "--type",
+        "-t",
+        help="Engine type: cpu, cpumax, t4, a10g, a100, 4_t4, 8_t4, 4_a10g, 8_a10g",
+    ),
+    user: Optional[str] = typer.Option(None, "--user", "-u", help="Override username"),
+    boot_disk_size: Optional[int] = typer.Option(
+        None,
+        "--size",
+        "-s",
+        help="Boot disk size in GB (default: 50GB, min: 20GB, max: 1000GB)",
+    ),
+    availability_zone: Optional[str] = typer.Option(
+        None,
+        "--az",
+        help="Prefer a specific Availability Zone (e.g., us-east-1b). If omitted the service will try all public subnets.",
+    ),
+):
+    """Launch a new engine instance."""
+    username = check_aws_sso()
+    if user:
+        username = user
+
+    # Validate engine type
+    valid_types = [
+        "cpu",
+        "cpumax",
+        "t4",
+        "a10g",
+        "a100",
+        "4_t4",
+        "8_t4",
+        "4_a10g",
+        "8_a10g",
+    ]
+    if engine_type not in valid_types:
+        console.print(f"[red]❌ Invalid engine type: {engine_type}[/red]")
+        console.print(f"Valid types: {', '.join(valid_types)}")
+        raise typer.Exit(1)
+
+    # Validate boot disk size
+    if boot_disk_size is not None:
+        if boot_disk_size < 20:
+            console.print("[red]❌ Boot disk size must be at least 20GB[/red]")
+            raise typer.Exit(1)
+        if boot_disk_size > 1000:
+            console.print("[red]❌ Boot disk size cannot exceed 1000GB[/red]")
+            raise typer.Exit(1)
+
+    cost = HOURLY_COSTS.get(engine_type, 0)
+    disk_info = f" with {boot_disk_size}GB boot disk" if boot_disk_size else ""
+    console.print(
+        f"Launching [cyan]{name}[/cyan] ({engine_type}){disk_info} for ${cost:.2f}/hour..."
+    )
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        transient=True,
+    ) as progress:
+        progress.add_task("Creating engine...", total=None)
+
+        request_data: Dict[str, Any] = {
+            "name": name,
+            "user": username,
+            "engine_type": engine_type,
+        }
+        if boot_disk_size is not None:
+            request_data["boot_disk_size"] = boot_disk_size
+        if availability_zone:
+            request_data["availability_zone"] = availability_zone
+
+        response = make_api_request("POST", "/engines", json_data=request_data)
+
+    if response.status_code == 201:
+        data = response.json()
+        console.print(f"[green]✓ Engine launched successfully![/green]")
+        console.print(f"Instance ID: [cyan]{data['instance_id']}[/cyan]")
+        console.print(f"Type: {data['instance_type']} (${cost:.2f}/hour)")
+        if boot_disk_size:
+            console.print(f"Boot disk: {boot_disk_size}GB")
+        console.print("\nThe engine is initializing. This may take a few minutes.")
+        console.print(f"Check status with: [cyan]dh engine status {name}[/cyan]")
+    else:
+        error = response.json().get("error", "Unknown error")
+        console.print(f"[red]❌ Failed to launch engine: {error}[/red]")
+
+
+def list_engines(
+    user: Optional[str] = typer.Option(None, "--user", "-u", help="Filter by user"),
+    running_only: bool = typer.Option(
+        False, "--running", help="Show only running engines"
+    ),
+    stopped_only: bool = typer.Option(
+        False, "--stopped", help="Show only stopped engines"
+    ),
+    detailed: bool = typer.Option(
+        False, "--detailed", "-d", help="Show detailed status (slower)"
+    ),
+):
+    """List engines (shows all engines by default)."""
+    current_user = check_aws_sso()
+
+    params = {}
+    if user:
+        params["user"] = user
+    if detailed:
+        params["check_ready"] = "true"
+
+    response = make_api_request("GET", "/engines", params=params)
+
+    if response.status_code == 200:
+        data = response.json()
+        engines = data.get("engines", [])
+
+        # Filter by state if requested
+        if running_only:
+            engines = [e for e in engines if e["state"].lower() == "running"]
+        elif stopped_only:
+            engines = [e for e in engines if e["state"].lower() == "stopped"]
+
+        if not engines:
+            console.print("No engines found.")
+            return
+
+        # Only fetch detailed info if requested (slow)
+        stages_map = {}
+        if detailed:
+            stages_map = _fetch_init_stages([e["instance_id"] for e in engines])
+
+        # Create table
+        table = Table(title="Engines", box=box.ROUNDED)
+        table.add_column("Name", style="cyan")
+        table.add_column("Instance ID", style="dim")
+        table.add_column("Type")
+        table.add_column("User")
+        table.add_column("Status")
+        if detailed:
+            table.add_column("Disk Usage")
+        table.add_column("Uptime/Since")
+        table.add_column("$/hour", justify="right")
+
+        for engine in engines:
+            launch_time = parse_launch_time(engine["launch_time"])
+            uptime = datetime.now(timezone.utc) - launch_time
+            hourly_cost = HOURLY_COSTS.get(engine["engine_type"], 0)
+
+            if engine["state"].lower() == "running":
+                time_str = format_duration(uptime)
+                # Only get disk usage if detailed mode
+                if detailed:
+                    disk_usage = get_disk_usage_via_ssm(engine["instance_id"]) or "-"
+                else:
+                    disk_usage = None
+            else:
+                time_str = launch_time.strftime("%Y-%m-%d %H:%M")
+                disk_usage = "-" if detailed else None
+
+            row_data = [
+                engine["name"],
+                engine["instance_id"],
+                engine["engine_type"],
+                engine["user"],
+                format_status(engine["state"], engine.get("ready")),
+            ]
+            if detailed:
+                row_data.append(disk_usage)
+            row_data.extend(
+                [
+                    time_str,
+                    f"${hourly_cost:.2f}",
+                ]
+            )
+
+            table.add_row(*row_data)
+
+        console.print(table)
+        if not detailed and any(e["state"].lower() == "running" for e in engines):
+            console.print(
+                "\n[dim]Tip: Use --detailed to see disk usage and bootstrap status (slower)[/dim]"
+            )
+    else:
+        error = response.json().get("error", "Unknown error")
+        console.print(f"[red]❌ Failed to list engines: {error}[/red]")
+
+
 def engine_status(
     name_or_id: str = typer.Argument(help="Engine name or instance ID"),
     detailed: bool = typer.Option(