Set kpoints in from_str method as integer in auto Gamma and Monkhorst modes (#3994)

* kpoints as int in auto Gamma and Monkhorst

* add deprecation warning and docstring tweak

* add unit test

* filter Kpoints warning

* docstring tweaks

* also test deprecation warning

* merge tests into test_static_constructors

* assert int type in automatic_density methods

* clarify typing for Kpoint

* relocate setter and getter to avoid mypy redefine errors

* type annotate some class vars

* remove boilerplate code

* revert changes in io.vasp.inputs

* revert change in POTCAR_spec

* reapply deprecation warning

* My bad, reapply float -> int change

* use Tuple3Ints for more specific typing

* use Tuple3Floats when type is known

Author: DanielYang59

src/pymatgen/io/vasp/inputs.py

@@ -1245,6 +1245,8 @@ def automatic(cls, subdivisions: int) -> Self:
         Returns:
             Kpoints
         """
+        warnings.warn("Please use INCAR KSPACING tag.", DeprecationWarning, stacklevel=2)
+
         return cls(
             "Fully automatic kpoint scheme",
             0,
@@ -1255,7 +1257,7 @@ def automatic(cls, subdivisions: int) -> Self:
         )
 
     @classmethod
-    def gamma_automatic(cls, kpts: Kpoint = (1, 1, 1), shift: Vector3D = (0, 0, 0)) -> Self:
+    def gamma_automatic(cls, kpts: Tuple3Ints = (1, 1, 1), shift: Vector3D = (0, 0, 0)) -> Self:
         """
         Construct an automatic Gamma-centered Kpoint grid.
 
@@ -1270,7 +1272,7 @@ def gamma_automatic(cls, kpts: Kpoint = (1, 1, 1), shift: Vector3D = (0, 0, 0))
         return cls("Automatic kpoint scheme", 0, cls.supported_modes.Gamma, kpts=[kpts], kpts_shift=shift)
 
     @classmethod
-    def monkhorst_automatic(cls, kpts: Kpoint = (2, 2, 2), shift: Vector3D = (0, 0, 0)) -> Self:
+    def monkhorst_automatic(cls, kpts: Tuple3Ints = (2, 2, 2), shift: Vector3D = (0, 0, 0)) -> Self:
         """
         Construct an automatic Monkhorst-Pack Kpoint grid.
 
@@ -1417,7 +1419,7 @@ def automatic_density_by_lengths(
         lattice = structure.lattice
 
         abc = lattice.abc
-        num_div: Tuple3Ints = tuple(np.ceil(ld / abc[idx]) for idx, ld in enumerate(length_densities))
+        num_div: Tuple3Ints = tuple(math.ceil(ld / abc[idx]) for idx, ld in enumerate(length_densities))
 
         is_hexagonal: bool = lattice.is_hexagonal()
         is_face_centered: bool = structure.get_space_group_info()[0][0] == "F"
@@ -1516,10 +1518,10 @@ def from_str(cls, string: str) -> Self:
 
         # Automatic Gamma-centered or Monkhorst-Pack KPOINTS, with optional shift
         if style in {"g", "m"}:
-            _kpt: list[float] = [float(i) for i in lines[3].split()]
+            _kpt: list[int] = [int(i) for i in lines[3].split()]
             if len(_kpt) != 3:
                 raise ValueError("Invalid Kpoint length.")
-            kpt: Tuple3Floats = cast(Tuple3Floats, tuple(_kpt))
+            kpt: Tuple3Ints = cast(Tuple3Ints, tuple(_kpt))
 
             kpts_shift: Vector3D = (0, 0, 0)
             if len(lines) > 4 and coord_pattern.match(lines[4]):
@@ -1559,7 +1561,7 @@ def from_str(cls, string: str) -> Self:
                 "Cartesian" if lines[3].lower()[0] in "ck" else "Reciprocal"
             )
             _style = cls.supported_modes.Line_mode
-            _kpts: list[Kpoint] = []
+            _kpts: list[Tuple3Floats] = []
             labels = []
             patt = re.compile(r"([e0-9.\-]+)\s+([e0-9.\-]+)\s+([e0-9.\-]+)\s*!*\s*(.*)")
             for idx in range(4, len(lines)):
@@ -1588,7 +1590,7 @@ def from_str(cls, string: str) -> Self:
 
         for idx in range(3, 3 + num_kpts):
             tokens = lines[idx].split()
-            kpts.append(cast(Kpoint, tuple(float(i) for i in tokens[:3])))
+            kpts.append(cast(Tuple3Floats, tuple(float(i) for i in tokens[:3])))
             kpts_weights.append(float(tokens[3]))
             if len(tokens) > 4:
                 labels.append(tokens[4])

src/pymatgen/io/vasp/sets.py

@@ -810,6 +810,7 @@ def kpoints(self) -> Kpoints | None:
                     "added_kpoints, or zero weighted k-points."
                 )
             # If length is in kpoints settings use Kpoints.automatic
+            warnings.filterwarnings("ignore", message="Please use INCAR KSPACING tag")
             return Kpoints.automatic(kconfig["length"])
 
         base_kpoints = None

src/pymatgen/util/typing.py

@@ -60,7 +60,11 @@
 SitePropsType = Union[list[dict[Any, Sequence[Any]]], dict[Any, Sequence[Any]]]
 
 # Types specific to io.vasp
-Kpoint = Union[Tuple3Floats, tuple[int,]]
+Kpoint = Union[
+    Tuple3Ints,
+    tuple[int,],  # Automatic k-point mesh
+    Vector3D,  # Line-mode and explicit k-point mesh
+]
 
 # Miller index
 MillerIndex = Tuple3Ints

tests/io/vasp/test_inputs.py

@@ -888,29 +888,44 @@ def test_static_constructors(self):
         kpoints = Kpoints.gamma_automatic((3, 3, 3), [0, 0, 0])
         assert kpoints.style == Kpoints.supported_modes.Gamma
         assert kpoints.kpts == [(3, 3, 3)]
+        assert all(isinstance(kpt, int) for kpt in kpoints.kpts[0])
+
         kpoints = Kpoints.monkhorst_automatic((2, 2, 2), [0, 0, 0])
         assert kpoints.style == Kpoints.supported_modes.Monkhorst
         assert kpoints.kpts == [(2, 2, 2)]
-        kpoints = Kpoints.automatic(100)
+        assert all(isinstance(kpt, int) for kpt in kpoints.kpts[0])
+
+        with pytest.warns(DeprecationWarning, match="Please use INCAR KSPACING tag"):
+            kpoints = Kpoints.automatic(100)
         assert kpoints.style == Kpoints.supported_modes.Automatic
         assert kpoints.kpts == [(100,)]
+        assert all(isinstance(kpt, int) for kpt in kpoints.kpts[0])
+
         filepath = f"{VASP_IN_DIR}/POSCAR"
         struct = Structure.from_file(filepath)
         kpoints = Kpoints.automatic_density(struct, 500)
         assert kpoints.kpts == [(1, 3, 3)]
+        assert all(isinstance(kpt, int) for kpt in kpoints.kpts[0])
         assert kpoints.style == Kpoints.supported_modes.Gamma
+
         kpoints = Kpoints.automatic_density(struct, 500, force_gamma=True)
         assert kpoints.style == Kpoints.supported_modes.Gamma
+        assert all(isinstance(kpt, int) for kpt in kpoints.kpts[0])
+
         kpoints = Kpoints.automatic_density_by_vol(struct, 1000)
         assert kpoints.kpts == [(6, 10, 13)]
+        assert all(isinstance(kpt, int) for kpt in kpoints.kpts[0])
         assert kpoints.style == Kpoints.supported_modes.Gamma
+
         kpoints = Kpoints.automatic_density_by_lengths(struct, [50, 50, 1], force_gamma=True)
         assert kpoints.kpts == [(5, 9, 1)]
+        assert all(isinstance(kpt, int) for kpt in kpoints.kpts[0]), kpoints.kpts
         assert kpoints.style == Kpoints.supported_modes.Gamma
 
         struct.make_supercell(3)
         kpoints = Kpoints.automatic_density(struct, 500)
         assert kpoints.kpts == [(1, 1, 1)]
+        assert all(isinstance(kpt, int) for kpt in kpoints.kpts[0])
         assert kpoints.style == Kpoints.supported_modes.Gamma
         kpoints = Kpoints.from_str(
             """k-point mesh
@@ -966,7 +981,6 @@ def test_copy(self):
         assert kpts != kpt_copy
 
     def test_automatic_kpoint(self):
-        # struct = PymatgenTest.get_structure("Li2O")
         poscar = Poscar.from_str(
             """Al1
 1.0