Merge remote-tracking branch 'upstream/master' into fstar

Author: jonathanjdenney

.pre-commit-config.yaml

@@ -8,7 +8,7 @@ ci:
 
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.0.285
+    rev: v0.0.286
     hooks:
       - id: ruff
         args: [--fix]

dev_scripts/chemenv/get_plane_permutations_optimized.py

@@ -256,7 +256,7 @@ def random_permutations_iterator(initial_permutation, n_permutations):
                 explicit_permutations_per_plane.append(set(explicit_permutations))
                 prt1(string="", printing_volume=printing_volume)
             # Check that the explicit permutations found are the same for each plane
-            for ip1 in range(0, len(explicit_permutations_per_plane) - 1):
+            for ip1 in range(len(explicit_permutations_per_plane) - 1):
                 ep_p1 = explicit_permutations_per_plane[ip1]
                 for ip2 in range(1, len(explicit_permutations_per_plane)):
                     ep_p2 = explicit_permutations_per_plane[ip2]

pymatgen/analysis/bond_dissociation.py

@@ -184,7 +184,7 @@ def fragment_and_process(self, bonds):
             if not frags_done:
                 # If we haven't, we save this pair and search for the relevant fragment entries:
                 self.done_frag_pairs += [frags]
-                num_entries_for_this_frag_pair = 0
+                n_entries_for_this_frag_pair = 0
                 frag1_entries = self.search_fragment_entries(frags[0])
                 frag2_entries = self.search_fragment_entries(frags[1])
                 frag1_charges_found = []
@@ -203,14 +203,14 @@ def fragment_and_process(self, bonds):
                     smiles = pb_mol.write("smi").split()[0]
                     for charge in self.expected_charges:
                         if charge not in frag1_charges_found:
-                            print(f"Missing charge {charge} for fragment {smiles}")
+                            print(f"Missing {charge=} for fragment {smiles}")
                 if len(frag2_charges_found) < len(self.expected_charges):
                     bb = BabelMolAdaptor(frags[1].molecule)
                     pb_mol = bb.pybel_mol
                     smiles = pb_mol.write("smi").split()[0]
                     for charge in self.expected_charges:
                         if charge not in frag2_charges_found:
-                            print(f"Missing charge {charge} for fragment {smiles}")
+                            print(f"Missing {charge=} for fragment {smiles}")
                 # Now we attempt to pair fragments with the right total charge, starting with only fragments with no
                 # structural change:
                 for frag1 in frag1_entries[0]:  # 0 -> no structural change
@@ -220,26 +220,26 @@ def fragment_and_process(self, bonds):
                             == self.molecule_entry["final_molecule"]["charge"]
                         ):
                             self.bond_dissociation_energies += [self.build_new_entry([frag1, frag2], bonds)]
-                            num_entries_for_this_frag_pair += 1
+                            n_entries_for_this_frag_pair += 1
                 # If we haven't found the number of fragment pairs that we expect, we expand our search to include
                 # fragments that do exhibit structural change:
-                if num_entries_for_this_frag_pair < len(self.expected_charges):
+                if n_entries_for_this_frag_pair < len(self.expected_charges):
                     for frag1 in frag1_entries[0]:  # 0 -> no structural change
                         for frag2 in frag2_entries[1]:  # 1 -> YES structural change
                             if (
                                 frag1["initial_molecule"]["charge"] + frag2["initial_molecule"]["charge"]
                                 == self.molecule_entry["final_molecule"]["charge"]
                             ):
                                 self.bond_dissociation_energies += [self.build_new_entry([frag1, frag2], bonds)]
-                                num_entries_for_this_frag_pair += 1
+                                n_entries_for_this_frag_pair += 1
                     for frag1 in frag1_entries[1]:  # 1 -> YES structural change
                         for frag2 in frag2_entries[0]:  # 0 -> no structural change
                             if (
                                 frag1["initial_molecule"]["charge"] + frag2["initial_molecule"]["charge"]
                                 == self.molecule_entry["final_molecule"]["charge"]
                             ):
                                 self.bond_dissociation_energies += [self.build_new_entry([frag1, frag2], bonds)]
-                                num_entries_for_this_frag_pair += 1
+                                n_entries_for_this_frag_pair += 1
 
     def search_fragment_entries(self, frag):
         """

pymatgen/analysis/chemenv/connectivity/connected_components.py

@@ -556,13 +556,13 @@ def show_graph(
                 plt.savefig(save_file)
             # nx.draw(self._connected_subgraph)
         elif drawing_type == "draw_graphviz":
-            import networkx
+            import networkx as nx
 
-            networkx.nx_pydot.graphviz_layout(shown_graph)
+            nx.nx_pydot.graphviz_layout(shown_graph)
         elif drawing_type == "draw_random":
-            import networkx
+            import networkx as nx
 
-            networkx.draw_random(shown_graph)
+            nx.draw_random(shown_graph)
 
     @property
     def graph(self):

pymatgen/analysis/chemenv/utils/math_utils.py

@@ -81,7 +81,7 @@ def divisors(n):
     """
     factors = _factor_generator(n)
     _divisors = []
-    listexponents = [[k**x for x in range(0, factors[k] + 1)] for k in list(factors)]
+    listexponents = [[k**x for x in range(factors[k] + 1)] for k in list(factors)]
     listfactors = _cartesian_product(listexponents)
     for f in listfactors:
         _divisors.append(reduce(lambda x, y: x * y, f, 1))

pymatgen/analysis/chempot_diagram.py

@@ -44,7 +44,7 @@
 if TYPE_CHECKING:
     from pymatgen.entries.computed_entries import ComputedEntry
 
-with open(os.path.join(os.path.dirname(__file__), "..", "util", "plotly_chempot_layouts.json")) as file:
+with open(f"{os.path.dirname(__file__)}/../util/plotly_chempot_layouts.json") as file:
     plotly_layouts = json.load(file)
 
 
@@ -680,7 +680,7 @@ def get_centroid_2d(vertices: np.ndarray) -> np.ndarray:
     cy = 0
     a = 0
 
-    for idx in range(0, len(vertices) - 1):
+    for idx in range(len(vertices) - 1):
         xi = vertices[idx, 0]
         yi = vertices[idx, 1]
         xi_p = vertices[idx + 1, 0]

pymatgen/analysis/diffraction/tem.py

@@ -99,7 +99,7 @@ def generate_points(coord_left: int = -10, coord_right: int = 10) -> np.ndarray:
         points = [0, 0, 0]
         coord_values = np.arange(coord_left, coord_right + 1)
         points[0], points[1], points[2] = np.meshgrid(coord_values, coord_values, coord_values)  # type: ignore
-        points_matrix = (np.ravel(points[i]) for i in range(0, 3))
+        points_matrix = (np.ravel(points[i]) for i in range(3))
         return np.vstack(list(points_matrix)).transpose()
 
     def zone_axis_filter(

pymatgen/analysis/dimensionality.py

@@ -535,11 +535,11 @@ def get_dimensionality_gorai(
     if not bonds:
         bonds = get_max_bond_lengths(structure, el_radius_updates)
 
-    num_surfaces = 0
+    n_surfaces = 0
     for hh in range(max_hkl):
         for kk in range(max_hkl):
             for ll in range(max_hkl):
-                if max([hh, kk, ll]) > 0 and num_surfaces < 2:
+                if max([hh, kk, ll]) > 0 and n_surfaces < 2:
                     sg = SlabGenerator(
                         structure,
                         (hh, kk, ll),
@@ -548,6 +548,6 @@ def get_dimensionality_gorai(
                     )
                     slabs = sg.get_slabs(bonds)
                     for _ in slabs:
-                        num_surfaces += 1
+                        n_surfaces += 1
 
-    return 3 - min(num_surfaces, 2)
+    return 3 - min(n_surfaces, 2)

pymatgen/analysis/energy_models.py

@@ -56,10 +56,10 @@ def __init__(self, real_space_cut=None, recip_space_cut=None, eta=None, acc_fact
         Args:
             real_space_cut (float): Real space cutoff radius dictating how
                 many terms are used in the real space sum. Defaults to None,
-                which means determine automagically using the formula given
+                which means determine automatically using the formula given
                 in gulp 3.1 documentation.
             recip_space_cut (float): Reciprocal space cutoff radius.
-                Defaults to None, which means determine automagically using
+                Defaults to None, which means determine automatically using
                 the formula given in gulp 3.1 documentation.
             eta (float): Screening parameter. Defaults to None, which means
                 determine automatically.

pymatgen/analysis/fragmenter.py

@@ -299,7 +299,7 @@ def open_ring(mol_graph, bond, opt_steps):
     self.steps, and then convert the resulting structure back into a molecule graph
     to be returned.
     """
-    obmol = BabelMolAdaptor.from_molecule_graph(mol_graph)
-    obmol.remove_bond(bond[0][0] + 1, bond[0][1] + 1)
-    obmol.localopt(steps=opt_steps, forcefield="uff")
-    return MoleculeGraph.with_local_env_strategy(obmol.pymatgen_mol, OpenBabelNN())
+    ob_mol = BabelMolAdaptor.from_molecule_graph(mol_graph)
+    ob_mol.remove_bond(bond[0][0] + 1, bond[0][1] + 1)
+    ob_mol.localopt(steps=opt_steps, forcefield="uff")
+    return MoleculeGraph.with_local_env_strategy(ob_mol.pymatgen_mol, OpenBabelNN())