dayhoff-tools 1.10.0__py3-none-any.whl → 1.10.1__py3-none-any.whl

dayhoff_tools/cli/studio/create.py

@@ -0,0 +1,48 @@
+"""Studio create command."""
+
+import typer
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from ..engine_studio_utils.api_utils import get_user_studio, make_api_request
+from ..engine_studio_utils.aws_utils import check_aws_sso
+from ..engine_studio_utils.constants import console
+
+
+def create_studio(
+    size_gb: int = typer.Option(50, "--size", "-s", help="Studio size in GB"),
+):
+    """Create a new studio for the current user."""
+    username = check_aws_sso()
+
+    # Check if user already has a studio
+    existing = get_user_studio(username)
+    if existing:
+        console.print(
+            f"[yellow]You already have a studio: {existing['studio_id']}[/yellow]"
+        )
+        return
+
+    console.print(f"Creating {size_gb}GB studio for user [cyan]{username}[/cyan]...")
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        transient=True,
+    ) as progress:
+        progress.add_task("Creating studio volume...", total=None)
+
+        response = make_api_request(
+            "POST",
+            "/studios",
+            json_data={"user": username, "size_gb": size_gb},
+        )
+
+    if response.status_code == 201:
+        data = response.json()
+        console.print(f"[green]✓ Studio created successfully![/green]")
+        console.print(f"Studio ID: [cyan]{data['studio_id']}[/cyan]")
+        console.print(f"Size: {data['size_gb']}GB")
+        console.print(f"\nNext step: [cyan]dh studio attach <engine-name>[/cyan]")
+    else:
+        error = response.json().get("error", "Unknown error")
+        console.print(f"[red]❌ Failed to create studio: {error}[/red]")

dayhoff_tools/cli/studio/delete.py

@@ -0,0 +1,71 @@
+"""Studio delete command."""
+
+from typing import Optional
+
+import typer
+from rich.prompt import Confirm, Prompt
+
+from ..engine_studio_utils.api_utils import get_user_studio, make_api_request
+from ..engine_studio_utils.aws_utils import check_aws_sso
+from ..engine_studio_utils.constants import console
+
+
+def delete_studio(
+    user: Optional[str] = typer.Option(
+        None, "--user", "-u", help="Delete a different user's studio (admin only)"
+    ),
+):
+    """Delete your studio permanently."""
+    username = check_aws_sso()
+
+    # Use specified user if provided, otherwise use current user
+    target_user = user if user else username
+
+    # Extra warning when deleting another user's studio
+    if target_user != username:
+        console.print(
+            f"[red]⚠️  ADMIN ACTION: Deleting studio for user: {target_user}[/red]"
+        )
+
+    studio = get_user_studio(target_user)
+    if not studio:
+        if target_user == username:
+            console.print("[yellow]You don't have a studio to delete.[/yellow]")
+        else:
+            console.print(
+                f"[yellow]User {target_user} doesn't have a studio to delete.[/yellow]"
+            )
+        return
+
+    console.print(
+        "[red]⚠️  WARNING: This will permanently delete the studio and all data![/red]"
+    )
+    console.print(f"Studio ID: {studio['studio_id']}")
+    console.print(f"User: {target_user}")
+    console.print(f"Size: {studio['size_gb']}GB")
+
+    # Multiple confirmations
+    if not Confirm.ask(
+        f"\nAre you sure you want to delete {target_user}'s studio?"
+        if target_user != username
+        else "\nAre you sure you want to delete your studio?"
+    ):
+        console.print("Deletion cancelled.")
+        return
+
+    if not Confirm.ask("[red]This action cannot be undone. Continue?[/red]"):
+        console.print("Deletion cancelled.")
+        return
+
+    typed_confirm = Prompt.ask('Type "DELETE" to confirm permanent deletion')
+    if typed_confirm != "DELETE":
+        console.print("Deletion cancelled.")
+        return
+
+    response = make_api_request("DELETE", f"/studios/{studio['studio_id']}")
+
+    if response.status_code == 200:
+        console.print(f"[green]✓ Studio deleted successfully![/green]")
+    else:
+        error = response.json().get("error", "Unknown error")
+        console.print(f"[red]❌ Failed to delete studio: {error}[/red]")

dayhoff_tools/cli/studio/detach.py

@@ -0,0 +1,56 @@
+"""Studio detach command."""
+
+from typing import Optional
+
+import typer
+from rich.prompt import Confirm
+
+from ..engine_studio_utils.api_utils import get_user_studio, make_api_request
+from ..engine_studio_utils.aws_utils import check_aws_sso
+from ..engine_studio_utils.constants import console
+
+
+def detach_studio(
+    user: Optional[str] = typer.Option(
+        None, "--user", "-u", help="Detach a different user's studio (admin only)"
+    ),
+):
+    """Detach your studio from its current engine."""
+    username = check_aws_sso()
+
+    # Use specified user if provided, otherwise use current user
+    target_user = user if user else username
+
+    # Add confirmation when detaching another user's studio
+    if target_user != username:
+        console.print(f"[yellow]⚠️  Managing studio for user: {target_user}[/yellow]")
+        if not Confirm.ask(f"Are you sure you want to detach {target_user}'s studio?"):
+            console.print("Operation cancelled.")
+            return
+
+    studio = get_user_studio(target_user)
+    if not studio:
+        if target_user == username:
+            console.print("[yellow]You don't have a studio.[/yellow]")
+        else:
+            console.print(f"[yellow]User {target_user} doesn't have a studio.[/yellow]")
+        return
+
+    if studio.get("status") != "in-use":
+        if target_user == username:
+            console.print("[yellow]Your studio is not attached to any engine.[/yellow]")
+        else:
+            console.print(
+                f"[yellow]{target_user}'s studio is not attached to any engine.[/yellow]"
+            )
+        return
+
+    console.print(f"Detaching studio from {studio.get('attached_vm_id')}...")
+
+    response = make_api_request("POST", f"/studios/{studio['studio_id']}/detach")
+
+    if response.status_code == 200:
+        console.print(f"[green]✓ Studio detached successfully![/green]")
+    else:
+        error = response.json().get("error", "Unknown error")
+        console.print(f"[red]❌ Failed to detach studio: {error}[/red]")

dayhoff_tools/cli/studio/list.py

@@ -0,0 +1,81 @@
+"""Studio list command."""
+
+import typer
+from rich import box
+from rich.table import Table
+
+from ..engine_studio_utils.api_utils import make_api_request
+from ..engine_studio_utils.aws_utils import check_aws_sso
+from ..engine_studio_utils.constants import console
+from ..engine_studio_utils.formatting import get_studio_disk_usage_via_ssm
+
+
+def list_studios(
+    all_users: bool = typer.Option(
+        False, "--all", "-a", help="Show all users' studios"
+    ),
+):
+    """List studios."""
+    username = check_aws_sso()
+
+    response = make_api_request("GET", "/studios")
+
+    if response.status_code == 200:
+        studios = response.json().get("studios", [])
+
+        if not studios:
+            console.print("No studios found.")
+            return
+
+        # Get all engines to map instance IDs to names
+        engines_response = make_api_request("GET", "/engines")
+        engines = {}
+        if engines_response.status_code == 200:
+            for engine in engines_response.json().get("engines", []):
+                engines[engine["instance_id"]] = engine["name"]
+
+        # Create table
+        table = Table(title="Studios", box=box.ROUNDED)
+        table.add_column("Studio ID", style="cyan")
+        table.add_column("User")
+        table.add_column("Status")
+        table.add_column("Size", justify="right")
+        table.add_column("Disk Usage", justify="right")
+        table.add_column("Attached To")
+
+        for studio in studios:
+            # Change status display
+            if studio["status"] == "in-use":
+                status_display = "[bright_blue]attached[/bright_blue]"
+            elif studio["status"] in ["attaching", "detaching"]:
+                status_display = "[yellow]" + studio["status"] + "[/yellow]"
+            else:
+                status_display = "[green]available[/green]"
+
+            # Format attached engine info
+            attached_to = "-"
+            disk_usage = "?/?"
+            if studio.get("attached_vm_id"):
+                vm_id = studio["attached_vm_id"]
+                engine_name = engines.get(vm_id, "unknown")
+                attached_to = f"{engine_name} ({vm_id})"
+
+                # Try to get disk usage if attached
+                if studio["status"] == "in-use":
+                    usage = get_studio_disk_usage_via_ssm(vm_id, studio["user"])
+                    if usage:
+                        disk_usage = usage
+
+            table.add_row(
+                studio["studio_id"],
+                studio["user"],
+                status_display,
+                f"{studio['size_gb']}GB",
+                disk_usage,
+                attached_to,
+            )
+
+        console.print(table)
+    else:
+        error = response.json().get("error", "Unknown error")
+        console.print(f"[red]❌ Failed to list studios: {error}[/red]")

dayhoff_tools/cli/studio/reset.py

@@ -0,0 +1,90 @@
+"""Studio reset command."""
+
+from typing import Optional
+
+import boto3
+import typer
+from botocore.exceptions import ClientError
+from rich.prompt import Confirm
+
+from ..engine_studio_utils.api_utils import get_user_studio
+from ..engine_studio_utils.aws_utils import check_aws_sso
+from ..engine_studio_utils.constants import console
+
+
+def reset_studio(
+    user: Optional[str] = typer.Option(
+        None, "--user", "-u", help="Reset a different user's studio"
+    ),
+):
+    """Reset a stuck studio (admin operation)."""
+    username = check_aws_sso()
+
+    # Use specified user if provided, otherwise use current user
+    target_user = user if user else username
+
+    # Add warning when resetting another user's studio
+    if target_user != username:
+        console.print(f"[yellow]⚠️  Resetting studio for user: {target_user}[/yellow]")
+
+    studio = get_user_studio(target_user)
+    if not studio:
+        if target_user == username:
+            console.print("[yellow]You don't have a studio.[/yellow]")
+        else:
+            console.print(f"[yellow]User {target_user} doesn't have a studio.[/yellow]")
+        return
+
+    console.print(f"[yellow]⚠️  This will force-reset the studio state[/yellow]")
+    console.print(f"Current status: {studio['status']}")
+    if studio.get("attached_vm_id"):
+        console.print(f"Listed as attached to: {studio['attached_vm_id']}")
+
+    if not Confirm.ask("\nReset studio state?"):
+        console.print("Reset cancelled.")
+        return
+
+    # Direct DynamoDB update
+    console.print("Resetting studio state...")
+
+    dynamodb = boto3.resource("dynamodb", region_name="us-east-1")
+    table = dynamodb.Table("dev-studios")
+
+    try:
+        # Check if volume is actually attached
+        ec2 = boto3.client("ec2", region_name="us-east-1")
+        volumes = ec2.describe_volumes(VolumeIds=[studio["studio_id"]])
+
+        if volumes["Volumes"]:
+            volume = volumes["Volumes"][0]
+            attachments = volume.get("Attachments", [])
+            if attachments:
+                console.print(
+                    f"[red]Volume is still attached to {attachments[0]['InstanceId']}![/red]"
+                )
+                if Confirm.ask("Force-detach the volume?"):
+                    ec2.detach_volume(
+                        VolumeId=studio["studio_id"],
+                        InstanceId=attachments[0]["InstanceId"],
+                        Force=True,
+                    )
+                    console.print("Waiting for volume to detach...")
+                    waiter = ec2.get_waiter("volume_available")
+                    waiter.wait(VolumeIds=[studio["studio_id"]])
+
+        # Reset in DynamoDB – align attribute names with Studio Manager backend
+        table.update_item(
+            Key={"StudioID": studio["studio_id"]},
+            UpdateExpression="SET #st = :status, AttachedVMID = :vm_id, AttachedDevice = :device",
+            ExpressionAttributeNames={"#st": "Status"},
+            ExpressionAttributeValues={
+                ":status": "available",
+                ":vm_id": None,
+                ":device": None,
+            },
+        )
+
+        console.print(f"[green]✓ Studio reset to available state![/green]")
+
+    except ClientError as e:
+        console.print(f"[red]❌ Failed to reset studio: {e}[/red]")

dayhoff_tools/cli/studio/resize.py

@@ -0,0 +1,134 @@
+"""Studio resize command."""
+
+import time
+from typing import Optional
+
+import boto3
+import typer
+from botocore.exceptions import ClientError
+from rich.prompt import Confirm
+
+from ..engine_studio_utils.api_utils import get_user_studio, make_api_request
+from ..engine_studio_utils.aws_utils import check_aws_sso
+from ..engine_studio_utils.constants import console
+
+
+def resize_studio(
+    size: int = typer.Option(..., "--size", "-s", help="New size in GB"),
+    user: Optional[str] = typer.Option(
+        None, "--user", "-u", help="Resize a different user's studio (admin only)"
+    ),
+):
+    """Resize your studio volume (requires detachment)."""
+    username = check_aws_sso()
+
+    # Use specified user if provided, otherwise use current user
+    target_user = user if user else username
+
+    # Add warning when resizing another user's studio
+    if target_user != username:
+        console.print(f"[yellow]⚠️  Resizing studio for user: {target_user}[/yellow]")
+
+    studio = get_user_studio(target_user)
+    if not studio:
+        if target_user == username:
+            console.print("[yellow]You don't have a studio yet.[/yellow]")
+        else:
+            console.print(f"[yellow]User {target_user} doesn't have a studio.[/yellow]")
+        return
+
+    current_size = studio["size_gb"]
+
+    if size <= current_size:
+        console.print(
+            f"[red]❌ New size ({size}GB) must be larger than current size ({current_size}GB)[/red]"
+        )
+        raise typer.Exit(1)
+
+    # Check if studio is attached
+    if studio["status"] == "in-use":
+        console.print("[yellow]⚠️  Studio must be detached before resizing[/yellow]")
+        console.print(f"Currently attached to: {studio.get('attached_vm_id')}")
+
+        if not Confirm.ask("\nDetach studio and proceed with resize?"):
+            console.print("Resize cancelled.")
+            return
+
+        # Detach the studio
+        console.print("Detaching studio...")
+        response = make_api_request("POST", f"/studios/{studio['studio_id']}/detach")
+        if response.status_code != 200:
+            console.print("[red]❌ Failed to detach studio[/red]")
+            raise typer.Exit(1)
+
+        console.print("[green]✓ Studio detached[/green]")
+
+        # Wait a moment for detachment to complete
+        time.sleep(5)
+
+    console.print(f"[yellow]Resizing studio from {current_size}GB to {size}GB[/yellow]")
+
+    # Call the resize API
+    resize_response = make_api_request(
+        "POST", f"/studios/{studio['studio_id']}/resize", json_data={"size": size}
+    )
+
+    if resize_response.status_code != 200:
+        error = resize_response.json().get("error", "Unknown error")
+        console.print(f"[red]❌ Failed to resize studio: {error}[/red]")
+        raise typer.Exit(1)
+
+    # Wait for volume modification to complete
+    ec2 = boto3.client("ec2", region_name="us-east-1")
+    console.print("Resizing volume...")
+
+    # Track progress
+    last_progress = 0
+
+    while True:
+        try:
+            mod_state = ec2.describe_volumes_modifications(
+                VolumeIds=[studio["studio_id"]]
+            )
+            if not mod_state["VolumesModifications"]:
+                break  # Modification complete
+
+            modification = mod_state["VolumesModifications"][0]
+            state = modification["ModificationState"]
+            progress = modification.get("Progress", 0)
+
+            # Show progress updates only for the resize phase
+            if state == "modifying" and progress > last_progress:
+                console.print(f"[yellow]Progress: {progress}%[/yellow]")
+                last_progress = progress
+
+            # Exit as soon as optimization starts (resize is complete)
+            if state == "optimizing":
+                console.print(
+                    f"[green]✓ Studio resized successfully to {size}GB![/green]"
+                )
+                console.print(
+                    "[dim]AWS is optimizing the volume in the background (no action needed).[/dim]"
+                )
+                break
+
+            if state == "completed":
+                console.print(
+                    f"[green]✓ Studio resized successfully to {size}GB![/green]"
+                )
+                break
+            elif state == "failed":
+                console.print("[red]❌ Volume modification failed[/red]")
+                raise typer.Exit(1)
+
+            time.sleep(2)  # Check more frequently for better UX
+
+        except ClientError:
+            # Modification might be complete
+            console.print(f"[green]✓ Studio resized successfully to {size}GB![/green]")
+            break
+
+    console.print(
+        "\n[dim]The filesystem will be automatically expanded when you next attach the studio.[/dim]"
+    )
+    console.print(f"To attach: [cyan]dh studio attach <engine-name>[/cyan]")

dayhoff_tools/cli/studio/status.py

@@ -0,0 +1,78 @@
+"""Studio status command."""
+
+from typing import Optional
+
+import typer
+from rich.panel import Panel
+
+from ..engine_studio_utils.api_utils import get_user_studio, make_api_request
+from ..engine_studio_utils.aws_utils import check_aws_sso
+from ..engine_studio_utils.constants import console
+
+
+def studio_status(
+    user: Optional[str] = typer.Option(
+        None, "--user", "-u", help="Check status for a different user (admin only)"
+    ),
+):
+    """Show status of your studio."""
+    username = check_aws_sso()
+
+    # Use specified user if provided, otherwise use current user
+    target_user = user if user else username
+
+    # Add warning when checking another user's studio
+    if target_user != username:
+        console.print(
+            f"[yellow]⚠️  Checking studio status for user: {target_user}[/yellow]"
+        )
+
+    studio = get_user_studio(target_user)
+    if not studio:
+        if target_user == username:
+            console.print("[yellow]You don't have a studio yet.[/yellow]")
+            console.print("Create one with: [cyan]dh studio create[/cyan]")
+        else:
+            console.print(f"[yellow]User {target_user} doesn't have a studio.[/yellow]")
+        return
+
+    # Create status panel
+    # Format status with colors
+    status = studio["status"]
+    if status == "in-use":
+        status_display = "[bright_blue]attached[/bright_blue]"
+    elif status in ["attaching", "detaching"]:
+        status_display = f"[yellow]{status}[/yellow]"
+    else:
+        status_display = f"[green]{status}[/green]"
+
+    status_lines = [
+        f"[bold]Studio ID:[/bold]    {studio['studio_id']}",
+        f"[bold]User:[/bold]         {studio['user']}",
+        f"[bold]Status:[/bold]       {status_display}",
+        f"[bold]Size:[/bold]         {studio['size_gb']}GB",
+        f"[bold]Created:[/bold]      {studio['creation_date']}",
+    ]
+
+    if studio.get("attached_vm_id"):
+        status_lines.append(f"[bold]Attached to:[/bold]  {studio['attached_vm_id']}")
+
+        # Try to get engine details
+        response = make_api_request("GET", "/engines")
+        if response.status_code == 200:
+            engines = response.json().get("engines", [])
+            attached_engine = next(
+                (e for e in engines if e["instance_id"] == studio["attached_vm_id"]),
+                None,
+            )
+            if attached_engine:
+                status_lines.append(
+                    f"[bold]Engine Name:[/bold]  {attached_engine['name']}"
+                )
+
+    panel = Panel(
+        "\n".join(status_lines),
+        title="Studio Details",
+        border_style="blue",
+    )
+    console.print(panel)

{dayhoff_tools-1.10.0.dist-info → dayhoff_tools-1.10.1.dist-info}/METADATA

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

dayhoff_tools-1.10.1.dist-info/RECORD

@@ -0,0 +1,61 @@
+dayhoff_tools/__init__.py,sha256=M5zThPyEBRYa5CfwlzKhcqTevWn3OKu62cjV6Zqie2A,469
+dayhoff_tools/chemistry/standardizer.py,sha256=uMn7VwHnx02nc404eO6fRuS4rsl4dvSPf2ElfZDXEpY,11188
+dayhoff_tools/chemistry/utils.py,sha256=jt-7JgF-GeeVC421acX-bobKbLU_X94KNOW24p_P-_M,2257
+dayhoff_tools/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dayhoff_tools/cli/cloud_commands.py,sha256=33qcWLmq-FwEXMdL3F0OHm-5Stlh2r65CldyEZgQ1no,40904
+dayhoff_tools/cli/engine/__init__.py,sha256=WV7aojsipkqQRXQ8U6KHGdPr0C1spX348sHp6dqz63Y,34
+dayhoff_tools/cli/engine/coffee.py,sha256=2IKKc6skpDv7kBJz7l5Tvu0FM8hjUoYA-k6LAxdVzKE,3935
+dayhoff_tools/cli/engine/config_ssh.py,sha256=qh5bJH-ELOZnFa9UdcGGXKV8wH5DzybhXJ4b2XSaTyI,3974
+dayhoff_tools/cli/engine/debug.py,sha256=29Cmzj3dyzkAjO3HcJzp4jkB4eCgRhyF2MjtHE4WarE,2714
+dayhoff_tools/cli/engine/gami.py,sha256=OwZKb87oq3zIQ2a9-n_oJ4UK84XOUP3InHYRSAERvaQ,6219
+dayhoff_tools/cli/engine/idle.py,sha256=YGAzII7Db0w1R4_3ebQZVSPWKRmwc_WR3ZafItFs35E,5607
+dayhoff_tools/cli/engine/launch.py,sha256=G6-vUbpFLC2DnMfD5HXQqWgCuCqZ5E42ZuOl45g6N3c,3519
+dayhoff_tools/cli/engine/lifecycle.py,sha256=_Dk-EZs_qbm8APdOuGOuxhlbK6RgkkoLk2nrwKoo1-A,4519
+dayhoff_tools/cli/engine/list.py,sha256=UsghtBxLgXIlvPuKu4_jqe9yrCHgh8uFEbulCA3Cfmg,3896
+dayhoff_tools/cli/engine/repair.py,sha256=lfe5vSfdgRX3uY2sPA4bLtl0Oj0myqSQZZNV_lYD7_g,5037
+dayhoff_tools/cli/engine/resize.py,sha256=BzbvmT5Hf-FbfiCFwS8Sjj6dfMZ8CYihUwpOLAUNpOI,7818
+dayhoff_tools/cli/engine/ssh.py,sha256=m8h-SdfXsok5PgkcvfAoai0-AKI78oE9sJeXWQnkn3g,2095
+dayhoff_tools/cli/engine/status.py,sha256=zlxDpKXCbWpfY7fnsKqxlvakq5txOmHTSeNA4VIX3cg,20461
+dayhoff_tools/cli/engine_studio_commands.py,sha256=tePPfiBtAUmhJ4ttjbtbkse9roqoTAi36nUAbKijFJM,9485
+dayhoff_tools/cli/engine_studio_utils/__init__.py,sha256=G9uYoIG79B9u8BmcWyy5Y_UN4U4CVLZe7yHhcQPJZNk,54
+dayhoff_tools/cli/engine_studio_utils/api_utils.py,sha256=3c7hwwD18b5v6aaDH0O_RZe8V0i5lz8UjgpR-2gl8xA,1347
+dayhoff_tools/cli/engine_studio_utils/aws_utils.py,sha256=T71HXI2RjZQB3QVlcGAB7Qpkn71dHf0Tzxt1QXjSW6Y,3656
+dayhoff_tools/cli/engine_studio_utils/constants.py,sha256=9usS7R2jS4qtieOi4EKZeB372clQpSIsa_NdOIGcrcc,526
+dayhoff_tools/cli/engine_studio_utils/formatting.py,sha256=0n_nHKjejJJCUF8HZOEbjtLOgDVNSImaPRH31Ag0eGs,6800
+dayhoff_tools/cli/engine_studio_utils/ssh_utils.py,sha256=1L5t-ZE3V5-eVznrEViJ8j1HouPwFq6CfoICQkySfCU,4867
+dayhoff_tools/cli/main.py,sha256=IIwgJBuCCSFg1JFnUOoo-o3g7E7eLLXgRvISWUy_HdQ,5939
+dayhoff_tools/cli/studio/__init__.py,sha256=SIg-34_DZT_w6OQGFEoHcf4NLWY5XyHlwcP585WwVWs,34
+dayhoff_tools/cli/studio/attach.py,sha256=NOT9jxCE6tGRXxxYF4_o4cCbnJ2xIh7B0B0HGD3YxaU,11810
+dayhoff_tools/cli/studio/create.py,sha256=x2UuSgj5V8S_P6derLdCsBmX3KTU4KJBuA2O17WxrOs,1664
+dayhoff_tools/cli/studio/delete.py,sha256=Fvt581Uve-IMazfHo_5vXws9smqWxXTdtCaxUCDKESA,2385
+dayhoff_tools/cli/studio/detach.py,sha256=NRvAAmOtJCkYPPnT04msL8Z2LfYA2zYo71WYekYreIA,2018
+dayhoff_tools/cli/studio/list.py,sha256=e-7psFx3A2fxxSbxafI0RqHtvZxaa8qWjK_4F3iO5RI,2813
+dayhoff_tools/cli/studio/reset.py,sha256=gENkUOsTzLqV4oyeVsMEF_EN5c6qAAf0pZtvGhk8Bnc,3308
+dayhoff_tools/cli/studio/resize.py,sha256=LadryhJoo-vo4xrl88wsLgiTEiaq1x5XXQNiWrGgQcU,4830
+dayhoff_tools/cli/studio/status.py,sha256=bua30619ue8tnmDc8KvY8X-udUHw8vSoXV9HLmiBKB4,2647
+dayhoff_tools/cli/swarm_commands.py,sha256=5EyKj8yietvT5lfoz8Zx0iQvVaNgc3SJX1z2zQR6o6M,5614
+dayhoff_tools/cli/utility_commands.py,sha256=WQTHOh1MttuxaJjl2c6zMa4x7_JuaKMQgcyotYrU3GA,25883
+dayhoff_tools/deployment/base.py,sha256=mYp560l6hSDFtyY2H42VoM8k9VUzfwuiyh9Knqpgc28,17441
+dayhoff_tools/deployment/deploy_aws.py,sha256=GvZpE2YIFA5Dl9rkAljFjtUypmPDNbWgw8NicHYTP24,18265
+dayhoff_tools/deployment/deploy_gcp.py,sha256=xgaOVsUDmP6wSEMYNkm1yRNcVskfdz80qJtCulkBIAM,8860
+dayhoff_tools/deployment/deploy_utils.py,sha256=StFwbqnr2_FWiKVg3xnJF4kagTHzndqqDkpaIOaAn_4,26027
+dayhoff_tools/deployment/job_runner.py,sha256=hljvFpH2Bw96uYyUup5Ths72PZRL_X27KxlYzBMgguo,5086
+dayhoff_tools/deployment/processors.py,sha256=LM0CQbr4XCb3AtLbrcuDQm4tYPXsoNqgVJ4WQYDjzJc,12406
+dayhoff_tools/deployment/swarm.py,sha256=YJfvVOcAS8cYcIj2fiN4qwC2leh0I9w5A4px8ZWSF6g,22833
+dayhoff_tools/embedders.py,sha256=1THnmio4FYkBswy_xkIiwT-ZOEMn6ZLbTAa-Uz0-kyE,36615
+dayhoff_tools/fasta.py,sha256=USdemH4c_dNhWXOTAhldvlDi8eLHogsy0YSrOnODB5I,50773
+dayhoff_tools/file_ops.py,sha256=JlGowvr-CUJFidV-4g_JmhUTN9bsYuaxtqKmnKomm-Q,8506
+dayhoff_tools/h5.py,sha256=j1nxxaiHsMidVX_XwB33P1Pz9d7K8ZKiDZwJWQUUQSY,21158
+dayhoff_tools/intake/gcp.py,sha256=uCeEskhbEwJIYpN6ne6siT1dbpTizCjjel-hRe0kReE,3030
+dayhoff_tools/intake/gtdb.py,sha256=58JNLWpr3LkXiIq-ubAcEFeR5DyN9YrA-YEoQI_FzlA,10608
+dayhoff_tools/intake/kegg.py,sha256=SaVbumB4leNTSevamT29yIqHurejw1wmcCC32D5Qyco,965
+dayhoff_tools/intake/mmseqs.py,sha256=uEYzRsthJAlUeRYNCfFtJFE73SbuhfUIS1ygYFkhmtw,6435
+dayhoff_tools/intake/structure.py,sha256=ufN3gAodQxhnt7psK1VTQeu9rKERmo_PhoxIbB4QKMw,27660
+dayhoff_tools/intake/uniprot.py,sha256=BZYJQF63OtPcBBnQ7_P9gulxzJtqyorgyuDiPeOJqE4,16456
+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.10.1.dist-info/METADATA,sha256=gQ7_S_-Xe_eFvVIi2VncpKssTfB3EhnODS0i47YTo0E,2915
+dayhoff_tools-1.10.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+dayhoff_tools-1.10.1.dist-info/entry_points.txt,sha256=iAf4jteNqW3cJm6CO6czLxjW3vxYKsyGLZ8WGmxamSc,49
+dayhoff_tools-1.10.1.dist-info/RECORD,,