rename single-letter loop vars

Author: janosh

dev_scripts/update_pt_data.py

@@ -238,11 +238,11 @@ def add_electron_affinities():
 
     req = requests.get("https://wikipedia.org/wiki/Electron_affinity_(data_page)")
     soup = BeautifulSoup(req.text, "html.parser")
-    for t in soup.find_all("table"):
-        if "Hydrogen" in t.text:
+    for table in soup.find_all("table"):
+        if "Hydrogen" in table.text:
             break
     data = []
-    for tr in t.find_all("tr"):
+    for tr in table.find_all("tr"):
         row = []
         for td in tr.find_all("td"):
             row.append(td.get_text().strip())

pymatgen/alchemy/materials.py

@@ -173,14 +173,14 @@ def extend_transformations(
                 return_alternatives can be a number, which stipulates the
                 total number of structures to return.
         """
-        for t in transformations:
-            self.append_transformation(t, return_alternatives=return_alternatives)
+        for trafo in transformations:
+            self.append_transformation(trafo, return_alternatives=return_alternatives)
 
     def get_vasp_input(self, vasp_input_set: type[VaspInputSet] = MPRelaxSet, **kwargs) -> dict[str, Any]:
         """Returns VASP input as a dict of VASP objects.
 
         Args:
-            vasp_input_set (pymatgen.io.vasp.sets.VaspInputSet): input set
+            vasp_input_set (VaspInputSet): input set
                 to create VASP input files from structures
             **kwargs: All keyword args supported by the VASP input set.
         """

pymatgen/alchemy/transmuters.py

@@ -131,8 +131,8 @@ def extend_transformations(self, transformations):
         Args:
             transformations: Sequence of Transformations
         """
-        for t in transformations:
-            self.append_transformation(t)
+        for trafo in transformations:
+            self.append_transformation(trafo)
 
     def apply_filter(self, structure_filter):
         """Applies a structure_filter to the list of TransformedStructures

pymatgen/analysis/chemenv/utils/chemenv_errors.py

@@ -25,7 +25,7 @@ def __init__(self, cls, method, msg):
         self.msg = msg
 
     def __str__(self):
-        return str(self.cls) + ": " + self.method + "\n" + repr(self.msg)
+        return f"{self.cls}: {self.method}\n{self.msg!r}"
 
 
 class NeighborsNotComputedChemenvError(AbstractChemenvError):

pymatgen/analysis/graphs.py

@@ -1251,12 +1251,12 @@ def __rmul__(self, other):
         return self.__mul__(other)
 
     @classmethod
-    def _edges_to_str(cls, g):
+    def _edges_to_str(cls, g) -> str:
         header = "from    to  to_image    "
         header_line = "----  ----  ------------"
         edge_weight_name = g.graph["edge_weight_name"]
         if edge_weight_name:
-            print_weights = ["weight"]
+            print_weights = True
             edge_label = g.graph["edge_weight_name"]
             edge_weight_units = g.graph["edge_weight_units"]
             if edge_weight_units:
@@ -1266,7 +1266,7 @@ def _edges_to_str(cls, g):
         else:
             print_weights = False
 
-        s = header + "\n" + header_line + "\n"
+        out = f"{header}\n{header_line}\n"
 
         edges = list(g.edges(data=True))
 
@@ -1275,12 +1275,12 @@ def _edges_to_str(cls, g):
 
         if print_weights:
             for u, v, data in edges:
-                s += f"{u:4}  {v:4}  {data.get('to_jimage', (0, 0, 0))!s:12}  {data.get('weight', 0):.3e}\n"
+                out += f"{u:4}  {v:4}  {data.get('to_jimage', (0, 0, 0))!s:12}  {data.get('weight', 0):.3e}\n"
         else:
             for u, v, data in edges:
-                s += f"{u:4}  {v:4}  {data.get('to_jimage', (0, 0, 0))!s:12}\n"
+                out += f"{u:4}  {v:4}  {data.get('to_jimage', (0, 0, 0))!s:12}\n"
 
-        return s
+        return out
 
     def __str__(self):
         out = "Structure Graph"

pymatgen/analysis/local_env.py

@@ -2279,15 +2279,15 @@ def __init__(self, types, parameters=None, cutoff=-10.0) -> None:
                 pruned using the get_nn method from the
                 VoronoiNN class.
         """
-        for t in types:
-            if t not in LocalStructOrderParams.__supported_types:
-                raise ValueError("Unknown order parameter type (" + t + ")!")
+        for typ in types:
+            if typ not in LocalStructOrderParams.__supported_types:
+                raise ValueError(f"Unknown order parameter type ({typ})!")
         self._types = tuple(types)
 
         self._comp_azi = False
         self._params = []
-        for i, t in enumerate(self._types):
-            d = deepcopy(default_op_params[t]) if default_op_params[t] is not None else None
+        for i, typ in enumerate(self._types):
+            d = deepcopy(default_op_params[typ]) if default_op_params[typ] is not None else None
             if parameters is None or parameters[i] is None:
                 self._params.append(d)
             else:

pymatgen/command_line/gulp_caller.py

@@ -301,7 +301,7 @@ def structure_lines(
             core_site_desc = f"{specie.symbol} core {' '.join(coord)}\n"
             gin += core_site_desc
             if (specie in _anions and anion_shell_flg) or (specie in _cations and cation_shell_flg):
-                shel_site_desc = specie.symbol + " shel " + " ".join(coord) + "\n"
+                shel_site_desc = f"{specie.symbol} shel {' '.join(coord)}\n"
                 gin += shel_site_desc
             else:
                 pass

pymatgen/core/tensors.py

@@ -689,7 +689,7 @@ def zeroed(self, tol: float = 1e-3):
         Returns:
             TensorCollection where small values are set to 0.
         """
-        return self.__class__([t.zeroed(tol) for t in self])
+        return self.__class__([tensor.zeroed(tol) for tensor in self])
 
     def transform(self, symm_op):
         """Transforms TensorCollection with a symmetry operation.
@@ -699,7 +699,7 @@ def transform(self, symm_op):
         Returns:
             TensorCollection.
         """
-        return self.__class__([t.transform(symm_op) for t in self])
+        return self.__class__([tensor.transform(symm_op) for tensor in self])
 
     def rotate(self, matrix, tol: float = 1e-3):
         """Rotates TensorCollection.
@@ -710,20 +710,20 @@ def rotate(self, matrix, tol: float = 1e-3):
         Returns:
             TensorCollection.
         """
-        return self.__class__([t.rotate(matrix, tol) for t in self])
+        return self.__class__([tensor.rotate(matrix, tol) for tensor in self])
 
     @property
     def symmetrized(self):
         """TensorCollection where all tensors are symmetrized."""
-        return self.__class__([t.symmetrized for t in self])
+        return self.__class__([tensor.symmetrized for tensor in self])
 
     def is_symmetric(self, tol: float = 1e-5):
         """:param tol: tolerance
 
         Returns:
             Whether all tensors are symmetric.
         """
-        return all(t.is_symmetric(tol) for t in self)
+        return all(tensor.is_symmetric(tol) for tensor in self)
 
     def fit_to_structure(self, structure: Structure, symprec: float = 0.1):
         """Fits all tensors to a Structure.
@@ -734,7 +734,7 @@ def fit_to_structure(self, structure: Structure, symprec: float = 0.1):
         Returns:
             TensorCollection.
         """
-        return self.__class__([t.fit_to_structure(structure, symprec) for t in self])
+        return self.__class__([tensor.fit_to_structure(structure, symprec) for tensor in self])
 
     def is_fit_to_structure(self, structure: Structure, tol: float = 1e-2):
         """:param structure: Structure
@@ -743,25 +743,25 @@ def is_fit_to_structure(self, structure: Structure, tol: float = 1e-2):
         Returns:
             Whether all tensors are fitted to Structure.
         """
-        return all(t.is_fit_to_structure(structure, tol) for t in self)
+        return all(tensor.is_fit_to_structure(structure, tol) for tensor in self)
 
     @property
     def voigt(self):
         """TensorCollection where all tensors are in Voigt form."""
-        return [t.voigt for t in self]
+        return [tensor.voigt for tensor in self]
 
     @property
     def ranks(self):
         """Ranks for all tensors."""
-        return [t.rank for t in self]
+        return [tensor.rank for tensor in self]
 
     def is_voigt_symmetric(self, tol: float = 1e-6):
         """:param tol: tolerance
 
         Returns:
             Whether all tensors are voigt symmetric.
         """
-        return all(t.is_voigt_symmetric(tol) for t in self)
+        return all(tensor.is_voigt_symmetric(tol) for tensor in self)
 
     @classmethod
     def from_voigt(cls, voigt_input_list, base_class=Tensor):
@@ -785,7 +785,7 @@ def convert_to_ieee(self, structure: Structure, initial_fit=True, refine_rotatio
         Returns:
             TensorCollection.
         """
-        return self.__class__([t.convert_to_ieee(structure, initial_fit, refine_rotation) for t in self])
+        return self.__class__([tensor.convert_to_ieee(structure, initial_fit, refine_rotation) for tensor in self])
 
     def round(self, *args, **kwargs):
         """Round all tensors.
@@ -796,12 +796,12 @@ def round(self, *args, **kwargs):
         Returns:
             TensorCollection.
         """
-        return self.__class__([t.round(*args, **kwargs) for t in self])
+        return self.__class__([tensor.round(*args, **kwargs) for tensor in self])
 
     @property
     def voigt_symmetrized(self):
         """TensorCollection where all tensors are voigt symmetrized."""
-        return self.__class__([t.voigt_symmetrized for t in self])
+        return self.__class__([tensor.voigt_symmetrized for tensor in self])
 
     def as_dict(self, voigt=False):
         """:param voigt: Whether to use Voigt form.
@@ -813,7 +813,7 @@ def as_dict(self, voigt=False):
         dct = {
             "@module": type(self).__module__,
             "@class": type(self).__name__,
-            "tensor_list": [t.tolist() for t in tensor_list],
+            "tensor_list": [tensor.tolist() for tensor in tensor_list],
         }
         if voigt:
             dct["voigt"] = voigt

pymatgen/electronic_structure/bandstructure.py

@@ -450,9 +450,7 @@ def get_band_gap(self):
 
         result["transition"] = "-".join(
             [
-                str(c.label)
-                if c.label is not None
-                else "(" + ",".join(f"{c.frac_coords[i]:.3f}" for i in range(3)) + ")"
+                str(c.label) if c.label is not None else f"({','.join(f'{c.frac_coords[i]:.3f}' for i in range(3))})"
                 for c in [vbm["kpoint"], cbm["kpoint"]]
             ]
         )

pymatgen/electronic_structure/boltztrap2.py

@@ -735,12 +735,12 @@ def __init__(
 
             # Derived properties
             cond_eff_mass = np.zeros((len(self.temp_r), len(self.mu_r), 3, 3))
-            for t in range(len(self.temp_r)):
+            for temp in range(len(self.temp_r)):
                 for i in range(len(self.mu_r)):
                     try:
-                        cond_eff_mass[t, i] = (
-                            np.linalg.inv(self.Conductivity_mu[t, i])
-                            * self.Carrier_conc_mu[t, i]
+                        cond_eff_mass[temp, i] = (
+                            np.linalg.inv(self.Conductivity_mu[temp, i])
+                            * self.Carrier_conc_mu[temp, i]
                             * units.qe_SI**2
                             / units.me_SI
                             * 1e6
@@ -1038,9 +1038,9 @@ def plot_props(
         mu = self.bzt_transP.mu_r_eV
 
         if prop_z == "doping" and prop_x == "temp":
-            p_array = eval("self.bzt_transP." + props[idx_prop] + "_" + prop_z)
+            p_array = eval(f"self.bzt_transP.{props[idx_prop]}_{prop_z}")
         else:
-            p_array = eval("self.bzt_transP." + props[idx_prop] + "_" + prop_x)
+            p_array = eval(f"self.bzt_transP.{props[idx_prop]}_{prop_x}")
 
         if ax is None:
             plt.figure(figsize=(10, 8))