dayhoff-tools 1.0.0__py3-none-any.whl

dayhoff_tools/chemistry/standardizer.py

@@ -0,0 +1,297 @@
+"""Normalization classes for molecules and reactions."""
+
+from abc import ABC, abstractmethod
+
+from rdkit import Chem, rdBase
+from rdkit.Chem import AllChem
+from rdkit.Chem.MolStandardize import rdMolStandardize  # type: ignore
+
+rdBase.DisableLog("rdApp.error")
+rdBase.DisableLog("rdApp.warning")
+
+
+def is_smiles_aromatic(smiles: str) -> bool:
+    """Check if SMILES string contains aromatic atoms.
+
+    Args:
+        smiles (str): Input SMILES string
+
+    Returns:
+        bool: True if aromatic atoms are found
+    """
+
+    rdmol = Chem.MolFromSmiles(smiles, sanitize=False)  # type: ignore
+    if rdmol is None:
+        raise ValueError("invalid SMILES string")
+    return any(at.GetIsAromatic() for at in rdmol.GetAtoms())
+
+
+class BaseStandardizer(ABC):
+    """Abstract base class  for normalizing molecules and reactions."""
+
+    @abstractmethod
+    def standardize_molecule(self, smiles: str) -> str:
+        """Standardize molecules as SMILES strings.
+
+        Args:
+            smiles (str): Input SMILES string
+
+        Returns:
+            str: Output SMILES string
+        """
+        pass
+
+    def standardize_reaction(self, smiles: str) -> str:
+        """Standardize reactions as SMILES/SMARTS strings.
+
+        Args:
+            smiles (str): Input SMILES/SMARTS string
+
+        Returns:
+            str: Output SMILES/SMARTS string
+        """
+        rdrxn = AllChem.ReactionFromSmarts(smiles, useSmiles=True)  # type: ignore
+        rdrxn1 = AllChem.ChemicalReaction()  # type: ignore
+        for rdmol in rdrxn.GetReactants():
+            smiles1 = Chem.MolToSmiles(rdmol, canonical=False)  # type: ignore
+            smiles2 = self.standardize_molecule(smiles1)
+            rdmol1 = Chem.MolFromSmiles(smiles2, sanitize=False)  # type: ignore
+            rdfrags = Chem.GetMolFrags(rdmol1, asMols=True, sanitizeFrags=False)  # type: ignore
+            if len(rdfrags) == 1:
+                rdrxn1.AddReactantTemplate(rdmol1)
+            else:
+                for rdfrag in rdfrags:
+                    rdrxn1.AddReactantTemplate(rdfrag)
+            # rdrxn1.AddReactantTemplate(rdmol1)
+        for rdmol in rdrxn.GetProducts():
+            smiles1 = Chem.MolToSmiles(rdmol, canonical=False)  # type: ignore
+            smiles2 = self.standardize_molecule(smiles1)
+            rdmol1 = Chem.MolFromSmiles(smiles2, sanitize=False)  # type: ignore
+            rdfrags = Chem.GetMolFrags(rdmol1, asMols=True, sanitizeFrags=False)  # type: ignore
+            if len(rdfrags) == 1:
+                rdrxn1.AddProductTemplate(rdmol1)
+            else:
+                for rdfrag in rdfrags:
+                    rdrxn1.AddProductTemplate(rdfrag)
+        return AllChem.ReactionToSmiles(rdrxn1)  # type: ignore
+
+
+class HypervalentStandardizer(BaseStandardizer):
+    """Standardizer for converting double to single bonds in hypervalent
+    compounds."""
+
+    def standardize_molecule(self, smiles: str) -> str:
+        """Standardize molecules as SMILES strings.
+
+        Args:
+            smiles (str): Input SMILES string
+
+        Returns:
+            str: Output SMILES string
+        """
+        rdmol = Chem.MolFromSmiles(smiles, sanitize=False)  # type: ignore
+        if rdmol is None:
+            raise ValueError(f"Invalid SMILES input '{smiles}'")
+        ret = Chem.SanitizeMol(rdmol, sanitizeOps=Chem.SANITIZE_CLEANUP)  # type: ignore
+        if ret > 0:
+            raise ValueError(f"Sanitization failed for SMILES input '{smiles}'")
+        return Chem.MolToSmiles(rdmol)  # type: ignore
+
+
+class RemoveHsStandardizer(BaseStandardizer):
+    """Standardizer for removing explicit hydrogens from molecules."""
+
+    def standardize_molecule(self, smiles: str) -> str:
+        """Standardize molecules as SMILES strings.
+
+        Args:
+            smiles (str): Input SMILES string
+
+        Returns:
+            str: Output SMILES string
+        """
+        rdmol = Chem.MolFromSmiles(smiles, sanitize=False)  # type: ignore
+        if rdmol is None:
+            raise ValueError(f"Invalid SMILES input '{smiles}'")
+        rdmol1 = Chem.RemoveHs(rdmol, sanitize=False)  # type: ignore
+        ret = Chem.SanitizeMol(rdmol1, sanitizeOps=Chem.SANITIZE_FINDRADICALS)  # type: ignore
+        if ret > 0:
+            raise ValueError(f"Sanitization failed for SMILES input '{smiles}'")
+        return Chem.MolToSmiles(rdmol1, canonical=True)  # type: ignore
+
+
+class KekulizeStandardizer(BaseStandardizer):
+    """Standardizer for kekulizing aromatic compounds."""
+
+    def standardize_molecule(self, smiles: str) -> str:
+        """Standardize molecules as SMILES strings.
+
+        Args:
+            smiles (str): Input SMILES string
+
+        Returns:
+            str: Output SMILES string
+        """
+        rdmol = Chem.MolFromSmiles(smiles, sanitize=False)  # type: ignore
+        if rdmol is None:
+            raise ValueError(f"Invalid SMILES input '{smiles}'")
+        rdmol.UpdatePropertyCache(strict=False)
+        Chem.Kekulize(rdmol, clearAromaticFlags=True)  # type: ignore
+        return Chem.MolToSmiles(rdmol, canonical=True)  # type: ignore
+
+
+class UnchargeStandardizer(BaseStandardizer):
+    """Standardizer for removing charges from molecules by protonation/deprotonation."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._uncharger = rdMolStandardize.Uncharger()
+
+    def standardize_molecule(self, smiles: str) -> str:
+        """Standardize molecules as SMILES strings.
+
+        Args:
+            smiles (str): Input SMILES string
+
+        Returns:
+            str: Output SMILES string
+        """
+        rdmol = Chem.MolFromSmiles(smiles, sanitize=False)  # type: ignore
+        if rdmol is None:
+            raise ValueError(f"Invalid SMILES input '{smiles}'")
+        rdmol1 = self._uncharger.uncharge(rdmol)
+        return Chem.MolToSmiles(rdmol1)  # type: ignore
+
+    def standardize_reaction(self, smiles: str) -> str:
+        """Standardize reactions as SMILES/SMARTS strings.
+
+        Args:
+            smiles (str): Input SMILES/SMARTS string
+
+        Returns:
+            str: Output SMILES/SMARTS string
+        """
+        rdrxn = AllChem.ReactionFromSmarts(smiles, useSmiles=True)  # type: ignore
+        rdrxn1 = AllChem.ChemicalReaction()  # type: ignore
+
+        # Remove all explicit protons from the reaction
+        reactant_total_charge = 0
+        product_total_charge = 0
+        for rdmol in rdrxn.GetReactants():
+            smiles1 = Chem.MolToSmiles(rdmol, canonical=False)  # type: ignore
+            if smiles1 != "[H+]":
+                smiles2 = self.standardize_molecule(smiles1)
+                rdmol1 = Chem.MolFromSmiles(smiles2, sanitize=False)  # type: ignore
+                reactant_total_charge += Chem.GetFormalCharge(rdmol1)  # type: ignore
+                rdrxn1.AddReactantTemplate(rdmol1)
+        for rdmol in rdrxn.GetProducts():
+            smiles1 = Chem.MolToSmiles(rdmol, canonical=False)  # type: ignore
+            if smiles1 != "[H+]":
+                smiles2 = self.standardize_molecule(smiles1)
+                rdmol1 = Chem.MolFromSmiles(smiles2, sanitize=False)  # type: ignore
+                product_total_charge += Chem.GetFormalCharge(rdmol1)  # type: ignore
+                rdrxn1.AddProductTemplate(rdmol1)
+
+        # Rebalance reaction with protons
+        if reactant_total_charge > product_total_charge:
+            rdmol1 = Chem.MolFromSmiles("[H+]", sanitize=False)  # type: ignore
+            for _ in range(reactant_total_charge - product_total_charge):
+                rdrxn1.AddProductTemplate(rdmol1)
+        elif product_total_charge > reactant_total_charge:
+            rdmol1 = Chem.MolFromSmiles("[H+]", sanitize=False)  # type: ignore
+            for _ in range(product_total_charge - reactant_total_charge):
+                rdrxn1.AddReactantTemplate(rdmol1)
+        return AllChem.ReactionToSmiles(rdrxn1)  # type: ignore
+
+
+class MetalStandardizer(BaseStandardizer):
+    """Standardizer for disconnecting bonds between metals and N, O, F atoms."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._disconnector = rdMolStandardize.MetalDisconnector()
+
+    def standardize_molecule(self, smiles: str) -> str:
+        """Standardize molecules as SMILES strings.
+
+        Args:
+            smiles (str): Input SMILES string
+
+        Returns:
+            str: Output SMILES string
+        """
+        rdmol = Chem.MolFromSmiles(smiles, sanitize=False)  # type: ignore
+        if rdmol is None:
+            raise ValueError(f"Invalid SMILES input '{smiles}'")
+
+        flags = Chem.SANITIZE_ALL ^ Chem.SANITIZE_PROPERTIES  # type: ignore
+        if not is_smiles_aromatic(smiles):
+            flags ^= Chem.SANITIZE_SETAROMATICITY  # type: ignore
+        Chem.SanitizeMol(rdmol, sanitizeOps=flags)  # type: ignore
+        rdmol1 = self._disconnector.Disconnect(rdmol)
+        return Chem.MolToSmiles(rdmol1)  # type: ignore
+
+
+class Standardizer(BaseStandardizer):
+    """Aggregate standardizer for molecules and reactions."""
+
+    def __init__(
+        self,
+        *,
+        standardize_hypervalent: bool = True,
+        standardize_remove_hs: bool = True,
+        standardize_kekulize: bool = False,
+        standardize_uncharge: bool = False,
+        standardize_metals: bool = True,
+    ):
+        """Initialize the standardizer.
+
+        Args:
+            standardize_hypervalent (bool): Convert double to single bonds in
+                hypervalent compounds
+            standardize_remove_hs (bool): Remove explicit hydrogen atoms
+            standardize_kekulize (bool): Kekulize aromatic compounds
+            standardize_uncharge (bool): Remove charges from molecules by
+                protonation/deprotonation
+            standardize_metals (bool): Disconnect bonds between metals and
+                N, O, F atoms
+        """
+        self._standardizers = []
+        if standardize_hypervalent:
+            self._standardizers.append(HypervalentStandardizer())
+        if standardize_remove_hs:
+            self._standardizers.append(RemoveHsStandardizer())
+        if standardize_kekulize:
+            self._standardizers.append(KekulizeStandardizer())
+        if standardize_uncharge:
+            self._standardizers.append(UnchargeStandardizer())
+        if standardize_metals:
+            self._standardizers.append(MetalStandardizer())
+
+    def standardize_molecule(self, smiles: str) -> str:
+        """Standardize molecules as SMILES strings.
+
+        Args:
+            smiles (str): Input SMILES string
+
+        Returns:
+            str: Output SMILES string
+        """
+        smiles1 = smiles
+        for standardizer in self._standardizers:
+            smiles1 = standardizer.standardize_molecule(smiles1)
+        return smiles1
+
+    def standardize_reaction(self, smiles: str) -> str:
+        """Standardize reactions as SMILES/SMARTS strings.
+
+        Args:
+            smarts (str): Input SMILES/SMARTS string
+
+        Returns:
+            str: Output SMILES/SMARTS string
+        """
+        smiles1 = smiles
+        for standardizer in self._standardizers:
+            smiles1 = standardizer.standardize_reaction(smiles1)
+        return smiles1

dayhoff_tools/chemistry/utils.py

@@ -0,0 +1,63 @@
+"""Chemistry utils for refinery."""
+
+from typing import Optional
+
+from rdkit import Chem, rdBase
+
+__all__ = ["generate_inchikey"]
+
+rdBase.DisableLog("rdApp.warning")
+rdBase.DisableLog("rdApp.error")
+
+
+def generate_inchikey(
+    s: str, rgroup_smiles: Optional[str] = None, ignore_direction: bool = False
+) -> str:
+    """Generate INChI key from SMILES or reaction SMILES string.
+       Passes exceptions to the caller.
+
+    Args:
+        s (str): SMILES or reaction SMILES
+        rgroup_smiles (Optional[str]): Replacement SMILES string for R groups (*).
+            If None, R groups raise a ValueError.
+        ignore_direction (bool, optional): Ignore direction in reaction SMILES.
+            Has no effect on SMILES. Defaults to False.
+
+    Returns:
+        str: INChI key of molecule (products>>substrates)
+    """
+
+    if ">>" in s:
+        reactants, products = s.split(">>", maxsplit=1)
+        reactants_inchikey = generate_inchikey(reactants, rgroup_smiles=rgroup_smiles)
+        products_inchikey = generate_inchikey(products, rgroup_smiles=rgroup_smiles)
+        if ignore_direction and reactants_inchikey > products_inchikey:
+            reaction_inchikey = products_inchikey + ">>" + reactants_inchikey
+        else:
+            reaction_inchikey = reactants_inchikey + ">>" + products_inchikey
+        return reaction_inchikey
+    elif "*" in s:
+        if rgroup_smiles is not None:
+            replaced_smiles = s.replace("*", rgroup_smiles)
+            if "()" in replaced_smiles:
+                replaced_smiles = replaced_smiles.replace("()", "")
+            return generate_inchikey(replaced_smiles)
+        else:
+            raise ValueError(
+                f"Found R (*) groups in SMILES string {s}. Set rgroup_smiles to replace."
+            )
+    elif s != "":
+        rdmol = None
+        try:
+            rdmol = Chem.MolFromSmiles(s, sanitize=True)  # type: ignore
+        except Exception:
+            pass
+        if rdmol is None:
+            raise ValueError(f"Invalid SMILES string {s}")
+        inchikey = Chem.MolToInchiKey(rdmol)
+        if inchikey != "":
+            return inchikey
+        else:
+            raise ValueError("Could not generate INChI key")
+    else:
+        raise ValueError("Empty SMILES string")

dayhoff_tools/cli/main.py

@@ -0,0 +1,90 @@
+"""Entry file for the CLI, which aggregates and aliases all commands."""
+
+import typer
+from dayhoff_tools.cli.utility_commands import (
+    add_to_warehouse_typer,
+    build_and_upload_wheel,
+    delete_local_branch,
+    get_ancestry,
+    import_from_warehouse_typer,
+    rebuild_devcontainer_file,
+    test_github_actions_locally,
+)
+
+app = typer.Typer()
+
+# Utility commands
+app.command("clean")(delete_local_branch)
+app.command("gha")(test_github_actions_locally)
+app.command("rebuild")(rebuild_devcontainer_file)
+app.command("wadd")(add_to_warehouse_typer)
+app.command("wancestry")(get_ancestry)
+app.command("wheel")(build_and_upload_wheel)
+app.command("wimport")(import_from_warehouse_typer)
+
+
+# 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(
+    mode: str = typer.Argument(help="Deployment mode. Options: local, shell, batch"),
+    config_path: str = typer.Argument(help="Path to the YAML configuration file"),
+):
+    """Unified deployment command."""
+    from dayhoff_tools.deployment.base import deploy
+
+    deploy(mode, config_path)
+
+
+@app.command("job")
+def run_job_command(
+    mode: str = typer.Argument(
+        default="setup_and_execute",
+        help="Mode to run in: setup (setup only), execute (execute only), or setup_and_execute (both)",
+    )
+):
+    """Run a job."""
+    from dayhoff_tools.deployment.job_runner import run_job
+
+    run_job(mode)
+
+
+if __name__ == "__main__":
+    app()

dayhoff_tools/cli/swarm_commands.py

@@ -0,0 +1,156 @@
+"""CLI commands specific for this repo."""
+
+from datetime import datetime, timedelta
+from zoneinfo import ZoneInfo
+
+import typer
+
+
+def get_firestore_collection_status(
+    firestore_collection: str = typer.Argument(),
+) -> None:
+    """Count the various statuses of items in a given collection."""
+    print(f"Checking collection: {firestore_collection}")
+
+    # Import heavy libraries inside the function
+    from dayhoff_tools.deployment.swarm import initialize_firebase
+    from firebase_admin import firestore
+
+    initialize_firebase()
+    collection = firestore.client().collection(firestore_collection)
+    docs = collection.stream()
+
+    # Instead of directly counting, we'll aggregate based on values
+    value_counts = {}
+    for doc in docs:
+        doc_data = doc.to_dict()
+        value = doc_data.get("status", None) if doc_data else None
+        if value is not None:
+            value_counts[value] = value_counts.get(value, 0) + 1
+
+    for value, count in value_counts.items():
+        typer.echo(f"status == {value}: {count}")
+
+
+def reset_failed_cards(
+    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."""
+    # Import heavy libraries inside the function
+    from dayhoff_tools.deployment.swarm import initialize_firebase
+    from firebase_admin import firestore
+    from google.cloud.firestore_v1.base_query import FieldFilter
+
+    initialize_firebase()
+    collection = firestore.client().collection(firestore_collection)
+    failed_cards = collection.where(
+        filter=FieldFilter("status", "==", old_status)
+    ).stream()
+
+    # Count the number of documents that would be changed
+    change_count = sum(1 for _ in failed_cards)
+
+    # Ask for confirmation before proceeding
+    confirmation = input(
+        f"This operation will change {change_count} documents. Do you want to continue? (Y/n): "
+    )
+    if confirmation.lower() not in ["y", "Y", ""]:
+        print("Operation cancelled.")
+        return
+
+    # Reset the failed_cards generator
+    failed_cards = collection.where(
+        filter=FieldFilter("status", "==", old_status)
+    ).stream()
+
+    reset_count = 0
+    for card in failed_cards:
+        # Make a fresh new one
+        packet_filename = card.to_dict()["packet_filename"]  # type: ignore
+        collection.document().set(
+            {
+                "status": new_status,
+                "packet_filename": packet_filename,
+                "created": datetime.now(ZoneInfo("America/Los_Angeles")),
+            }
+        )
+        reset_count += 1
+        if delete_old:
+            card.reference.delete()
+
+    print(f"Done: {reset_count} new '{new_status}' cards were created.")
+    if delete_old:
+        print(f"Done: {reset_count} '{old_status}' cards were deleted.")
+
+
+def reset_zombie_cards(
+    firestore_collection: str = typer.Option(prompt=True),
+    delete_old: bool = typer.Option(default=True, prompt=True),
+    minutes_threshold: int = typer.Option(default=20, prompt=True),
+):
+    """Find all the documents in the database with status "assigned", and "last_update"
+    older than a specified threshold, and make a new "available" document for them.
+
+    This implementation avoids requiring a composite index by filtering on the client side.
+    """
+    # Import heavy libraries inside the function
+    from dayhoff_tools.deployment.swarm import initialize_firebase
+    from firebase_admin import firestore
+    from google.cloud.firestore_v1.base_query import FieldFilter
+
+    initialize_firebase()
+    collection = firestore.client().collection(firestore_collection)
+    current_time = datetime.now(ZoneInfo("America/Los_Angeles"))
+    threshold_time = current_time - timedelta(minutes=minutes_threshold)
+
+    # First, get all documents with status "assigned"
+    assigned_cards = collection.where(
+        filter=FieldFilter("status", "==", "assigned")
+    ).stream()
+
+    # Filter client-side for those with last_update older than threshold
+    zombie_cards = []
+    for card in assigned_cards:
+        card_data = card.to_dict()
+        last_update = card_data.get(
+            "last_update"
+        )  # Note: field is "last_update", not "last_updated"
+        if last_update and last_update < threshold_time:
+            zombie_cards.append(card)
+
+    # Ask for confirmation before proceeding
+    change_count = len(zombie_cards)
+    if change_count == 0:
+        print("No zombie cards found. Nothing to do.")
+        return
+
+    confirmation = input(
+        f"This operation will reset {change_count} zombie documents. Do you want to continue? (Y/n): "
+    )
+    if confirmation.lower() not in ["y", "Y", ""]:
+        print("Operation cancelled.")
+        return
+
+    reset_count = 0
+    for card in zombie_cards:
+        # Make a fresh new one
+        card_data = card.to_dict()
+        packet_filename = card_data["packet_filename"]
+        collection.document().set(
+            {
+                "status": "available",
+                "packet_filename": packet_filename,
+                "created": current_time,
+            }
+        )
+        reset_count += 1
+        if delete_old:
+            card.reference.delete()
+
+    print(f"Done: {reset_count} new 'available' cards were created.")
+    if delete_old:
+        print(f"Done: {reset_count} 'assigned' zombie cards were deleted.")