mypy / precommit

Author: esoteric-ephemera

.github/workflows/linting.yml

@@ -25,7 +25,7 @@ jobs:
         python -m pip install types-requests
     - name: mypy
       run: |
-        mypy --namespace-packages --explicit-package-bases pymatgen
+        mypy pymatgen
     - name: black
       run: |
         black --version

.pre-commit-config.yaml

@@ -52,4 +52,4 @@ repos:
         args:
           - --namespace-packages
           - --explicit-package-bases
-        additional_dependencies: ['types-requests']
+        additional_dependencies: ['types-requests','pydantic>=2.0.1']

pymatgen/io/validation/check_common_errors.py

@@ -8,6 +8,7 @@
 from pymatgen.io.validation.common import SETTINGS, BaseValidator
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
     from numpy.typing import ArrayLike
 
     from pymatgen.io.validation.common import VaspFiles
@@ -151,8 +152,12 @@ def _check_positive_energy(self, vasp_files: VaspFiles, reasons: list[str], warn
     def _check_large_magmoms(self, vasp_files: VaspFiles, reasons: list[str], warnings: list[str]) -> None:
         # Check for excessively large final magnetic moments
 
-        if not vasp_files.outcar:
-            warnings.append("MAGNETISM --> No OUTCAR file specified")
+        if (
+            not vasp_files.outcar
+            or not vasp_files.outcar.magnetization
+            or any(mag.get("tot") is None for mag in vasp_files.outcar.magnetization)
+        ):
+            warnings.append("MAGNETISM --> No OUTCAR file specified or data missing.")
             return
 
         cur_magmoms = [abs(mag["tot"]) for mag in vasp_files.outcar.magnetization]
@@ -221,7 +226,7 @@ class CheckStructureProperties(BaseValidator):
     )
 
     @staticmethod
-    def _has_frozen_degrees_of_freedom(selective_dynamics_array: ArrayLike[bool] | None) -> bool:
+    def _has_frozen_degrees_of_freedom(selective_dynamics_array: Sequence[bool] | None) -> bool:
         """Check selective dynamics array for False values."""
         if selective_dynamics_array is None:
             return False
@@ -243,7 +248,7 @@ def _check_selective_dynamics(self, vasp_files: VaspFiles, reasons: list[str], w
     def _has_nonzero_velocities(velocities: ArrayLike | None, tol: float = 1.0e-8) -> bool:
         if velocities is None:
             return False
-        return np.any(np.abs(velocities) > tol)
+        return np.any(np.abs(velocities) > tol)  # type: ignore [return-value]
 
     def _check_velocities(self, vasp_files: VaspFiles, reasons: list[str], warnings: list[str]) -> None:
         """Check structure for non-zero velocities."""

pymatgen/io/validation/check_incar.py

@@ -236,8 +236,7 @@ def _update_misc_special_params(self, user_incar: dict, ref_incar: dict, vasp_fi
 
         if (
             user_incar["ISPIN"] == 2
-            and vasp_files.outcar
-            and len(vasp_files.outcar.magnetization) != vasp_files.user_input.structure.num_sites
+            and len(getattr(vasp_files.outcar, "magnetization", [])) != vasp_files.user_input.structure.num_sites
         ):
             self.vasp_defaults["LORBIT"].update(
                 {
@@ -308,18 +307,19 @@ def _update_fft_params(self, user_incar: dict, ref_incar: dict, vasp_files: Vasp
             enmaxs = [user_incar["ENMAX"], ref_incar["ENMAX"]]
             ref_incar["ENMAX"] = max([v for v in enmaxs if v < float("inf")])
 
-            (
-                [
-                    ref_incar["NGX"],
-                    ref_incar["NGY"],
-                    ref_incar["NGZ"],
-                ],
-                [
-                    ref_incar["NGXF"],
-                    ref_incar["NGYF"],
-                    ref_incar["NGZF"],
-                ],
-            ) = vasp_files.valid_input_set._calculate_ng(custom_encut=ref_incar["ENMAX"])
+            if fft_grid := vasp_files.valid_input_set._calculate_ng(custom_encut=ref_incar["ENMAX"]):
+                (
+                    [
+                        ref_incar["NGX"],
+                        ref_incar["NGY"],
+                        ref_incar["NGZ"],
+                    ],
+                    [
+                        ref_incar["NGXF"],
+                        ref_incar["NGYF"],
+                        ref_incar["NGZF"],
+                    ],
+                ) = fft_grid
 
             for key in grid_keys:
                 ref_incar[key] = int(ref_incar[key] * self.fft_grid_tolerance)
@@ -490,7 +490,7 @@ def _update_electronic_params(self, user_incar: dict, ref_incar: dict, vasp_file
 
         # ENAUG. Should only be checked for calculations where the relevant MP input set specifies ENAUG.
         # In that case, ENAUG should be the same or greater than in valid_input_set.
-        if ref_incar.get("ENAUG") < float("inf"):
+        if ref_incar.get("ENAUG") and not np.isinf(ref_incar["ENAUG"]):
             self.vasp_defaults["ENAUG"].operation = ">="
 
         # IALGO.
@@ -502,7 +502,7 @@ def _update_electronic_params(self, user_incar: dict, ref_incar: dict, vasp_file
         if vasp_files.vasprun and (nelect := vasp_files.vasprun.parameters.get("NELECT")):
             ref_incar["NELECT"] = 0.0
             try:
-                user_incar["NELECT"] = float(vasp_files.vasprun.final_structure._charge)
+                user_incar["NELECT"] = float(vasp_files.vasprun.final_structure._charge or 0.0)
                 self.vasp_defaults["NELECT"].operation = "approx"
                 self.vasp_defaults["NELECT"].comment = (
                     f"This causes the structure to have a charge of {user_incar['NELECT']}. "

pymatgen/io/validation/check_kpoints_kspacing.py

@@ -15,7 +15,7 @@ class CheckKpointsKspacing(BaseValidator):
     """Check that k-point density is sufficiently high and is compatible with lattice symmetry."""
 
     name: str = "Check k-point density"
-    kpts_tolerance: float | None = Field(
+    kpts_tolerance: float = Field(
         SETTINGS.VASP_KPTS_TOLERANCE,
         description="Tolerance for evaluating k-point density, to accommodate different the k-point generation schemes across VASP versions.",
     )
@@ -46,16 +46,18 @@ def _get_valid_num_kpts(
         int, the minimum permitted number of k-points, consistent with self.kpts_tolerance
         """
         # If MP input set specifies KSPACING in the INCAR
-        if ("KSPACING" in vasp_files.valid_input_set.incar.keys()) and (vasp_files.valid_input_set.kpoints is None):
-            valid_kspacing = vasp_files.valid_input_set.incar.get("KSPACING", self.vasp_defaults["KSPACING"].value)
+        if (kspacing := vasp_files.valid_input_set.incar.get("KSPACING")) and (
+            vasp_files.valid_input_set.kpoints is None
+        ):
+            valid_kspacing = kspacing
             # number of kpoints along each of the three lattice vectors
             nk = [
                 max(1, np.ceil(vasp_files.user_input.structure.lattice.reciprocal_lattice.abc[ik] / valid_kspacing))
                 for ik in range(3)
             ]
             valid_num_kpts = np.prod(nk)
         # If MP input set specifies a KPOINTS file
-        else:
+        elif vasp_files.valid_input_set.kpoints:
             valid_num_kpts = vasp_files.valid_input_set.kpoints.num_kpts or np.prod(
                 vasp_files.valid_input_set.kpoints.kpts[0]
             )
@@ -64,7 +66,7 @@ def _get_valid_num_kpts(
 
     def _check_user_shifted_mesh(self, vasp_files: VaspFiles, reasons: list[str], warnings: list[str]) -> None:
         # Check for user shifts
-        if (not self.allow_kpoint_shifts) and any(shift_val != 0 for shift_val in vasp_files.actual_kpoints.kpts_shift):
+        if (not self.allow_kpoint_shifts) and any(shift_val != 0 for shift_val in vasp_files.actual_kpoints.kpts_shift):  # type: ignore[union-attr]
             reasons.append("INPUT SETTINGS --> KPOINTS: shifting the kpoint mesh is not currently allowed.")
 
     def _check_explicit_mesh_permitted(self, vasp_files: VaspFiles, reasons: list[str], warnings: list[str]) -> None:
@@ -77,7 +79,7 @@ def _check_explicit_mesh_permitted(self, vasp_files: VaspFiles, reasons: list[st
         else:
             allow_explicit = False
 
-        if (not allow_explicit) and len(vasp_files.actual_kpoints.kpts) > 1:
+        if (not allow_explicit) and len(vasp_files.actual_kpoints.kpts) > 1:  # type: ignore[union-attr]
             reasons.append(
                 "INPUT SETTINGS --> KPOINTS: explicitly defining "
                 "the k-point mesh is not currently allowed. "
@@ -92,10 +94,10 @@ def _check_kpoint_density(self, vasp_files: VaspFiles, reasons: list[str], warni
         # Check number of kpoints used
         valid_num_kpts = self._get_valid_num_kpts(vasp_files)
 
-        cur_num_kpts = max(
-            vasp_files.actual_kpoints.num_kpts,
-            np.prod(vasp_files.actual_kpoints.kpts),
-            len(vasp_files.actual_kpoints.kpts),
+        cur_num_kpts: int = max(  # type: ignore[assignment]
+            vasp_files.actual_kpoints.num_kpts,  # type: ignore[union-attr]
+            np.prod(vasp_files.actual_kpoints.kpts),  # type: ignore[union-attr]
+            len(vasp_files.actual_kpoints.kpts),  # type: ignore[union-attr]
         )
         if cur_num_kpts < valid_num_kpts:
             reasons.append(
@@ -106,19 +108,19 @@ def _check_kpoint_density(self, vasp_files: VaspFiles, reasons: list[str], warni
     def _check_kpoint_mesh_symmetry(self, vasp_files: VaspFiles, reasons: list[str], warnings: list[str]) -> None:
         # check for valid kpoint mesh (which depends on symmetry of the structure)
 
-        cur_kpoint_style = vasp_files.actual_kpoints.style.name.lower()
+        cur_kpoint_style = vasp_files.actual_kpoints.style.name.lower()  # type: ignore[union-attr]
         is_hexagonal = vasp_files.user_input.structure.lattice.is_hexagonal()
         is_face_centered = vasp_files.user_input.structure.get_space_group_info()[0][0] == "F"
         monkhorst_mesh_is_invalid = is_hexagonal or is_face_centered
         if (
             cur_kpoint_style == "monkhorst"
             and monkhorst_mesh_is_invalid
-            and any(x % 2 == 0 for x in vasp_files.actual_kpoints.kpts[0])
+            and any(x % 2 == 0 for x in vasp_files.actual_kpoints.kpts[0])  # type: ignore[union-attr]
         ):
             # only allow Monkhorst with all odd number of subdivisions per axis.
-            kx, ky, kz = vasp_files.actual_kpoints.kpts[0]
+            kv = vasp_files.actual_kpoints.kpts[0]  # type: ignore[union-attr]
             reasons.append(
-                f"INPUT SETTINGS --> KPOINTS or KGAMMA: ({kx}x{ky}x{kz}) "
+                f"INPUT SETTINGS --> KPOINTS or KGAMMA: ({'×'.join([f'{_k}' for _k in kv])}) "
                 "Monkhorst-Pack kpoint mesh was used."
                 "To be compatible with the symmetry of the lattice, "
                 "a Monkhorst-Pack mesh should have only odd number of "

pymatgen/io/validation/check_package_versions.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 from importlib.metadata import version
-import requests
+import requests  # type: ignore[import-untyped]
 import warnings
 
 

pymatgen/io/validation/check_potcar.py

@@ -11,9 +11,10 @@
 
 from pymatgen.io.vasp import PotcarSingle
 
-from pymatgen.io.validation.common import BaseValidator
+from pymatgen.io.validation.common import BaseValidator, ValidationError
 
 if TYPE_CHECKING:
+    from typing import Any
     from pymatgen.io.validation.common import VaspFiles
 
 
@@ -24,7 +25,7 @@ class CheckPotcar(BaseValidator):
 
     name: str = "Check POTCAR"
     potcar_summary_stats_path: str | Path | None = Field(
-        import_resource_files("pymatgen.io.vasp") / "potcar-summary-stats.json.bz2",
+        str(import_resource_files("pymatgen.io.vasp") / "potcar-summary-stats.json.bz2"),
         description="Path to potcar summary data. Mapping is calculation type -> potcar symbol -> summary data.",
     )
     data_match_tol: float = Field(1.0e-6, description="Tolerance for matching POTCARs to summary statistics data.")
@@ -33,11 +34,11 @@ class CheckPotcar(BaseValidator):
     )
 
     @cached_property
-    def potcar_summary_stats(self) -> dict | None:
+    def potcar_summary_stats(self) -> dict:
         """Load POTCAR summary statistics file."""
         if self.potcar_summary_stats_path:
             return loadfn(self.potcar_summary_stats_path, cls=None)
-        return None
+        return {}
 
     def auto_fail(self, vasp_files: VaspFiles, reasons: list[str], warnings: list[str]) -> bool:
         """Skip if no POTCAR was provided, or if summary stats file was unset."""
@@ -63,26 +64,28 @@ def _check_potcar_spec(self, vasp_files: VaspFiles, reasons: list[str], warnings
 
         if vasp_files.valid_input_set.potcar:
             # If the user has pymatgen set up, use the pregenerated POTCAR summary stats.
-            valid_potcar_summary_stats = {
+            valid_potcar_summary_stats: dict[str, list[dict[str, Any]]] = {
                 p.titel.replace(" ", ""): [p.model_dump()] for p in vasp_files.valid_input_set.potcar
             }
-        else:
+        elif vasp_files.valid_input_set._pmg_vis:
             # Fallback, use the stats from pymatgen - only load and cache summary stats here.
-            psp_subset = self.potcar_summary_stats.get(vasp_files.valid_input_set._config_dict["POTCAR_FUNCTIONAL"], {})
+            psp_subset = self.potcar_summary_stats.get(vasp_files.valid_input_set.potcar_functional, {})
 
-            valid_potcar_summary_stats = {}  # type: ignore
+            valid_potcar_summary_stats = {}
             for element in vasp_files.user_input.structure.composition.remove_charges().as_dict():
-                potcar_symbol = vasp_files.valid_input_set._config_dict["POTCAR"][element]
+                potcar_symbol = vasp_files.valid_input_set._pmg_vis._config_dict["POTCAR"][element]
                 for titel_no_spc in psp_subset:
                     for psp in psp_subset[titel_no_spc]:
                         if psp["symbol"] == potcar_symbol:
                             if titel_no_spc not in valid_potcar_summary_stats:
                                 valid_potcar_summary_stats[titel_no_spc] = []
                             valid_potcar_summary_stats[titel_no_spc].append(psp)
+        else:
+            raise ValidationError("Could not determine reference POTCARs.")
 
         try:
-            incorrect_potcars = []
-            for potcar in vasp_files.user_input.potcar:
+            incorrect_potcars: list[str] = []
+            for potcar in vasp_files.user_input.potcar:  # type: ignore[union-attr]
                 reference_summary_stats = valid_potcar_summary_stats.get(potcar.titel.replace(" ", ""), [])
                 potcar_symbol = potcar.titel.split(" ")[1]
 
@@ -94,7 +97,7 @@ def _check_potcar_spec(self, vasp_files: VaspFiles, reasons: list[str], warnings
                     user_summary_stats = potcar.model_dump()
                     ref_psp = deepcopy(_ref_psp)
                     for _set in (user_summary_stats, ref_psp):
-                        _set["keywords"]["header"] = set(_set["keywords"]["header"]).difference(self.ignore_header_keys)
+                        _set["keywords"]["header"] = set(_set["keywords"]["header"]).difference(self.ignore_header_keys)  # type: ignore[arg-type]
                     if found_match := PotcarSingle.compare_potcar_stats(
                         ref_psp, user_summary_stats, tolerance=self.data_match_tol
                     ):

pymatgen/io/validation/common.py

@@ -61,10 +61,12 @@ class _PotcarSummaryStatsNames(BaseModel):
     lexch: str
 
     @classmethod
-    def from_file(cls, potcar: os.PathLike | Potcar) -> list[Self]:
+    def from_file(cls, potcar_path: os.PathLike | Potcar) -> list[Self]:
         """Create a list of PotcarSummaryStats from a POTCAR."""
-        if not isinstance(potcar, Potcar):
-            potcar = Potcar.from_file(potcar)
+        if isinstance(potcar_path, Potcar):
+            potcar: Potcar = potcar_path
+        else:
+            potcar = Potcar.from_file(str(potcar_path))
         return [cls(**p._summary_stats, titel=p.TITEL, lexch=p.LEXCH) for p in potcar]
 
 
@@ -107,12 +109,15 @@ class VaspInputSafe(BaseModel):
     structure: Structure = Field(description="The structure associated with the calculation.")
     kpoints: Kpoints | None = Field(None, description="The optional KPOINTS or IBZKPT file used in the calculation.")
     potcar: list[PotcarSummaryStats] | None = Field(None, description="The optional POTCAR used in the calculation.")
+    potcar_functional: str | None = Field(None, description="The pymatgen-labelled POTCAR library release.")
     _pmg_vis: VaspInputSet | None = PrivateAttr(None)
 
     @model_serializer
     def deserialize_objects(self) -> dict[str, Any]:
         """Ensure all pymatgen objects are deserialized."""
-        model_dumped: dict[str, Any] = {"potcar": [p.model_dump() for p in self.potcar]}
+        model_dumped: dict[str, Any] = {}
+        if self.potcar:
+            model_dumped["potcar"] = [p.model_dump() for p in self.potcar]
         for k in (
             "incar",
             "structure",
@@ -134,6 +139,7 @@ def from_vasp_input_set(cls, vis: VaspInputSet) -> Self:
                 )
             },
             potcar=PotcarSummaryStats.from_file(vis.potcar),
+            potcar_functional=vis.potcar_functional,
         )
         new_vis._pmg_vis = vis
         return new_vis
@@ -194,7 +200,7 @@ def from_paths(
         for file_name, file_cls in to_obj.items():
             if (path := _vars.get(file_name)) and Path(path).exists():
                 if file_name == "poscar":
-                    config["user_input"]["structure"] = file_cls.from_file(path).structure
+                    config["user_input"]["structure"] = Poscar.from_file(path).structure
                 elif hasattr(file_cls, "from_file"):
                     config["user_input"][file_name] = file_cls.from_file(path)
                 else:
@@ -208,11 +214,11 @@ def from_paths(
                 drift=config["outcar"].drift,
                 magnetization=config["outcar"].magnetization,
             )
+
         if config.get("vasprun"):
             config["vasprun"] = LightVasprun.from_vasprun(config["vasprun"])
-        else:
-            if not config["incar"].get("ENCUT") and potcar_enmax:
-                config["incar"]["ENCUT"] = potcar_enmax
+        elif not config["user_input"]["incar"].get("ENCUT") and potcar_enmax:
+            config["user_input"]["incar"]["ENCUT"] = potcar_enmax
 
         return cls(**config)
 

pymatgen/io/validation/compare_to_MP_ehull.py

@@ -1,6 +1,6 @@
 """Module for checking if a structure's energy is within a certain distance of the MPDB hull"""
 
-from mp_api.client import MPRester
+from mp_api.client import MPRester  # type: ignore[import-untyped]
 from pymatgen.analysis.phase_diagram import PhaseDiagram
 from pymatgen.entries.mixing_scheme import MaterialsProjectDFTMixingScheme
 from pymatgen.entries.computed_entries import ComputedStructureEntry

pymatgen/io/validation/emmet_validation.py

@@ -5,12 +5,12 @@
 from datetime import datetime
 from pydantic import Field
 
-from emmet.core.tasks import TaskDoc
-from emmet.core.vasp.calculation import Calculation
-from emmet.core.vasp.task_valid import TaskDocument
-from emmet.core.base import EmmetBaseModel
-from emmet.core.mpid import MPID
-from emmet.core.utils import utcnow
+from emmet.core.tasks import TaskDoc  # type: ignore[import-untyped]
+from emmet.core.vasp.calculation import Calculation  # type: ignore[import-untyped]
+from emmet.core.vasp.task_valid import TaskDocument  # type: ignore[import-untyped]
+from emmet.core.base import EmmetBaseModel  # type: ignore[import-untyped]
+from emmet.core.mpid import MPID  # type: ignore[import-untyped]
+from emmet.core.utils import utcnow  # type: ignore[import-untyped]
 
 from pymatgen.io.vasp import Incar