Py 14

Author: alongd

arc/level/cbs.py

@@ -41,7 +41,7 @@
 import ast
 import math
 import re
-from typing import Callable, Dict, Mapping
+from collections.abc import Callable, Mapping
 
 import numpy as np
 
@@ -221,7 +221,7 @@ def martin_3pt(energies: Mapping[int, float]) -> float:
 
 # String → callable registry advertised to user input. New built-in formulas are
 # added by inserting an entry here (and a corresponding test).
-BUILTIN_FORMULAS: Dict[str, Callable[..., float]] = {
+BUILTIN_FORMULAS: dict[str, Callable[..., float]] = {
     "helgaker_corr_2pt": helgaker_corr_2pt,
     "helgaker_hf_2pt": helgaker_hf_2pt,
     "martin_3pt": martin_3pt,

arc/level/presets.py

@@ -22,7 +22,8 @@
 
 import copy
 import os
-from typing import Any, Dict, List, Mapping, Optional
+from collections.abc import Mapping
+from typing import Any
 
 import yaml
 
@@ -33,7 +34,7 @@
 _PRESETS_PATH = os.path.join(_HERE, "presets.yml")
 
 
-def _load_presets(path: str) -> Dict[str, Dict[str, Any]]:
+def _load_presets(path: str) -> dict[str, dict[str, Any]]:
     """Load ``presets.yml`` once; return the parsed mapping."""
     with open(path, "r") as fh:
         data = yaml.safe_load(fh) or {}
@@ -43,15 +44,15 @@ def _load_presets(path: str) -> Dict[str, Dict[str, Any]]:
 
 
 # Module-level cache. Loaded once at import time; a single source of truth.
-PRESETS: Dict[str, Dict[str, Any]] = _load_presets(_PRESETS_PATH)
-REGISTERED_PRESET_NAMES: List[str] = sorted(PRESETS.keys())
+PRESETS: dict[str, dict[str, Any]] = _load_presets(_PRESETS_PATH)
+REGISTERED_PRESET_NAMES: list[str] = sorted(PRESETS.keys())
 
 
 # Fields that may appear on a preset term by its ``type`` discriminator.
 # Used to reject typos in preset overrides (e.g. ``delta_T.hihg``). The key
 # ``"base"`` is not a term type — it's the protocol's base level dict, for
 # which we accept any Level-level keyword plus ``label``.
-_ALLOWED_OVERRIDE_FIELDS_BY_TYPE: Dict[str, set] = {
+_ALLOWED_OVERRIDE_FIELDS_BY_TYPE: dict[str, set] = {
     "single_point": {"label", "type", "level"},
     "delta": {"label", "type", "high", "low"},
     "cbs_extrapolation": {"label", "type", "formula", "components", "levels"},
@@ -69,7 +70,7 @@ def _load_presets(path: str) -> Dict[str, Dict[str, Any]]:
 }
 
 
-def _deep_merge_level_dict(target: Dict[str, Any], patch: Dict[str, Any]) -> None:
+def _deep_merge_level_dict(target: dict[str, Any], patch: dict[str, Any]) -> None:
     """Shallow-merge ``patch`` into ``target`` with one level of nesting for
     ``high``/``low``/``level`` — replacing fields of the inner dict rather than
     the whole dict. Mutates ``target`` in place.
@@ -94,8 +95,8 @@ def _deep_merge_level_dict(target: Dict[str, Any], patch: Dict[str, Any]) -> Non
             target[key] = new_val
 
 
-def _validate_override_fields(term_or_base: Dict[str, Any],
-                              patch: Dict[str, Any],
+def _validate_override_fields(term_or_base: dict[str, Any],
+                              patch: dict[str, Any],
                               target_name: str) -> None:
     """Reject typos in override patch keys.
 
@@ -123,9 +124,9 @@ def _validate_override_fields(term_or_base: Dict[str, Any],
 
 
 def _apply_overrides(
-    recipe: Dict[str, Any],
+    recipe: dict[str, Any],
     overrides: Mapping[str, Any],
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Merge per-term ``overrides`` into a recipe and return the result.
 
     ``overrides`` is a mapping ``{term_label: {field_name: new_value}}``. The
@@ -173,8 +174,8 @@ def _apply_overrides(
 
 def expand_preset(
     name: str,
-    overrides: Optional[Mapping[str, Any]] = None,
-) -> Dict[str, Any]:
+    overrides: Mapping[str, Any] | None = None,
+) -> dict[str, Any]:
     """Resolve a preset name (with optional overrides) to an independent recipe dict.
 
     Parameters

arc/level/protocol.py

@@ -41,7 +41,8 @@
 
 import copy
 from abc import ABC, abstractmethod
-from typing import Any, Dict, Iterable, List, Optional, Tuple, Union
+from collections.abc import Iterable
+from typing import Any
 
 from arc.exceptions import InputError
 from arc.level.cbs import (
@@ -74,11 +75,11 @@ class Term(ABC):
     label: str
 
     @abstractmethod
-    def required_levels(self) -> List[Tuple[str, Level]]:
+    def required_levels(self) -> list[tuple[str, Level]]:
         """Return ``[(sub_label, Level), ...]`` pairs for every SP this term needs."""
 
     @abstractmethod
-    def evaluate(self, energies: Dict[str, float]) -> float:
+    def evaluate(self, energies: dict[str, float]) -> float:
         """Combine sub-job energies into this term's contribution.
 
         The keys of ``energies`` are the ``sub_label`` strings yielded by
@@ -87,11 +88,11 @@ def evaluate(self, energies: Dict[str, float]) -> float:
         """
 
     @abstractmethod
-    def as_dict(self) -> Dict[str, Any]:
+    def as_dict(self) -> dict[str, Any]:
         """Serialise to a JSON/YAML-friendly dict including a discriminator ``type``."""
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "Term":
+    def from_dict(cls, data: dict[str, Any]) -> "Term":
         """Reconstruct a ``Term`` subclass from its serialised dict.
 
         Dispatches on the ``type`` discriminator written by :meth:`as_dict`.
@@ -114,7 +115,7 @@ def from_dict(cls, data: Dict[str, Any]) -> "Term":
         )
 
 
-def _coerce_level(value: Union[str, Dict[str, Any], Level]) -> Level:
+def _coerce_level(value: str | dict[str, Any] | Level) -> Level:
     """Accept either a string, dict, or Level; return a Level instance."""
     if isinstance(value, Level):
         return value
@@ -128,27 +129,27 @@ def _coerce_level(value: Union[str, Dict[str, Any], Level]) -> Level:
 class SinglePointTerm(Term):
     """One absolute single-point energy at one level of theory."""
 
-    def __init__(self, label: str, level: Union[str, Dict[str, Any], Level]):
+    def __init__(self, label: str, level: str | dict[str, Any] | Level):
         if not label:
             raise InputError("SinglePointTerm requires a non-empty label.")
         self.label = label
         self.level = _coerce_level(level)
 
-    def required_levels(self) -> List[Tuple[str, Level]]:
+    def required_levels(self) -> list[tuple[str, Level]]:
         return [(self.label, self.level)]
 
-    def evaluate(self, energies: Dict[str, float]) -> float:
+    def evaluate(self, energies: dict[str, float]) -> float:
         return energies[self.label]
 
-    def as_dict(self) -> Dict[str, Any]:
+    def as_dict(self) -> dict[str, Any]:
         return {
             "type": "single_point",
             "label": self.label,
             "level": self.level.as_dict(),
         }
 
     @classmethod
-    def _from_dict(cls, data: Dict[str, Any]) -> "SinglePointTerm":
+    def _from_dict(cls, data: dict[str, Any]) -> "SinglePointTerm":
         return cls(label=data["label"], level=data["level"])
 
 
@@ -162,8 +163,8 @@ class DeltaTerm(Term):
     def __init__(
         self,
         label: str,
-        high: Optional[Union[str, Dict[str, Any], Level]],
-        low: Optional[Union[str, Dict[str, Any], Level]],
+        high: str | dict[str, Any] | Level | None,
+        low: str | dict[str, Any] | Level | None,
     ):
         if not label:
             raise InputError("DeltaTerm requires a non-empty label.")
@@ -179,13 +180,13 @@ def __init__(
     def _sub(self, suffix: str) -> str:
         return f"{self.label}__{suffix}"
 
-    def required_levels(self) -> List[Tuple[str, Level]]:
+    def required_levels(self) -> list[tuple[str, Level]]:
         return [(self._sub("high"), self.high), (self._sub("low"), self.low)]
 
-    def evaluate(self, energies: Dict[str, float]) -> float:
+    def evaluate(self, energies: dict[str, float]) -> float:
         return energies[self._sub("high")] - energies[self._sub("low")]
 
-    def as_dict(self) -> Dict[str, Any]:
+    def as_dict(self) -> dict[str, Any]:
         return {
             "type": "delta",
             "label": self.label,
@@ -194,7 +195,7 @@ def as_dict(self) -> Dict[str, Any]:
         }
 
     @classmethod
-    def _from_dict(cls, data: Dict[str, Any]) -> "DeltaTerm":
+    def _from_dict(cls, data: dict[str, Any]) -> "DeltaTerm":
         return cls(label=data["label"], high=data["high"], low=data["low"])
 
 
@@ -241,7 +242,7 @@ def __init__(
         self,
         label: str,
         formula: str,
-        levels: List[Union[str, Dict[str, Any], Level]],
+        levels: list[str | dict[str, Any] | Level],
         components: str = "total",
     ):
         if not label:
@@ -282,7 +283,7 @@ def __init__(
     # construction time catches "martin_3pt with 2 levels" before a sub-job
     # ever runs. When new built-ins are added, update this table alongside
     # the entry in arc.level.cbs.BUILTIN_FORMULAS.
-    _BUILTIN_FORMULA_ARITY: Dict[str, int] = {
+    _BUILTIN_FORMULA_ARITY: dict[str, int] = {
         "helgaker_corr_2pt": 2,
         "helgaker_hf_2pt": 2,
         "martin_3pt": 3,
@@ -336,14 +337,14 @@ def _user_fn(energies):
     def _sub(self, cardinal: int) -> str:
         return f"{self.label}__card_{cardinal}"
 
-    def required_levels(self) -> List[Tuple[str, Level]]:
+    def required_levels(self) -> list[tuple[str, Level]]:
         return [(self._sub(c), lvl) for c, lvl in zip(self._cardinals, self.levels)]
 
-    def evaluate(self, energies: Dict[str, float]) -> float:
+    def evaluate(self, energies: dict[str, float]) -> float:
         cardinal_to_energy = {c: energies[self._sub(c)] for c in self._cardinals}
         return self._formula_callable(cardinal_to_energy)
 
-    def as_dict(self) -> Dict[str, Any]:
+    def as_dict(self) -> dict[str, Any]:
         return {
             "type": "cbs_extrapolation",
             "label": self.label,
@@ -353,7 +354,7 @@ def as_dict(self) -> Dict[str, Any]:
         }
 
     @classmethod
-    def _from_dict(cls, data: Dict[str, Any]) -> "CBSExtrapolationTerm":
+    def _from_dict(cls, data: dict[str, Any]) -> "CBSExtrapolationTerm":
         return cls(
             label=data["label"],
             formula=data["formula"],
@@ -388,9 +389,9 @@ class CompositeProtocol:
     def __init__(
         self,
         base: SinglePointTerm,
-        corrections: Optional[List[Term]] = None,
-        preset_name: Optional[str] = None,
-        reference: Optional[str] = None,
+        corrections: list[Term] | None = None,
+        preset_name: str | None = None,
+        reference: str | None = None,
     ):
         if not isinstance(base, SinglePointTerm):
             raise InputError(
@@ -409,7 +410,7 @@ def __init__(
         # A collision (e.g. SinglePointTerm(label='delta_T__high') plus a
         # DeltaTerm(label='delta_T', ...) whose 'high' sub-leg also ends up as
         # 'delta_T__high') would overwrite state silently. Reject at construction.
-        sub_labels: List[str] = []
+        sub_labels: list[str] = []
         for term in [base, *corrections]:
             for sub_label, _level in term.required_levels():
                 sub_labels.append(sub_label)
@@ -427,22 +428,22 @@ def __init__(
         self.reference = reference
 
     @property
-    def terms(self) -> List[Term]:
+    def terms(self) -> list[Term]:
         """Convenience: ``[base, *corrections]`` in protocol order."""
         return [self.base, *self.corrections]
 
-    def evaluate(self, energies: Dict[str, float]) -> float:
+    def evaluate(self, energies: dict[str, float]) -> float:
         """Combine all sub-job energies into the protocol's electronic energy."""
         return sum(term.evaluate(energies) for term in self.terms)
 
-    def iter_required_jobs(self) -> Iterable[Tuple[str, str, Level]]:
+    def iter_required_jobs(self) -> Iterable[tuple[str, str, Level]]:
         """Yield ``(term_label, sub_label, Level)`` triples for every required SP."""
         for term in self.terms:
             for sub_label, level in term.required_levels():
                 yield (term.label, sub_label, level)
 
-    def as_dict(self) -> Dict[str, Any]:
-        out: Dict[str, Any] = {
+    def as_dict(self) -> dict[str, Any]:
+        out: dict[str, Any] = {
             "base": self.base.as_dict(),
             "corrections": [t.as_dict() for t in self.corrections],
         }
@@ -453,7 +454,7 @@ def as_dict(self) -> Dict[str, Any]:
         return out
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "CompositeProtocol":
+    def from_dict(cls, data: dict[str, Any]) -> "CompositeProtocol":
         """Inverse of :meth:`as_dict`. Each entry must already include its discriminator."""
         if not isinstance(data, dict) or "base" not in data:
             raise InputError(
@@ -479,7 +480,7 @@ def from_dict(cls, data: Dict[str, Any]) -> "CompositeProtocol":
         )
 
     @classmethod
-    def from_user_input(cls, raw: Union[str, Dict[str, Any]]) -> "CompositeProtocol":
+    def from_user_input(cls, raw: str | dict[str, Any]) -> "CompositeProtocol":
         """Accept the YAML-shaped user input and produce a validated protocol.
 
         Three forms are accepted:
@@ -498,7 +499,7 @@ def from_user_input(cls, raw: Union[str, Dict[str, Any]]) -> "CompositeProtocol"
         arc.exceptions.InputError
             On any malformed input.
         """
-        preset_name: Optional[str] = None
+        preset_name: str | None = None
         if isinstance(raw, str):
             preset_name = raw
             raw = expand_preset(raw)
@@ -549,7 +550,7 @@ def from_user_input(cls, raw: Union[str, Dict[str, Any]]) -> "CompositeProtocol"
                 f"SinglePointTerm dict; got {type(base_raw).__name__}."
             )
 
-        corrections: List[Term] = []
+        corrections: list[Term] = []
         for entry in raw.get("corrections", []):
             if not isinstance(entry, dict):
                 raise InputError(