Fix CI error "pdentries_test.csv" not found (#3168)

* snake_case

* get_asum_FCM change AssertionError to RuntimeError

* fix empty doc strings

* snake_case

* fix CI error "pdentries_test.csv" not found

* better TransformedPDEntryTest.test_str

* fix PeriodicSite._frac_coords type

refactor PeriodicSite.__repr__
remove unused type ignore

* fix TransformedPDEntryTest.test_str

* better TransformedPDEntry.test_is_element

* breaking: remove pltshow=True kwarg from ConnectedComponent.show_graph

fix mypy

* fix test broken by PeriodicSite.__repr__ dropping redundant float precision

* fix mypy

* fix >       assert self.labeled_site.label == "Fe2"
E       AssertionError: assert 'site label' == 'Fe2'

* mypy ignore

Author: janosh

pymatgen/analysis/chemenv/connectivity/connected_components.py

@@ -392,7 +392,7 @@ def compute_periodicity(self, algorithm="all_simple_paths"):
         self._order_periodicity_vectors()
 
     def compute_periodicity_all_simple_paths_algorithm(self):
-        """Returns:"""
+        """Get the periodicity vectors of the connected component."""
         self_loop_nodes = list(nx.nodes_with_selfloops(self._connected_subgraph))
         all_nodes_independent_cell_image_vectors = []
         my_simple_graph = nx.Graph(self._connected_subgraph)
@@ -476,23 +476,22 @@ def compute_periodicity_all_simple_paths_algorithm(self):
                 if len(self._periodicity_vectors) == 3:
                     break
 
-    def compute_periodicity_cycle_basis(self):
-        """Returns:"""
+    def compute_periodicity_cycle_basis(self) -> None:
+        """Compute periodicity vectors of the connected component."""
         my_simple_graph = nx.Graph(self._connected_subgraph)
         cycles = nx.cycle_basis(my_simple_graph)
-        all_deltas = []
-        for cyc in cycles:
-            mycyc = list(cyc)
-            mycyc.append(cyc[0])
+        all_deltas: list[list] = []
+        for cyc in map(list, cycles):
+            cyc.append(cyc[0])
             this_cycle_deltas = [np.zeros(3, int)]
-            for node1, node2 in [(node1, mycyc[inode1 + 1]) for inode1, node1 in enumerate(mycyc[:-1])]:
+            for node1, node2 in [(node1, cyc[inode1 + 1]) for inode1, node1 in enumerate(cyc[:-1])]:
                 this_cycle_deltas_new = []
                 for edge_data in self._connected_subgraph[node1][node2].values():
                     delta = get_delta(node1, node2, edge_data)
                     for current_delta in this_cycle_deltas:
                         this_cycle_deltas_new.append(current_delta + delta)
                 this_cycle_deltas = this_cycle_deltas_new
-            all_deltas.extend(this_cycle_deltas)
+            all_deltas.extend(this_cycle_deltas)  # type: ignore
             all_deltas = get_linearly_independent_vectors(all_deltas)
             if len(all_deltas) == 3:
                 return
@@ -510,7 +509,7 @@ def compute_periodicity_cycle_basis(self):
                     current_delta = get_delta(n1, n2, e1data)
                     delta = get_delta(n2, n1, e2data)
                     current_delta += delta
-                    all_deltas.append(current_delta)
+                    all_deltas.append(current_delta)  # type: ignore
             else:
                 raise ValueError("Should not be here ...")
             all_deltas = get_linearly_independent_vectors(all_deltas)
@@ -528,13 +527,17 @@ def make_supergraph(self, multiplicity):
         """
         return make_supergraph(self._connected_subgraph, multiplicity, self._periodicity_vectors)
 
-    def show_graph(self, graph=None, save_file=None, drawing_type="internal", pltshow=True) -> None:
+    def show_graph(
+        self, graph: nx.MultiGraph | None = None, save_file: str | None = None, drawing_type: str = "internal"
+    ) -> None:
         """
+        Displays the graph using the specified drawing type.
+
         Args:
-            graph ():
-            save_file ():
-            drawing_type ():
-            pltshow ():
+            graph (Graph, optional): The graph to display. If not provided, the current graph is used.
+            save_file (str, optional): The file path to save the graph image to.
+                If not provided, the graph is not saved.
+            drawing_type (str): The type of drawing to use. Can be "internal" or "external".
         """
         import matplotlib.pyplot as plt
 
@@ -560,51 +563,49 @@ def show_graph(self, graph=None, save_file=None, drawing_type="internal", pltsho
             import networkx
 
             networkx.draw_random(shown_graph)
-        if pltshow:
-            plt.show()
 
     @property
     def graph(self):
         """Return the graph of this connected component.
 
         Returns:
             MultiGraph: Networkx MultiGraph object with environment as nodes and links between these nodes as edges
-                        with information about the image cell difference if any.
+                with information about the image cell difference if any.
         """
         return self._connected_subgraph
 
     @property
     def is_periodic(self) -> bool:
-        """Returns:"""
+        """Whether this connected component is periodic."""
         return not self.is_0d
 
     @property
     def is_0d(self) -> bool:
-        """Returns:"""
+        """Whether this connected component is 0-dimensional."""
         if self._periodicity_vectors is None:
             self.compute_periodicity()
         assert self._periodicity_vectors is not None  # fix mypy arg 1 to len has incompatible type Optional
         return len(self._periodicity_vectors) == 0
 
     @property
     def is_1d(self) -> bool:
-        """Returns:"""
+        """Whether this connected component is 1-dimensional."""
         if self._periodicity_vectors is None:
             self.compute_periodicity()
         assert self._periodicity_vectors is not None  # fix mypy arg 1 to len has incompatible type Optional
         return len(self._periodicity_vectors) == 1
 
     @property
     def is_2d(self) -> bool:
-        """Returns:"""
+        """Whether this connected component is 2-dimensional."""
         if self._periodicity_vectors is None:
             self.compute_periodicity()
         assert self._periodicity_vectors is not None  # fix mypy arg 1 to len has incompatible type Optional
         return len(self._periodicity_vectors) == 2
 
     @property
     def is_3d(self) -> bool:
-        """Returns:"""
+        """Whether this connected component is 3-dimensional."""
         if self._periodicity_vectors is None:
             self.compute_periodicity()
         assert self._periodicity_vectors is not None  # fix mypy arg 1 to len has incompatible type Optional
@@ -622,8 +623,8 @@ def _order_vectors(vectors):
         Example: [[1, 1, 0], [0, 1, -1], [0, 1, 1]] is ordered as [[0, 1, -1], [0, 1, 1], [1, 1, 0]]
         """
         for ipv, pv in enumerate(vectors):
-            nonzeros = np.nonzero(pv)[0]
-            if pv[nonzeros[0]] < 0 < len(nonzeros):
+            non_zeros = np.nonzero(pv)[0]
+            if pv[non_zeros[0]] < 0 < len(non_zeros):
                 vectors[ipv] = -pv
         return sorted(vectors, key=lambda x: x.tolist())
 
@@ -633,21 +634,21 @@ def _order_periodicity_vectors(self):
             raise ValueError("Number of periodicity vectors is larger than 3.")
         self._periodicity_vectors = self._order_vectors(self._periodicity_vectors)
         # for ipv, pv in enumerate(self._periodicity_vectors):
-        #     nonzeros = np.nonzero(pv)[0]
-        #     if (len(nonzeros) > 0) and (pv[nonzeros[0]] < 0):
+        #     non_zeros = np.nonzero(pv)[0]
+        #     if (len(non_zeros) > 0) and (pv[non_zeros[0]] < 0):
         #         self._periodicity_vectors[ipv] = -pv
         # self._periodicity_vectors = sorted(self._periodicity_vectors, key=lambda x: x.tolist())
 
     @property
     def periodicity_vectors(self):
-        """Returns:"""
+        """Get periodicity vectors of this connected component."""
         if self._periodicity_vectors is None:
             self.compute_periodicity()
         return [np.array(pp) for pp in self._periodicity_vectors]
 
     @property
     def periodicity(self):
-        """Returns:"""
+        """Get periodicity of this connected component."""
         if self._periodicity_vectors is None:
             self.compute_periodicity()
         return f"{len(self._periodicity_vectors):d}D"

pymatgen/analysis/chemenv/connectivity/structure_connectivity.py

@@ -266,8 +266,8 @@ def setup_environments_subgraph(self, environments_symbols):
     def setup_atom_environments_subgraph(self, atoms_environments):
         raise NotImplementedError
 
-    def print_links(self):
-        """Returns:"""
+    def print_links(self) -> None:
+        """Print all links in the graph."""
         nodes = self.environment_subgraph().nodes()
         print("Links in graph :")
         for node in nodes:
@@ -285,7 +285,7 @@ def print_links(self):
                     )
 
     def as_dict(self):
-        """Returns:"""
+        """Convert to MSONable dict."""
         return {
             "@module": type(self).__module__,
             "@class": type(self).__name__,

pymatgen/analysis/chemenv/coordination_environments/structure_environments.py

@@ -1746,10 +1746,10 @@ def setup_statistic_lists(self):
                 fraction_ion_stat[elmt][oxi_state] = {env: fraction / sumspecie for env, fraction in envs.items()}
         for ce_symbol, ions in ce_ion_stat.items():
             fraction_ce_ion_stat[ce_symbol] = {}
-            sum_ce = np.sum([np.sum(list(oxistates.values())) for elmt, oxistates in ions.items()])
-            for elmt, oxistates in ions.items():
+            sum_ce = np.sum([np.sum(list(oxi_states.values())) for elmt, oxi_states in ions.items()])
+            for elmt, oxi_states in ions.items():
                 fraction_ce_ion_stat[ce_symbol][elmt] = {
-                    oxistate: fraction / sum_ce for oxistate, fraction in oxistates.items()
+                    oxistate: fraction / sum_ce for oxistate, fraction in oxi_states.items()
                 }
 
     def get_site_info_for_specie_ce(self, specie, ce_symbol):

pymatgen/analysis/chemenv/utils/coordination_geometry_utils.py

@@ -603,11 +603,11 @@ def __init__(self, coefficients, p1=None, p2=None, p3=None):
         self.normal_vector = np.array([coefficients[0], coefficients[1], coefficients[2]], np.float_)
         normv = np.linalg.norm(self.normal_vector)
         self.normal_vector /= normv
-        nonzeros = np.argwhere(self.normal_vector != 0.0).flatten()
-        zeros = list(set(range(3)) - set(nonzeros))
-        if len(nonzeros) == 0:
+        non_zeros = np.argwhere(self.normal_vector != 0.0).flatten()
+        zeros = list(set(range(3)) - set(non_zeros))
+        if len(non_zeros) == 0:
             raise ValueError("Normal vector is equal to 0.0")
-        if self.normal_vector[nonzeros[0]] < 0.0:
+        if self.normal_vector[non_zeros[0]] < 0.0:
             self.normal_vector = -self.normal_vector
             dd = -np.float_(coefficients[3]) / normv
         else:
@@ -622,32 +622,32 @@ def __init__(self, coefficients, p1=None, p2=None, p3=None):
         self.p3 = p3
         # Initializes 3 points belonging to the plane (useful for some methods)
         if self.p1 is None:
-            self.init_3points(nonzeros, zeros)
+            self.init_3points(non_zeros, zeros)
         self.vector_to_origin = dd * self.normal_vector
         self.e1 = self.e2 = None
         self.e3 = self.normal_vector
 
-    def init_3points(self, nonzeros, zeros):
+    def init_3points(self, non_zeros, zeros):
         """Initialize three random points on this plane.
 
-        :param nonzeros: Indices of plane coefficients ([a, b, c]) that are not zero.
+        :param non_zeros: Indices of plane coefficients ([a, b, c]) that are not zero.
         :param zeros: Indices of plane coefficients ([a, b, c]) that are equal to zero.
         :return: None
         """
-        if len(nonzeros) == 3:
+        if len(non_zeros) == 3:
             self.p1 = np.array([-self.d / self.a, 0.0, 0.0], np.float_)
             self.p2 = np.array([0.0, -self.d / self.b, 0.0], np.float_)
             self.p3 = np.array([0.0, 0.0, -self.d / self.c], np.float_)
-        elif len(nonzeros) == 2:
+        elif len(non_zeros) == 2:
             self.p1 = np.zeros(3, np.float_)
-            self.p1[nonzeros[1]] = -self.d / self.coefficients[nonzeros[1]]
+            self.p1[non_zeros[1]] = -self.d / self.coefficients[non_zeros[1]]
             self.p2 = np.array(self.p1)
             self.p2[zeros[0]] = 1.0
             self.p3 = np.zeros(3, np.float_)
-            self.p3[nonzeros[0]] = -self.d / self.coefficients[nonzeros[0]]
-        elif len(nonzeros) == 1:
+            self.p3[non_zeros[0]] = -self.d / self.coefficients[non_zeros[0]]
+        elif len(non_zeros) == 1:
             self.p1 = np.zeros(3, np.float_)
-            self.p1[nonzeros[0]] = -self.d / self.coefficients[nonzeros[0]]
+            self.p1[non_zeros[0]] = -self.d / self.coefficients[non_zeros[0]]
             self.p2 = np.array(self.p1)
             self.p2[zeros[0]] = 1.0
             self.p3 = np.array(self.p1)
@@ -937,8 +937,8 @@ def from_3points(cls, p1, p2, p3):
         """
         nn = np.cross(p1 - p3, p2 - p3)
         normal_vector = nn / norm(nn)
-        nonzeros = np.argwhere(normal_vector != 0.0)
-        if normal_vector[nonzeros[0, 0]] < 0.0:
+        non_zeros = np.argwhere(normal_vector != 0.0)
+        if normal_vector[non_zeros[0, 0]] < 0.0:
             normal_vector = -normal_vector
         dd = -np.dot(normal_vector, p1)
         coefficients = np.array([normal_vector[0], normal_vector[1], normal_vector[2], dd], np.float_)
@@ -980,8 +980,8 @@ def from_npoints_least_square_distance(cls, points):
         [UU, SS, Vt] = np.linalg.svd(AA)
         imin = np.argmin(SS)
         normal_vector = Vt[imin]
-        nonzeros = np.argwhere(normal_vector != 0.0)
-        if normal_vector[nonzeros[0, 0]] < 0.0:
+        non_zeros = np.argwhere(normal_vector != 0.0)
+        if normal_vector[non_zeros[0, 0]] < 0.0:
             normal_vector = -normal_vector
         dd = -np.dot(normal_vector, mean_point)
         coefficients = np.array([normal_vector[0], normal_vector[1], normal_vector[2], dd], np.float_)

pymatgen/analysis/ewald.py

@@ -315,10 +315,10 @@ def _calc_recip(self):
         This method is heavily vectorized to utilize numpy's C backend for
         speed.
         """
-        numsites = self._s.num_sites
+        n_sites = self._s.num_sites
         prefactor = 2 * pi / self._vol
-        erecip = np.zeros((numsites, numsites), dtype=np.float_)
-        forces = np.zeros((numsites, 3), dtype=np.float_)
+        e_recip = np.zeros((n_sites, n_sites), dtype=np.float_)
+        forces = np.zeros((n_sites, 3), dtype=np.float_)
         coords = self._coords
         rcp_latt = self._s.lattice.reciprocal_lattice
         recip_nn = rcp_latt.get_points_in_sphere([[0, 0, 0]], [0, 0, 0], self._gmax)
@@ -327,51 +327,51 @@ def _calc_recip(self):
 
         gs = rcp_latt.get_cartesian_coords(frac_coords)
         g2s = np.sum(gs**2, 1)
-        expvals = np.exp(-g2s / (4 * self._eta))
+        exp_vals = np.exp(-g2s / (4 * self._eta))
         grs = np.sum(gs[:, None] * coords[None, :], 2)
 
-        oxistates = np.array(self._oxi_states)
+        oxi_states = np.array(self._oxi_states)
 
         # create array where q_2[i,j] is qi * qj
-        qiqj = oxistates[None, :] * oxistates[:, None]
+        qiqj = oxi_states[None, :] * oxi_states[:, None]
 
         # calculate the structure factor
-        sreals = np.sum(oxistates[None, :] * np.cos(grs), 1)
-        simags = np.sum(oxistates[None, :] * np.sin(grs), 1)
+        s_reals = np.sum(oxi_states[None, :] * np.cos(grs), 1)
+        s_imags = np.sum(oxi_states[None, :] * np.sin(grs), 1)
 
-        for g, g2, gr, expval, sreal, simag in zip(gs, g2s, grs, expvals, sreals, simags):
+        for g, g2, gr, expval, sreal, simag in zip(gs, g2s, grs, exp_vals, s_reals, s_imags):
             # Uses the identity sin(x)+cos(x) = 2**0.5 sin(x + pi/4)
             m = (gr[None, :] + pi / 4) - gr[:, None]
             np.sin(m, m)
             m *= expval / g2
 
-            erecip += m
+            e_recip += m
 
             if self._compute_forces:
-                pref = 2 * expval / g2 * oxistates
+                pref = 2 * expval / g2 * oxi_states
                 factor = prefactor * pref * (sreal * np.sin(gr) - simag * np.cos(gr))
 
                 forces += factor[:, None] * g[None, :]
 
         forces *= EwaldSummation.CONV_FACT
-        erecip *= prefactor * EwaldSummation.CONV_FACT * qiqj * 2**0.5
-        return erecip, forces
+        e_recip *= prefactor * EwaldSummation.CONV_FACT * qiqj * 2**0.5
+        return e_recip, forces
 
     def _calc_real_and_point(self):
         """Determines the self energy -(eta/pi)**(1/2) * sum_{i=1}^{N} q_i**2."""
         fcoords = self._s.frac_coords
         forcepf = 2 * self._sqrt_eta / sqrt(pi)
         coords = self._coords
-        numsites = self._s.num_sites
-        ereal = np.empty((numsites, numsites), dtype=np.float_)
+        n_sites = self._s.num_sites
+        ereal = np.empty((n_sites, n_sites), dtype=np.float_)
 
-        forces = np.zeros((numsites, 3), dtype=np.float_)
+        forces = np.zeros((n_sites, 3), dtype=np.float_)
 
         qs = np.array(self._oxi_states)
 
         epoint = -(qs**2) * sqrt(self._eta / pi)
 
-        for i in range(numsites):
+        for i in range(n_sites):
             nfcoords, rij, js, _ = self._s.lattice.get_points_in_sphere(
                 fcoords, coords[i], self._rmax, zip_results=False
             )
@@ -389,7 +389,7 @@ def _calc_real_and_point(self):
             new_ereals = erfcval * qi * qj / rij
 
             # insert new_ereals
-            for key in range(numsites):
+            for key in range(n_sites):
                 ereal[key, i] = np.sum(new_ereals[js == key])
 
             if self._compute_forces:

pymatgen/analysis/local_env.py

@@ -208,8 +208,8 @@ def _handle_disorder(structure: Structure, on_disorder: on_disorder_options):
         raise ValueError(
             f"Generating StructureGraphs for disordered Structures is unsupported. Pass on_disorder='take "
             "majority' | 'take_max_species' | 'error'. 'take_majority_strict' considers only the majority species from "
-            "each site in the bonding algorithm and raises ValueError in case there is no majority (e.g. as in {{Fe: "
-            "0.4, O: 0.4, C: 0.2}}) whereas 'take_majority_drop' just ignores the site altogether when computing bonds "
+            "each site in the bonding algorithm and raises ValueError in case there is no majority (e.g. as in {Fe: "
+            "0.4, O: 0.4, C: 0.2}) whereas 'take_majority_drop' just ignores the site altogether when computing bonds "
             "as if it didn't exist. 'take_max_species' extracts the first max species on each site (Fe in prev. "
             "example since Fe and O have equal occupancy and Fe comes first). 'error' raises an error in case "
             f"of disordered structure. Offending {structure = }"

pymatgen/analysis/magnetism/tests/test_analyzer.py

@@ -212,10 +212,10 @@ def test_str(self):
       B : 0.0 0.0 -4.17
       C : -2.085 2.085 0.0
 Magmoms Sites
-+5.00   PeriodicSite: Ni (0.0000, 0.0000, 0.0000) [0.0000, 0.0000, 0.0000]
-        PeriodicSite: O (0.0000, 0.0000, -2.0850) [0.0000, 0.5000, 0.0000]
-        PeriodicSite: O (0.0000, 2.0850, 0.0000) [0.5000, 0.0000, 0.5000]
--5.00   PeriodicSite: Ni (0.0000, 2.0850, -2.0850) [0.5000, 0.5000, 0.5000]"""
++5.00   PeriodicSite: Ni (0.0, 0.0, 0.0) [0.0, 0.0, 0.0]
+        PeriodicSite: O (0.0, 0.0, -2.085) [0.0, 0.5, 0.0]
+        PeriodicSite: O (0.0, 2.085, 0.0) [0.5, 0.0, 0.5]
+-5.00   PeriodicSite: Ni (0.0, 2.085, -2.085) [0.5, 0.5, 0.5]"""
 
         # just compare lines form 'Magmoms Sites',
         # since lattice param string can vary based on machine precision