xyz.__iter__() -> iter(xyz) (#3228)

Author: janosh

pymatgen/analysis/chemenv/connectivity/environment_nodes.py

@@ -42,7 +42,7 @@ def isite(self):
 
     def __hash__(self) -> int:
         """Simple hash function based on the hash function of the central site."""
-        return self.central_site.__hash__()
+        return hash(self.central_site)
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, AbstractEnvironmentNode):

pymatgen/analysis/graphs.py

@@ -1151,8 +1151,8 @@ def __mul__(self, scaling_matrix):
         # this could probably be a lot smaller
         tol = 0.05
 
-        for u, v, k, d in new_g.edges(keys=True, data=True):
-            to_jimage = d["to_jimage"]  # for node v
+        for u, v, k, dct in new_g.edges(keys=True, data=True):
+            to_jimage = dct["to_jimage"]  # for node v
 
             # reduce unnecessary checking
             if to_jimage != (0, 0, 0):
@@ -1191,7 +1191,7 @@ def __mul__(self, scaling_matrix):
                 if v_present is not None:
                     new_u = u
                     new_v = v_present
-                    new_d = d.copy()
+                    new_d = dct.copy()
 
                     # node now inside supercell
                     new_d["to_jimage"] = (0, 0, 0)
@@ -1229,13 +1229,13 @@ def __mul__(self, scaling_matrix):
                     if v_present is not None:
                         new_u = u
                         new_v = v_present
-                        new_d = d.copy()
+                        new_d = dct.copy()
                         new_to_jimage = tuple(map(int, v_expec_image))
 
                         # normalize direction
                         if new_v < new_u:
                             new_u, new_v = new_v, new_u
-                            new_to_jimage = tuple(np.multiply(-1, d["to_jimage"]).astype(int))
+                            new_to_jimage = tuple(np.multiply(-1, dct["to_jimage"]).astype(int))
 
                         new_d["to_jimage"] = new_to_jimage
 
@@ -1250,18 +1250,18 @@ def __mul__(self, scaling_matrix):
         # add/delete marked edges
         for edge in edges_to_remove:
             new_g.remove_edge(*edge)
-        for u, v, d in edges_to_add:
-            new_g.add_edge(u, v, **d)
+        for u, v, dct in edges_to_add:
+            new_g.add_edge(u, v, **dct)
 
         # return new instance of StructureGraph with supercell
-        d = {
+        dct = {
             "@module": type(self).__module__,
             "@class": type(self).__name__,
             "structure": new_structure.as_dict(),
             "graphs": json_graph.adjacency_data(new_g),
         }
 
-        return StructureGraph.from_dict(d)
+        return StructureGraph.from_dict(dct)
 
     def __rmul__(self, other):
         return self.__mul__(other)
@@ -1307,7 +1307,7 @@ def __str__(self):
 
     def __repr__(self):
         s = "Structure Graph"
-        s += f"\nStructure: \n{self.structure.__repr__()}"
+        s += f"\nStructure: \n{self.structure!r}"
         s += f"\nGraph: {self.name}\n"
         s += self._edges_to_string(self.graph)
         return s
@@ -1363,8 +1363,7 @@ def __eq__(self, other: object) -> bool:
         if not isinstance(other, StructureGraph):
             return NotImplemented
         # sort for consistent node indices
-        # PeriodicSite should have a proper __hash__() value,
-        # using its frac_coords as a convenient key
+        # PeriodicSite should have a proper __hash__() value, using its frac_coords as a convenient key
         mapping = {tuple(site.frac_coords): self.structure.index(site) for site in other.structure}
         other_sorted = other.__copy__()
         other_sorted.sort(key=lambda site: mapping[tuple(site.frac_coords)])
@@ -1406,8 +1405,7 @@ def diff(self, other, strict=True):
 
         if strict:
             # sort for consistent node indices
-            # PeriodicSite should have a proper __hash__() value,
-            # using its frac_coords as a convenient key
+            # PeriodicSite should have a proper __hash__() value, using its frac_coords as a convenient key
             mapping = {tuple(site.frac_coords): self.structure.index(site) for site in other.structure}
             other_sorted = copy.copy(other)
             other_sorted.sort(key=lambda site: mapping[tuple(site.frac_coords)])
@@ -2668,7 +2666,7 @@ def __str__(self) -> str:
 
     def __repr__(self) -> str:
         out = "Molecule Graph"
-        out += f"\nMolecule: \n{self.molecule.__repr__()}"
+        out += f"\nMolecule: \n{self.molecule!r}"
         out += f"\nGraph: {self.name}\n"
         out += self._edges_to_string(self.graph)
         return out
@@ -2725,8 +2723,7 @@ def __eq__(self, other: object) -> bool:
             return NotImplemented
 
         # sort for consistent node indices
-        # PeriodicSite should have a proper __hash__() value,
-        # using its frac_coords as a convenient key
+        # PeriodicSite should have a proper __hash__() value, using its frac_coords as a convenient key
         try:
             mapping = {tuple(site.coords): self.molecule.index(site) for site in other.molecule}
         except ValueError:
@@ -2789,8 +2786,7 @@ def diff(self, other, strict=True):
 
         if strict:
             # sort for consistent node indices
-            # PeriodicSite should have a proper __hash__() value,
-            # using its frac_coords as a convenient key
+            # PeriodicSite should have a proper __hash__() value, using its frac_coords as a convenient key
             mapping = {tuple(site.frac_coords): self.molecule.index(site) for site in other.molecule}
             other_sorted = copy.copy(other)
             other_sorted.sort(key=lambda site: mapping[tuple(site.frac_coords)])

pymatgen/apps/battery/battery_abc.py

@@ -142,7 +142,7 @@ def __contains__(self, obj):
         return obj in self.voltage_pairs
 
     def __iter__(self):
-        return self.voltage_pairs.__iter__()
+        return iter(self.voltage_pairs)
 
     def __len__(self):
         return len(self.voltage_pairs)

pymatgen/core/composition.py

@@ -146,7 +146,7 @@ def __len__(self) -> int:
         return len(self._data)
 
     def __iter__(self) -> Iterator[Species | Element | DummySpecies]:
-        return self._data.__iter__()
+        return iter(self._data)
 
     def __contains__(self, key) -> bool:
         try:
@@ -437,8 +437,9 @@ def __str__(self):
         return " ".join(f"{k}{formula_double_format(v, ignore_ones=False)}" for k, v in self.as_dict().items())
 
     def to_pretty_string(self) -> str:
-        """Returns:
-        str: Same as output __str__() but without spaces.
+        """
+        Returns:
+            str: Same output as __str__() but without spaces.
         """
         return re.sub(r"\s+", "", str(self))
 
@@ -1250,7 +1251,7 @@ def get_energy(self, composition: Composition, strict: bool = True) -> float:
         return sum(self.get(k, 0) * v for k, v in composition.items())
 
     def __repr__(self):
-        return "ChemPots: " + super().__repr__()
+        return f"ChemPots: {super()!r}"
 
 
 class CompositionError(Exception):

pymatgen/core/structure.py

@@ -327,7 +327,7 @@ def __contains__(self, site: object) -> bool:
         return site in self.sites
 
     def __iter__(self) -> Iterator[Site]:
-        return self.sites.__iter__()
+        return iter(self.sites)
 
     # TODO return type needs fixing (can be list[Site] but raises lots of mypy errors)
     def __getitem__(self, ind: int | slice) -> Site:
@@ -1322,25 +1322,25 @@ def __mul__(self, scaling_matrix: int | Sequence[int] | Sequence[Sequence[int]])
 
         new_sites = []
         for site in self:
-            for v in c_lat:
-                s = PeriodicSite(
+            for vec in c_lat:
+                periodic_site = PeriodicSite(
                     site.species,
-                    site.coords + v,
+                    site.coords + vec,
                     new_lattice,
                     properties=site.properties,
                     coords_are_cartesian=True,
                     to_unit_cell=False,
                     skip_checks=True,
                     label=site.label,
                 )
-                new_sites.append(s)
+                new_sites.append(periodic_site)
 
         new_charge = self._charge * np.linalg.det(scale_matrix) if self._charge else None
         return Structure.from_sites(new_sites, charge=new_charge, to_unit_cell=True)
 
     def __rmul__(self, scaling_matrix):
         """Similar to __mul__ to preserve commutativeness."""
-        return self.__mul__(scaling_matrix)
+        return self * scaling_matrix
 
     @property
     def frac_coords(self):

pymatgen/core/tensors.py

@@ -682,7 +682,7 @@ def __getitem__(self, ind):
         return self.tensors[ind]
 
     def __iter__(self):
-        return self.tensors.__iter__()
+        return iter(self.tensors)
 
     def zeroed(self, tol: float = 1e-3):
         """:param tol: Tolerance

pymatgen/core/units.py

@@ -23,9 +23,7 @@
 __status__ = "Production"
 __date__ = "Aug 30, 2013"
 
-"""
-Some conversion factors
-"""
+"""Some conversion factors"""
 Ha_to_eV = 1 / const.physical_constants["electron volt-hartree relationship"][0]
 eV_to_Ha = 1 / Ha_to_eV
 Ry_to_eV = Ha_to_eV / 2
@@ -134,11 +132,7 @@
 SUPPORTED_UNIT_NAMES = tuple(i for d in ALL_UNITS.values() for i in d)
 
 # Mapping unit name --> unit type (unit names must be unique).
-_UNAME2UTYPE = {}  # type: ignore
-for utype, d in ALL_UNITS.items():
-    assert not set(d).intersection(_UNAME2UTYPE)  # type: ignore
-    _UNAME2UTYPE.update({uname: utype for uname in d})  # type: ignore
-del utype, d
+_UNAME2UTYPE = {uname: utype for utype, dct in ALL_UNITS.items() for uname in dct}
 
 
 def _get_si_unit(unit):
@@ -199,9 +193,6 @@ def __mul__(self, other):
             new_units[k] += v
         return Unit(new_units)
 
-    def __rmul__(self, other):
-        return self.__mul__(other)
-
     def __div__(self, other):
         new_units = collections.defaultdict(int)
         for k, v in self.items():
@@ -217,7 +208,7 @@ def __pow__(self, i):
         return Unit({k: v * i for k, v in self.items()})
 
     def __iter__(self):
-        return self._unit.__iter__()
+        return iter(self._unit)
 
     def __getitem__(self, i):
         return self._unit[i]
@@ -526,7 +517,7 @@ def __setstate__(self, state):
         self._unit = state["_unit"]
 
     def __repr__(self):
-        return f"{np.array(self).__repr__()} {self.unit}"
+        return f"{np.array(self)!r} {self.unit}"
 
     def __str__(self):
         return f"{np.array(self)} {self.unit}"
@@ -564,7 +555,7 @@ def __mul__(self, other):
         # Same protocol for __div__
         if not hasattr(other, "unit_type"):
             return self.__class__(
-                np.array(self).__mul__(np.array(other)),
+                np.array(self) * np.array(other),
                 unit_type=self._unit_type,
                 unit=self._unit,
             )
@@ -576,34 +567,30 @@ def __rmul__(self, other):
         # pylint: disable=E1101
         if not hasattr(other, "unit_type"):
             return self.__class__(
-                np.array(self).__rmul__(np.array(other)),
+                np.array(self) * np.array(other),
                 unit_type=self._unit_type,
                 unit=self._unit,
             )
-        return self.__class__(np.array(self).__rmul__(np.array(other)), unit=self.unit * other.unit)
+        return self.__class__(np.array(self) * np.array(other), unit=self.unit * other.unit)
 
     def __div__(self, other):
         # pylint: disable=E1101
         if not hasattr(other, "unit_type"):
             return self.__class__(
-                np.array(self).__div__(np.array(other)),
+                np.array(self) / np.array(other),
                 unit_type=self._unit_type,
                 unit=self._unit,
             )
-        return self.__class__(np.array(self).__div__(np.array(other)), unit=self.unit / other.unit)
+        return self.__class__(np.array(self) / np.array(other), unit=self.unit / other.unit)
 
     def __truediv__(self, other):
         # pylint: disable=E1101
         if not hasattr(other, "unit_type"):
-            return self.__class__(
-                np.array(self).__truediv__(np.array(other)),
-                unit_type=self._unit_type,
-                unit=self._unit,
-            )
-        return self.__class__(np.array(self).__truediv__(np.array(other)), unit=self.unit / other.unit)
+            return self.__class__(np.array(self) / np.array(other), unit_type=self._unit_type, unit=self._unit)
+        return self.__class__(np.array(self) / np.array(other), unit=self.unit / other.unit)
 
     def __neg__(self):
-        return self.__class__(np.array(self).__neg__(), unit_type=self.unit_type, unit=self.unit)
+        return self.__class__(-np.array(self), unit_type=self.unit_type, unit=self.unit)
 
     def to(self, new_unit):
         """Conversion to a new_unit.

pymatgen/electronic_structure/core.py

@@ -432,7 +432,7 @@ def __neg__(self):
         return Magmom(-self.moment, saxis=self.saxis)
 
     def __hash__(self) -> int:
-        return (tuple(self.moment) + tuple(self.saxis)).__hash__()
+        return hash(tuple(self.moment) + tuple(self.saxis))
 
     def __float__(self):
         """Returns magnitude of magnetic moment with a sign with respect to

pymatgen/entries/entry_tools.py

@@ -205,7 +205,7 @@ def __contains__(self, item):
         return item in self.entries
 
     def __iter__(self):
-        return self.entries.__iter__()
+        return iter(self.entries)
 
     def __len__(self):
         return len(self.entries)

pymatgen/io/abinit/abitimer.py

@@ -94,7 +94,7 @@ def __init__(self):
         self._timers = {}
 
     def __iter__(self):
-        return self._timers.__iter__()
+        return iter(self._timers)
 
     def __len__(self):
         return len(self._timers)