More cleanup.

Author: shyuep

pyproject.toml

@@ -302,7 +302,7 @@ ignore_missing_imports = true
 namespace_packages = true
 no_implicit_optional = false
 disable_error_code = ["annotation-unchecked", "override", "operator", "attr-defined", "union-attr", "misc", "call-overload", "call-arg", "var-annotated"] #, "operator", "arg-type", "index", "call-arg", "return-value", "assignment", "attr-defined"]
-exclude = ['src/pymatgen/analysis', 'src/pymatgen/phonon', 'src/pymatgen/io/lobster', 'src/pymatgen/io/cp2k', 'src/pymatgen/io/aims', 'src/pymatgen/io/lammps']
+exclude = ['src/pymatgen/analysis', 'src/pymatgen/phonon', 'src/pymatgen/io/lobster', 'src/pymatgen/io/cp2k', 'src/pymatgen/io/lammps']
 plugins = ["numpy.typing.mypy_plugin"]
 
 [[tool.mypy.overrides]]

src/pymatgen/io/aims/inputs.py

@@ -109,16 +109,16 @@ def from_str(cls, contents: str) -> Self:
 
         site_props = {"magmom": magmom, "charge": charge}
         if velocities_dct:
-            site_props["velocity"] = velocity
+            site_props["velocity"] = np.array(velocity)  # type:ignore[assignment]
 
         if lattice is None:
-            structure = Molecule(species, coords, np.sum(charge), site_properties=site_props)
+            structure = Molecule(species, coords, np.sum(charge), site_properties=site_props)  # type:ignore[arg-type]
         else:
-            structure = Structure(
+            structure = Structure(  # type:ignore[assignment]
                 lattice,
                 species,
                 coords,
-                np.sum(charge),
+                np.sum(charge),  # type:ignore[arg-type]
                 coords_are_cartesian=True,
                 site_properties=site_props,
             )
@@ -137,7 +137,7 @@ def from_file(cls, filepath: str | Path) -> Self:
         """
         with zopen(filepath, mode="rt", encoding="utf-8") as in_file:
             content = in_file.read()
-        return cls.from_str(content)
+        return cls.from_str(content)  # type:ignore[arg-type]
 
     @classmethod
     def from_structure(cls, structure: Structure | IStructure | Molecule) -> Self:
@@ -180,7 +180,7 @@ def from_structure(cls, structure: Structure | IStructure | Molecule) -> Self:
             if (v is not None) and any(v_i != 0.0 for v_i in v):
                 content_lines.append(f"     velocity   {'  '.join([f'{v_i:.12e}' for v_i in v])}")
 
-        return cls(_content="\n".join(content_lines), _structure=structure)
+        return cls(_content="\n".join(content_lines), _structure=structure)  # type:ignore[arg-type]
 
     @property
     def structure(self) -> Structure | Molecule:
@@ -232,7 +232,7 @@ def as_dict(self) -> dict[str, Any]:
         dct["@module"] = type(self).__module__
         dct["@class"] = type(self).__name__
         dct["content"] = self.content
-        dct["structure"] = self.structure
+        dct["structure"] = self.structure  # type:ignore[assignment]
         return dct
 
     @classmethod
@@ -303,7 +303,7 @@ class AimsCube(MSONable):
 
     type: str = field(default_factory=str)
     origin: Sequence[float] | tuple[float, float, float] = field(default_factory=lambda: [0.0, 0.0, 0.0])
-    edges: Sequence[Sequence[float]] = field(default_factory=lambda: 0.1 * np.eye(3))
+    edges: Sequence[Sequence[float]] = field(default_factory=lambda: 0.1 * np.eye(3))  # type:ignore[return-value, arg-type]
     points: Sequence[int] | tuple[int, int, int] = field(default_factory=lambda: [0, 0, 0])
     format: str = "cube"
     spin_state: int | None = None
@@ -766,7 +766,7 @@ def from_file(cls, filename: str, label: str | None = None) -> Self:
             AimsSpeciesFile
         """
         with zopen(filename, mode="rt", encoding="utf-8") as file:
-            return cls(data=file.read(), label=label)
+            return cls(data=file.read(), label=label)  # type:ignore[arg-type]
 
     @classmethod
     def from_element_and_basis_name(

src/pymatgen/io/aims/outputs.py

@@ -206,22 +206,19 @@ def forces(self) -> Sequence[tuple[float, float, float]] | None:
     @property
     def stress(
         self,
-    ) -> Sequence[Sequence[float, float, float], Sequence[float, float, float], Sequence[float, float, float]]:
+    ) -> np.ndarray:
         """The stress for the final image of the calculation."""
         return self.get_results_for_image(-1).properties.get("stress", None)
 
     @property
     def stresses(
         self,
-    ) -> (
-        Sequence[Sequence[Sequence[float, float, float], Sequence[float, float, float], Sequence[float, float, float]]]
-        | None
-    ):
+    ) -> list[list[float]] | None:
         """The atomic virial stresses for the final image of the calculation."""
         stresses_array = self.get_results_for_image(-1).site_properties.get("atomic_virial_stress", None)
         if isinstance(stresses_array, np.ndarray):
             return stresses_array.tolist()
-        return stresses_array
+        return stresses_array  # type:ignore[return-value]
 
     @property
     def all_forces(self) -> list[list[tuple[float, float, float]]]:

src/pymatgen/io/aims/parsers.py

@@ -300,7 +300,7 @@ def _parse_initial_charges_and_moments(self) -> None:
                     magmoms = None
                 else:
                     charges[ll] = float(inp[3])
-                    magmoms[ll] = float(inp[2])
+                    magmoms[ll] = float(inp[2])  # type:ignore[index]
 
         self._cache["initial_charges"] = charges
         self._cache["initial_magnetic_moments"] = magmoms
@@ -476,7 +476,7 @@ def _parse_structure(self) -> Structure | Molecule:
 
         site_properties: dict[str, Sequence[Any]] = {}
         if len(velocities) > 0:
-            site_properties["velocity"] = np.array(velocities)
+            site_properties["velocity"] = np.array(velocities)  # type:ignore [assignment]
 
         results = self.results
         site_prop_keys = {
@@ -641,14 +641,14 @@ def stresses(self) -> np.ndarray | None:
         stresses = []
         for line in self.lines[line_start : line_start + self.n_atoms]:
             xx, yy, zz, xy, xz, yz = (float(d) for d in line.split()[2:8])
-            stresses.append(Tensor.from_voigt([xx, yy, zz, yz, xz, xy]))
+            stresses.append(Tensor.from_voigt([xx, yy, zz, yz, xz, xy]))  # type:ignore [arg-type]
 
         return np.array(stresses) * EV_PER_A3_TO_KBAR
 
     @property
     def stress(
         self,
-    ) -> Sequence[Sequence[float, float, float], Sequence[float, float, float], Sequence[float, float, float]] | None:
+    ) -> np.ndarray | None:
         """The stress from the aims.out file and convert to kBar."""
         line_start = self.reverse_search_for(
             ["Analytical stress tensor - Symmetrized", "Numerical stress tensor"]
@@ -680,7 +680,7 @@ def energy(self) -> float:
         return float(self.lines[line_ind].split()[5])
 
     @property
-    def dipole(self) -> tuple[float, float, float] | None:
+    def dipole(self) -> np.ndarray | None:
         """The electric dipole moment from the aims.out file."""
         line_start = self.reverse_search_for(["Total dipole moment [eAng]"])
         if line_start == LINE_NOT_FOUND:
@@ -692,7 +692,7 @@ def dipole(self) -> tuple[float, float, float] | None:
     @property
     def dielectric_tensor(
         self,
-    ) -> Sequence[Sequence[float, float, float], Sequence[float, float, float], Sequence[float, float, float]] | None:
+    ) -> np.ndarray | None:
         """The dielectric tensor from the aims.out file."""
         line_start = self.reverse_search_for(["PARSE DFPT_dielectric_tensor"])
         if line_start == LINE_NOT_FOUND:
@@ -705,7 +705,7 @@ def dielectric_tensor(
         return np.array([np.fromstring(line, sep=" ") for line in lines])
 
     @property
-    def polarization(self) -> tuple[float, float, float] | None:
+    def polarization(self) -> np.ndarray | None:
         """The polarization vector from the aims.out file."""
         line_start = self.reverse_search_for(["| Cartesian Polarization"])
         if line_start == LINE_NOT_FOUND:

src/pymatgen/io/aims/sets/base.py

@@ -396,7 +396,7 @@ def d2k(
         recip_cell = structure.lattice.inv_matrix.transpose()
         return self.d2k_recip_cell(recip_cell, structure.lattice.pbc, kpt_density, even)
 
-    def k2d(self, structure: Structure | IStructure, k_grid: np.ndarray[int]):
+    def k2d(self, structure: Structure | IStructure, k_grid: np.ndarray):
         """Generate the kpoint density in each direction from given k_grid.
 
         Args: