add rudimentary hashing to prevent user manipulation

Author: esoteric-ephemera

README.md

@@ -21,7 +21,7 @@ from pymatgen.io.validation import VaspValidator
 validation_doc = VaspValidator.from_directory(path_to_vasp_calculation_directory)
 ```
 
-In the above case, whether a calculation passes the validator can be accessed via `validation_doc.is_valid`. Moreover, reasons for an invalidated calculation can be accessed via `validation_doc.reasons` (this will be empty for valid calculations). Last but not least, warnings for potential issues (sometimes minor, sometimes major) can be accessed via `validation_doc.warnings`.
+In the above case, whether a calculation passes the validator can be accessed via `validation_doc.valid`. Moreover, reasons for an invalidated calculation can be accessed via `validation_doc.reasons` (this will be empty for valid calculations). Last but not least, warnings for potential issues (sometimes minor, sometimes major) can be accessed via `validation_doc.warnings`.
 
 Contributors
 =====

examples/using_validation_docs.ipynb

@@ -105,7 +105,7 @@
    "outputs": [],
    "source": [
     "mp_compliant_doc = check_calc(\"MP_compliant\")\n",
-    "print(mp_compliant_doc.is_valid)"
+    "print(mp_compliant_doc.valid)"
    ]
   },
   {
@@ -127,7 +127,7 @@
    "outputs": [],
    "source": [
     "mp_non_compliant_doc = check_calc(\"MP_non_compliant\")\n",
-    "print(mp_non_compliant_doc.is_valid)\n",
+    "print(mp_non_compliant_doc.valid)\n",
     "for reason in mp_non_compliant_doc.reasons:\n",
     "    print(reason)"
    ]

pymatgen/io/validation/common.py

@@ -3,8 +3,10 @@
 from __future__ import annotations
 
 from functools import cached_property
+import hashlib
 from importlib import import_module
 import os
+import numpy as np
 from pathlib import Path
 from pydantic import BaseModel, Field, model_serializer, PrivateAttr
 from typing import TYPE_CHECKING, Any, Optional
@@ -115,6 +117,20 @@ def from_vasprun(cls, vasprun: Vasprun) -> Self:
             bandgap=vasprun.get_band_structure(efermi="smart").get_band_gap()["energy"],
         )
 
+    @model_serializer
+    def deserialize_objects(self) -> dict[str, Any]:
+        """Ensure all pymatgen objects are deserialized."""
+        model_dumped = {k: getattr(self, k) for k in self.__class__.model_fields}
+        for k in ("final_structure", "kpoints"):
+            model_dumped[k] = model_dumped[k].as_dict()
+        for iion, istep in enumerate(model_dumped["ionic_steps"]):
+            if (istruct := istep.get("structure")) and isinstance(istruct, Structure):
+                model_dumped["ionic_steps"][iion]["structure"] = istruct.as_dict()
+            for k in ("forces", "stress"):
+                if (val := istep.get(k)) is not None and isinstance(val, np.ndarray):
+                    model_dumped["ionic_steps"][iion][k] = val.tolist()
+        return model_dumped
+
 
 class VaspInputSafe(BaseModel):
     """Stricter VaspInputSet with no POTCAR info."""
@@ -183,6 +199,11 @@ class VaspFiles(BaseModel):
     outcar: Optional[LightOutcar] = None
     vasprun: Optional[LightVasprun] = None
 
+    @property
+    def md5(self) -> str:
+        """Get MD5 of VaspFiles for use in validation checks."""
+        return hashlib.md5(self.model_dump_json().encode()).hexdigest()
+
     @property
     def actual_kpoints(self) -> Kpoints | None:
         """The actual KPOINTS / IBZKPT used in the calculation, if applicable."""

pymatgen/io/validation/validation.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 from pathlib import Path
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, PrivateAttr
 from typing import TYPE_CHECKING
 
 from monty.os.path import zpath
@@ -18,6 +18,7 @@
     import os
     from typing_extensions import Self
 
+
 DEFAULT_CHECKS = [CheckStructureProperties, CheckPotcar, CheckCommonErrors, CheckKpointsKspacing, CheckIncar]
 
 # TODO: check for surface/slab calculations. Especially necessary for external calcs.
@@ -27,20 +28,67 @@
 class VaspValidator(BaseModel):
     """Validate a VASP calculation."""
 
+    vasp_files: VaspFiles = Field(description="The VASP I/O.")
     reasons: list[str] = Field([], description="List of deprecation tags detailing why this task isn't valid")
     warnings: list[str] = Field([], description="List of warnings about this calculation")
-    vasp_files: VaspFiles = Field(description="The VASP I/O.")
+
+    _validated_md5: str | None = PrivateAttr(None)
 
     @property
-    def is_valid(self) -> bool:
-        """Determine if the calculation is valid."""
+    def valid(self) -> bool:
+        """Determine if the calculation is valid after ensuring inputs have not changed."""
+        self.recheck()
         return len(self.reasons) == 0
 
     @property
     def has_warnings(self) -> bool:
         """Determine if any warnings were incurred."""
         return len(self.warnings) > 0
 
+    def recheck(self) -> None:
+        """Rerun validation, prioritizing speed."""
+        new_md5 = None
+        if self._validated_md5 is None or (new_md5 := self.vasp_files.md5) != self._validated_md5:
+
+            if self.vasp_files.user_input.potcar:
+                check_list = DEFAULT_CHECKS
+            else:
+                check_list = [c for c in DEFAULT_CHECKS if c.__name__ != "CheckPotcar"]
+            self.reasons, self.warnings = self.run_checks(self.vasp_files, check_list=check_list, fast=True)
+            self._validated_md5 = new_md5 or self.vasp_files.md5
+
+    @staticmethod
+    def run_checks(
+        vasp_files: VaspFiles,
+        check_list: list | tuple = DEFAULT_CHECKS,
+        fast: bool = False,
+    ) -> tuple[list[str], list[str]]:
+        """Perform validation.
+
+        Parameters
+        -----------
+        vasp_files : VaspFiles
+            The VASP I/O to validate.
+        check_list : list or tuple of BaseValidator.
+            The list of checks to perform. Defaults to `DEFAULT_CHECKS`.
+        fast : bool (default = False)
+            Whether to stop validation at the first validation failure (True)
+            or compile a list of all failure reasons.
+
+        Returns
+        -----------
+        tuple of list of str
+            The first list are all reasons for validation failure,
+            the second list contains all warnings.
+        """
+        reasons: list[str] = []
+        warnings: list[str] = []
+        for check in check_list:
+            check(fast=fast).check(vasp_files, reasons, warnings)  # type: ignore[arg-type]
+            if fast and len(reasons) > 0:
+                break
+        return reasons, warnings
+
     @classmethod
     def from_vasp_input(
         cls,
@@ -87,15 +135,14 @@ def from_vasp_input(
         }
 
         if check_potcar:
-            checkers = DEFAULT_CHECKS
+            check_list = DEFAULT_CHECKS
         else:
-            checkers = [c for c in DEFAULT_CHECKS if c.__name__ != "CheckPotcar"]
+            check_list = [c for c in DEFAULT_CHECKS if c.__name__ != "CheckPotcar"]
 
-        for check in checkers:
-            check(fast=fast).check(vf, config["reasons"], config["warnings"])  # type: ignore[arg-type]
-            if fast and len(config["reasons"]) > 0:
-                break
-        return cls(**config, vasp_files=vf, **kwargs)
+        config["reasons"], config["warnings"] = cls.run_checks(vf, check_list=check_list, fast=fast)
+        validated = cls(**config, vasp_files=vf, **kwargs)
+        validated._validated_md5 = vf.md5
+        return validated
 
     @classmethod
     def from_directory(cls, dir_name: str | Path, **kwargs) -> Self:

tests/test_validation.py

@@ -54,6 +54,20 @@ def test_validation_from_files(test_dir):
         for k in ("incar", "structure", "kpoints")
     )
 
+    # Ensure that user modifcation to inputs after submitting valid
+    # input leads to subsequent validation failures.
+    # Re-instantiate VaspValidator to ensure pointers don't get messed up
+    validated = VaspValidator(**validator_from_paths.model_dump())
+    og_md5 = validated.vasp_files.md5
+    assert validated.valid
+    assert validated._validated_md5 == og_md5
+
+    validated.vasp_files.user_input.incar["ENCUT"] = 1.0
+    new_md5 = validated.vasp_files.md5
+    assert new_md5 != og_md5
+    assert not validated.valid
+    assert validated._validated_md5 == new_md5
+
 
 @pytest.mark.parametrize(
     "object_name",
@@ -470,7 +484,7 @@ def test_fast_mode():
     validated = VaspValidator.from_vasp_input(vasp_files=vf, check_potcar=False)
 
     # Without POTCAR check, this doc is valid
-    assert validated.is_valid
+    assert validated.valid
 
     # Now introduce sequence of changes to test how fast validation works
     # Check order:
@@ -532,7 +546,7 @@ def test_site_properties(test_dir):
     vf = VaspFiles(**loadfn(test_dir / "vasp" / "mp-1245223_site_props_check.json.gz"))
     vd = VaspValidator.from_vasp_input(vasp_files=vf)
 
-    assert not vd.is_valid
+    assert not vd.valid
     assert any("selective dynamics" in reason.lower() for reason in vd.reasons)
 
     # map non-zero velocities to input structure and re-check