dayhoff-tools 1.7.5__py3-none-any.whl → 1.8.1__py3-none-any.whl

dayhoff_tools/cli/engine_commands.py

@@ -9,7 +9,7 @@ import sys
 import time
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 import boto3
 import requests
@@ -647,7 +647,7 @@ def launch_engine(
     ) as progress:
         progress.add_task("Creating engine...", total=None)
 
-        request_data = {
+        request_data: Dict[str, Any] = {
             "name": name,
             "user": username,
             "engine_type": engine_type,
@@ -797,18 +797,50 @@ def engine_status(
 
     engine_details = response.json()
     engine = engine_details.get("engine", engine)  # Use detailed info if available
-    idle_detector = engine_details.get("idle_detector", {})
+    idle_detector = engine_details.get("idle_detector", {}) or {}
     attached_studios = engine_details.get("attached_studios", [])
 
     # Calculate costs
     launch_time = parse_launch_time(engine["launch_time"])
     uptime = datetime.now(timezone.utc) - launch_time
     hourly_cost = HOURLY_COSTS.get(engine["engine_type"], 0)
-    total_cost = hourly_cost * (uptime.total_seconds() / 3600)
+    # total_cost intentionally not shown in status view
 
     stages_map = _fetch_init_stages([engine["instance_id"]])
     stage_val = stages_map.get(engine["instance_id"], "-")
 
+    # Try to fetch actual boot time via SSM (best-effort)
+    boot_time_str: Optional[str] = None
+    try:
+        if engine["state"].lower() == "running":
+            ssm = boto3.client("ssm", region_name="us-east-1")
+            resp = ssm.send_command(
+                InstanceIds=[engine["instance_id"]],
+                DocumentName="AWS-RunShellScript",
+                Parameters={
+                    "commands": ["uptime -s || who -b | awk '{print $3\" \"$4}'"]
+                },
+            )
+            cid = resp["Command"]["CommandId"]
+            time.sleep(1)
+            inv = ssm.get_command_invocation(
+                CommandId=cid, InstanceId=engine["instance_id"]
+            )
+            if inv.get("Status") == "Success":
+                boot_time_str = (
+                    (inv.get("StandardOutputContent") or "").strip().splitlines()[0]
+                    if inv.get("StandardOutputContent")
+                    else None
+                )
+    except Exception:
+        boot_time_str = None
+
+    started_line = (
+        f"[bold]Started:[/bold]     {boot_time_str} ({format_duration(uptime)} ago)"
+        if boot_time_str
+        else f"[bold]Started:[/bold]     {launch_time.strftime('%Y-%m-%d %H:%M:%S')} ({format_duration(uptime)} ago)"
+    )
+
     status_lines = [
         f"[bold]Name:[/bold]        {engine['name']}",
         f"[bold]Instance:[/bold]    {engine['instance_id']}",
@@ -816,10 +848,15 @@ def engine_status(
         f"[bold]Status:[/bold]      {format_status(engine['state'], engine.get('ready'))}",
         f"[bold]User:[/bold]        {engine['user']}",
         f"[bold]IP:[/bold]          {engine.get('public_ip', 'N/A')}",
-        f"[bold]Launched:[/bold]    {launch_time.strftime('%Y-%m-%d %H:%M:%S')} ({format_duration(uptime)} ago)",
-        f"[bold]Cost:[/bold]        ${hourly_cost:.2f}/hour (${total_cost:.2f} total)",
+        started_line,
+        f"[bold]$/hour:[/bold]     ${hourly_cost:.2f}",
     ]
 
+    # Disk usage (like list --detailed)
+    if engine["state"].lower() == "running":
+        disk_usage = get_disk_usage_via_ssm(engine["instance_id"]) or "-"
+        status_lines.append(f"[bold]Disk:[/bold]       {disk_usage}")
+
     # Health report (only if bootstrap finished)
     if stage_val == "finished":
         try:
@@ -854,7 +891,88 @@ def engine_status(
         except Exception:
             pass
 
-    # Idle detector status (from new API endpoint)
+    # Try to enrich/fallback idle-detector details from on-engine summary file via SSM
+    def _fetch_idle_summary_via_ssm(instance_id: str) -> Optional[Dict]:
+        try:
+            ssm = boto3.client("ssm", region_name="us-east-1")
+            res = ssm.send_command(
+                InstanceIds=[instance_id],
+                DocumentName="AWS-RunShellScript",
+                Parameters={
+                    "commands": [
+                        "cat /var/run/idle-detector/last_state.json 2>/dev/null || true",
+                    ],
+                    "executionTimeout": ["5"],
+                },
+            )
+            cid = res["Command"]["CommandId"]
+            time.sleep(1)
+            inv = ssm.get_command_invocation(CommandId=cid, InstanceId=instance_id)
+            if inv["Status"] != "Success":
+                return None
+            content = inv["StandardOutputContent"].strip()
+            if not content:
+                return None
+            data = json.loads(content)
+            # Convert last_state schema to idle_detector schema used by CLI output
+            idle_info: Dict[str, Any] = {"available": True}
+            idle_info["status"] = "active" if not data.get("idle", True) else "idle"
+            # thresholds if present
+            if isinstance(data.get("timeout_sec"), (int, float)):
+                idle_info["idle_threshold"] = int(data["timeout_sec"])  # seconds
+            # keep raw reasons for sensor display
+            if isinstance(data.get("reasons"), list):
+                idle_info["_reasons_raw"] = data["reasons"]
+            # derive details from sensors
+            for r in data.get("reasons", []):
+                if not r.get("active"):
+                    continue
+                sensor = (r.get("sensor") or "").lower()
+                forensic = r.get("forensic") or {}
+                if sensor == "ideconnectionsensor":
+                    cnt = forensic.get("matches")
+                    if isinstance(cnt, int):
+                        idle_info["ide_connections"] = {"connection_count": cnt}
+                    else:
+                        idle_info["ide_connections"] = {"connection_count": 1}
+                elif sensor == "coffeelocksensor":
+                    rem = forensic.get("remaining_sec")
+                    if isinstance(rem, (int, float)) and rem > 0:
+                        idle_info["coffee_lock"] = format_duration(
+                            timedelta(seconds=int(rem))
+                        )
+                elif sensor == "activeloginsensor":
+                    # Provide a single summarized SSH session if available
+                    sess = {
+                        "tty": r.get("forensic", {}).get("tty", "pts/?"),
+                        "pid": r.get("forensic", {}).get("pid", "?"),
+                        "idle_time": r.get("forensic", {}).get("idle_sec", 0),
+                        "from_ip": r.get("forensic", {}).get("remote_addr", "unknown"),
+                    }
+                    idle_info.setdefault("ssh_sessions", []).append(sess)
+            return idle_info
+        except Exception:
+            return None
+
+    # Enrich missing fields or provide full fallback when API lacks details
+    overlay = (
+        _fetch_idle_summary_via_ssm(engine["instance_id"])
+        if not idle_detector.get("available")
+        or not any(
+            k in idle_detector
+            for k in ("ide_connections", "ssh_sessions", "coffee_lock")
+        )
+        else None
+    )
+    if overlay:
+        # If API didn't indicate availability, replace entirely; otherwise fill gaps
+        if not idle_detector.get("available"):
+            idle_detector = overlay
+        else:
+            for k, v in overlay.items():
+                idle_detector.setdefault(k, v)
+
+    # Idle detector status (API and/or on-engine fallback)
     if idle_detector.get("available"):
         status_lines.append("")
         status_lines.append("[bold]Idle Detector:[/bold]")
@@ -882,8 +1000,13 @@ def engine_status(
         if ssh_sessions:
             status_lines.append(f"  • [blue]SSH Sessions ({len(ssh_sessions)}):[/blue]")
             for session in ssh_sessions:
+                idle_time = session.get("idle_time")
+                if isinstance(idle_time, (int, float)):
+                    idle_disp = f"{int(idle_time)//60}m"
+                else:
+                    idle_disp = str(idle_time) if idle_time else "0m"
                 status_lines.append(
-                    f"    - {session['tty']} (pid {session['pid']}, idle {session['idle_time']}) from {session['from_ip']}"
+                    f"    - {session.get('tty', 'pts/?')} (pid {session.get('pid', '?')}, idle {idle_disp}) from {session.get('from_ip', 'unknown')}"
                 )
 
         # IDE connections
@@ -893,6 +1016,18 @@ def engine_status(
                 f"  • [magenta]🖥  IDE connected ({ide_conn['connection_count']} connections)[/magenta]"
             )
 
+        # Sensors contributing to ACTIVE
+        reasons_raw = idle_detector.get("_reasons_raw")
+        if isinstance(reasons_raw, list):
+            active_sensors = [r for r in reasons_raw if r.get("active")]
+            if active_sensors:
+                status_lines.append("")
+                status_lines.append("[bold]Active Sensors:[/bold]")
+                for r in active_sensors:
+                    sensor = r.get("sensor", "Sensor")
+                    reason = r.get("reason") or "active"
+                    status_lines.append(f"  • {sensor}: {reason}")
+
     # Audit one-liner (best-effort SSM fetch)
     try:
         last_audit = _fetch_last_audit_via_ssm(engine["instance_id"])

dayhoff_tools/cli/main.py

@@ -22,6 +22,7 @@ from dayhoff_tools.warehouse import (
     import_from_warehouse_typer,
 )
 
+
 def _get_dht_version() -> str:
     try:
         return version("dayhoff-tools")
@@ -35,7 +36,9 @@ def _get_dht_version() -> str:
             return "unknown"
 
 
-app = typer.Typer(help=f"Dayhoff Tools (dh) v{_get_dht_version()}\n\nUse 'dh --version' to print version and exit.")
+app = typer.Typer(
+    help=f"Dayhoff Tools (dh) v{_get_dht_version()}\n\nUse 'dh --version' to print version and exit."
+)
 
 # Utility commands
 app.command("clean")(delete_local_branch)
@@ -73,7 +76,7 @@ def _version_option(
         "-v",
         help="Print version and exit.",
         is_eager=True,
-    )
+    ),
 ):
     """Global options for the dh CLI (e.g., version)."""
     if version_flag:

dayhoff_tools/cli/utility_commands.py

@@ -9,7 +9,6 @@ from pathlib import Path
 
 import toml
 import typer
-import yaml
 
 # Import cloud helper lazily inside functions to avoid heavy deps at module load
 
@@ -370,11 +369,15 @@ def install_dependencies(
             print("Ensuring lock file matches pyproject.mac.toml (Mac devcon)…")
             lock_cmd = ["uv", "lock"]
             print(f"Running command: {BLUE}{' '.join(lock_cmd)}{RESET}")
-            subprocess.run(lock_cmd, check=True, capture_output=True, cwd=str(mac_uv_dir))
+            subprocess.run(
+                lock_cmd, check=True, capture_output=True, cwd=str(mac_uv_dir)
+            )
 
             # Sync into the active environment
             if install_project:
-                print("Syncing dependencies into ACTIVE env and installing project [full]…")
+                print(
+                    "Syncing dependencies into ACTIVE env and installing project [full]…"
+                )
                 sync_cmd = ["uv", "sync", "--all-groups", "--active"]
                 print(f"Running command: {BLUE}{' '.join(sync_cmd)}{RESET}")
                 subprocess.run(sync_cmd, check=True, cwd=str(mac_uv_dir))
@@ -385,7 +388,13 @@ def install_dependencies(
                 print("Project installed with 'full' extras successfully.")
             else:
                 print("Syncing dependencies into ACTIVE env (project not installed)…")
-                sync_cmd = ["uv", "sync", "--all-groups", "--no-install-project", "--active"]
+                sync_cmd = [
+                    "uv",
+                    "sync",
+                    "--all-groups",
+                    "--no-install-project",
+                    "--active",
+                ]
                 print(f"Running command: {BLUE}{' '.join(sync_cmd)}{RESET}")
                 subprocess.run(sync_cmd, check=True, cwd=str(mac_uv_dir))
                 print("Dependencies synced successfully (project not installed).")
@@ -403,7 +412,13 @@ def install_dependencies(
                 subprocess.run(sync_cmd, check=True)
             else:
                 print("Syncing dependencies into ACTIVE env (project not installed)…")
-                sync_cmd = ["uv", "sync", "--all-groups", "--no-install-project", "--active"]
+                sync_cmd = [
+                    "uv",
+                    "sync",
+                    "--all-groups",
+                    "--no-install-project",
+                    "--active",
+                ]
                 print(f"Running command: {BLUE}{' '.join(sync_cmd)}{RESET}")
                 subprocess.run(sync_cmd, check=True)
                 print("Dependencies synced successfully (project not installed).")
@@ -436,16 +451,16 @@ def update_dependencies(
     """Update dependencies to newer versions (Mac-aware, active venv friendly).
 
     - Default Action (no flags): Updates only 'dayhoff-tools' package to latest,
-      updates the manifest's version constraint, and syncs.
+      updates ALL manifest files with the version constraint, and syncs.
     - Flags:
       --all/-a: Updates all dependencies (uv lock --upgrade) and syncs.
 
-    Mac devcontainer behavior:
-    - If STUDIO_PLATFORM=mac and `pyproject.mac.toml` exists, operate in `.mac_uv_project/`:
-      copy `pyproject.mac.toml` to `.mac_uv_project/pyproject.toml`, run uv there, and always
-      use `--active` for sync so installs target the active venv.
-    - Update the constraint inside `pyproject.mac.toml`. If not found, try `pyproject.toml`.
-    Otherwise (non-Mac), operate in repo root and also target the active venv during sync.
+    Cross-platform behavior:
+    - Always updates BOTH `pyproject.toml` and `pyproject.mac.toml` (if they exist)
+      to ensure version consistency across AWS and Mac platforms.
+    - On Mac: If STUDIO_PLATFORM=mac and `pyproject.mac.toml` exists, operates in
+      `.mac_uv_project/` and copies `pyproject.mac.toml` to `.mac_uv_project/pyproject.toml`.
+    - Always uses `--active` for sync to target the active venv.
     """
     # ANSI color codes
     BLUE = "\033[94m"
@@ -491,7 +506,7 @@ def update_dependencies(
         print(f"Running command: {BLUE}{' '.join(lock_cmd)}{RESET}")
         subprocess.run(lock_cmd, check=True, capture_output=True, cwd=uv_cwd)
 
-        # Step 2: Update pyproject.toml only if doing the dayhoff update (default)
+        # Step 2: Update both manifest files if doing the dayhoff update (default)
         if run_pyproject_update:
             print(f"Reading {lock_file_path} to find new dayhoff-tools version...")
             if not lock_file_path.exists():
@@ -518,59 +533,62 @@ def update_dependencies(
                 return
 
             print(f"Found dayhoff-tools version {locked_version} in lock file.")
-            print(f"Updating {manifest_path_for_constraint} version constraint...")
-            try:
-                content = manifest_path_for_constraint.read_text()
 
-                package_name = "dayhoff-tools"
-                package_name_esc = re.escape(package_name)
+            # Update both manifest files to ensure consistency across platforms
+            manifest_files_to_update = []
+            if pyproject_path.exists():
+                manifest_files_to_update.append(pyproject_path)
+            if mac_manifest.exists():
+                manifest_files_to_update.append(mac_manifest)
 
-                # Regex to match the dependency line, with optional extras and version spec
-                pattern = re.compile(
-                    rf"^(\s*['\"]){package_name_esc}(\[[^]]+\])?(?:[><=~^][^'\"]*)?(['\"].*)$",
-                    re.MULTILINE,
-                )
+            if not manifest_files_to_update:
+                print("Warning: No manifest files found to update.")
+                return
 
-                new_constraint_text = f">={locked_version}"
+            package_name = "dayhoff-tools"
+            package_name_esc = re.escape(package_name)
 
-                def _repl(match: re.Match):
-                    prefix = match.group(1)
-                    extras = match.group(2) or ""
-                    suffix = match.group(3)
-                    return (
-                        f"{prefix}{package_name}{extras}{new_constraint_text}{suffix}"
-                    )
+            # Regex to match the dependency line, with optional extras and version spec
+            pattern = re.compile(
+                rf"^(\s*['\"]){package_name_esc}(\[[^]]+\])?(?:[><=~^][^'\"]*)?(['\"].*)$",
+                re.MULTILINE,
+            )
 
-                new_content, num_replacements = pattern.subn(_repl, content)
-                if num_replacements > 0:
-                    manifest_path_for_constraint.write_text(new_content)
-                    print(
-                        f"Updated dayhoff-tools constraint in {manifest_path_for_constraint} to '{new_constraint_text}'"
-                    )
-                else:
-                    # Fallback: try the root pyproject if we were targeting mac manifest
-                    if manifest_path_for_constraint != pyproject_path and pyproject_path.exists():
-                        content2 = pyproject_path.read_text()
-                        new_content2, n2 = pattern.subn(_repl, content2)
-                        if n2 > 0:
-                            pyproject_path.write_text(new_content2)
-                            print(
-                                f"Updated dayhoff-tools constraint in {pyproject_path} to '{new_constraint_text}'"
-                            )
-                        else:
-                            print(
-                                f"Warning: Could not find dayhoff-tools dependency line in {manifest_path_for_constraint} or {pyproject_path} to update constraint."
-                            )
+            new_constraint_text = f">={locked_version}"
+
+            def _repl(match: re.Match):
+                prefix = match.group(1)
+                extras = match.group(2) or ""
+                suffix = match.group(3)
+                return f"{prefix}{package_name}{extras}{new_constraint_text}{suffix}"
+
+            # Update all manifest files
+            updated_files = []
+            for manifest_file in manifest_files_to_update:
+                try:
+                    print(f"Updating {manifest_file} version constraint...")
+                    content = manifest_file.read_text()
+                    new_content, num_replacements = pattern.subn(_repl, content)
+                    if num_replacements > 0:
+                        manifest_file.write_text(new_content)
+                        print(
+                            f"Updated dayhoff-tools constraint in {manifest_file} to '{new_constraint_text}'"
+                        )
+                        updated_files.append(str(manifest_file))
                     else:
                         print(
-                            f"Warning: Could not find dayhoff-tools dependency line in {manifest_path_for_constraint} to update constraint."
+                            f"Warning: Could not find dayhoff-tools dependency line in {manifest_file}"
                         )
-            except FileNotFoundError:
-                print(f"Error: {manifest_path_for_constraint} not found.")
-                return
-            except Exception as e:
-                print(f"Error updating {manifest_path_for_constraint}: {e}")
-                print("Proceeding with sync despite pyproject.toml update error.")
+                except FileNotFoundError:
+                    print(f"Warning: {manifest_file} not found.")
+                except Exception as e:
+                    print(f"Error updating {manifest_file}: {e}")
+
+            if not updated_files:
+                print(
+                    "Warning: No manifest files were successfully updated with dayhoff-tools constraint."
+                )
+                print("Proceeding with sync despite manifest update failures.")
 
         # Step 3: Sync environment
         print("Syncing environment with updated lock file...")
@@ -584,7 +602,7 @@ def update_dependencies(
             print("All dependencies updated and environment synced successfully.")
         else:  # Default case (dayhoff update)
             print(
-                "dayhoff-tools updated, pyproject.toml modified, and environment synced successfully."
+                "dayhoff-tools updated, manifest files modified, and environment synced successfully."
             )
 
     except subprocess.CalledProcessError as e:

dayhoff_tools/warehouse.py

@@ -19,7 +19,9 @@ def _find_project_root() -> Path | None:
     """
     current_dir = Path.cwd().resolve()
     while current_dir != current_dir.parent:
-        if (current_dir / ".git").is_dir() or (current_dir / "pyproject.toml").is_file():
+        if (current_dir / ".git").is_dir() or (
+            current_dir / "pyproject.toml"
+        ).is_file():
             return current_dir
         current_dir = current_dir.parent
     # Check the final directory in the hierarchy (e.g., '/')

{dayhoff_tools-1.7.5.dist-info → dayhoff_tools-1.8.1.dist-info}/METADATA

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

{dayhoff_tools-1.7.5.dist-info → dayhoff_tools-1.8.1.dist-info}/RECORD

@@ -3,10 +3,10 @@ dayhoff_tools/chemistry/standardizer.py,sha256=uMn7VwHnx02nc404eO6fRuS4rsl4dvSPf
 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_commands.py,sha256=0syRVrJjWtRi7Y_q7MbEA5PKJ8TSXtEodHzxXu2Ymhs,102461
-dayhoff_tools/cli/main.py,sha256=LLMybU9KbtV_F4rwvoYAQZKTTF1nswlSZIfDMKdkh00,5925
+dayhoff_tools/cli/engine_commands.py,sha256=yFloQmS3IEvoVWIQzlWKIBedb5XJPmJFsOHbW_EJH-U,108516
+dayhoff_tools/cli/main.py,sha256=LoFs3SI4fdCjP4pdxEAhri-_q0dmNYupmBCRE4KbBac,5933
 dayhoff_tools/cli/swarm_commands.py,sha256=5EyKj8yietvT5lfoz8Zx0iQvVaNgc3SJX1z2zQR6o6M,5614
-dayhoff_tools/cli/utility_commands.py,sha256=q2XyNy1uMGKg95cRXv1uA4MhaUDqlDBvkQwmvRo3hnA,25865
+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
@@ -26,8 +26,8 @@ dayhoff_tools/intake/structure.py,sha256=ufN3gAodQxhnt7psK1VTQeu9rKERmo_PhoxIbB4
 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=heaYc64qplgN3_1WVPFmqj53goStioWwY5NqlWc4c0s,24453
-dayhoff_tools-1.7.5.dist-info/METADATA,sha256=tnZl6OD70iojC4Avmej4LaBhAAQO2afIzZ4PBj6BEws,2914
-dayhoff_tools-1.7.5.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-dayhoff_tools-1.7.5.dist-info/entry_points.txt,sha256=iAf4jteNqW3cJm6CO6czLxjW3vxYKsyGLZ8WGmxamSc,49
-dayhoff_tools-1.7.5.dist-info/RECORD,,
+dayhoff_tools/warehouse.py,sha256=UETBtZD3r7WgvURqfGbyHlT7cxoiVq8isjzMuerKw8I,24475
+dayhoff_tools-1.8.1.dist-info/METADATA,sha256=gwCqNlp8VZ8npiW7RY6kbQ5r-tYUCubDruy38BvdsFY,2914
+dayhoff_tools-1.8.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+dayhoff_tools-1.8.1.dist-info/entry_points.txt,sha256=iAf4jteNqW3cJm6CO6czLxjW3vxYKsyGLZ8WGmxamSc,49
+dayhoff_tools-1.8.1.dist-info/RECORD,,