Cleanup all unnecessary type definitions. There really isn't a need to

define things like Tuple3Ints, etc. when it is easier to just read the
primitive types. We only introduce type definitions for things that are
not easily covered under typical primitives or NDArray.

Author: shyuep

src/pymatgen/analysis/diffraction/tem.py

@@ -20,7 +20,6 @@
     from numpy.typing import NDArray
 
     from pymatgen.core import Structure
-    from pymatgen.util.typing import Tuple3Ints
 
 __author__ = "Frank Wan, Jason Liang"
 __copyright__ = "Copyright 2020, The Materials Project"
@@ -48,7 +47,7 @@ def __init__(
         self,
         symprec: float | None = None,
         voltage: float = 200,
-        beam_direction: Tuple3Ints = (0, 0, 1),
+        beam_direction: tuple[int, int, int] = (0, 0, 1),
         camera_length: int = 160,
         debye_waller_factors: dict[str, float] | None = None,
         cs: float = 1,
@@ -105,7 +104,9 @@ def generate_points(coord_left: int = -10, coord_right: int = 10) -> np.ndarray:
         points_matrix = (np.ravel(points[i]) for i in range(3))
         return np.vstack(list(points_matrix)).transpose()
 
-    def zone_axis_filter(self, points: list[Tuple3Ints] | np.ndarray, laue_zone: int = 0) -> list[Tuple3Ints]:
+    def zone_axis_filter(
+        self, points: list[tuple[int, int, int]] | np.ndarray, laue_zone: int = 0
+    ) -> list[tuple[int, int, int]]:
         """Filter out all points that exist within the specified Laue zone according to the zone axis rule.
 
         Args:
@@ -121,11 +122,11 @@ def zone_axis_filter(self, points: list[Tuple3Ints] | np.ndarray, laue_zone: int
             return []
         filtered = np.where(np.dot(np.array(self.beam_direction), np.transpose(points)) == laue_zone)
         result = points[filtered]
-        return cast("list[Tuple3Ints]", [tuple(x) for x in result.tolist()])
+        return cast("list[tuple[int, int, int]]", [tuple(x) for x in result.tolist()])
 
     def get_interplanar_spacings(
-        self, structure: Structure, points: list[Tuple3Ints] | np.ndarray
-    ) -> dict[Tuple3Ints, float]:
+        self, structure: Structure, points: list[tuple[int, int, int]] | np.ndarray
+    ) -> dict[tuple[int, int, int], float]:
         """
         Args:
             structure (Structure): the input structure.
@@ -141,7 +142,9 @@ def get_interplanar_spacings(
         interplanar_spacings_val = np.array([structure.lattice.d_hkl(x) for x in points_filtered])
         return dict(zip(points_filtered, interplanar_spacings_val, strict=True))
 
-    def bragg_angles(self, interplanar_spacings: dict[Tuple3Ints, float]) -> dict[Tuple3Ints, float]:
+    def bragg_angles(
+        self, interplanar_spacings: dict[tuple[int, int, int], float]
+    ) -> dict[tuple[int, int, int], float]:
         """Get the Bragg angles for every hkl point passed in (where n = 1).
 
         Args:
@@ -155,7 +158,7 @@ def bragg_angles(self, interplanar_spacings: dict[Tuple3Ints, float]) -> dict[Tu
         bragg_angles_val = np.arcsin(self.wavelength_rel() / (2 * interplanar_spacings_val))
         return dict(zip(plane, bragg_angles_val, strict=True))
 
-    def get_s2(self, bragg_angles: dict[Tuple3Ints, float]) -> dict[Tuple3Ints, float]:
+    def get_s2(self, bragg_angles: dict[tuple[int, int, int], float]) -> dict[tuple[int, int, int], float]:
         """
         Calculates the s squared parameter (= square of sin theta over lambda) for each hkl plane.
 
@@ -172,8 +175,8 @@ def get_s2(self, bragg_angles: dict[Tuple3Ints, float]) -> dict[Tuple3Ints, floa
         return dict(zip(plane, s2_val, strict=True))
 
     def x_ray_factors(
-        self, structure: Structure, bragg_angles: dict[Tuple3Ints, float]
-    ) -> dict[str, dict[Tuple3Ints, float]]:
+        self, structure: Structure, bragg_angles: dict[tuple[int, int, int], float]
+    ) -> dict[str, dict[tuple[int, int, int], float]]:
         """
         Calculates x-ray factors, which are required to calculate atomic scattering factors. Method partially inspired
         by the equivalent process in the xrd module.
@@ -202,8 +205,8 @@ def x_ray_factors(
         return x_ray_factors
 
     def electron_scattering_factors(
-        self, structure: Structure, bragg_angles: dict[Tuple3Ints, float]
-    ) -> dict[str, dict[Tuple3Ints, float]]:
+        self, structure: Structure, bragg_angles: dict[tuple[int, int, int], float]
+    ) -> dict[str, dict[tuple[int, int, int], float]]:
         """
         Calculates atomic scattering factors for electrons using the Mott-Bethe formula (1st order Born approximation).
 
@@ -229,8 +232,8 @@ def electron_scattering_factors(
         return electron_scattering_factors
 
     def cell_scattering_factors(
-        self, structure: Structure, bragg_angles: dict[Tuple3Ints, float]
-    ) -> dict[Tuple3Ints, int]:
+        self, structure: Structure, bragg_angles: dict[tuple[int, int, int], float]
+    ) -> dict[tuple[int, int, int], int]:
         """
         Calculates the scattering factor for the whole cell.
 
@@ -255,7 +258,9 @@ def cell_scattering_factors(
             scattering_factor_curr = 0
         return cell_scattering_factors
 
-    def cell_intensity(self, structure: Structure, bragg_angles: dict[Tuple3Ints, float]) -> dict[Tuple3Ints, float]:
+    def cell_intensity(
+        self, structure: Structure, bragg_angles: dict[tuple[int, int, int], float]
+    ) -> dict[tuple[int, int, int], float]:
         """
         Calculates cell intensity for each hkl plane. For simplicity's sake, take I = |F|**2.
 
@@ -312,8 +317,8 @@ def get_pattern(
         return pd.DataFrame(rows, columns=field_names)
 
     def normalized_cell_intensity(
-        self, structure: Structure, bragg_angles: dict[Tuple3Ints, float]
-    ) -> dict[Tuple3Ints, float]:
+        self, structure: Structure, bragg_angles: dict[tuple[int, int, int], float]
+    ) -> dict[tuple[int, int, int], float]:
         """
         Normalizes the cell_intensity dict to 1, for use in plotting.
 
@@ -335,8 +340,8 @@ def normalized_cell_intensity(
     def is_parallel(
         self,
         structure: Structure,
-        plane: Tuple3Ints,
-        other_plane: Tuple3Ints,
+        plane: tuple[int, int, int],
+        other_plane: tuple[int, int, int],
     ) -> bool:
         """Checks if two hkl planes are parallel in reciprocal space.
 
@@ -351,7 +356,7 @@ def is_parallel(
         phi = self.get_interplanar_angle(structure, plane, other_plane)
         return phi in (180, 0) or np.isnan(phi)
 
-    def get_first_point(self, structure: Structure, points: list) -> dict[Tuple3Ints, float]:
+    def get_first_point(self, structure: Structure, points: list) -> dict[tuple[int, int, int], float]:
         """Get the first point to be plotted in the 2D DP, corresponding to maximum d/minimum R.
 
         Args:
@@ -372,7 +377,7 @@ def get_first_point(self, structure: Structure, points: list) -> dict[Tuple3Ints
         return {max_d_plane: max_d}
 
     @staticmethod
-    def get_interplanar_angle(structure: Structure, p1: Tuple3Ints, p2: Tuple3Ints) -> float:
+    def get_interplanar_angle(structure: Structure, p1: tuple[int, int, int], p2: tuple[int, int, int]) -> float:
         """Get the interplanar angle (in degrees) between the normal of two crystal planes.
         Formulas from International Tables for Crystallography Volume C pp. 2-9.
 
@@ -426,9 +431,9 @@ def get_interplanar_angle(structure: Structure, p1: Tuple3Ints, p2: Tuple3Ints)
 
     @staticmethod
     def get_plot_coeffs(
-        p1: Tuple3Ints,
-        p2: Tuple3Ints,
-        p3: Tuple3Ints,
+        p1: tuple[int, int, int],
+        p2: tuple[int, int, int],
+        p3: tuple[int, int, int],
     ) -> np.ndarray:
         """
         Calculates coefficients of the vector addition required to generate positions for each DP point
@@ -448,7 +453,7 @@ def get_plot_coeffs(
         x = np.dot(a_pinv, b)
         return np.ravel(x)
 
-    def get_positions(self, structure: Structure, points: list) -> dict[Tuple3Ints, np.ndarray]:
+    def get_positions(self, structure: Structure, points: list) -> dict[tuple[int, int, int], np.ndarray]:
         """
         Calculates all the positions of each hkl point in the 2D diffraction pattern by vector addition.
         Distance in centimeters.
@@ -518,7 +523,7 @@ def tem_dots(self, structure: Structure, points) -> list:
 
         class dot(NamedTuple):
             position: NDArray
-            hkl: Tuple3Ints
+            hkl: tuple[int, int, int]
             intensity: float
             film_radius: float
             d_spacing: float

src/pymatgen/analysis/graphs.py

@@ -43,7 +43,6 @@
 
     from pymatgen.analysis.local_env import NearNeighbors
     from pymatgen.core import Species
-    from pymatgen.util.typing import Tuple3Ints
 
 
 logger = logging.getLogger(__name__)
@@ -59,7 +58,7 @@
 
 class ConnectedSite(NamedTuple):
     site: PeriodicSite
-    jimage: Tuple3Ints
+    jimage: tuple[int, int, int]
     index: Any  # TODO: use more specific type
     weight: float
     dist: float
@@ -334,8 +333,8 @@ def add_edge(
         self,
         from_index: int,
         to_index: int,
-        from_jimage: Tuple3Ints = (0, 0, 0),
-        to_jimage: Tuple3Ints | None = None,
+        from_jimage: tuple[int, int, int] = (0, 0, 0),
+        to_jimage: tuple[int, int, int] | None = None,
         weight: float | None = None,
         warn_duplicates: bool = True,
         edge_properties: dict | None = None,
@@ -755,7 +754,7 @@ def map_indices(grp: Molecule) -> dict[int, int]:
                         warn_duplicates=False,
                     )
 
-    def get_connected_sites(self, n: int, jimage: Tuple3Ints = (0, 0, 0)) -> list[ConnectedSite]:
+    def get_connected_sites(self, n: int, jimage: tuple[int, int, int] = (0, 0, 0)) -> list[ConnectedSite]:
         """Get a named tuple of neighbors of site n:
         periodic_site, jimage, index, weight.
         Index is the index of the corresponding site

src/pymatgen/analysis/interfaces/coherent_interfaces.py

@@ -17,7 +17,6 @@
     from collections.abc import Iterator, Sequence
 
     from pymatgen.core import Structure
-    from pymatgen.util.typing import Tuple3Ints
 
 
 class CoherentInterfaceBuilder:
@@ -30,8 +29,8 @@ def __init__(
         self,
         substrate_structure: Structure,
         film_structure: Structure,
-        film_miller: Tuple3Ints,
-        substrate_miller: Tuple3Ints,
+        film_miller: tuple[int, int, int],
+        substrate_miller: tuple[int, int, int],
         zslgen: ZSLGenerator | None = None,
         termination_ftol: float = 0.25,
         label_index: bool = False,  # necessary to add index to termination

src/pymatgen/analysis/interfaces/substrate_analyzer.py

@@ -14,7 +14,6 @@
     from typing_extensions import Self
 
     from pymatgen.core import Structure
-    from pymatgen.util.typing import Tuple3Ints
 
 
 @dataclass
@@ -25,8 +24,8 @@ class SubstrateMatch(ZSLMatch):
     energy if provided, and the elastic energy.
     """
 
-    film_miller: Tuple3Ints
-    substrate_miller: Tuple3Ints
+    film_miller: tuple[int, int, int]
+    substrate_miller: tuple[int, int, int]
     strain: Strain
     von_mises_strain: float
     ground_state_energy: float

src/pymatgen/analysis/local_env.py

@@ -40,7 +40,6 @@
 
     from pymatgen.analysis.graphs import MoleculeGraph
     from pymatgen.core.composition import SpeciesLike
-    from pymatgen.util.typing import Tuple3Ints
 
 
 __author__ = "Shyue Ping Ong, Geoffroy Hautier, Sai Jayaraman, "
@@ -563,7 +562,7 @@ def _get_nn_shell_info(
         return list(all_sites.values())
 
     @staticmethod
-    def _get_image(structure: Structure, site: Site) -> Tuple3Ints:
+    def _get_image(structure: Structure, site: Site) -> tuple[int, int, int]:
         """Private convenience method for get_nn_info,
         gives lattice image from provided PeriodicSite and Structure.
 

src/pymatgen/analysis/surface_analysis.py

@@ -57,7 +57,6 @@
 if TYPE_CHECKING:
     from typing_extensions import Self
 
-    from pymatgen.util.typing import Tuple3Ints
 
 EV_PER_ANG2_TO_JOULES_PER_M2 = 16.0217656
 
@@ -573,7 +572,7 @@ def area_frac_vs_chempot_plot(
         all_chempots = np.linspace(min(chempot_range), max(chempot_range), increments)
 
         # initialize a dictionary of lists of fractional areas for each hkl
-        hkl_area_dict: dict[Tuple3Ints, list[float]] = {}
+        hkl_area_dict: dict[tuple[int, int, int], list[float]] = {}
         for hkl in self.all_slab_entries:
             hkl_area_dict[hkl] = []