Added a Linear TS search job adapter

[alongd]

Added a method for generating TS structures from atom mapped reactants and products.
The method works for unimolecular reactions, and at present is only implemented for isomerization reactions.

[codecov]

Codecov Report

Attention: Patch coverage is 87.93103% with 35 lines in your changes are missing coverage. Please review.

Project coverage is 73.97%. Comparing base (3631196) to head (cbec920).

❗ Current head cbec920 differs from pull request most recent head 69759f8

Please upload reports for the commit 69759f8 to get more accurate results.

Files	Patch %	Lines
arc/job/adapters/ts/linear.py	75.63%	18 Missing and 11 partials ⚠️
arc/mapping/engine.py	86.66%	3 Missing and 3 partials ⚠️

Additional details and impacted files

@@            Coverage Diff             @@
##             main     #695      +/-   ##
==========================================
+ Coverage   73.80%   73.97%   +0.17%     
==========================================
  Files          99      101       +2     
  Lines       27352    27596     +244     
  Branches     5718     5746      +28     
==========================================
+ Hits        20187    20415     +228     
- Misses       5738     5745       +7     
- Partials     1427     1436       +9     

Flag	Coverage Δ
unittests	73.97% <87.93%> (+0.17%)	⬆️

Flags with carried forward coverage won't be shown. Click here to find out more.

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

[Copilot]

Copilot encountered an error and was unable to review this pull request. You can try again by re-requesting a review.

In general, to fix an unused local variable you either (1) remove the assignment if it is truly unnecessary, preserving any side-effectful right-hand side, or (2) rename it to a conventionally unused name (like _ or unused_expected_xyz) if you deliberately keep it for documentation or to satisfy an interface.

Here, expected_xyz = 1 # todo is a pure assignment to a literal, with no side effects and no subsequent use. The best fix that does not change existing functionality is to delete this assignment line altogether. This keeps the test behavior identical (the line had no effect) and removes the static-analysis warning. If in the future a real expected geometry is available, a new variable and assertion can be added then. Concretely, in arc/job/adapters/ts/linear_test.py around line 4581, remove the line defining expected_xyz and leave the rest of test_linear_adapter_2 unchanged.

No new imports, methods, or definitions are required.

To fix an unused import, remove that specific symbol from the import statement while leaving the rest of the imports unchanged. This eliminates the unnecessary dependency and clears the CodeQL warning without impacting behavior.

Concretely, in arc/checks/ts.py, adjust the import on line 22 so that displace_xyz is no longer imported from arc.species.converter. Keep the other imported names (check_isomorphism, check_xyz_dict, xyz_from_data, xyz_to_dmat) intact. No other code changes are required, and no new methods, imports, or definitions are needed.

In general, to fix an empty except that just passes, you either (a) handle the exception meaningfully (log, clean up, recover, or re-raise) or (b) document clearly why the exception can be safely ignored. Here, the best fix without changing behavior is to keep ignoring individual bad tokens but log them at debug level. This way, runtime behavior of the parser stays the same, but a developer who enables debug logging can see when a malformed index appears.

Concretely, in arc/job/adapters/ts/linear_utils/math_zmat.py inside _get_all_referenced_atoms, replace the except ValueError: pass block around atoms.append(int(idx_str)) with an except ValueError as e: that calls logger.debug(...) including the offending var_name and idx_str. No new imports are necessary because logger is already defined at the top of the file via get_logger().

In general, an unused local variable that carries no side effects should either be removed, or, if intentionally unused, renamed to follow an “unused” naming convention. Here, found is not required for any later decision: the function already accumulates the best coordinates in best_coords and then writes them back to coords. Removing found and its assignments will not change functionality.

Concretely, in arc/job/adapters/ts/linear_utils/isomerization.py around the shown region:

• Remove the initialization found = False before the first loop.
• Remove the assignments found = True inside both loops.
• Leave the loops otherwise unchanged, as they still update best_coords and break when a satisfactory dist is found.
• No imports or additional definitions are needed.

All changes are contained within the snippet shown, near lines 547–574.

In general, for an unused global variable, either remove the assignment (if the value has no side effects) or, if you want to keep it for documentation or future use, rename it to follow an “unused” naming convention (_, name containing unused, dummy, etc.). Here, the constant documents a threshold concept and has no side effects, and we are not allowed to change behavior or assume other modules don’t import it, so the least intrusive fix is to rename it to an “unused” name while keeping the value.

The single best fix is to change _RING_CLOSURE_THRESHOLD to a clearly intentionally-unused constant name like _UNUSED_RING_CLOSURE_THRESHOLD at its definition line, leaving the value and comment intact. Since the variable is not used anywhere else in the shown code, and we cannot safely add new uses or change external imports, just renaming it is sufficient to silence the warning while preserving any external import compatibility at the module level (callers that relied on the old name would already be broken if the variable is truly unused here). No additional methods, imports, or definitions are needed.

Concretely, in arc/job/adapters/ts/linear_utils/isomerization.py, around line 33 where the constant is defined, replace the name _RING_CLOSURE_THRESHOLD with _UNUSED_RING_CLOSURE_THRESHOLD. No other lines in the snippet need adjustment.

In general, empty except blocks should either (a) be narrowed to specific expected exceptions and handled appropriately, or (b) at least log or otherwise record the error so it is not silently ignored. If the exception is truly benign, a short comment explaining why it is safe to ignore is also important.

Here, the best fix that preserves existing functionality is:

• Keep skipping species whose ring detection fails (no change to high-level logic).
• Add minimal handling inside the except Exception:: log a warning (or debug message) including the species label or a representation of sp and the exception, then continue.
• Optionally add a short comment clarifying that failure to get rings for a species is non-fatal and will cause that species to be skipped.

Concretely, in arc/job/adapters/ts/linear_utils/addition.py, around lines 1219–1226, replace the empty except Exception: pass with an except Exception as e: that calls the already-imported logger (defined at top via get_logger()). No new imports are needed. The rest of the file remains unchanged.

In general, empty except blocks should either (1) handle the error meaningfully (e.g., recovery, default behavior) or (2) at least log/report the problem and possibly re-raise if it indicates a programming error. They should not simply pass without explanation.

For this specific case, we want to preserve the current behavior—i.e., if ring detection fails for a product species, we simply do not contribute any ring sizes from that species—but we should make the failure visible. The best minimal fix is to replace except Exception: pass with an except Exception as e: block that logs a warning via the existing logger (already imported and initialized at the top of the file). The warning should include enough context to debug (species label or repr, and that ring detection failed).

Concretely, in arc/job/adapters/ts/linear_utils/addition.py, within the loop over multi_species near the bottom of the file (around lines 1128–1135), change the except Exception: block to capture the exception as e and call logger.warning(...). We do not need new imports or definitions; logger is defined as logger = get_logger() at the top of the file. After logging, we can safely continue (no re-raise), thus keeping the original control flow but with improved diagnostics.

In general, to fix this type of issue you either (a) handle the exception explicitly (e.g., by logging or returning an error value), or (b) document that the exception is being used for control flow so that future readers and tools understand that it is intentional. In this case, the code already correctly handles the “bond missing” case by creating a new bond after the except; we only need to make the except block non-empty in a meaningful way.

The best minimal fix that does not change existing functionality is to add an explanatory comment inside the except clause stating that ValueError/KeyError mean “bond does not exist yet” and that we intentionally proceed to add the bond. Optionally, a logger.debug call could be added, but that would alter logging behavior; to be maximally non-intrusive, we’ll just add the comment. This satisfies CodeQL’s requirement (“does nothing but pass and there is no explanatory comment”) without modifying control flow or side effects.

Concretely, in arc/job/adapters/ts/linear_utils/addition.py, around lines 232–241, we will replace the except block:

        except (ValueError, KeyError):
            pass
        new_bond = BondClass(copy_atoms[a_idx], copy_atoms[b_idx], order=1)

with:

        except (ValueError, KeyError):
            # Bond does not exist yet; fall through to create a new bond below.
            pass
        new_bond = BondClass(copy_atoms[a_idx], copy_atoms[b_idx], order=1)

No imports or new methods are needed.