ruff fix RUF031: Avoid parentheses for tuples in subscripts.

Author: janosh

src/pymatgen/analysis/chemenv/connectivity/connected_components.py

@@ -121,7 +121,7 @@ def draw_network(env_graph, pos, ax, sg=None, periodicity_vectors=None):
             xytext=xy_text_offset,
             textcoords="offset points",
         )
-        seen[(u, v)] = rad
+        seen[u, v] = rad
         ax.add_patch(e)
 
 
@@ -242,13 +242,13 @@ def __init__(
                     edge_data = None
 
                 elif (env_node1, env_node2, key) in links_data:
-                    edge_data = links_data[(env_node1, env_node2, key)]
+                    edge_data = links_data[env_node1, env_node2, key]
                 elif (env_node2, env_node1, key) in links_data:
-                    edge_data = links_data[(env_node2, env_node1, key)]
+                    edge_data = links_data[env_node2, env_node1, key]
                 elif (env_node1, env_node2) in links_data:
-                    edge_data = links_data[(env_node1, env_node2)]
+                    edge_data = links_data[env_node1, env_node2]
                 elif (env_node2, env_node1) in links_data:
-                    edge_data = links_data[(env_node2, env_node1)]
+                    edge_data = links_data[env_node2, env_node1]
                 else:
                     edge_data = None
 

src/pymatgen/analysis/chemenv/utils/graph_utils.py

@@ -479,15 +479,15 @@ def get_all_elementary_cycles(graph):
     index2edge = []
     edge_idx = 0
     for n1, n2 in graph.edges:
-        all_edges_dict[(n1, n2)] = edge_idx
-        all_edges_dict[(n2, n1)] = edge_idx
+        all_edges_dict[n1, n2] = edge_idx
+        all_edges_dict[n2, n1] = edge_idx
         index2edge.append((n1, n2))
         edge_idx += 1
     cycles_matrix = np.zeros(shape=(len(cycle_basis), edge_idx), dtype=bool)
     for icycle, cycle in enumerate(cycle_basis):
         for in1, n1 in enumerate(cycle, start=1):
             n2 = cycle[(in1) % len(cycle)]
-            iedge = all_edges_dict[(n1, n2)]
+            iedge = all_edges_dict[n1, n2]
             cycles_matrix[icycle, iedge] = True
 
     elementary_cycles_list = []

src/pymatgen/analysis/diffraction/tem.py

@@ -484,7 +484,7 @@ def get_positions(self, structure: Structure, points: list) -> dict[Tuple3Ints,
             points.remove((0, 0, 0))
         points.remove(first_point)
         points.remove(second_point)
-        positions[(0, 0, 0)] = np.array([0, 0])
+        positions[0, 0, 0] = np.array([0, 0])
         r1 = self.wavelength_rel() * self.camera_length / first_d
         positions[first_point] = np.array([r1, 0])
         r2 = self.wavelength_rel() * self.camera_length / second_d

src/pymatgen/analysis/disorder.py

@@ -28,13 +28,13 @@ def get_warren_cowley_parameters(structure: Structure, r: float, dr: float) -> d
     n_neighbors: defaultdict = defaultdict(int)
     for site in structure:
         for nn in structure.get_neighbors_in_shell(site.coords, r, dr):
-            n_ij[(site.specie, nn.specie)] += 1
+            n_ij[site.specie, nn.specie] += 1
             n_neighbors[site.specie] += 1
 
     alpha_ij = {}
     for sp1, sp2 in itertools.product(comp, comp):
         pij = n_ij.get((sp1, sp2), 0) / n_neighbors[sp1]
         conc2 = comp.get_atomic_fraction(sp2)
-        alpha_ij[(sp1, sp2)] = (pij - conc2) / ((1 if sp1 == sp2 else 0) - conc2)
+        alpha_ij[sp1, sp2] = (pij - conc2) / ((1 if sp1 == sp2 else 0) - conc2)
 
     return alpha_ij

src/pymatgen/analysis/eos.py

@@ -471,10 +471,10 @@ def get_rms(x, y):
                 if a * b < 0:
                     rms = get_rms(energies, np.poly1d(coeffs)(volumes))
                     rms_min = min(rms_min, rms * idx / n_data_fit)
-                    all_coeffs[(idx, n_data_fit)] = [coeffs.tolist(), rms]
+                    all_coeffs[idx, n_data_fit] = [coeffs.tolist(), rms]
                     # store the fit coefficients small to large,
                     # i.e a0, a1, .. an
-                    all_coeffs[(idx, n_data_fit)][0].reverse()
+                    all_coeffs[idx, n_data_fit][0].reverse()
             # remove 1 data point from each end.
             e_v_work.pop()
             e_v_work.pop(0)

src/pymatgen/analysis/graphs.py

@@ -717,7 +717,7 @@ def map_indices(grp: Molecule) -> dict[int, int]:
 
         if graph_dict is not None:
             for u, v in graph_dict:
-                edge_props = graph_dict[(u, v)]
+                edge_props = graph_dict[u, v]
                 # default of (0, 0, 0) says that all edges should stay inside the initial image
                 to_jimage = edge_props.get("to_jimage", (0, 0, 0))
                 weight = edge_props.pop("weight", None)
@@ -2097,12 +2097,12 @@ def split_molecule_subgraphs(self, bonds, allow_reverse=False, alterations=None)
         # alter any bonds before partition, to avoid remapping
         if alterations is not None:
             for u, v in alterations:
-                if "weight" in alterations[(u, v)]:
-                    weight = alterations[(u, v)].pop("weight")
-                    edge_properties = alterations[(u, v)] if len(alterations[(u, v)]) != 0 else None
+                if "weight" in alterations[u, v]:
+                    weight = alterations[u, v].pop("weight")
+                    edge_properties = alterations[u, v] if len(alterations[u, v]) != 0 else None
                     original.alter_edge(u, v, new_weight=weight, new_edge_properties=edge_properties)
                 else:
-                    original.alter_edge(u, v, new_edge_properties=alterations[(u, v)])
+                    original.alter_edge(u, v, new_edge_properties=alterations[u, v])
 
         return original.get_disconnected_fragments()
 
@@ -2160,7 +2160,7 @@ def build_unique_fragments(self):
                 for from_index, to_index, key in remapped.edges:
                     edge_props = fragment.get_edge_data(from_index, to_index, key=key)
 
-                    edges[(from_index, to_index)] = edge_props
+                    edges[from_index, to_index] = edge_props
 
                 unique_mol_graph_list.append(
                     self.from_edges(
@@ -2261,7 +2261,7 @@ def map_indices(grp):
 
             if graph_dict is not None:
                 for u, v in graph_dict:
-                    edge_props = graph_dict[(u, v)]
+                    edge_props = graph_dict[u, v]
                     weight = edge_props.pop("weight", None)
                     self.add_edge(
                         mapping[u],

src/pymatgen/analysis/local_env.py

@@ -1288,7 +1288,7 @@ def get_nn_info(self, structure: Structure, n: int):
         for nn in structure.get_neighbors(site, max_rad):
             dist = nn.nn_distance
             # Confirm neighbor based on bond length specific to atom pair
-            if dist <= (bonds[(site.specie, nn.specie)]) and (nn.nn_distance > self.min_bond_distance):
+            if dist <= (bonds[site.specie, nn.specie]) and (nn.nn_distance > self.min_bond_distance):
                 weight = min_rad / dist
                 siw.append(
                     {

src/pymatgen/analysis/magnetism/heisenberg.py

@@ -886,27 +886,26 @@ def as_dict(self):
     def from_dict(cls, dct: dict) -> Self:
         """Create a HeisenbergModel from a dict."""
         # Reconstitute the site ids
-        usids = {}
-        wids = {}
-        nnis = {}
+        unique_site_ids = {}
+        wyckoff_ids = {}
+        nn_interactions = {}
 
         for k, v in dct["nn_interactions"].items():
             nn_dict = {}
             for k1, v1 in v.items():
                 key = literal_eval(k1)
                 nn_dict[key] = v1
-            nnis[k] = nn_dict
+            nn_interactions[k] = nn_dict
 
         for k, v in dct["unique_site_ids"].items():
             key = literal_eval(k)
             if isinstance(key, int):
-                usids[(key,)] = v
+                unique_site_ids[key,] = v
             elif isinstance(key, tuple):
-                usids[key] = v
+                unique_site_ids[key] = v
 
         for k, v in dct["wyckoff_ids"].items():
-            key = literal_eval(k)
-            wids[key] = v
+            wyckoff_ids[literal_eval(k)] = v
 
         # Reconstitute the structure and graph objects
         structures = []
@@ -933,9 +932,9 @@ def from_dict(cls, dct: dict) -> Self:
             cutoff=dct["cutoff"],
             tol=dct["tol"],
             sgraphs=sgraphs,
-            unique_site_ids=usids,
-            wyckoff_ids=wids,
-            nn_interactions=nnis,
+            unique_site_ids=unique_site_ids,
+            wyckoff_ids=wyckoff_ids,
+            nn_interactions=nn_interactions,
             dists=dct["dists"],
             ex_mat=ex_mat,
             ex_params=dct["ex_params"],
@@ -956,8 +955,7 @@ def _get_j_exc(self, i, j, dist):
             float: Exchange parameter J_exc in meV
         """
         # Get unique site identifiers
-        i_index = 0
-        j_index = 0
+        i_index = j_index = 0
         for k in self.unique_site_ids:
             if i in k:
                 i_index = self.unique_site_ids[k]

src/pymatgen/analysis/phase_diagram.py

@@ -3538,7 +3538,7 @@ def _get_matplotlib_2d_plot(
                 # whether an entry is a new compound or an existing (from the
                 #  ICSD or from the MP) one.
                 for x, y in labels:
-                    if labels[(x, y)].attribute is None or labels[(x, y)].attribute == "existing":
+                    if labels[x, y].attribute is None or labels[x, y].attribute == "existing":
                         plt.plot(x, y, "ko", **self.plotkwargs)
                     else:
                         plt.plot(x, y, "k*", **self.plotkwargs)
@@ -3566,7 +3566,7 @@ def _get_matplotlib_2d_plot(
             ii = 0
             if process_attributes:
                 for x, y in labels:
-                    if labels[(x, y)].attribute is None or labels[(x, y)].attribute == "existing":
+                    if labels[x, y].attribute is None or labels[x, y].attribute == "existing":
                         plt.plot(x, y, "o", markerfacecolor=vals_stable[ii], markersize=12)
                     else:
                         plt.plot(x, y, "*", markerfacecolor=vals_stable[ii], markersize=18)

src/pymatgen/cli/pmg_structure.py

@@ -56,7 +56,7 @@ def analyze_localenv(args):
     for bond in args.localenv:
         tokens = bond.split("=")
         species = tokens[0].split("-")
-        bonds[(species[0], species[1])] = float(tokens[1])
+        bonds[species[0], species[1]] = float(tokens[1])
     for filename in args.filenames:
         print(f"Analyzing {filename}...")
         data = []