AutoREACTER 0.2b1__tar.gz → 0.2.2__tar.gz

{autoreacter-0.2b1 → autoreacter-0.2.2}/AutoREACTER/__init__.py

@@ -5,13 +5,13 @@ Automated generation of LAMMPS/REACTER-ready reaction templates
 for polymerization workflows.
 """
 
-__version__ = "0.3.0b1"
+__version__ = "0.2.2b1"
 
 from .input_parser import (
     InputParser,
     SimulationSetup,
     MonomerEntry,
-    Replica,
+    Simulation,
     InputError,
     InputSchemaError,
     InputConflictError,

autoreacter-0.2.2/AutoREACTER/_compat.py

@@ -0,0 +1,60 @@
+import sys
+import collections
+import collections.abc
+import numpy as np
+
+def apply_legacy_patches():
+    """
+    Injects removed aliases back into numpy and collections at runtime, 
+    and bridges the OpenMM simtk namespace for older versions of Foyer/mBuild.
+    """
+    # 1. Restore removed Collections aliases
+    _missing_classes = [
+        "MutableSet", "MutableMapping", "Mapping", "MutableSequence",
+        "Sequence", "Set", "Iterable", "Iterator", "Callable",
+        "Container", "Hashable", "ItemsView", "KeysView", "ValuesView"
+    ]
+    for _name in _missing_classes:
+        if not hasattr(collections, _name) and hasattr(collections.abc, _name):
+            setattr(collections, _name, getattr(collections.abc, _name))
+
+    # 2. Restore removed NumPy aliases
+    if not hasattr(np, "float"): np.float = float
+    if not hasattr(np, "int"): np.int = int
+    if not hasattr(np, "complex"): np.complex = complex
+    if not hasattr(np, "bool"): np.bool = np.bool_
+    if not hasattr(np, "object"): np.object = np.object_
+    if not hasattr(np, "str"): np.str = np.str_
+
+    # 3. Robust OpenMM 'simtk' shim for Python 3.12+
+    try:
+        import sys
+        import types
+        import openmm
+        import openmm.app
+        import openmm.app.element
+        import openmm.unit
+
+        # Create pure, fake modules to bypass strict filesystem import checks
+        simtk = types.ModuleType("simtk")
+        simtk_openmm = types.ModuleType("simtk.openmm")
+        simtk_openmm_app = types.ModuleType("simtk.openmm.app")
+
+        # Copy the contents of the real modules into our fake ones
+        simtk_openmm.__dict__.update(openmm.__dict__)
+        simtk_openmm_app.__dict__.update(openmm.app.__dict__)
+        
+        # Manually wire the internal tree together
+        simtk.openmm = simtk_openmm
+        simtk.unit = openmm.unit
+        simtk_openmm.app = simtk_openmm_app
+        simtk_openmm_app.element = openmm.app.element
+
+        # Register them in sys.modules so the 'import' statements find them instantly
+        sys.modules["simtk"] = simtk
+        sys.modules["simtk.openmm"] = simtk_openmm
+        sys.modules["simtk.openmm.app"] = simtk_openmm_app
+        sys.modules["simtk.openmm.app.element"] = openmm.app.element
+        sys.modules["simtk.unit"] = openmm.unit
+    except ImportError:
+        pass

autoreacter-0.2.2/AutoREACTER/cache.py

@@ -0,0 +1,155 @@
+from pathlib import Path
+import shutil
+import tempfile
+import uuid
+from AutoREACTER.reaction_preparation.ff_wrapper.REACTER_files_builder import REACTERFiles
+
+
+class GetCacheDir:
+    def __init__(self, clear_staging: bool = True):
+        """
+        Initializes the cache manager.
+        
+        Args:
+            clear_staging: 
+                If True, clear all contents inside the staging directory.
+                The staging directory itself is preserved.
+        """
+        # Generate a unique staging directory for this run to prevent concurrent conflicts
+        run_id = uuid.uuid4().hex[:8]
+        # self.staging_dir = Path(tempfile.gettempdir()) / f"AutoREACTER_staging_{run_id}"
+        self.staging_dir = Path(tempfile.gettempdir()) / f"AutoREACTER_staging"
+        self.staging_dir.mkdir(parents=True, exist_ok=True)
+        self.clear_staging_dir()
+
+    def clear_staging_dir(self) -> None:
+        """
+        Clear all files and folders inside the staging cache directory.
+
+        This only clears the temporary staging directory 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}")
+
+
+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 remove_path(self, path: Path) -> None:
+        """
+        Remove a file, symlink, or directory recursively.
+        """
+        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
+