reporting

Author: alongd

arc/level/reporting.py

@@ -322,13 +322,36 @@ def _toc_cell(sections: list[SpeciesSection]):
 
 _SETUP_SOURCE = '''\
 # Shared setup — imports + helpers used by every species/TS section below.
+import os as _os
+
+import arc.common as arc_common
 import arc.parser.parser as arc_parser
 from arc.constants import E_h_kJmol
 from arc.level.protocol import CompositeProtocol
 
 # Accumulates per-section results so the Project summary can aggregate them.
 _RESULTS = {}
 
+# Determine the project directory from this notebook's location at runtime.
+# Notebook lives at ``<project>/output/sp_composite.ipynb``, so the project
+# directory is the parent of the notebook's directory. Jupyter / VS Code run
+# kernels with the notebook file's directory as cwd, so ``os.getcwd()``
+# resolves to ``<project>/output/`` and its parent is what we need.
+_NB_PROJECT_DIRECTORY = _os.path.dirname(_os.path.abspath(_os.curdir))
+
+
+def _resolve_path(p):
+    """Rebase a stored absolute path on the current project directory.
+
+    When the project folder is moved (or this notebook is opened on a different
+    machine), the originally-stored absolute paths under
+    ``<project>/calcs/Species/...`` and ``<project>/calcs/TSs/...`` no longer
+    point anywhere. ``arc.common.globalize_path`` recognises those prefixes and
+    rewrites the leading project-directory portion to match the current
+    notebook location. No-op when the project hasn't moved.
+    """
+    return arc_common.globalize_path(p, _NB_PROJECT_DIRECTORY)
+
 
 def _format_breakdown(protocol, energies_kJmol):
     """Render a fixed-width per-term breakdown table as a string."""
@@ -405,26 +428,28 @@ def _recipe_code(section: SpeciesSection) -> str:
 
 
 def _paths_code(section: SpeciesSection, notebook_dir: str) -> str:
+    """Render the per-section ``paths`` dict as a code-cell source.
+
+    Each value is wrapped in ``_resolve_path(...)`` (defined in the shared
+    setup cell, which calls ``arc.common.globalize_path``) so absolute paths
+    pointing under ``<project>/calcs/Species|TSs/`` get auto-rebased when the
+    project directory is moved or the notebook is opened on a different
+    machine. Paths that don't match those prefixes flow through unchanged.
+
+    The ``notebook_dir`` parameter is kept on the signature for API stability
+    (callers in the writer pass it positionally) but is no longer used to
+    pre-render relative paths — runtime rebase via ``_resolve_path`` is more
+    robust because it handles moves the relative-path approach can't (e.g.,
+    paths outside the project tree, paths whose relative offset to the
+    notebook changes when the project tree is restructured).
+    """
+    del notebook_dir  # no longer used; kept on the signature for API stability
     entries = []
     for sub_label, abs_path in sorted(section.sub_job_paths.items()):
-        rendered = _render_path(abs_path, notebook_dir)
-        entries.append(f"    {sub_label!r}: {rendered!r},")
+        entries.append(f"    {sub_label!r}: _resolve_path({abs_path!r}),")
     return "paths = {\n" + "\n".join(entries) + "\n}"
 
 
-def _render_path(abs_path: str, notebook_dir: str) -> str:
-    """Render ``abs_path`` relative to ``notebook_dir`` if under it, else absolute."""
-    try:
-        common = os.path.commonpath([os.path.abspath(abs_path),
-                                     os.path.abspath(notebook_dir)])
-    except ValueError:
-        return abs_path
-    if common == os.path.abspath(notebook_dir):
-        rel = os.path.relpath(abs_path, notebook_dir)
-        return rel if rel.startswith((".", os.sep)) else f"./{rel}"
-    return abs_path
-
-
 def _parse_code(section: SpeciesSection) -> str:
     return (
         "# Parse the electronic energy from each sub-job's QM output file.\n"

arc/level/reporting_test.py

@@ -299,17 +299,32 @@ def test_section_markdown_includes_formula(self):
 
     # --- path rendering ----------------------------------------------------- #
 
-    def test_paths_rendered_relative_when_under_notebook_dir(self):
+    def test_paths_kept_absolute_and_wrapped_in_resolve_path(self):
+        """Absolute paths survive into the paths-dict cell and each is wrapped
+        in ``_resolve_path(...)`` so they're rebased through
+        ``arc.common.globalize_path`` at notebook execution time. This makes
+        the notebook robust to the user moving the project directory or
+        running on a different machine — paths under ``<project>/calcs/Species/``
+        or ``<project>/calcs/TSs/`` get auto-rebased to the new project root."""
         write_composite_notebook(**self.kwargs)
         paths_cell = next(c for c in self._cells()
                           if c.cell_type == "code" and "paths = " in c.source
                           and "parse_e_elect" not in c.source)
-        # Relative paths should start with './' and not have the tmp absolute prefix.
-        self.assertNotIn(self.tmp, paths_cell.source)
-        self.assertIn("./base.out", paths_cell.source)
-
-    def test_paths_rendered_absolute_when_outside(self):
-        # A path outside the notebook dir must appear as absolute.
+        # Each path value must be wrapped in _resolve_path(...).
+        self.assertIn("_resolve_path(", paths_cell.source)
+        # Paths are stored as absolute strings so globalize_path can recognise
+        # the project-directory prefix and rewrite it. The rewrite is a no-op
+        # if the project hasn't moved.
+        self.assertIn(self.base_path, paths_cell.source)
+        self.assertIn(self.hi_path, paths_cell.source)
+        self.assertIn(self.lo_path, paths_cell.source)
+
+    def test_paths_outside_project_survive_resolve_unchanged(self):
+        """Paths that don't match the ``/calcs/Species|TSs/`` pattern flow
+        through ``globalize_path`` unchanged (it only rebases project-tree
+        QM-output paths). They must still appear as absolutes wrapped in
+        ``_resolve_path(...)`` — the notebook can't pre-judge what's
+        inside vs outside the project."""
         outside_dir = tempfile.mkdtemp()
         outside_path = os.path.join(outside_dir, "far.out")
         _write_gaussian_fixture(outside_path, -1.0)
@@ -325,10 +340,26 @@ def test_paths_rendered_absolute_when_outside(self):
                               if c.cell_type == "code" and "paths = " in c.source
                               and "parse_e_elect" not in c.source)
             self.assertIn(outside_path, paths_cell.source)
+            self.assertIn("_resolve_path(", paths_cell.source)
         finally:
             os.unlink(outside_path)
             os.rmdir(outside_dir)
 
+    def test_setup_cell_defines_resolve_path_and_imports_arc_common(self):
+        """The setup cell must define ``_resolve_path`` and import
+        ``arc.common`` so the per-section paths-dict cells can call
+        ``_resolve_path(...)`` on each absolute path."""
+        write_composite_notebook(**self.kwargs)
+        # Setup cell is the first code cell after the title/banner markdown.
+        setup_cells = [c for c in self._cells()
+                       if c.cell_type == "code" and "_resolve_path" in c.source]
+        self.assertGreaterEqual(len(setup_cells), 1,
+                                "Expected at least one code cell defining _resolve_path.")
+        setup_src = setup_cells[0].source
+        self.assertIn("arc.common", setup_src)
+        self.assertIn("globalize_path", setup_src)
+        self.assertIn("def _resolve_path", setup_src)
+
     # --- determinism -------------------------------------------------------- #
 
     def test_deterministic_byte_identical_across_runs(self):