Deprecate from_string (#3158)

* types in pymatgen/core/periodic_table.py

* rename all from_string methods to from_str (for API consistency)

add deprecated from_string fallback for backwards compatibility

* same thing for to_string -> to_str

* fix lint

Author: janosh

pymatgen/alchemy/materials.py

@@ -286,7 +286,7 @@ def from_cif_string(
         Returns:
             TransformedStructure
         """
-        parser = CifParser.from_string(cif_string, occupancy_tolerance=occupancy_tolerance)
+        parser = CifParser.from_str(cif_string, occupancy_tolerance=occupancy_tolerance)
         raw_string = re.sub(r"'", '"', cif_string)
         cif_dict = parser.as_dict()
         cif_keys = list(cif_dict)
@@ -316,7 +316,7 @@ def from_poscar_string(
             transformations (list[Transformation]): Sequence of transformations
                 to be applied to the input structure.
         """
-        p = Poscar.from_string(poscar_string)
+        p = Poscar.from_str(poscar_string)
         if not p.true_names:
             raise ValueError(
                 "Transformation can be created only from POSCAR strings with proper VASP5 element symbols."

pymatgen/analysis/bond_valence.py

@@ -31,8 +31,8 @@
 
 # Read in yaml containing data-mined ICSD BV data.
 all_data = loadfn(os.path.join(module_dir, "icsd_bv.yaml"))
-ICSD_BV_DATA = {Species.from_string(sp): data for sp, data in all_data["bvsum"].items()}
-PRIOR_PROB = {Species.from_string(sp): data for sp, data in all_data["occurrence"].items()}
+ICSD_BV_DATA = {Species.from_str(sp): data for sp, data in all_data["bvsum"].items()}
+PRIOR_PROB = {Species.from_str(sp): data for sp, data in all_data["occurrence"].items()}
 
 
 def calculate_bv_sum(site, nn_list, scale_factor=1.0):

pymatgen/analysis/dimensionality.py

@@ -418,7 +418,7 @@ def find_connected_atoms(struct, tolerance=0.45, ldict=None):
     # in case of charged species
     for ii, item in enumerate(species):
         if item not in ldict:
-            species[ii] = str(Species.from_string(item).element)
+            species[ii] = str(Species.from_str(item).element)
     connected_matrix = np.zeros((n_atoms, n_atoms))
 
     for ii in range(n_atoms):

pymatgen/analysis/reaction_calculator.py

@@ -247,8 +247,13 @@ def from_dict(cls, d):
         products = {Composition(comp): coeff for comp, coeff in d["products"].items()}
         return cls(reactants, products)
 
+    @classmethod
+    @np.deprecate(message="Use from_str instead")
+    def from_string(cls, *args, **kwargs):
+        return cls.from_str(*args, **kwargs)
+
     @staticmethod
-    def from_string(rxn_string):
+    def from_str(rxn_string):
         """
         Generates a balanced reaction from a string. The reaction must
         already be balanced.

pymatgen/analysis/structure_prediction/substitution_probability.py

@@ -67,8 +67,8 @@ def __init__(self, lambda_table=None, alpha=-5):
         self.species = set()
         for row in self._lambda_table:
             if "D1+" not in row:
-                s1 = Species.from_string(row[0])
-                s2 = Species.from_string(row[1])
+                s1 = Species.from_str(row[0])
+                s2 = Species.from_str(row[1])
                 self.species.add(s1)
                 self.species.add(s2)
                 self._l[frozenset([s1, s2])] = float(row[2])

pymatgen/analysis/tests/test_dimensionality.py

@@ -89,12 +89,12 @@ def test_get_structure_components(self):
         assert list(components[0]["structure_graph"].graph.nodes()) == [0, 1]
 
     def test_calculate_dimensionality_of_site(self):
-        dimen = calculate_dimensionality_of_site(self.tricky_structure, 0)
-        assert dimen == 3
+        dim = calculate_dimensionality_of_site(self.tricky_structure, 0)
+        assert dim == 3
 
         # test vertices returned correctly
-        dimen, vertices = calculate_dimensionality_of_site(self.cscl, 0, inc_vertices=True)
-        assert dimen == 3
+        dim, vertices = calculate_dimensionality_of_site(self.cscl, 0, inc_vertices=True)
+        assert dim == 3
         assert len(vertices) == 4
 
     def test_zero_d_to_molecule_graph(self):

pymatgen/analysis/tests/test_reaction_calculator.py

@@ -160,9 +160,9 @@ def test_scientific_notation(self):
         reactants = [Composition("FePO4")]
         rxn = Reaction(reactants, products)
         assert str(rxn) == "FePO4 -> Fe1P1O3.9999 + 5e-05 O2"
-        assert rxn == Reaction.from_string(str(rxn))
+        assert rxn == Reaction.from_str(str(rxn))
 
-        rxn2 = Reaction.from_string("FePO4 + 20 CO -> 1e1 O2 + Fe1P1O4 + 20 C")
+        rxn2 = Reaction.from_str("FePO4 + 20 CO -> 1e1 O2 + Fe1P1O4 + 20 C")
         assert str(rxn2) == "20 CO -> 20 C + 10 O2"
 
     def test_equals(self):
@@ -322,9 +322,9 @@ def test_to_from_dict(self):
         for comp in new_rxn.all_comp:
             assert new_rxn.get_coeff(comp) == rxn.get_coeff(comp)
 
-    def test_from_string(self):
+    def test_from_str(self):
         rxn = BalancedReaction({Composition("Li"): 4, Composition("O2"): 1}, {Composition("Li2O"): 2})
-        assert rxn == BalancedReaction.from_string("4 Li + O2 -> 2Li2O")
+        assert rxn == BalancedReaction.from_str("4 Li + O2 -> 2Li2O")
 
         rxn = BalancedReaction(
             {Composition("Li(NiO2)3"): 1},
@@ -335,7 +335,7 @@ def test_from_string(self):
             },
         )
 
-        assert rxn == BalancedReaction.from_string("1.000 Li(NiO2)3 -> 0.500 O2 + 1.000 Li(NiO2)2 + 1.000 NiO")
+        assert rxn == BalancedReaction.from_str("1.000 Li(NiO2)3 -> 0.500 O2 + 1.000 Li(NiO2)2 + 1.000 NiO")
 
     def test_remove_spectator_species(self):
         rxn = BalancedReaction(

pymatgen/cli/pmg_config.py

@@ -52,7 +52,7 @@ def setup_cp2k_data(cp2k_data_dirs: list[str]) -> None:
                 continue
         for chk in chunks:
             try:
-                potential = GthPotential.from_string(chk)
+                potential = GthPotential.from_str(chk)
                 potential.filename = os.path.basename(potential_file)
                 potential.version = None
                 settings[potential.element.symbol]["potentials"][potential.get_hash()] = jsanitize(
@@ -74,7 +74,7 @@ def setup_cp2k_data(cp2k_data_dirs: list[str]) -> None:
                 continue
         for chk in chunks:
             try:
-                basis = GaussianTypeOrbitalBasisSet.from_string(chk)
+                basis = GaussianTypeOrbitalBasisSet.from_str(chk)
                 basis.filename = os.path.basename(basis_file)
                 settings[basis.element.symbol]["basis_sets"][basis.get_hash()] = jsanitize(  # type: ignore
                     basis, strict=True

pymatgen/command_line/enumlib_caller.py

@@ -367,7 +367,7 @@ def _get_structures(self, num_structs):
                 data = f.read()
                 data = re.sub(r"scale factor", "1", data)
                 data = re.sub(r"(\d+)-(\d+)", r"\1 -\2", data)
-                poscar = Poscar.from_string(data, self.index_species)
+                poscar = Poscar.from_str(data, self.index_species)
                 sub_structure = poscar.structure
                 # Enumeration may have resulted in a super lattice. We need to
                 # find the mapping from the new lattice to the old lattice, and

pymatgen/core/composition.py

@@ -921,7 +921,7 @@ def _get_oxid_state_guesses(self, all_oxi_states, max_sites, oxi_states_override
         if not Composition.oxi_prob:
             module_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)))
             all_data = loadfn(os.path.join(module_dir, "..", "analysis", "icsd_bv.yaml"))
-            Composition.oxi_prob = {Species.from_string(sp): data for sp, data in all_data["occurrence"].items()}
+            Composition.oxi_prob = {Species.from_str(sp): data for sp, data in all_data["occurrence"].items()}
         oxi_states_override = oxi_states_override or {}
         # assert: Composition only has integer amounts
         if not all(amt == int(amt) for amt in comp.values()):