test nested square bracket in formula strings

add ref to GH issue in _parse_formula()

Author: janosh

pymatgen/analysis/chempot_diagram.py

@@ -548,12 +548,11 @@ def _get_min_entries_and_el_refs(
         el_refs = {}
         min_entries = []
 
-        for c, g in groupby(entries, key=lambda e: e.composition.reduced_formula):
-            c = Composition(c)
-            group = list(g)
+        for formula, group in groupby(entries, key=lambda e: e.composition.reduced_formula):
+            comp = Composition(formula)
             min_entry = min(group, key=lambda e: e.energy_per_atom)
-            if c.is_element:
-                el_refs[c.elements[0]] = min_entry
+            if comp.is_element:
+                el_refs[comp.elements[0]] = min_entry
             min_entries.append(min_entry)
 
         return min_entries, el_refs

pymatgen/core/composition.py

@@ -544,6 +544,7 @@ def _parse_formula(self, formula: str, strict: bool = True) -> dict[str, float]:
             raise ValueError(f"Invalid {formula=}")
         # for Metallofullerene like "Y3N@C80"
         formula = formula.replace("@", "")
+        # square brackets are used in formulas to denote coordination complexes (gh-3583)
         formula = formula.replace("[", "(")
         formula = formula.replace("]", ")")
 

pymatgen/ext/matproj_legacy.py

@@ -1633,12 +1633,12 @@ def parse_tok(t):
             parts = re.split(r"(\*|\{.*\})", t)
             parts = [parse_sym(s) for s in parts if s != ""]
             for f in itertools.product(*parts):
-                c = Composition("".join(f))
-                if len(c) == n_elements:
+                comp = Composition("".join(f))
+                if len(comp) == n_elements:
                     # Check for valid Elements in keys.
-                    for e in c:
-                        Element(e.symbol)
-                    all_formulas.add(c.reduced_formula)
+                    for elem in comp:
+                        Element(elem.symbol)
+                    all_formulas.add(comp.reduced_formula)
             return {"pretty_formula": {"$in": list(all_formulas)}}
 
         if len(tokens) == 1:

tests/analysis/structure_prediction/test_substitution_probability.py

@@ -69,8 +69,8 @@ def test_prediction(self):
         assert result["probability"] == approx(cond_prob)
         assert set(result["substitutions"].values()) != {"Na+", "Cl-"}
 
-        c = Composition({"Ag2+": 1, "Cl-": 2})
-        result = sp.composition_prediction(c, to_this_composition=True)[2]
-        assert set(result["substitutions"].values()) == set(c.elements)
-        result = sp.composition_prediction(c, to_this_composition=False)[2]
-        assert set(result["substitutions"]) == set(c.elements)
+        comp = Composition({"Ag2+": 1, "Cl-": 2})
+        result = sp.composition_prediction(comp, to_this_composition=True)[2]
+        assert set(result["substitutions"].values()) == set(comp.elements)
+        result = sp.composition_prediction(comp, to_this_composition=False)[2]
+        assert set(result["substitutions"]) == set(comp.elements)

tests/analysis/structure_prediction/test_substitutor.py

@@ -26,8 +26,8 @@ def test_substitutor(self):
         s_list = [Species("O", -2), Species("Li", 1)]
         subs = self.s.pred_from_list(s_list)
         assert len(subs) == 4, "incorrect number of substitutions"
-        c = Composition({"O2-": 1, "Li1+": 2})
-        subs = self.s.pred_from_comp(c)
+        comp = Composition({"O2-": 1, "Li1+": 2})
+        subs = self.s.pred_from_comp(comp)
         assert len(subs) == 4, "incorrect number of substitutions"
 
         structures = [{"structure": PymatgenTest.get_structure("Li2O"), "id": "pmgtest"}]

tests/core/test_composition.py

@@ -115,16 +115,16 @@ def test_getitem(self):
         assert comp["O"] == 4
 
     def test_hill_formula(self):
-        c = Composition("CaCO3")
-        assert c.hill_formula == "C Ca O3"
-        c = Composition("C2H5OH")
-        assert c.hill_formula == "C2 H6 O"
+        comp = Composition("CaCO3")
+        assert comp.hill_formula == "C Ca O3"
+        comp = Composition("C2H5OH")
+        assert comp.hill_formula == "C2 H6 O"
         # A test case with both C and H, but not one after another (mp-1228185)
-        c = Composition("Ga8 As16 H102 C32 S36 O3")
-        assert c.hill_formula == "C32 H102 As16 Ga8 O3 S36"
+        comp = Composition("Ga8 As16 H102 C32 S36 O3")
+        assert comp.hill_formula == "C32 H102 As16 Ga8 O3 S36"
         # A test case with H but no C
-        c = Composition("Ga8 As16 H102 S36 O3")
-        assert c.hill_formula == "As16 Ga8 H102 O3 S36"
+        comp = Composition("Ga8 As16 H102 S36 O3")
+        assert comp.hill_formula == "As16 Ga8 H102 O3 S36"
 
     def test_init(self):
         with pytest.raises(ValueError, match="Amounts in Composition cannot be negative"):
@@ -138,8 +138,8 @@ def test_init(self):
         assert Composition({1: 2, 8: 1}).formula == "H2 O1"
         assert Composition(Na=2, O=1).formula == "Na2 O1"
 
-        c = Composition({"S": Composition.amount_tolerance / 2})
-        assert len(c.elements) == 0
+        comp = Composition({"S": Composition.amount_tolerance / 2})
+        assert len(comp.elements) == 0
 
     def test_str_and_repr(self):
         test_cases = [
@@ -838,5 +838,11 @@ def test_math(self):
         assert fe_pot - o_pot == pots - o_pot - o_pot
 
     def test_square_brackets(self):
-        c = Composition("(NH4)2[FeCl5(H2O)]")
-        assert str(c) == "N2 H10 Fe1 Cl5 O1"
+        comp = Composition("(NH4)2[FeCl5(H2O)]")
+        assert str(comp) == "N2 H10 Fe1 Cl5 O1"
+        # test nested brackets
+        comp = Composition("[[[[Fe]]]]")
+        assert str(comp) == "Fe1"
+        # test nested brackets with charge
+        comp = Composition("[N[Fe]2]2")
+        assert str(comp) == "N2 Fe4"

tests/core/test_ion.py

@@ -23,12 +23,12 @@ def setUp(self):
         self.comp.append(Ion.from_formula("NaOH(aq)"))
 
     def test_init(self):
-        c = Composition({"Fe": 4, "O": 16, "P": 4})
+        comp = Composition({"Fe": 4, "O": 16, "P": 4})
         charge = 4
-        assert Ion(c, charge).formula == "Fe4 P4 O16 +4"
-        f = {1: 1, 8: 1}
+        assert Ion(comp, charge).formula == "Fe4 P4 O16 +4"
+        formula_dict = {1: 1, 8: 1}
         charge = -1
-        assert Ion(Composition(f), charge).formula == "H1 O1 -1"
+        assert Ion(Composition(formula_dict), charge).formula == "H1 O1 -1"
         assert Ion(Composition(S=2, O=3), -2).formula == "S2 O3 -2"
 
     def test_charge_from_formula(self):

tests/entries/test_compatibility.py

@@ -461,14 +461,14 @@ def test_get_corrections_dict(self):
                 ],
             },
         )
-        c = compat.get_corrections_dict(entry)[0]
-        assert c["MP Anion Correction"] == approx(-2.10687)
-        assert c["MP Advanced Correction"] == approx(-5.466)
+        comp = compat.get_corrections_dict(entry)[0]
+        assert comp["MP Anion Correction"] == approx(-2.10687)
+        assert comp["MP Advanced Correction"] == approx(-5.466)
 
         entry.parameters["is_hubbard"] = False
         del entry.parameters["hubbards"]
-        c = gga_compat.get_corrections_dict(entry)[0]
-        assert "MP Advanced Correction" not in c
+        comp = gga_compat.get_corrections_dict(entry)[0]
+        assert "MP Advanced Correction" not in comp
 
     def test_process_entries(self):
         entries = self.compat.process_entries([self.entry1, self.entry2, self.entry3, self.entry4])
@@ -936,12 +936,12 @@ def test_energy_adjustments(self):
         }
         entry = ComputedEntry.from_dict(entry)
 
-        c = compat.process_entry(entry)
-        assert "MP2020 anion correction (oxide)" in [ea.name for ea in c.energy_adjustments]
-        assert "MP2020 GGA/GGA+U mixing correction (Fe)" in [ea.name for ea in c.energy_adjustments]
-        assert "MP2020 GGA/GGA+U mixing correction (Co)" in [ea.name for ea in c.energy_adjustments]
+        processed = compat.process_entry(entry)
+        assert "MP2020 anion correction (oxide)" in [ea.name for ea in processed.energy_adjustments]
+        assert "MP2020 GGA/GGA+U mixing correction (Fe)" in [ea.name for ea in processed.energy_adjustments]
+        assert "MP2020 GGA/GGA+U mixing correction (Co)" in [ea.name for ea in processed.energy_adjustments]
 
-        for ea in c.energy_adjustments:
+        for ea in processed.energy_adjustments:
             if ea.name == "MP2020 GGA/GGA+U mixing correction (Fe)":
                 assert ea.value == approx(-2.256 * 4)
                 assert ea.uncertainty == approx(0.0101 * 4)
@@ -954,8 +954,8 @@ def test_energy_adjustments(self):
 
         entry.parameters["is_hubbard"] = False
         del entry.parameters["hubbards"]
-        c = gga_compat.process_entry(entry)
-        assert "MP2020 GGA/GGA+U mixing correction" not in [ea.name for ea in c.energy_adjustments]
+        processed = gga_compat.process_entry(entry)
+        assert "MP2020 GGA/GGA+U mixing correction" not in [ea.name for ea in processed.energy_adjustments]
 
     def test_process_entries(self):
         entries = self.compat.process_entries([self.entry1, self.entry2, self.entry3])