remove unneeded unittest tearDown methods

Author: janosh

.github/workflows/test.yml

@@ -1,5 +1,5 @@
 # Runs the complete test suite incl. many external command line dependencies (like Openbabel)
-# as well as the pymatgen.ext package. Coverage is computed based on this workflow.
+# as well as the pymatgen.ext package. Coverage used to be computed based on this workflow.
 name: Tests
 
 on:

pymatgen/analysis/interface_reactions.py

@@ -304,7 +304,7 @@ def _get_reaction(self, x: float) -> Reaction:
 
         reactants = self._get_reactants(x)
 
-        product = [Composition(k.name) for k, v in decomp.items()]
+        product = [Composition(entry.name) for entry in decomp]
         reaction = Reaction(reactants, product)
 
         x_original = self._get_original_composition_ratio(reaction)
@@ -695,7 +695,7 @@ def get_no_mixing_energy(self):
     def _get_reactants(self, x: float) -> list[Composition]:
         """Returns a list of relevant reactant compositions given an x coordinate."""
         reactants = super()._get_reactants(x)
-        reactants += [Composition(e.symbol) for e, v in self.pd.chempots.items()]
+        reactants += [Composition(entry.symbol) for entry in self.pd.chempots]
 
         return reactants
 

pymatgen/analysis/phase_diagram.py

@@ -1095,7 +1095,7 @@ def get_critical_compositions(self, comp1, comp2):
         num_atoms = n1 + (n2 - n1) * x_unnormalized
         cs *= num_atoms[:, None]
 
-        return [Composition((c, v) for c, v in zip(pd_els, m)) for m in cs]
+        return [Composition((elem, val) for elem, val in zip(pd_els, m)) for m in cs]
 
     def get_element_profile(self, element, comp, comp_tol=1e-5):
         """

pymatgen/analysis/reaction_calculator.py

@@ -367,16 +367,16 @@ def as_dict(self):
         }
 
     @classmethod
-    def from_dict(cls, d):
+    def from_dict(cls, dct):
         """
         Args:
-            d (dict): from as_dict().
+            dct (dict): from as_dict().
 
         Returns:
-            A Reaction object.
+            Reaction
         """
-        reactants = [Composition(sym_amt) for sym_amt in d["reactants"]]
-        products = [Composition(sym_amt) for sym_amt in d["products"]]
+        reactants = [*map(Composition, dct["reactants"])]
+        products = [*map(Composition, dct["products"])]
         return cls(reactants, products)
 
 

pymatgen/io/abinit/abiobjects.py

@@ -605,16 +605,16 @@ def as_dict(self):
         return dct
 
     @classmethod
-    def from_dict(cls, d):
+    def from_dict(cls, dct):
         """Build object from dictionary."""
-        d = d.copy()
-        d.pop("@module", None)
-        d.pop("@class", None)
+        dct = dct.copy()
+        dct.pop("@module", None)
+        dct.pop("@class", None)
         dec = MontyDecoder()
-        d["spin_mode"] = dec.process_decoded(d["spin_mode"])
-        d["smearing"] = dec.process_decoded(d["smearing"])
-        d["algorithm"] = dec.process_decoded(d["algorithm"]) if d["algorithm"] else None
-        return cls(**d)
+        dct["spin_mode"] = dec.process_decoded(dct["spin_mode"])
+        dct["smearing"] = dec.process_decoded(dct["smearing"])
+        dct["algorithm"] = dec.process_decoded(dct["algorithm"]) if dct["algorithm"] else None
+        return cls(**dct)
 
     def to_abivars(self):
         """Return dictionary with Abinit variables."""

tests/analysis/test_interface_reactions.py

@@ -217,7 +217,7 @@ def test_get_reaction(self):
 
     def test_get_get_elmt_amt_in_rxt(self):
         rxt1 = Reaction(
-            [Composition("Mn"), Composition("O2"), Composition("Li")],
+            [*map(Composition, ["Mn", "O2", "Li"])],
             [Composition("LiMnO2")],
         )
         test1 = np.isclose(self.irs[2]._get_elem_amt_in_rxn(rxt1), 3)

tests/analysis/test_local_env.py

@@ -242,10 +242,6 @@ def test_filtered(self):
         all_nns = nn.get_all_nn_info(bcc * [2, 2, 2])
         assert [len(x) for x in all_nns] == [8] * 16
 
-    def tearDown(self):
-        del self.struct
-        del self.nn
-
 
 class TestJmolNN(PymatgenTest):
     def setUp(self):
@@ -562,12 +558,6 @@ def test_get_neighbors_of_site_with_index(self):
         assert len(get_neighbors_of_site_with_index(self.diamond, 0, approach="min_OKeeffe")) == 4
         assert len(get_neighbors_of_site_with_index(self.diamond, 0, approach="min_VIRE")) == 4
 
-    def tearDown(self):
-        del self.silicon
-        del self.diamond
-        del self.nacl
-        del self.cscl
-
 
 class TestNearNeighbor(PymatgenTest):
     def setUp(self):

tests/analysis/test_phase_diagram.py

@@ -80,9 +80,9 @@ def test_as_from_dict(self):
 
         assert entry.name == "mp-757614"
         assert entry.energy_per_atom == 53.0 / 4
-        gpentry = GrandPotPDEntry.from_dict(gpd)
-        assert gpentry.name == "mp-757614"
-        assert gpentry.energy_per_atom == 50.0 / 2
+        gp_entry = GrandPotPDEntry.from_dict(gpd)
+        assert gp_entry.name == "mp-757614"
+        assert gp_entry.energy_per_atom == 50.0 / 2
 
         d_anon = d.copy()
         del d_anon["name"]
@@ -109,12 +109,11 @@ def setUp(self):
         comp = Composition("LiFeO2")
         entry = PDEntry(comp, 53)
 
-        terminal_compositions = ["Li2O", "FeO", "LiO8"]
-        terminal_compositions = [Composition(c) for c in terminal_compositions]
+        terminal_compositions = [*map(Composition, ("Li2O", "FeO", "LiO8"))]
 
         sp_mapping = {}
         for idx, comp in enumerate(terminal_compositions):
-            sp_mapping[comp] = DummySpecies("X" + chr(102 + idx))
+            sp_mapping[comp] = DummySpecies(f"X{chr(102 + idx)}")
 
         self.transformed_entry = TransformedPDEntry(entry, sp_mapping)
 

tests/analysis/test_structure_matcher.py

@@ -342,9 +342,9 @@ def test_as_dict_and_from_dict(self):
             scale=False,
             comparator=FrameworkComparator(),
         )
-        d = sm.as_dict()
-        sm2 = StructureMatcher.from_dict(d)
-        assert sm2.as_dict() == d
+        dct = sm.as_dict()
+        sm2 = StructureMatcher.from_dict(dct)
+        assert sm2.as_dict() == dct
 
     def test_no_scaling(self):
         sm = StructureMatcher(ltol=0.1, stol=0.1, angle_tol=2, scale=False, comparator=ElementComparator())

tests/apps/battery/test_conversion_battery.py

@@ -100,14 +100,14 @@ def test_init(self):
 
             # try to export/import a voltage pair via a dict
             pair = c.voltage_pairs[0]
-            d = pair.as_dict()
-            pair2 = ConversionVoltagePair.from_dict(d)
+            dct = pair.as_dict()
+            pair2 = ConversionVoltagePair.from_dict(dct)
             for prop in ["voltage", "mass_charge", "mass_discharge"]:
                 assert getattr(pair, prop) == getattr(pair2, prop), 2
 
             # try to create an electrode from a dict and test methods
-            d = c.as_dict()
-            electrode = ConversionElectrode.from_dict(d)
+            dct = c.as_dict()
+            electrode = ConversionElectrode.from_dict(dct)
             for k, v in p.items():
                 assert getattr(electrode, "get_" + k)() == approx(v, abs=1e-2)
 
@@ -121,14 +121,14 @@ def test_repr(self):
         )
 
     def test_summary(self):
-        kmap = {"specific_energy": "energy_grav", "energy_density": "energy_vol"}
+        key_map = {"specific_energy": "energy_grav", "energy_density": "energy_vol"}
         for f in self.formulas:
             c = self.conversion_electrodes[f]["CE"]
-            d = c.get_summary_dict()
+            dct = c.get_summary_dict()
             p = self.expected_properties[f]
             for k, v in p.items():
-                summary_key = kmap.get(k, k)
-                assert d[summary_key] == approx(v, abs=1e-2)
+                summary_key = key_map.get(k, k)
+                assert dct[summary_key] == approx(v, abs=1e-2)
 
     def test_composite(self):
         # check entries in charged/discharged state