Merge branch 'master' into python-3.14

Author: DanielYang59

.github/workflows/test.yml

@@ -118,8 +118,8 @@ jobs:
           PYTHONWARNDEFAULTENCODING: "true" # PEP 597: Enable optional EncodingWarning
         run: |
           pytest tests \
-            --splits 10 --group ${{ matrix.split }} \
-            --durations-path tests/files/.pytest-split-durations
+            -n auto --splits 10 --group ${{ matrix.split }} \
+            --durations-path tests/files/.pytest-split-durations \
 
   trigger_atomate2_ci:
     needs: test

pyproject.toml

@@ -167,7 +167,7 @@ include = ["pymatgen", "pymatgen.*"]
 
 [tool.pdm.dev-dependencies]
 lint = ["mypy>=1.10.0", "pre-commit>=3.7.1", "ruff>=0.4.9"]
-test = ["pytest-cov>=5.0.0", "pytest-split>=0.9.0", "pytest>=8.2.2"]
+test = ["pytest-cov>=5.0.0", "pytest-split>=0.9.0", "pytest>=8.2.2","pytest-xdist>=3.0.0"]
 
 [tool.cibuildwheel.linux]
 archs = ["auto64"]
@@ -259,7 +259,7 @@ docstring-code-format = true
 "dev_scripts/*" = ["D"]
 
 [tool.pytest.ini_options]
-addopts = "--durations=30 --quiet -r xXs --color=yes --import-mode=importlib"
+addopts = "-n auto --durations=30 --quiet -r xXs --color=yes --import-mode=importlib"
 filterwarnings = [
     # NOTE: the LAST matching option would be used
     "ignore::UserWarning",
@@ -334,7 +334,8 @@ dev = [
 test = [
     "pytest>=8.3.5",
     "pytest-cov>=6.0.0",
-    "pytest-split>=0.10.0"
+    "pytest-split>=0.10.0",
+    "pytest-xdist>=3.0.0"
 ]
 lint = [
     "mypy>=1.15.0",

src/pymatgen/analysis/structure_prediction/dopant_predictor.py

@@ -127,26 +127,21 @@ def get_dopants_from_shannon_radii(bonded_structure, num_dopants=5, match_oxi_si
 
 def _get_dopants(substitutions, num_dopants, match_oxi_sign) -> dict:
     """Utility method to get n- and p-type dopants from a list of substitutions."""
-    n_type = [
-        pred
-        for pred in substitutions
-        if pred["dopant_species"].oxi_state > pred["original_species"].oxi_state
-        and (
-            not match_oxi_sign
-            or np.sign(pred["dopant_species"].oxi_state) == np.sign(pred["original_species"].oxi_state)
-        )
-    ]
-    p_type = [
-        pred
-        for pred in substitutions
-        if pred["dopant_species"].oxi_state < pred["original_species"].oxi_state
-        and (
-            not match_oxi_sign
-            or np.sign(pred["dopant_species"].oxi_state) == np.sign(pred["original_species"].oxi_state)
-        )
-    ]
-
-    return {"n_type": n_type[:num_dopants], "p_type": p_type[:num_dopants]}
+    dopants = {k: [] for k in ("n_type", "p_type")}
+    for k in dopants:  # noqa: PLC0206
+        for pred in substitutions:
+            if (
+                pred["dopant_species"].oxi_state > pred["original_species"].oxi_state
+                if k == "n_type"
+                else pred["dopant_species"].oxi_state < pred["original_species"].oxi_state
+            ) and (
+                not match_oxi_sign
+                or np.sign(pred["dopant_species"].oxi_state) == np.sign(pred["original_species"].oxi_state)
+            ):
+                dopants[k].append(pred)
+            if len(dopants[k]) == num_dopants:
+                break
+    return dopants
 
 
 def _shannon_radii_from_cn(species_list, cn_roman, radius_to_compare=0):
@@ -171,7 +166,7 @@ def _shannon_radii_from_cn(species_list, cn_roman, radius_to_compare=0):
 
             - "species": The species with charge state.
             - "radius": The Shannon radius for the species.
-            - "radius_diff": The difference between the Shannon radius and the
+            - "radii_diff": The difference between the Shannon radius and the
                 radius_to_compare optional argument.
     """
     shannon_radii = []

src/pymatgen/cli/pmg.py

@@ -62,15 +62,21 @@ def format_lists(v):
         ["---------------", "", ""],
     ]
     output += [
-        [k, format_lists(diff["Same"][k]), format_lists(diff["Same"][k])] for k in sorted(diff["Same"]) if k != "SYSTEM"
+        (  # type: ignore[misc]
+            k,
+            format_lists(diff["Same"][k]),
+            format_lists(diff["Same"][k]),
+        )
+        for k in sorted(diff["Same"])
+        if k != "SYSTEM"
     ]
     output += [
         ["", "", ""],
         ["DIFFERENT PARAMS", "", ""],
         ["----------------", "", ""],
     ]
     output += [
-        [
+        [  # type: ignore[misc]
             k,
             format_lists(diff["Different"][k]["INCAR1"]),
             format_lists(diff["Different"][k]["INCAR2"]),

src/pymatgen/core/composition.py

@@ -370,7 +370,7 @@ def formula(self) -> str:
         e.g. Li4 Fe4 P4 O16.
         """
         sym_amt = self.get_el_amt_dict()
-        syms = sorted(sym_amt, key=lambda sym: get_el_sp(sym).X)
+        syms = _symbol_sort_order(sym_amt)
         formula = [f"{s}{formula_double_format(sym_amt[s], ignore_ones=False)}" for s in syms]
         return " ".join(formula)
 
@@ -550,7 +550,7 @@ def num_atoms(self) -> float:
     @property
     def weight(self) -> FloatWithUnit:
         """Total molecular weight of Composition."""
-        return Mass(sum([amount * el.atomic_mass for el, amount in self.items()], 0.0), _PT_UNIT["Atomic mass"])
+        return Mass(sum(amount * el.atomic_mass for el, amount in self.items()), _PT_UNIT["Atomic mass"])  # type: ignore[misc]
 
     def get_atomic_fraction(self, el: SpeciesLike) -> float:
         """Calculate atomic fraction of an Element or Species.
@@ -1363,7 +1363,7 @@ def reduce_formula(
     Returns:
         tuple[str, int]: reduced formula and factor.
     """
-    syms: list[str] = sorted(sym_amt, key=lambda x: [get_el_sp(x).X, x])
+    syms: list[str] = _symbol_sort_order(sym_amt)
 
     syms = list(filter(lambda x: abs(sym_amt[x]) > Composition.amount_tolerance, syms))
 
@@ -1394,6 +1394,11 @@ def reduce_formula(
     return "".join([*reduced_form, *poly_anions]), factor
 
 
+def _symbol_sort_order(sym: list[str] | Mapping[str, Any]) -> list[str]:
+    """Define fixed order for sorting based on electronegativity + alphabatical fallback."""
+    return sorted(sym, key=lambda x: [float("inf") if math.isnan(e_neg := get_el_sp(x).X) else e_neg, x])
+
+
 class CompositionError(Exception):
     """Composition exceptions."""
 

src/pymatgen/io/vasp/inputs.py

@@ -1220,7 +1220,7 @@ def __init__(
         style: KpointsSupportedModes = supported_modes.Gamma,
         kpts: Sequence[Kpoint] = ((1, 1, 1),),
         kpts_shift: tuple[float, float, float] = (0, 0, 0),
-        kpts_weights: list[float] | None = None,
+        kpts_weights: Sequence[float] | None = None,
         coord_type: Literal["Reciprocal", "Cartesian"] | None = None,
         labels: list[str] | None = None,
         tet_number: int = 0,
@@ -1246,12 +1246,12 @@ def __init__(
                 (or negative), VASP automatically generates the KPOINTS.
             style: Style for generating KPOINTS. Use one of the
                 Kpoints.supported_modes enum types.
-            kpts (2D array): Array of kpoints. Even when only a single
+            kpts (2D sequence): Sequence of kpoints. Even when only a single
                 specification is required, e.g. in the automatic scheme,
-                the kpts should still be specified as a 2D array. e.g.
+                the kpts should still be specified as a 2D sequence. e.g.
                 [(20,),] or [(2, 2, 2),].
             kpts_shift (3x1 array): Shift for kpoints.
-            kpts_weights (list[float]): Optional weights for explicit kpoints.
+            kpts_weights (Sequence[float]): Optional weights for explicit kpoints.
             coord_type: In line-mode, this variable specifies whether the
                 Kpoints were given in Cartesian or Reciprocal coordinates.
             labels: In line-mode, this should provide a list of labels for
@@ -1266,15 +1266,15 @@ def __init__(
                 Format is a list of tuples, [ (sym_weight, [tet_vertices]),
                 ...]
         """
-        if num_kpts > 0 and not labels and not kpts_weights:
+        if num_kpts > 0 and not labels and kpts_weights is None:
             raise ValueError("For explicit or line-mode kpoints, either the labels or kpts_weights must be specified.")
 
         self.comment = comment
         self.num_kpts = num_kpts
         self.kpts = kpts  # type: ignore[assignment]
         self.style = style
         self.coord_type = coord_type
-        self.kpts_weights = kpts_weights
+        self.kpts_weights = list(kpts_weights) if kpts_weights is not None else None
         self.kpts_shift = tuple(kpts_shift)
         self.labels = labels
         self.tet_number = tet_number

tests/core/test_composition.py

@@ -869,6 +869,26 @@ def test_curly_bracket_deeply_nested_formulas(self):
         }.items():
             assert Composition(formula).formula == expected
 
+    def test_formula_order(self):
+        ref_vals = {
+            "formula": "Zn2 C2 Br2 Ar2 Ne2",
+            "reduced_formula": "ZnCBrArNe",
+        }
+        assert all(
+            all(getattr(Composition(dict.fromkeys(ele_order, 2)), k) == v for k, v in ref_vals.items())
+            for ele_order in [
+                ("Br", "Ar", "Zn", "C", "Ne"),
+                (
+                    "Ne",
+                    "Br",
+                    "Ar",
+                    "Zn",
+                    "C",
+                ),
+                ("Ar", "Br", "Ne", "C", "Zn"),
+            ]
+        )
+
 
 def test_reduce_formula():
     assert reduce_formula({"Li": 2, "Mn": 4, "O": 8}) == ("LiMn2O4", 2)

tests/io/vasp/test_inputs.py

@@ -1112,6 +1112,11 @@ def test_init(self):
 0.5 0.5 0.5 4 None"""
         assert str(kpoints).strip() == expected_kpt_str
 
+        # ensure KPOINTS deserialize even when weights are numpy array
+        conf_dict = kpoints.as_dict()
+        conf_dict["kpts_weights"] = np.array(conf_dict["kpts_weights"])
+        assert Kpoints.from_dict(conf_dict) == kpoints
+
         # Explicit tetrahedra method
         filepath = f"{VASP_IN_DIR}/KPOINTS_explicit_tet"
         kpoints = Kpoints.from_file(filepath)

tests/performance/test_import_time.py

@@ -79,6 +79,7 @@ def test_get_ref_import_time() -> None:
     pytest.fail("Reference import times generated. Copy from output to update JSON file.")
 
 
+@pytest.mark.xfail(reason="High variance in CI run times.")
 @pytest.mark.skipif(GEN_REF_TIME, reason="Generating reference import time.")
 @pytest.mark.parametrize(
     ("grace_percent", "hard_percent"),