AutoREACTER 0.2b1__py3-none-any.whl

AutoREACTER/__init__.py

@@ -0,0 +1,46 @@
+"""
+AutoREACTER
+
+Automated generation of LAMMPS/REACTER-ready reaction templates
+for polymerization workflows.
+"""
+
+__version__ = "0.3.0b1"
+
+from .input_parser import (
+    InputParser,
+    SimulationSetup,
+    MonomerEntry,
+    Replica,
+    InputError,
+    InputSchemaError,
+    InputConflictError,
+    NumericFieldError,
+    SmilesValidationError,
+    DuplicateMonomerError,
+)
+
+from .detectors.functional_groups_detector import (
+    FunctionalGroupsDetector,
+    FunctionalGroupInfo,
+    MonomerRole,
+    FunctionalGroupVisualization,
+)
+
+__all__ = [
+    "__version__",
+    "InputParser",
+    "SimulationSetup",
+    "MonomerEntry",
+    "Replica",
+    "InputError",
+    "InputSchemaError",
+    "InputConflictError",
+    "NumericFieldError",
+    "SmilesValidationError",
+    "DuplicateMonomerError",
+    "FunctionalGroupsDetector",
+    "FunctionalGroupInfo",
+    "MonomerRole",
+    "FunctionalGroupVisualization",
+]

AutoREACTER/cache.py

@@ -0,0 +1,300 @@
+from pathlib import Path
+import os
+import re
+import shutil
+import subprocess
+import datetime as dt
+from AutoREACTER.reaction_preparation.lunar_client.REACTER_files_builder import REACTERFiles
+
+class GetCacheDir:
+    """
+    Manages the base cache directory for the AutoREACTER workflow.
+    
+    This class determines the root of the git repository (or falls back to a
+    path relative to the script) and creates a standardized cache directory
+    structure with a staging area.
+    """
+
+    def __init__(self, clear_staging: bool = False):
+        """
+        Initialize cache directory structure.
+
+        Args:
+            clear_staging:
+                If True, clear all contents inside cache/00_cache.
+                The 00_cache directory itself is preserved.
+        """
+        self.git_root = self.get_git_root()
+        self.cache_base_dir = self.git_root / "cache"
+        self.cache_base_dir.mkdir(parents=True, exist_ok=True)
+
+        # Staging directory for temporary files before moving to dated run folders
+        self.staging_dir = self.cache_base_dir / "00_cache"
+        self.staging_dir.mkdir(parents=True, exist_ok=True)
+
+        if clear_staging:
+            self.clear_staging_dir()
+
+    def clear_staging_dir(self) -> None:
+        """
+        Clear all files and folders inside the staging cache directory.
+
+        This only clears cache/00_cache contents.
+        It does not delete dated run folders.
+        """
+        self.staging_dir.mkdir(parents=True, exist_ok=True)
+
+        failed = []
+        for item in self.staging_dir.iterdir():
+            try:
+                if item.is_symlink() or item.is_file():
+                    item.unlink()
+                elif item.is_dir():
+                    shutil.rmtree(item)
+            except Exception as e:
+                print(f"[WARN] Failed to remove staging cache item {item}: {e}")
+                failed.append(item)
+
+        if failed:
+            print(f"[WARN] Staging cache partially cleared ({len(failed)} item(s) could not be removed): {self.staging_dir}")
+        else:
+            print(f"[OK] Cleared staging cache: {self.staging_dir}")
+
+    def get_git_root(self) -> Path:
+        """
+        Return the root directory of the current git repository.
+        
+        Falls back to a path derived from this script's location if git
+        command fails.
+        """
+        try:
+            out = subprocess.check_output(
+                ["git", "rev-parse", "--show-toplevel"],
+                text=True
+            ).strip()
+            return Path(out)
+        except Exception:
+            script_dir = Path(__file__).resolve().parent
+        
+            for parent in [script_dir] + list(script_dir.parents):
+                if (parent / ".git").exists() or (parent / "pyproject.toml").exists():
+                    return parent
+        
+            return script_dir.parent
+
+
+class RunDirectoryManager:
+    """
+    Handles creation and management of dated run directories for simulations.
+    
+    Organizes output into a structure like: cache/YYYY-MM-DD/1/, cache/YYYY-MM-DD/2/, etc.
+    Provides utilities for moving files and updating REACTER file references.
+    """
+
+    def __init__(self, base_dir: Path):
+        """
+        Initialize with a base directory for storing run folders.
+        
+        Args:
+            base_dir: Base path where dated run directories will be created
+        """
+        self.base_dir = Path(base_dir)
+        self.base_dir.mkdir(parents=True, exist_ok=True)
+
+    def _is_empty(self, path: Path) -> bool:
+        """Check if a directory contains no files or subdirectories."""
+        return not any(path.iterdir())
+
+    def make_dated_run_dir(self) -> Path:
+        """
+        Create and return a dated run directory following the pattern: {base}/{today}/{run_number}.
+        
+        Reuses the latest run directory if it is empty. Otherwise, increments the run number.
+        
+        Returns:
+            Path: Path to the final run directory
+        """
+        today = dt.date.today().isoformat()
+        date_dir = self.base_dir / today
+        date_dir.mkdir(parents=True, exist_ok=True)
+
+        # Find existing run numbers (directories named with integers)
+        existing_runs = [
+            int(p.name) for p in date_dir.iterdir()
+            if p.is_dir() and p.name.isdigit()
+        ]
+
+        if existing_runs:
+            latest_run = date_dir / str(max(existing_runs))
+            if self._is_empty(latest_run):
+                print(f"[INFO] Final directory: {latest_run}")
+                return latest_run
+
+        # Create new run directory with incremented number
+        run_number = max(existing_runs, default=0) + 1
+        run_dir = date_dir / str(run_number)
+        run_dir.mkdir()
+
+        print(f"[INFO] Final directory: {run_dir}")
+        return run_dir
+
+    def remove_path(self, path: Path) -> None:
+        """
+        Remove a file, symlink, or directory recursively.
+        
+        Args:
+            path: Path to remove
+        """
+        if path.is_symlink() or path.is_file():
+            path.unlink()
+        elif path.is_dir():
+            shutil.rmtree(path)
+
+    def move_into_run(self, source_dir: Path, dest_dir: Path) -> Path:
+        """
+        Move all contents from source_dir into dest_dir, overwriting if necessary.
+        
+        Args:
+            source_dir: Directory containing files to move
+            dest_dir: Destination run directory
+            
+        Returns:
+            Path: The destination directory
+        """
+        for item in source_dir.iterdir():
+            target = dest_dir / item.name
+
+            if target.exists():
+                self.remove_path(target)
+
+            shutil.move(str(item), str(target))
+
+        print(f"[OK] Moved files → {dest_dir}")
+        return dest_dir
+
+    def move_reacter_files(
+        self, 
+        reacter_files: REACTERFiles, 
+        staging_dir: Path, 
+        final_dir: Path
+    ) -> REACTERFiles:
+        """
+        Move REACTER-related files from staging area into the final run directory
+        and update all internal Path references in the REACTERFiles object.
+        
+        Args:
+            reacter_files: REACTERFiles object containing various file paths
+            staging_dir: Current staging directory (usually .../00_cache)
+            final_dir: Target run directory
+            
+        Returns:
+            REACTERFiles: Updated object with remapped paths
+            
+        Raises:
+            FileNotFoundError: If the expected REACTER files directory doesn't exist
+        """
+        old_base = staging_dir / "lunar" / "REACTER_files"
+
+        if not old_base.exists():
+            raise FileNotFoundError(f"REACTER files not found: {old_base}")
+
+        new_base = self.move_into_run(old_base, final_dir)
+
+        def remap(p: Path) -> Path:
+            """Remap a path from old_base to new_base while preserving relative structure."""
+            try:
+                return new_base / p.relative_to(old_base)
+            except ValueError:
+                return p
+
+        # Update all file references to point to the new location
+        reacter_files.force_field_data = remap(reacter_files.force_field_data)
+        reacter_files.in_file = remap(reacter_files.in_file)
+
+        for mol in reacter_files.molecule_files:
+            mol.molecule_files.lmp_molecule_file = remap(
+                mol.molecule_files.lmp_molecule_file
+            )
+
+        for tpl in reacter_files.template_files:
+            tpl.map_file = remap(tpl.map_file)
+            tpl.pre_reaction_file.lmp_molecule_file = remap(
+                tpl.pre_reaction_file.lmp_molecule_file
+            )
+            tpl.post_reaction_file.lmp_molecule_file = remap(
+                tpl.post_reaction_file.lmp_molecule_file
+            )
+
+        print(f"[OK] REACTER files moved → {new_base}")
+        return reacter_files
+
+
+class RetentionCleanup:
+    """
+    Provides interactive cleanup functionality for old cache directories.
+    
+    Allows users to delete simulation run folders older than a chosen retention
+    period (1 week, 1 month, 3 months) or delete everything.
+    """
+
+    def __init__(self, base_dir: Path):
+        """
+        Initialize cleanup manager with target base directory.
+        
+        Args:
+            base_dir: Cache base directory to clean up
+        """
+        self.base_dir = Path(base_dir)
+
+    def run(self, mode="skip"):
+        """
+        Run the cleanup process based on the specified mode.
+        Modes are:
+            - "skip": Do not perform any cleanup
+            - "all": Delete all dated run directories
+            - int (number of days): Delete directories older than this many days
+        Args:
+            mode: Cleanup mode - "skip", int(number of days), or "all"
+        Returns:
+            None
+        """
+        print(f"\n[INFO] Cache directory: {self.base_dir}")
+
+        if mode == "skip":
+            print("[INFO] Cache cleanup skipped.")
+            return
+
+        pattern = re.compile(r"\d{4}-\d{2}-\d{2}")
+        protected = {"00_cache"}
+        
+        if mode == "all":
+            for folder in self.base_dir.iterdir():
+                if (
+                    folder.is_dir()
+                    and folder.name not in protected
+                    and pattern.match(folder.name)
+                ):
+                    shutil.rmtree(folder)
+                    print(f"[OK] Deleted: {folder}")
+            return
+
+        try:
+            days = int(mode)
+        except Exception:
+            print(f"[WARN] Invalid cleanup mode: {mode}")
+            return
+
+        cutoff = dt.date.today() - dt.timedelta(days=days)
+
+        for folder in self.base_dir.iterdir():
+            if not folder.is_dir() or folder.name == "00_cache":
+                continue
+
+            try:
+                folder_date = dt.datetime.strptime(folder.name, "%Y-%m-%d").date()
+            except ValueError:
+                continue
+
+            if folder_date < cutoff:
+                shutil.rmtree(folder)
+                print(f"[OK] Deleted: {folder}")

AutoREACTER/detectors/detector.py

@@ -0,0 +1,259 @@
+"""
+Module for detecting reactions and handling non-reactant monomers.
+
+This module provides functionality to analyze a set of input monomers, detect
+potential chemical reactions based on functional groups, and identify monomers
+that do not participate in any detected reactions. It also includes an interactive
+workflow to allow users to decide whether to retain non-reactant molecules in
+the simulation.
+"""
+
+import warnings
+import os, json
+
+if os.environ.get("AUTOREACTER_SHOW_DEPRECATION", "").lower() in {"1", "true", "yes", "on"}:
+    warnings.warn(
+        """This script is deprecated and will be modified in future versions. Within v0.2, the whole package will primaraliy 
+        support on jupyter notebook and the CLI is removed. Please use the notebook version for now and refer to the README for how to use the package.""",
+        DeprecationWarning,
+        stacklevel=2
+    )
+
+# Attempt to import detector modules. Handles different import paths depending on
+# whether the script is run as a module, part of a package, or standalone.
+try:
+    from functional_groups_detector import FunctionalGroupsDetector
+    from reaction_detector import ReactionDetector
+except (ImportError, ModuleNotFoundError):
+    from .functional_groups_detector import FunctionalGroupsDetector
+    from .reaction_detector import ReactionDetector
+
+from AutoREACTER.input_parser import MonomerEntry
+
+class Detector:
+    """
+    A class to encapsulate the reaction detection workflow.
+
+    This class provides methods to detect reactions based on input monomers and
+    to identify non-reactant monomers. It serves as a structured way to organize
+    the detection logic and can be extended in the future for additional functionality.
+    """
+    def __init__(self, input_dict: dict, interactive: bool = True):
+        """
+        Initializes the Detector with the given input dictionary.
+
+        Args:
+            input_dict (dict): A dictionary containing the 'monomers' key, which maps
+                               monomer IDs (int/str) to SMILES strings (str).
+            interactive (bool): If False, automatically retain all non-reactants without prompting.
+        """
+        self.input_dict = input_dict
+        self.reactions = {}
+        self.non_reactants_list = []
+        self.functional_groups_detector = FunctionalGroupsDetector()
+        self.reactions_detector = ReactionDetector()
+        self.reactions_dict, self.non_reactants_list, self.input_dict = self.detect_reactions(self.input_dict)
+
+    def find_non_reactant_monomers(self, reactions_dict, input_dict) -> list:
+        """
+        Identifies monomers from the input that are not participating in any detected reactions
+        and prompts the user to decide whether to retain them in the simulation.
+    Args:
+        reactions_dict (dict): A dictionary containing detected reaction data. Expected keys
+            include 'monomer_1', 'monomer_2', and 'smiles' for each reaction entry.
+        input_dict (dict): The original input dictionary containing a 'monomers' key
+            mapping monomer IDs to SMILES strings.
+        interactive (bool): If False, automatically retain all non-reactants without prompting.
+
+    Returns:
+        list: A list of SMILES strings representing the non-reactant monomers selected
+              by the user to be retained. Returns an empty list if the user chooses
+              to proceed with reactants only.
+    """
+    # 1) Collect all unique SMILES strings that participate in detected reactions
+        reactant_smiles = set()
+
+        for reaction_data in reactions_dict.values():
+            # Extract SMILES for monomer 1, monomer 2, and the reaction itself
+            for k, v in reaction_data.items():
+                if not str(k).isdigit():
+                    continue
+                if not isinstance(v, dict):
+                    continue
+
+                m1 = v.get("monomer_1", {}).get("smiles")
+                m2 = v.get("monomer_2", {}).get("smiles")
+
+                if isinstance(m1, str):
+                    reactant_smiles.add(m1)
+                if isinstance(m2, str):
+                    reactant_smiles.add(m2)
+
+        # 2) Build a dictionary of monomers that are not found in the reactant set
+        monomers = input_dict.get("monomers", {})
+        self.non_reactants = {}
+
+        # Re-index non-reactants starting from ID 1
+        new_id = 1
+        for _, smi in monomers.items():
+            if smi not in reactant_smiles:
+                self.non_reactants[new_id] = smi
+                new_id += 1
+
+        # 3) Handle user interaction if non-reactant monomers are found
+        if self.non_reactants:
+            print(
+                "\nThere are non-reactant monomers/molecules in the input.\n"
+                "There may be reactions possible with the given monomers in the user inputs,\n"
+                "but some of them are not detected for a reaction.\n"
+                "You can choose to retain some or all of these non-reactant molecules in the simulation.\n"
+                "Non-reactant molecules:"
+            )
+            # Display the list of non-reactant molecules to the user
+            for mid, molecule in self.non_reactants.items():
+                print(f"{mid}. {molecule}")
+
+            # Ask user if they want to exclude all non-reactants
+            select = input(
+                "Do you want to proceed with monomers only (no non-monomer molecules)? (y/n): "
+            ).strip().lower()
+
+            if select == "y":
+                print("Proceeding with monomers only. No non-monomer molecules will be retained.")
+                self.non_reactants_list = []  # Return empty list if user declines non-reactants
+            else:
+                # Ask user to specify which non-reactants to keep by ID
+                self.selected_non_reactants = input(
+                    "Please specify the monomer IDs (comma-separated) you wish to retain as non-monomer molecules: "
+                ).strip()
+
+                # Parse the comma-separated input into a set of IDs
+                selected_ids = {s.strip() for s in self.selected_non_reactants.split(",") if s.strip()}
+
+                # Filter the non-reactants dictionary based on user selection
+                # strings only (SMILES)
+                self.non_reactants_list = [
+                    smi
+                    for mid, smi in self.non_reactants.items()
+                    if str(mid) in selected_ids
+                ]
+
+            return self.non_reactants_list
+        
+        # Return empty list if no non-reactants were found
+        return []
+    
+    def filter_simulation_molecules(self, input_dict, non_reactants_list, reactions_dict):
+        """
+        Filters the input monomers to include only those that are part of detected reactions
+        and any non-reactant monomers that the user has chosen to retain.
+
+        Args:
+            input_dict (dict): The original input dictionary containing a 'monomers' key mapping monomer IDs to SMILES strings.
+            non_reactants_list (list): A list of SMILES strings for non-reactant monomers that the user has chosen to retain.
+            reactions_dict (dict): A dictionary containing detected reaction data.
+        Returns:
+            dict: A filtered dictionary of monomers that includes only those participating in reactions and the selected non-reactants.
+        """
+        # Collect SMILES of reactants from detected reactions
+        reactant_smiles = set()
+        for reaction_data in reactions_dict.values():
+            for k, v in reaction_data.items():
+                if not str(k).isdigit():
+                    continue
+                if not isinstance(v, dict):
+                    continue
+
+                m1 = v.get("monomer_1", {}).get("smiles")
+                m2 = v.get("monomer_2", {}).get("smiles")
+
+                if isinstance(m1, str):
+                    reactant_smiles.add(m1)
+                if isinstance(m2, str):
+                    reactant_smiles.add(m2)
+                    
+        # Combine reactant SMILES with the selected non-reactant SMILES
+        combined = reactant_smiles | set(non_reactants_list)
+
+        # Filter input monomers to include only reactants and selected non-reactants
+        monomers_dict_from_input = input_dict.get("monomers", {})
+        for k in list(monomers_dict_from_input.keys()):
+            if monomers_dict_from_input[k] not in combined:
+                del monomers_dict_from_input[k]
+                
+        # Update the input dictionary with the filtered monomers
+        input_dict["monomers"] = monomers_dict_from_input  # Update the input dictionary with the filtered monomers
+
+        return input_dict
+
+
+    def detect_reactions(self, monomer_entry: MonomerEntry, interactive=True) -> tuple:
+        """
+        Detects chemical reactions and identifies non-reactant monomers based on the provided input.
+
+        This function serves as the main workflow controller. It validates the input,
+        detects functional groups, selects appropriate reactions, and identifies any
+        monomers that did not participate in the detected reactions.
+
+        Args:
+            monomer_entry (MonomerEntry): A MonomerEntry object containing the monomers data.
+
+        Returns:
+            tuple: A tuple containing:
+                - dict: The detected reactions.
+                - list: A list of SMILES strings for non-reactant monomers to be retained.
+
+        Raises:
+            ValueError: If the input dictionary is missing the 'monomers' key or if it is empty.
+        """
+        
+        # Step 1: Detect functional groups within the monomers
+        fg_results = self.functional_groups_detector.functional_groups_detector(monomer_entry)
+
+        # Debug: Print detected functional groups
+        # print("Detected Functional Groups:", json.dumps(fg_results, indent=2))
+        
+        # Step 2: Select reactions based on the detected functional groups
+        reactions = self.reactions_detector.reaction_detector(fg_results)
+
+        # Debug: Print detected reactions
+        # print("Detected Reactions:", json.dumps(reactions, indent=2))
+
+        # Print detected reactions
+        print("\nDetected Reactions:")
+        for reaction_name, reaction_data in reactions.items():
+            print(f"\n{reaction_name}:")
+            monomer_1 = reaction_data.get("reactant_1", {})
+            monomer_2 = reaction_data.get("reactant_2", {})
+            if monomer_2:
+                print(f"Reaction between {monomer_1} and {monomer_2}")
+            else:
+                print(f"Reaction involving {monomer_1}")
+                
+        # Step 3: Identify and handle monomers that are not part of any detected reaction
+        non_reactants_list = self.find_non_reactant_monomers(reactions, self.input_dict)
+
+        # Update the input dictionary to include only reactants and selected non-reactants
+        self.input_dict = self.filter_simulation_molecules(self.input_dict, non_reactants_list, reactions)
+        
+        return reactions, non_reactants_list , self.input_dict
+
+
+if __name__ == "__main__":
+    # Example usage of the module with sample monomer data
+    sample_inputs = {
+        "monomers": {
+            1: "ClC(=O)c1cc(cc(c1)C(Cl)=O)C(Cl)=O",  # Example monomer 1 - Trimesoyl chloride (TMC)
+            2: "C1=CC(=CC(=C1)N)N",                  # Example monomer 2 - m-Phenylenediamine (MPD)
+            3: "CCO",                                # Example Non - monomer - Ethanol                       
+        }
+    }
+    
+    # Run the detection workflow
+    detector = Detector(sample_inputs)
+    print("Detected Reactions:", json.dumps(detector.reactions_dict, indent=2))
+    # Output results
+    print("Detected Reactions:", json.dumps(detector.reactions_dict, indent=2))
+    if detector.non_reactants_list:
+        print("Non-monomer molecules to retain:", detector.non_reactants_list)
+    print("Filtered Input Dictionary for Simulation:", json.dumps(detector.input_dict, indent=2))