Added a Linear TS search job adapter

.github/workflows/ci.yml

@@ -23,21 +23,21 @@ jobs:
           path: ARC
 
       - name: Clean Ubuntu Image
-        uses: jlumbroso/free-disk-space@main
+        uses: jlumbroso/free-disk-space@v1.3.1
         with:
           tool-cache: true
           android: true
           dotnet: true
           haskell: true
           large-packages: true
-          swap-storage: true
+          swap-storage: false
 
       - name: Set up micromamba (arc_env)
         uses: mamba-org/setup-micromamba@v3
         with:
           environment-name: arc_env
           environment-file: ARC/environment.yml
-          cache-environment: true
+          cache-environment: false
           cache-downloads: true
           generate-run-shell: true
 
@@ -102,7 +102,7 @@ jobs:
         run: |
           echo "Running Unit Tests..."
           export PYTHONPATH="${{ github.workspace }}/AutoTST:${{ github.workspace }}/KinBot:$PYTHONPATH"
-          pytest arc/ --cov --cov-report=xml -ra -vv -n auto
+          pytest arc/ --cov --cov-report=xml -ra -vv -n 4 --dist worksteal -m "not slow"
 
       - name: Run Functional Tests
         shell: micromamba-shell {0}
@@ -113,7 +113,7 @@ jobs:
         run: |
           echo "Running Functional Tests from $(pwd)..."
           export PYTHONPATH="${{ github.workspace }}/AutoTST:${{ github.workspace }}/KinBot:$PYTHONPATH"
-          pytest functional/ --cov --cov-append --cov-report=xml -ra -vv -n auto
+          pytest functional/ --cov --cov-append --cov-report=xml -ra -vv -n 4 --dist worksteal
 
       - name: Upload coverage data
         uses: codecov/codecov-action@v6

.github/workflows/nightly.yml

@@ -0,0 +1,99 @@
+name: Nightly (Slow Tests)
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '0 6 * * *'
+
+jobs:
+  nightly-slow-tests:
+    name: Nightly Unit Tests (including slow)
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash -el {0}
+
+    steps:
+      - name: Checkout ARC
+        uses: actions/checkout@v6
+        with:
+          ref: main
+          path: ARC
+
+      - name: Clean Ubuntu Image
+        uses: jlumbroso/free-disk-space@v1.3.1
+        with:
+          tool-cache: true
+          android: true
+          dotnet: true
+          haskell: true
+          large-packages: true
+          swap-storage: false
+
+      - name: Set up micromamba (arc_env)
+        uses: mamba-org/setup-micromamba@v3
+        with:
+          environment-name: arc_env
+          environment-file: ARC/environment.yml
+          cache-environment: false
+          cache-downloads: true
+          generate-run-shell: true
+
+      - name: Install conda in micromamba base
+        shell: micromamba-shell {0}
+        run: |
+          echo "::group::Install conda in micromamba base"
+          micromamba install -n base -c conda-forge conda
+          echo "::endgroup::"
+
+      - name: Export ARC paths
+        shell: micromamba-shell {0}
+        working-directory: ARC
+        run: |
+          echo "PATH=$PATH:$PWD" >> "$GITHUB_ENV"
+          echo "PYTHONPATH=$PYTHONPATH:$PWD" >> "$GITHUB_ENV"
+
+      - name: Install Julia 1.10
+        shell: micromamba-shell {0}
+        run: |
+          echo "::group::Install juliaup + Julia 1.10"
+          curl -fsSL https://install.julialang.org | sh -s -- -y
+          export PATH="$HOME/.juliaup/bin:$PATH"
+          juliaup add 1.10
+          juliaup default 1.10
+          echo "PATH=$HOME/.juliaup/bin:$PATH" >> "$GITHUB_ENV"
+          echo "::endgroup::"
+          julia --version
+
+      - name: Install all extras - CI
+        shell: micromamba-shell {0}
+        working-directory: ARC
+        env:
+          MAMBA_ALWAYS_YES: "true"
+          CONDA_ALWAYS_YES: "true"
+        run: make install-ci
+
+      - name: Set TS-GCN and AutoTST in PYTHONPATH
+        shell: micromamba-shell {0}
+        working-directory: ARC
+        run: |
+          echo "PYTHONPATH=$(realpath ../TS-GCN):$(realpath ../AutoTST):$PYTHONPATH" >> $GITHUB_ENV
+
+      - name: Compile ARC molecule
+        shell: micromamba-shell {0}
+        working-directory: ARC
+        env:
+          ARC_COVERAGE: 1
+        run: |
+          make compile
+
+      - name: Run Unit Tests (including slow)
+        shell: micromamba-shell {0}
+        working-directory: ARC
+        env:
+          ARC_COVERAGE: 1
+          CYTHON_TRACE: 1
+        run: |
+          echo "Running Unit Tests (including slow)..."
+          export PYTHONPATH="${{ github.workspace }}/AutoTST:${{ github.workspace }}/KinBot:$PYTHONPATH"
+          pytest arc/ -ra -vv -n 4 --dist worksteal

.gitignore

@@ -55,6 +55,10 @@ timer.dat
 # .vscode
 .vscode
 
+# Claude
+CLAUDE.md
+.claude/*
+
 # .trunk folder
 .trunk
 

arc/common.py

@@ -45,6 +45,8 @@
 
 R = 8.31446261815324  # J/(mol*K)
 EA_UNIT_CONVERSION = {'J/mol': 1, 'kJ/mol': 1e+3, 'cal/mol': 4.184, 'kcal/mol': 4.184e+3}
+FULL_CIRCLE = 360.0
+HALF_CIRCLE = 180.0
 
 default_job_types, servers, supported_ess = settings['default_job_types'], settings['servers'], settings['supported_ess']
 
@@ -1507,14 +1509,11 @@ def is_xyz_linear(xyz: Optional[dict]) -> Optional[bool]:
     return True
 
 
-FULL_CIRCLE = 360.0
-HALF_CIRCLE = 180.0
-
 def get_angle_in_180_range(angle: float,
-                           round_to: Optional[int] = 2,
+                           round_to: Optional[int] = None,
                            ) -> float:
     """
-    Get the corresponding angle in the -180 to +180 degree range.
+    Get the corresponding angle in the -180 to +180 degree range, (-180,180]
 
     Args:
         angle (float): An angle in degrees.
@@ -1524,7 +1523,8 @@ def get_angle_in_180_range(angle: float,
     Returns:
         float: The corresponding angle in the -180 to +180 degree range.
     """
-    return (angle + HALF_CIRCLE) % FULL_CIRCLE - HALF_CIRCLE
+    wrapped = (angle + HALF_CIRCLE) % FULL_CIRCLE - HALF_CIRCLE
+    return round(wrapped, round_to) if round_to is not None else wrapped
 
 
 def signed_angular_diff(phi_1: float, phi_2: float) -> float:

arc/common_test.py

@@ -30,11 +30,33 @@
     """
     Contains unit tests for ARC's common module
     """
+    @classmethod
+    def _clean_globalized_restart_artifact(cls):
+        """Remove the globalized restart-paths artifact written by
+        :meth:`test_globalize_paths`.
+
+        Called from BOTH ``setUpClass`` (defensive — wipes a stale
+        artifact left behind by a previously interrupted run) and
+        ``tearDownClass`` (the normal cleanup path).  This makes the
+        cleanup self-healing: a Ctrl+C, ``kill``, or hard error during
+        a previous run cannot leave the next run inheriting the prior
+        ``restart_paths_globalized.yml``.
+        """
+        globalized_restart_path = os.path.join(
+            common.ARC_TESTING_PATH, 'restart', '4_globalized_paths',
+            'restart_paths_globalized.yml')
+        if os.path.isfile(globalized_restart_path):
+            try:
+                os.remove(path=globalized_restart_path)
+            except OSError:
+                pass
+
     @classmethod
     def setUpClass(cls):
         """
         A method that is run before all unit tests in this class.
         """
+        cls._clean_globalized_restart_artifact()
         cls.maxDiff = None
         cls.default_job_types = {'conf_opt': True,
                                  'opt': True,
@@ -1098,6 +1120,7 @@
         self.assertEqual(common.get_angle_in_180_range(-270), 90)
         self.assertAlmostEqual(common.get_angle_in_180_range(45.5), 45.5, places=7)
         self.assertAlmostEqual(common.get_angle_in_180_range(719.9), -0.1, places=7)
+        self.assertAlmostEqual(common.get_angle_in_180_range(-5.364589, round_to=2), -5.36)
 
     def test_signed_angular_diff(self):
         """Test the signed angular difference between two angles"""
@@ -1396,10 +1419,7 @@
         """
         A function that is run ONCE after all unit tests in this class.
         """
-        globalized_restart_path = os.path.join(common.ARC_TESTING_PATH, 'restart', '4_globalized_paths',
-                                               'restart_paths_globalized.yml')
-        if os.path.isfile(globalized_restart_path):
-            os.remove(path=globalized_restart_path)
+        cls._clean_globalized_restart_artifact()
 
 
 if __name__ == '__main__':

arc/family/family.py

@@ -592,6 +592,17 @@ def check_product_isomorphism(products: List['Molecule'],
         return False
     prods_a = [generate_resonance_structures_safely(mol) or [mol.copy(deep=True)] for mol in products]
     prods_b = [spc.mol_list or [spc.mol] for spc in p_species]
+    # For singlet biradicals (multiplicity forced below the natural value),
+    # add a copy with the natural multiplicity so template-generated products
+    # (which use the high-spin default) can match.
+    for i, spc in enumerate(p_species):
+        n_rad = spc.mol.get_radical_count()
+        natural_mult = n_rad + 1
+        if n_rad and spc.mol.multiplicity < natural_mult:
+            aug = [m.copy(deep=True) for m in prods_b[i]]
+            for m in aug:
+                m.multiplicity = natural_mult
+            prods_b[i] = prods_b[i] + aug
     isomorphic = [False] * len(products)
     for i, prod_a in enumerate(prods_a):
         for prod_b in prods_b:
@@ -869,6 +880,82 @@ def get_recipe_actions(groups_as_lines: List[str]) -> List[List[str]]:
     return actions
 
 
+def split_entries(groups_str: str) -> List[str]:
+    """Split a groups.py source string into the bodies of every top-level
+    ``entry(...)`` block.
+
+    A naive ``re.findall(r'entry\\((.*?)\\)', ..., re.DOTALL)`` is fooled by
+    ``)`` characters that appear inside the entry's string literals (for
+    example a ``label = "C1(R)(H)(O(OC3(OH)(R'))C2)"`` for Korcek_step2),
+    causing the entry to be truncated and downstream parsing to miss the
+    label and the group adjacency list entirely.
+
+    This helper does a small character-by-character scan that tracks
+    parenthesis depth while skipping over single-quoted, double-quoted,
+    and triple-quoted string literals.  The body returned for each entry
+    is the text between the opening ``entry(`` and the matching ``)`` —
+    exactly what the original ``re.findall`` was supposed to return.
+    """
+    bodies: List[str] = []
+    n = len(groups_str)
+    pos = 0
+    while True:
+        marker = groups_str.find('entry(', pos)
+        if marker < 0:
+            break
+        body_start = marker + len('entry(')
+        # Walk forward from body_start, tracking paren depth and skipping
+        # over string literals.  Start at depth 1 because we're already
+        # inside the outer ``entry(`` parentheses.
+        depth = 1
+        j = body_start
+        in_string: Optional[str] = None  # None | '"' | "'" | '"""' | "'''"
+        while j < n and depth > 0:
+            if in_string is None:
+                # Check for a triple-quoted string opener first.
+                triple = groups_str[j:j + 3]
+                if triple in ('"""', "'''"):
+                    in_string = triple
+                    j += 3
+                    continue
+                ch = groups_str[j]
+                if ch in ('"', "'"):
+                    in_string = ch
+                    j += 1
+                    continue
+                if ch == '(':
+                    depth += 1
+                elif ch == ')':
+                    depth -= 1
+                    if depth == 0:
+                        break
+                j += 1
+            else:
+                if len(in_string) == 3:
+                    if groups_str[j:j + 3] == in_string:
+                        in_string = None
+                        j += 3
+                        continue
+                    j += 1
+                    continue
+                ch = groups_str[j]
+                if ch == '\\' and j + 1 < n:
+                    # Skip the escape and the escaped character.
+                    j += 2
+                    continue
+                if ch == in_string:
+                    in_string = None
+                    j += 1
+                    continue
+                j += 1
+        if depth != 0:
+            # Unmatched ``entry(`` — give up rather than mis-attribute.
+            break
+        bodies.append(groups_str[body_start:j])
+        pos = j + 1
+    return bodies
+
+
 def get_entries(groups_as_lines: List[str],
                 entry_labels: List[str],
                 ) -> Dict[str, str]:
@@ -883,11 +970,11 @@ def get_entries(groups_as_lines: List[str],
         Dict[str, str]: The extracted entries, keys are the labels, values are the groups.
     """
     groups_str = ''.join(groups_as_lines)
-    entries = re.findall(r'entry\((.*?)\)', groups_str, re.DOTALL)
+    entries = split_entries(groups_str)
     specific_entries = dict()
     for i, entry in enumerate(entries):
-        label_match = re.search(r'label = "(.*?)"', entry)
-        group_match = re.search(r'group =(.*?)(?=\w+ =)', entry, re.DOTALL)
+        label_match = re.search(r'label\s*=\s*"(.*?)"', entry)
+        group_match = re.search(r'group\s*=(.*?)(?=\w+\s*=)', entry, re.DOTALL)
         if label_match is not None and group_match is not None and label_match.group(1) in entry_labels:
             specific_entries[label_match.group(1)] = clean_text(group_match.group(1))
         if i > 2000: