dayhoff-tools 1.14.15__tar.gz → 1.15.1__tar.gz

{dayhoff_tools-1.14.15 → dayhoff_tools-1.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dayhoff-tools
-Version: 1.14.15
+Version: 1.15.1
 Summary: Common tools for all the repos at Dayhoff Labs
 Author: Daniel Martin-Alarcon
 Author-email: dma@dayhofflabs.com
@@ -40,8 +40,8 @@ Requires-Dist: sqlalchemy (>=2.0.40,<3.0.0) ; extra == "full"
 Requires-Dist: toml (>=0.10)
 Requires-Dist: tqdm (>=4.67.1) ; extra == "embedders"
 Requires-Dist: tqdm (>=4.67.1) ; extra == "full"
-Requires-Dist: transformers (==4.36.2) ; extra == "full"
 Requires-Dist: transformers (>=4.36.2) ; extra == "embedders"
+Requires-Dist: transformers (>=4.36.2) ; extra == "full"
 Requires-Dist: typer (>=0.9.0)
 Requires-Dist: tzdata (>=2025.2)
 Description-Content-Type: text/markdown

{dayhoff_tools-1.14.15 → dayhoff_tools-1.15.1}/dayhoff_tools/batch/workers/boltz.py

@@ -235,7 +235,7 @@ class BoltzProcessor:
         # Determine output directory
         # Boltz always creates boltz_results_{input_name} inside --out_dir
         input_base = os.path.splitext(os.path.basename(input_file))[0]
-        
+
         if output_dir is None:
             # No output_dir specified, boltz creates in current directory
             expected_output_dir = f"boltz_results_{input_base}"
@@ -244,7 +244,9 @@ class BoltzProcessor:
             # output_dir specified - use its parent for --out_dir
             # and expect boltz_results_{input_base} inside it
             parent_dir = os.path.dirname(output_dir)
-            expected_output_dir = os.path.join(parent_dir, f"boltz_results_{input_base}")
+            expected_output_dir = os.path.join(
+                parent_dir, f"boltz_results_{input_base}"
+            )
             out_dir_arg = parent_dir if parent_dir else None
 
         logger.info(f"Running Boltz prediction for {input_file}")
@@ -455,9 +457,7 @@ def main():
                 completed += 1
                 continue
 
-            logger.info(
-                f"[{file_idx + 1}/{len(my_files)}] Processing {file_stem}..."
-            )
+            logger.info(f"[{file_idx + 1}/{len(my_files)}] Processing {file_stem}...")
 
             try:
                 # Determine output directory

{dayhoff_tools-1.14.15 → dayhoff_tools-1.15.1}/dayhoff_tools/cli/batch/commands/cancel.py

@@ -152,9 +152,13 @@ def _cancel_retry_job(manifest, retry_id: str, force: bool, base_path: str):
             )
 
         click.echo()
-        click.echo(click.style(f"✓ Retry job {retry_id} cancelled successfully", fg="green"))
+        click.echo(
+            click.style(f"✓ Retry job {retry_id} cancelled successfully", fg="green")
+        )
         click.echo(f"Parent job: {manifest.job_id}")
 
     except BatchError as e:
-        click.echo(click.style(f"✗ Failed to cancel retry job: {e}", fg="red"), err=True)
+        click.echo(
+            click.style(f"✗ Failed to cancel retry job: {e}", fg="red"), err=True
+        )
         raise SystemExit(1)

{dayhoff_tools-1.14.15 → dayhoff_tools-1.15.1}/dayhoff_tools/cli/batch/commands/clean.py

@@ -20,7 +20,9 @@ from .status import format_time_ago, _aws_status_to_job_status
     default=7,
     help="Only clean jobs older than N days [default: 7]",
 )
-@click.option("--dry-run", is_flag=True, help="Show what would be cleaned without deleting")
+@click.option(
+    "--dry-run", is_flag=True, help="Show what would be cleaned without deleting"
+)
 @click.option("--force", is_flag=True, help="Delete without confirmation")
 @click.option("--base-path", default=BATCH_JOBS_BASE, help="Base path for job data")
 def clean(user, older_than, dry_run, force, base_path):
@@ -81,7 +83,9 @@ def clean(user, older_than, dry_run, force, base_path):
             live_statuses = client.get_job_statuses_batch(batch_job_ids)
         except BatchError as e:
             click.echo(f"Error: Could not fetch status from AWS Batch: {e}", err=True)
-            click.echo("Cannot safely clean jobs without knowing their status.", err=True)
+            click.echo(
+                "Cannot safely clean jobs without knowing their status.", err=True
+            )
             raise SystemExit(1)
 
     # Find jobs that are safe to clean (SUCCEEDED or FAILED)

{dayhoff_tools-1.14.15 → dayhoff_tools-1.15.1}/dayhoff_tools/cli/batch/commands/embed_t5.py

@@ -21,7 +21,6 @@ from ..manifest import (
     save_manifest,
 )
 
-
 # Default settings for T5 embedding
 DEFAULT_QUEUE = "t4-1x-spot"
 DEFAULT_WORKERS = 50

{dayhoff_tools-1.14.15 → dayhoff_tools-1.15.1}/dayhoff_tools/cli/batch/commands/finalize.py

@@ -40,7 +40,9 @@ from ..manifest import (
     help="Skip deduplication step (use if input has no duplicates)",
 )
 @click.option("--base-path", default=BATCH_JOBS_BASE, help="Base path for job data")
-def finalize(job_id, output, force, keep_intermediates, full_output, skip_dedup, base_path):
+def finalize(
+    job_id, output, force, keep_intermediates, full_output, skip_dedup, base_path
+):
     """Combine results and clean up job intermediates.
 
     For embedding jobs, combines H5 files into a single output file.
@@ -238,14 +240,18 @@ def _finalize_embeddings(output_dir: Path, output_path: Path, skip_dedup: bool =
                 if skip_dedup:
                     # Skip dedup - optimize directly from combined
                     click.echo("Optimizing chunks...")
-                    optimize_protein_embedding_chunks(str(combined_path), str(output_path))
+                    optimize_protein_embedding_chunks(
+                        str(combined_path), str(output_path)
+                    )
                 else:
                     # Full pipeline: combine -> dedup -> optimize
                     deduped_path = Path(tmpdir) / "deduped.h5"
                     click.echo("Deduplicating...")
                     deduplicate_h5_file(str(combined_path), str(deduped_path))
                     click.echo("Optimizing chunks...")
-                    optimize_protein_embedding_chunks(str(deduped_path), str(output_path))
+                    optimize_protein_embedding_chunks(
+                        str(deduped_path), str(output_path)
+                    )
 
         click.echo(click.style("✓ H5 files combined successfully", fg="green"))
 
@@ -269,7 +275,7 @@ def _finalize_embeddings(output_dir: Path, output_path: Path, skip_dedup: bool =
 
 def _finalize_boltz(output_dir: Path, output_path: Path, full_output: bool = False):
     """Move Boltz output to destination.
-    
+
     Args:
         output_dir: Source directory containing boltz_results_* folders
         output_path: Destination directory for outputs
@@ -277,20 +283,24 @@ def _finalize_boltz(output_dir: Path, output_path: Path, full_output: bool = Fal
                     extract only essential files (CIF structures and confidence JSON).
     """
     # Find all output directories (one per complex)
-    complex_dirs = [d for d in output_dir.iterdir() if d.is_dir() and d.name.startswith("boltz_results_")]
+    complex_dirs = [
+        d
+        for d in output_dir.iterdir()
+        if d.is_dir() and d.name.startswith("boltz_results_")
+    ]
 
     if not complex_dirs:
         click.echo("No output directories found.", err=True)
         raise SystemExit(1)
 
     click.echo(f"Found {len(complex_dirs)} structure predictions")
-    
+
     if full_output:
         click.echo("Mode: Copying full output (all files)")
     else:
         click.echo("Mode: Extracting essential files only (CIF + confidence JSON)")
         click.echo("       Use --full-output to copy all files")
-    
+
     # Confirm before proceeding
     click.echo()
     if not click.confirm(f"Copy results to {output_path}?"):
@@ -302,16 +312,16 @@ def _finalize_boltz(output_dir: Path, output_path: Path, full_output: bool = Fal
 
     copied_count = 0
     skipped_count = 0
-    
+
     for complex_dir in complex_dirs:
         complex_name = complex_dir.name.replace("boltz_results_", "")
         dest = output_path / complex_name
-        
+
         if dest.exists():
             click.echo(f"  Skipping {complex_name} (already exists)")
             skipped_count += 1
             continue
-        
+
         if full_output:
             # Copy entire directory
             shutil.copytree(complex_dir, dest)
@@ -320,44 +330,53 @@ def _finalize_boltz(output_dir: Path, output_path: Path, full_output: bool = Fal
             # Extract only essential files
             _extract_essential_boltz_files(complex_dir, dest, complex_name)
             click.echo(f"  Extracted {complex_name} (essential files)")
-        
+
         copied_count += 1
 
     click.echo()
     if skipped_count > 0:
-        click.echo(f"Copied {copied_count} predictions, skipped {skipped_count} existing")
+        click.echo(
+            f"Copied {copied_count} predictions, skipped {skipped_count} existing"
+        )
     else:
-        click.echo(click.style(f"✓ Copied {copied_count} structure predictions successfully", fg="green"))
+        click.echo(
+            click.style(
+                f"✓ Copied {copied_count} structure predictions successfully",
+                fg="green",
+            )
+        )
 
 
 def _extract_essential_boltz_files(source_dir: Path, dest_dir: Path, complex_name: str):
     """Extract only essential files from Boltz output.
-    
+
     Essential files are:
     - predictions/*/*.cif (structure files)
     - predictions/*/confidence_*.json (confidence metrics)
-    
+
     Args:
         source_dir: Source boltz_results_* directory
         dest_dir: Destination directory to create
         complex_name: Name of the complex (for better error messages)
     """
     dest_dir.mkdir(parents=True, exist_ok=True)
-    
+
     predictions_dir = source_dir / "predictions"
     if not predictions_dir.exists():
-        click.echo(f"    Warning: No predictions directory found for {complex_name}", err=True)
+        click.echo(
+            f"    Warning: No predictions directory found for {complex_name}", err=True
+        )
         return
-    
+
     # Find all subdirectories in predictions/ (usually just one named after the complex)
     for pred_subdir in predictions_dir.iterdir():
         if not pred_subdir.is_dir():
             continue
-        
+
         # Copy CIF files (structures)
         for cif_file in pred_subdir.glob("*.cif"):
             shutil.copy2(cif_file, dest_dir / cif_file.name)
-        
+
         # Copy confidence JSON files
         for json_file in pred_subdir.glob("confidence_*.json"):
             shutil.copy2(json_file, dest_dir / json_file.name)

{dayhoff_tools-1.14.15 → dayhoff_tools-1.15.1}/dayhoff_tools/cli/batch/commands/status.py

@@ -264,7 +264,9 @@ def _show_job_details(job_id: str, base_path: str):
             reslice_info = ""
             if retry.reslice_prefix:
                 reslice_info = f" (resliced to {retry.reslice_count} chunks)"
-            click.echo(f"  - {retry.retry_id}: {len(retry.indices)} indices{reslice_info}")
+            click.echo(
+                f"  - {retry.retry_id}: {len(retry.indices)} indices{reslice_info}"
+            )
             click.echo(f"    Indices: {retry.indices}")
             if retry.batch_job_id:
                 # Show brief status for retry job
@@ -273,7 +275,9 @@ def _show_job_details(job_id: str, base_path: str):
                     array_status = client.get_array_job_status(retry.batch_job_id)
                     if array_status.is_complete:
                         pct = array_status.success_rate * 100
-                        color = "green" if pct == 100 else "yellow" if pct > 90 else "red"
+                        color = (
+                            "green" if pct == 100 else "yellow" if pct > 90 else "red"
+                        )
                         click.echo(
                             f"    Status: Complete - {click.style(f'{pct:.0f}%', fg=color)} "
                             f"({array_status.succeeded}/{array_status.total} succeeded)"
@@ -364,7 +368,9 @@ def _show_retry_details(manifest, retry_id: str):
     click.echo("Retry Config:")
     click.echo(f"  Indices:   {retry_info.indices}")
     if retry_info.reslice_prefix:
-        click.echo(f"  Reslice:   {retry_info.reslice_prefix} ({retry_info.reslice_count} chunks)")
+        click.echo(
+            f"  Reslice:   {retry_info.reslice_prefix} ({retry_info.reslice_count} chunks)"
+        )
     else:
         click.echo(f"  Reslice:   No (retrying original chunks)")
 

{dayhoff_tools-1.14.15 → dayhoff_tools-1.15.1}/dayhoff_tools/cli/batch/commands/submit.py

@@ -18,7 +18,6 @@ from ..manifest import (
     save_manifest,
 )
 
-
 # Default job definition for generic jobs
 DEFAULT_JOB_DEFINITION = "dayhoff-batch-base"
 DEFAULT_QUEUE = "t4-1x-spot"

{dayhoff_tools-1.14.15 → dayhoff_tools-1.15.1}/dayhoff_tools/cli/main.py

@@ -5,19 +5,13 @@ from importlib.metadata import PackageNotFoundError, version
 
 import typer
 from dayhoff_tools.cli.cloud_commands import aws_app, gcp_app
+from dayhoff_tools.cli.engine1 import engine_app as engine1_app
+from dayhoff_tools.cli.engine1 import studio_app as studio1_app
 from dayhoff_tools.cli.github_commands import gh_app
-from dayhoff_tools.cli.engine1 import (
-    engine_app as engine1_app,
-    studio_app as studio1_app,
-)
 from dayhoff_tools.cli.utility_commands import (
-    add_dependency,
     build_and_upload_wheel,
     delete_local_branch,
-    remove_dependency,
-    sync_with_toml,
     test_github_actions_locally,
-    update_dependencies,
 )
 from dayhoff_tools.warehouse import (
     _warn_if_gcp_default_sa,
@@ -48,19 +42,6 @@ app = typer.Typer(
 # Utility commands
 app.command("clean")(delete_local_branch)
 
-# Dependency Management
-app.command(
-    "tomlsync",
-    help="Sync environment with platform-specific TOML manifest (install/update dependencies).",
-)(sync_with_toml)
-app.command("add", help="Add a dependency to all platform manifests.")(add_dependency)
-app.command("remove", help="Remove a dependency from all platform manifests.")(
-    remove_dependency
-)
-app.command("update", help="Update dayhoff-tools (or all deps) and sync environment.")(
-    update_dependencies
-)
-
 # Other Utilities
 app.command("gha")(test_github_actions_locally)
 app.command("wadd")(add_to_warehouse_typer)
@@ -183,44 +164,6 @@ def build_and_upload_wheel_command(
     build_and_upload_wheel(bump_part=bump)
 
 
-# Use lazy loading for slow-loading swarm commands
-@app.command("reset")
-def reset_wrapper(
-    firestore_collection: str = typer.Option(prompt=True),
-    old_status: str = typer.Option(default="failed", prompt=True),
-    new_status: str = typer.Option(default="available", prompt=True),
-    delete_old: bool = typer.Option(default=True, prompt=True),
-):
-    """Find all the documents in the database with a given status, and
-    make a new document with the same name and a new status."""
-    from dayhoff_tools.cli.swarm_commands import reset_failed_cards
-
-    reset_failed_cards(firestore_collection, old_status, new_status, delete_old)
-
-
-@app.command("zombie")
-def zombie_wrapper(
-    firestore_collection: str = typer.Option(prompt=True),
-    delete_old: bool = typer.Option(default=True, prompt=True),
-    minutes_threshold: int = typer.Option(default=60, prompt=True),
-):
-    """Find all the documents in the database with status "assigned", and "last_updated"
-    older than a specified threshold, and make a new "available" document for them."""
-    from dayhoff_tools.cli.swarm_commands import reset_zombie_cards
-
-    reset_zombie_cards(firestore_collection, delete_old, minutes_threshold)
-
-
-@app.command("status")
-def status_wrapper(
-    firestore_collection: str = typer.Argument(),
-):
-    """Count the various statuses of items in a given collection."""
-    from dayhoff_tools.cli.swarm_commands import get_firestore_collection_status
-
-    get_firestore_collection_status(firestore_collection)
-
-
 # Deployment commands - use lazy loading but preserve argument passing
 @app.command("deploy")
 def deploy_command(

dayhoff_tools-1.15.1/dayhoff_tools/cli/utility_commands.py

@@ -0,0 +1,260 @@
+"""CLI commands common to all repos."""
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import toml
+import typer
+
+# Import cloud helper lazily inside functions to avoid heavy deps at module load
+
+
+def test_github_actions_locally():
+    """Run the script test_pytest_in_github_actions_container.sh.sh."""
+    script_path = ".devcontainer/scripts/test_pytest_in_github_actions_container.sh"
+
+    try:
+        subprocess.check_call(["bash", script_path])
+        print("Script ran successfully!")
+    except subprocess.CalledProcessError as e:
+        print(f"Error occurred while running the script: {e}")
+
+
+def delete_local_branch(branch_name: str, folder_path: str):
+    """Delete a local Git branch after fetching with pruning.
+
+    Args:
+        branch_name: Name of the branch to delete
+        folder_path: Path to the git repository folder
+    """
+    try:
+        # Store current working directory
+        original_dir = os.getcwd()
+
+        # Change to the specified directory
+        os.chdir(folder_path)
+        print(f"Changed to directory: {folder_path}")
+
+        # Delete the specified branch
+        delete_branch_cmd = ["git", "branch", "-D", branch_name]
+        subprocess.run(delete_branch_cmd, check=True)
+        print(f"Deleted branch: {branch_name}")
+
+        # Fetch changes from the remote repository and prune obsolete branches
+        fetch_prune_cmd = ["git", "fetch", "-p"]
+        subprocess.run(fetch_prune_cmd, check=True)
+        print("Fetched changes and pruned obsolete branches")
+
+    except subprocess.CalledProcessError as e:
+        print(f"Error occurred while running Git commands: {e}")
+    finally:
+        # Always return to the original directory
+        os.chdir(original_dir)
+
+
+def get_current_version_from_toml(file_path="pyproject.toml"):
+    """Reads the version from a pyproject.toml file."""
+    try:
+        with open(file_path, "r") as f:
+            content = f.read()
+        version_match = re.search(r'^version\s*=\s*"([^"]+)"', content, re.MULTILINE)
+        if version_match:
+            return version_match.group(1)
+        else:
+            raise ValueError(f"Could not find version string in {file_path}")
+    except FileNotFoundError:
+        raise FileNotFoundError(f"{file_path} not found.")
+    except Exception as e:
+        raise e
+
+
+def build_and_upload_wheel(bump_part: str = "patch"):
+    """Build a Python wheel and upload to PyPI using UV.
+
+    Automatically increments the version number in pyproject.toml before building
+    based on the bump_part argument ('major', 'minor', 'patch').
+
+    Expects PyPI authentication to be configured via the environment variable:
+    - UV_PUBLISH_TOKEN
+
+    Args:
+        bump_part (str): The part of the version to bump. Defaults to 'patch'.
+    """
+    if bump_part not in ["major", "minor", "patch"]:
+        print(
+            f"Error: Invalid bump_part '{bump_part}'. Must be 'major', 'minor', or 'patch'."
+        )
+        return
+
+    # ANSI color codes
+    BLUE = "\033[94m"
+    RESET = "\033[0m"
+
+    # --- Authentication Setup ---
+    token = os.environ.get("UV_PUBLISH_TOKEN")
+
+    if not token:
+        print("Error: PyPI authentication not configured.")
+        print(
+            "Please set the UV_PUBLISH_TOKEN environment variable with your PyPI API token."
+        )
+        return
+
+    # Build the command with token authentication
+    # IMPORTANT: Mask token for printing
+    publish_cmd_safe_print = ["uv", "publish", "--token", "*****"]
+    publish_cmd = ["uv", "publish", "--token", token]
+    print("Using UV_PUBLISH_TOKEN for authentication.")
+
+    # Use standard pyproject.toml
+    pyproject_path = "pyproject.toml"
+    if not Path(pyproject_path).exists():
+        print("Error: pyproject.toml not found in current directory.")
+        return
+    current_version = None  # Initialize in case the first try block fails
+
+    try:
+        # --- Clean dist directory ---
+        dist_dir = Path("dist")
+        if dist_dir.exists():
+            print(f"Removing existing build directory: {dist_dir}")
+            shutil.rmtree(dist_dir)
+        # --- End Clean dist directory ---
+
+        # --- Version Bumping Logic ---
+        current_version = get_current_version_from_toml(pyproject_path)
+        print(f"Current version: {current_version}")
+
+        try:
+            major, minor, patch = map(int, current_version.split("."))
+        except ValueError:
+            print(
+                f"Error: Could not parse version '{current_version}'. Expected format X.Y.Z"
+            )
+            return
+
+        if bump_part == "major":
+            major += 1
+            minor = 0
+            patch = 0
+        elif bump_part == "minor":
+            minor += 1
+            patch = 0
+        else:  # patch
+            patch += 1
+
+        new_version = f"{major}.{minor}.{patch}"
+        print(f"Bumping {bump_part} version to: {new_version}")
+
+        # Read pyproject.toml
+        with open(pyproject_path, "r") as f:
+            content = f.read()
+
+        # Replace the version string
+        pattern = re.compile(
+            f'^version\s*=\s*"{re.escape(current_version)}"', re.MULTILINE
+        )
+        new_content, num_replacements = pattern.subn(
+            f'version = "{new_version}"', content
+        )
+
+        if num_replacements == 0:
+            print(
+                f"Error: Could not find 'version = \"{current_version}\"' in {pyproject_path}"
+            )
+            return  # Exit before build/publish if version wasn't updated
+        if num_replacements > 1:
+            print(
+                f"Warning: Found multiple version lines for '{current_version}'. Only the first was updated."
+            )
+
+        # Write the updated content back
+        with open(pyproject_path, "w") as f:
+            f.write(new_content)
+        print(f"Updated {pyproject_path} with version {new_version}")
+
+        # --- End Version Bumping Logic ---
+
+        # Build wheel and sdist
+        build_cmd = ["uv", "build"]
+        print(f"Running command: {BLUE}{' '.join(build_cmd)}{RESET}")
+        subprocess.run(build_cmd, check=True)
+
+        # Upload to PyPI
+        print(f"Running command: {BLUE}{' '.join(publish_cmd_safe_print)}{RESET}")
+        subprocess.run(publish_cmd, check=True)
+
+        print(f"Successfully built and uploaded version {new_version} to PyPI")
+
+        # Re-install DHT in Pixi environment when building from DHT itself
+        try:
+            proj_toml = toml.load(pyproject_path)
+            proj_name = proj_toml.get("project", {}).get("name")
+            if proj_name == "dayhoff-tools":
+                print("Re-installing dayhoff-tools into the Pixi environment...")
+                reinstall_cmd = ["pixi", "install"]
+                print(f"Running command: {BLUE}{' '.join(reinstall_cmd)}{RESET}")
+                subprocess.run(reinstall_cmd, check=True)
+                print("dayhoff-tools reinstalled in the Pixi environment.")
+        except subprocess.CalledProcessError as e:
+            print(f"Warning: Failed to reinstall dayhoff-tools locally: {e}")
+        except Exception:
+            pass  # Not dayhoff-tools or couldn't read toml
+
+    except FileNotFoundError:
+        print(f"Error: {pyproject_path} not found.")
+        # No version change happened, so no rollback needed
+    except subprocess.CalledProcessError as e:
+        print(f"Error during build/upload: {e}")
+        # Attempt to roll back version change only if it was bumped successfully
+        if current_version and new_version:
+            try:
+                print(
+                    f"Attempting to revert version in {pyproject_path} back to {current_version}..."
+                )
+                with open(pyproject_path, "r") as f:
+                    content_revert = f.read()
+                # Use new_version in pattern for reverting
+                pattern_revert = re.compile(
+                    f'^version\s*=\s*"{re.escape(new_version)}"', re.MULTILINE
+                )
+                reverted_content, num_revert = pattern_revert.subn(
+                    f'version = "{current_version}"', content_revert
+                )
+                if num_revert > 0:
+                    with open(pyproject_path, "w") as f:
+                        f.write(reverted_content)
+                    print(f"Successfully reverted version in {pyproject_path}.")
+                else:
+                    print(
+                        f"Warning: Could not find version {new_version} to revert in {pyproject_path}."
+                    )
+
+            except Exception as revert_e:
+                print(f"Warning: Failed to revert version change: {revert_e}")
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+        # Attempt rollback if version was bumped
+        if current_version and "new_version" in locals() and new_version:
+            try:
+                print(f"Attempting to revert version back to {current_version}...")
+                with open(pyproject_path, "r") as f:
+                    content_revert = f.read()
+                pattern_revert = re.compile(
+                    f'^version\\s*=\\s*"{re.escape(new_version)}"', re.MULTILINE
+                )
+                reverted_content, num_revert = pattern_revert.subn(
+                    f'version = "{current_version}"', content_revert
+                )
+                if num_revert > 0:
+                    with open(pyproject_path, "w") as f:
+                        f.write(reverted_content)
+                    print("Successfully reverted version in pyproject.toml.")
+                else:
+                    print(f"Warning: Could not find version {new_version} to revert.")
+            except Exception as revert_e:
+                print(f"Warning: Failed to revert version change: {revert_e}")

{dayhoff_tools-1.14.15 → dayhoff_tools-1.15.1}/dayhoff_tools/embedders.py

@@ -179,8 +179,8 @@ class H5Reformatter(Processor):
     def embedding_file_to_df(self, file_name: str) -> pd.DataFrame:
         with h5py.File(file_name, "r") as f:
             gene_names = list(f.keys())
-            Xg = [f[key][()] for key in gene_names]  # type:ignore
-        return pd.DataFrame(np.asmatrix(Xg), index=gene_names)  # type:ignore
+            Xg = [f[key][()] for key in gene_names]  # type: ignore
+        return pd.DataFrame(np.asmatrix(Xg), index=gene_names)  # type: ignore
 
     def write_df_to_h5(self, df: pd.DataFrame, filename: str, description: str) -> None:
         """

{dayhoff_tools-1.14.15 → dayhoff_tools-1.15.1}/dayhoff_tools/fasta.py

@@ -857,14 +857,12 @@ def fasta_to_sqlite(fasta_file: str, db_file: str, batch_size: int = 1000) -> No
     # Create the SQLite database and table
     print("Creating SQLite database...")
     with sqlite3.connect(db_file) as conn:
-        conn.execute(
-            """
+        conn.execute("""
             CREATE TABLE IF NOT EXISTS proteins (
                 protein_id TEXT PRIMARY KEY,
                 sequence TEXT NOT NULL
             )
-        """
-        )
+        """)
     print("Database created successfully.")
 
     # Estimate number of records for progress bar