AutoREACTER v0.3: Functional group detection refactor and reaction library expansion

AutoREACTER/__init__.py

@@ -3,7 +3,7 @@
 
 AutoREACTER is a tool for automated reaction-based molecular system generation.
 """
-__version__ = "0.2.3"
+__version__ = "0.3"
 
 __title__ = "AutoREACTER"
 __author__ = "Janitha Mahanthe, Jacob Gissinger"
@@ -304,6 +304,7 @@ def process() -> None:
     "__authors__",
     "__license__",
     "run",
+    "session",
     "show_molecules",
     "show_functional_groups",
     "show_reactions",
@@ -313,4 +314,4 @@ def process() -> None:
     "prepare_reactions",
     "show_reaction_templates",
     "process",
-]
+]

AutoREACTER/arx_cli.py

@@ -14,6 +14,7 @@
 from contextlib import contextmanager
 import os
 from pathlib import Path
+import shutil
 import sys
 import threading
 from PIL import Image
@@ -30,6 +31,9 @@
 from AutoREACTER.reaction_preparation.ff_wrapper.REACTER_files_builder import REACTERFilesBuilder
 from AutoREACTER.sim_setup.simulation_setup import SimulationSetupManager
 
+class NoReactionGenerated(Exception):
+    """Custom exception raised when no reaction is generated in the pipeline.""" 
+    pass
 
 class ErrorHandler:
     """
@@ -98,7 +102,8 @@ def __init__(self, input: Path) -> None:
         self.img_dir = self.session.images_dir
         # with open(self.session.output_dir / "AutoREACTER.log", 'w') as f:
         #     f.write("--- Starting AutoREACTER Session ---\n")
-
+        # Save a copy of the input JSON to the output directory
+        self._save_input_json(abs_path)
         # Save an initial grid image of all monomers
         self._save_rdkit_img(
             InputParser().initial_molecules_image_grid(self.session),
@@ -241,14 +246,6 @@ def prepare_reactions(self) -> None:
         """
         PrepareReactions(self.session).prepare_reactions(self.session)
         self.error_handler["process"] = True
-        highlight_types = ["template", "edge", "initiators", "delete"]
-        for highlight_type in highlight_types:
-            img = PrepareReactions(self.session).reaction_templates_highlighted_image_grid(
-                self.session, highlight_type=highlight_type
-            )
-            self._save_rdkit_img(
-                img, self.img_dir / f"templates_{highlight_type}.png"
-            )
         return None
 
     def show_reaction_templates(self, highlight_type: str = "template") -> Image:
@@ -311,9 +308,24 @@ def process(self):
 
             SimulationSetupManager().setup_and_write_simulation(self.session)
 
+            highlight_types = ["template", "edge", "initiators", "delete"]
+            for highlight_type in highlight_types:
+                img = PrepareReactions(self.session).reaction_templates_highlighted_image_grid(
+                    self.session, highlight_type=highlight_type
+                )
+                self._save_rdkit_img(
+                    img, self.img_dir / f"templates_{highlight_type}.png"
+                )
+
+            self.error_handler["process"] = True
+
     # ------------------------------------------------------------------
     # Internal helpers – lazy detection & image saving
     # ------------------------------------------------------------------
+    def _save_input_json(self, abs_path: Path): 
+            destination_file = "input.json"
+            destination_path = self.session.output_dir / destination_file
+            shutil.copy(abs_path, destination_path)
 
     def _ensure_fg_detected(self):
         """
@@ -384,7 +396,10 @@ def _save_rdkit_img(self, img, path: Path, is_non_reactant: bool = False):
         if img is None:
             if is_non_reactant:
                 return
-            raise ValueError("No image was generated. Cannot save molecule image.")
+            raise NoReactionGenerated(
+                "No reaction was generated. This is an error from AutoREACTER. "
+                "Please file an issue on https://github.com/NanoCIPHER-Lab/AutoREACTER/issues to improve the software."
+            )
 
         # Case 1: PIL image
         if hasattr(img, "save"):
@@ -430,59 +445,160 @@ def _writer(self, filename="AutoREACTER.log"):
         self.session.output_dir.mkdir(parents=True, exist_ok=True)
         log_path = self.session.output_dir / filename
 
-        # 1. Save the original OS-level terminal output
+        # Save both Python's stdout object and the original OS-level stdout.
+        #
+        # These are not always the same destination. For example, pytest,
+        # Jupyter, and other environments may replace sys.stdout with their
+        # own wrapper while file descriptor 1 still exists separately.
+        original_stdout = sys.stdout
         original_stdout_fd = os.dup(1)
 
-        # 2. Create an OS-level pipe (a temporary tunnel for our data)
+        # Create an OS-level pipe. Both Python print() output and raw fd-1
+        # output will be redirected into this pipe.
         pipe_read_fd, pipe_write_fd = os.pipe()
 
+        redirected_stdout = None
+
+        def write_to_original_stdout(data: bytes) -> None:
+            """
+            Forward captured output back to the original visible stdout.
+
+            If the original Python stdout directly represents fd 1, write to
+            the saved duplicate of fd 1. Otherwise, use the original Python
+            stdout object so capture systems such as pytest/Jupyter still see
+            the output.
+            """
+            try:
+                original_fileno = original_stdout.fileno()
+            except (AttributeError, OSError, ValueError):
+                original_fileno = None
+
+            if original_fileno == 1:
+                os.write(original_stdout_fd, data)
+                return
+
+            text = data.decode(
+                "utf-8",
+                errors="replace",
+            )
+
+            original_stdout.write(text)
+            original_stdout.flush()
+
         def tee_thread():
-            """Background worker that reads the pipe and writes to both destinations."""
-            with open(log_path, 'a') as log_file:
+            """
+            Background worker that reads the pipe and writes to both
+            the original output destination and the log file.
+            """
+            with open(
+                log_path,
+                "a",
+                encoding="utf-8",
+            ) as log_file:
                 while True:
                     # Read incoming data from the pipe
-                    data = os.read(pipe_read_fd, 1024)
-
+                    data = os.read(
+                        pipe_read_fd,
+                        1024,
+                    )
+
                     # If the pipe is closed, stop the thread
                     if not data:
                         break
-
-                    # Write to the actual terminal
-                    os.write(original_stdout_fd, data)
-
+
+                    # Write to the original terminal / stdout capture
+                    write_to_original_stdout(
+                        data
+                    )
+
                     # Write to the log file
-                    log_file.write(data.decode('utf-8', errors='replace'))
+                    log_file.write(
+                        data.decode(
+                            "utf-8",
+                            errors="replace",
+                        )
+                    )
                     log_file.flush()
 
-        # 3. Start the background thread
-        thread = threading.Thread(target=tee_thread)
+        # Start the background tee worker
+        thread = threading.Thread(
+            target=tee_thread
+        )
         thread.start()
 
-        # Flush Python's buffers before we switch the tracks
-        sys.stdout.flush()
+        # Flush Python's current stdout before changing destinations
+        original_stdout.flush()
 
         try:
-            # 4. Redirect all OS-level output to the write-end of our pipe
-            os.dup2(pipe_write_fd, 1)
+            # Redirect OS-level stdout (fd 1) into the pipe.
+            #
+            # This captures subprocess output, os.write(1, ...), native
+            # library output, and anything else that writes directly to
+            # standard output.
+            os.dup2(
+                pipe_write_fd,
+                1,
+            )
+
+            # Redirect Python's sys.stdout explicitly as well.
+            #
+            # This is necessary because environments such as pytest and
+            # Jupyter can replace sys.stdout with an object that does not
+            # automatically follow changes made to file descriptor 1.
+            redirected_stdout = os.fdopen(
+                os.dup(1),
+                "w",
+                buffering=1,
+                encoding=getattr(
+                    original_stdout,
+                    "encoding",
+                    None,
+                )
+                or "utf-8",
+                errors="replace",
+            )
+
+            sys.stdout = redirected_stdout
+
             yield
-            
+
         finally:
-            # Flush Python buffers one last time
-            sys.stdout.flush()
-
-            # 5. Restore the original terminal output
-            os.dup2(original_stdout_fd, 1)
-
-            # 6. Close the write end of the pipe (this tells the thread to stop)
-            os.close(pipe_write_fd)
-
-            # 7. Wait for the thread to finish processing the last bits of data
+            # Flush all pending Python output into the pipe
+            if redirected_stdout is not None:
+                redirected_stdout.flush()
+
+            # Restore Python's original stdout object first
+            sys.stdout = original_stdout
+
+            # Close the duplicated Python pipe writer
+            if redirected_stdout is not None:
+                redirected_stdout.close()
+
+            # Restore OS-level stdout
+            os.dup2(
+                original_stdout_fd,
+                1,
+            )
+
+            # Close the original pipe write descriptor.
+            #
+            # Once every write descriptor pointing at the pipe is closed,
+            # the background thread receives EOF and exits.
+            os.close(
+                pipe_write_fd
+            )
+
+            # Wait until the final buffered output has been copied
             thread.join()
-
-            # 8. Clean up remaining file descriptors
-            os.close(pipe_read_fd)
-            os.close(original_stdout_fd)
 
+            # Clean up remaining file descriptors
+            os.close(
+                pipe_read_fd
+            )
+
+            os.close(
+                original_stdout_fd
+            )
     # ------------------------------------------------------------------
     # Magic Methods
     # ------------------------------------------------------------------

AutoREACTER/cache.py

@@ -21,7 +21,9 @@ def __init__(self, clear_staging: bool = True):
         # generate a unique staging directory for this run to prevent concurrent conflicts
         self.staging_dir = Path(tempfile.gettempdir()) / f"AutoREACTER_staging"
         self.staging_dir.mkdir(parents=True, exist_ok=True)
-        self.clear_staging_dir()
+
+        if clear_staging:
+            self.clear_staging_dir()
 
     def clear_staging_dir(self) -> None:
         """