From 40e30aa2fe90becdd26b925dd154450188712721 Mon Sep 17 00:00:00 2001 From: stevenhua0320 Date: Fri, 27 Feb 2026 23:26:31 -0500 Subject: [PATCH 1/3] chore: deprecate SymmetryConstraints class method --- news/deprecate-symmetryutilities-6.rst | 32 ++++++++ src/diffpy/structure/symmetryutilities.py | 90 +++++++++++++++++++++-- tests/test_symmetryutilities.py | 59 ++++++++++++++- 3 files changed, 175 insertions(+), 6 deletions(-) create mode 100644 news/deprecate-symmetryutilities-6.rst diff --git a/news/deprecate-symmetryutilities-6.rst b/news/deprecate-symmetryutilities-6.rst new file mode 100644 index 0000000..c31ab91 --- /dev/null +++ b/news/deprecate-symmetryutilities-6.rst @@ -0,0 +1,32 @@ +**Added:** + +* Added ``_find_constraints`` method in ``SymmetryConstraints`` class +* Added ``pospar_symbols`` method in ``SymmetryConstraints`` class +* Added ``pospar_values`` method in ``SymmetryConstraints`` class +* Added ``upar_symbols`` method in ``SymmetryConstraints`` class +* Added ``upar_values`` method in ``SymmetryConstraints`` class +* Added ``u_formulas`` method in ``SymmetryConstraints`` class + +**Changed:** + +* + +**Deprecated:** + +* Deprecated ``posparSymbols`` method in ``SymmetryConstraints`` class for removal in version 4.0.0 +* Deprecated ``posparValues`` method in ``SymmetryConstraints`` class for removal in version 4.0.0 +* Deprecated ``UparSymbols`` method in ``SymmetryConstraints`` class for removal in version 4.0.0 +* Deprecated ``UparValues`` method in ``SymmetryConstraints`` class for removal in version 4.0.0 +* Deprecated ``UFormulas`` method in ``SymmetryConstraints`` class for removal in version 4.0.0 + +**Removed:** + +* + +**Fixed:** + +* + +**Security:** + +* diff --git a/src/diffpy/structure/symmetryutilities.py b/src/diffpy/structure/symmetryutilities.py index 8c605e5..412882e 100644 --- a/src/diffpy/structure/symmetryutilities.py +++ b/src/diffpy/structure/symmetryutilities.py @@ -1043,6 +1043,39 @@ def prune_formula_dictionary(eqdict): return pruned +symmetry_constraints = "diffpy.symmetryutilities.SymmetryConstraints" +posparSymbols_deprecation_msg = build_deprecation_message( + symmetry_constraints, + "posparSymbols", + "pospar_symbols", + removal_version, +) +posparValues_deprecation_msg = build_deprecation_message( + symmetry_constraints, + "posparValues", + "pospar_values", + removal_version, +) +UparSymbols_deprecation_msg = build_deprecation_message( + symmetry_constraints, + "UparSymbols", + "upar_symbols", + removal_version, +) +UparValues_deprecation_msg = build_deprecation_message( + symmetry_constraints, + "UparValues", + "upar_values", + removal_version, +) +UFormulas_deprecation_msg = build_deprecation_message( + symmetry_constraints, + "UFormulas", + "u_formulas", + removal_version, +) + + class SymmetryConstraints(object): """Generate symmetry constraints for specified positions. @@ -1132,10 +1165,10 @@ def __init__(self, spacegroup, positions, Uijs=None, sgoffset=[0, 0, 0], eps=Non self.Ueqns = numpos * [None] self.Uisotropy = numpos * [False] # all members should be initialized here - self._findConstraints() + self._find_constraints() return - def _findConstraints(self): + def _find_constraints(self): """Find constraints for positions and anisotropic displacements `Uij`.""" numpos = len(self.positions) @@ -1184,11 +1217,29 @@ def _findConstraints(self): self.corepos = [self.positions[i] for i in coreidx] return + @deprecated(posparSymbols_deprecation_msg) def posparSymbols(self): + """'diffpy.structure.SymmetryConstraints.posparSymbols' is + deprecated and will be removed in version 4.0.0. + + Please use 'diffpy.structure.SymmetryConstraints.pospar_symbols' instead. + """ + return self.pospar_symbols() + + def pospar_symbols(self): """Return list of standard position parameter symbols.""" return [n for n, v in self.pospars] + @deprecated(posparValues_deprecation_msg) def posparValues(self): + """'diffpy.structure.SymmetryConstraints.posparValues' is + deprecated and will be removed in version 4.0.0. + + Please use 'diffpy.structure.SymmetryConstraints.pospar_values' instead. + """ + return self.pospar_values() + + def pospar_values(self): """Return list of position parameters values.""" return [v for n, v in self.pospars] @@ -1214,7 +1265,7 @@ def positionFormulas(self, xyzsymbols=None): emsg = "Not enough symbols for %i position parameters" % len(self.pospars) raise SymmetryError(emsg) # build translation dictionary - trsmbl = dict(zip(self.posparSymbols(), xyzsymbols)) + trsmbl = dict(zip(self.pospar_symbols(), xyzsymbols)) def translatesymbol(matchobj): return trsmbl[matchobj.group(0)] @@ -1249,16 +1300,45 @@ def positionFormulasPruned(self, xyzsymbols=None): rv = [prune_formula_dictionary(eqns) for eqns in self.positionFormulas(xyzsymbols)] return rv + @deprecated(UparSymbols_deprecation_msg) def UparSymbols(self): + """'diffpy.structure.SymmetryConstraints.UparSymbols' is + deprecated and will be removed in version 4.0.0. + + Please use 'diffpy.structure.SymmetryConstraints.upar_symbols' instead. + """ + return self.upar_symbols() + + def upar_symbols(self): """Return list of standard atom displacement parameter symbols.""" return [n for n, v in self.Upars] + @deprecated(UparValues_deprecation_msg) def UparValues(self): + """'diffpy.structure.SymmetryConstraints.UparValues' is + deprecated and will be removed in version 4.0.0. + + Please use 'diffpy.structure.SymmetryConstraints.upar_values' + instead. + """ + return [v for n, v in self.Upars] + + def upar_values(self): """Return list of atom displacement parameters values.""" return [v for n, v in self.Upars] + @deprecated(UFormula_deprecation_msg) def UFormulas(self, Usymbols=None): + """'diffpy.structure.SymmetryConstraints.UFormulas' is + deprecated and will be removed in version 4.0.0. + + Please use 'diffpy.structure.SymmetryConstraints.u_formulas' + instead. + """ + return self.u_formulas(Usymbols) + + def u_formulas(self, Usymbols=None): """List of atom displacement formulas with custom parameter symbols. @@ -1282,7 +1362,7 @@ def UFormulas(self, Usymbols=None): emsg = "Not enough symbols for %i U parameters" % len(self.Upars) raise SymmetryError(emsg) # build translation dictionary - trsmbl = dict(zip(self.UparSymbols(), Usymbols)) + trsmbl = dict(zip(self.upar_symbols(), Usymbols)) def translatesymbol(matchobj): return trsmbl[matchobj.group(0)] @@ -1315,7 +1395,7 @@ def UFormulasPruned(self, Usymbols=None): List of atom displacement formulas in tuples of ``(U11, U22, U33, U12, U13, U23)``. """ - rv = [prune_formula_dictionary(eqns) for eqns in self.UFormulas(Usymbols)] + rv = [prune_formula_dictionary(eqns) for eqns in self.u_formulas(Usymbols)] return rv diff --git a/tests/test_symmetryutilities.py b/tests/test_symmetryutilities.py index f4294b6..ef5da84 100644 --- a/tests/test_symmetryutilities.py +++ b/tests/test_symmetryutilities.py @@ -758,7 +758,7 @@ def test_u_formula_g186c_eqxyz(self): "U13": 0.0, "U23": 0.0, } - for ufms in symcon.UFormulas(): + for ufms in symcon.u_formulas(): for n, fm in ufms.items(): self.assertEqual(uisod[n], eval(fm, upd)) return @@ -905,6 +905,18 @@ def test_UparSymbols(self): self.assertEqual(["U110"], sc225.UparSymbols()) return + def test_upar_symbols(self): + """Check SymmetryConstraints.UparSymbols()""" + sg1 = GetSpaceGroup(1) + sg225 = GetSpaceGroup(225) + pos = [[0, 0, 0]] + Uijs = numpy.zeros((1, 3, 3)) + sc1 = SymmetryConstraints(sg1, pos, Uijs) + self.assertEqual(6, len(sc1.upar_symbols())) + sc225 = SymmetryConstraints(sg225, pos, Uijs) + self.assertEqual(["U110"], sc225.upar_symbols()) + return + def test_UparValues(self): """Check SymmetryConstraints.UparValues()""" places = 12 @@ -920,6 +932,34 @@ def test_UparValues(self): self.assertAlmostEqual(0.2, sc225.UparValues()[0], places) return + def test_upar_values(self): + """Check SymmetryConstraints.UparValues()""" + places = 12 + sg1 = GetSpaceGroup(1) + sg225 = GetSpaceGroup(225) + pos = [[0, 0, 0]] + Uijs = [[[0.1, 0.4, 0.5], [0.4, 0.2, 0.6], [0.5, 0.6, 0.3]]] + sc1 = SymmetryConstraints(sg1, pos, Uijs) + duv = 0.1 * numpy.arange(1, 7) - sc1.upar_values() + self.assertAlmostEqual(0, max(numpy.fabs(duv)), places) + sc225 = SymmetryConstraints(sg225, pos, Uijs) + self.assertEqual(1, len(sc225.upar_values())) + self.assertAlmostEqual(0.2, sc225.upar_values()[0], places) + return + + def test_posparSymbols_and_posparValues(self): + """Check SymmetryConstraints.posparSymbols and_posparValues()""" + sg225 = GetSpaceGroup(225) + eau = ExpandAsymmetricUnit(sg225, [[0, 0, 0]]) + sc = SymmetryConstraints(sg225, eau.expandedpos) + sc.pospars = [("x", 0.12), ("y", 0.34), ("z", 0.56)] + actual_symbols = sc.posparSymbols() + actual_values = sc.posparValues() + expected_symbols = ["x", "y", "z"] + expected_values = [0.12, 0.34, 0.56] + assert expected_symbols == actual_symbols + assert expected_values == actual_values + # def test_UFormulas(self): # """check SymmetryConstraints.UFormulas() @@ -1056,5 +1096,22 @@ def test_null_space(A, expected_dim): assert numpy.allclose(actual @ actual.T, numpy.eye(expected_dim), atol=1e-12) +@pytest.mark.parametrize( + "params, expected_symbols, expected_values", + [ + pytest.param([("x", 0.12), ("y", 0.34), ("z", 0.56)], ["x", "y", "z"], [0.12, 0.34, 0.56]), + ], +) +def test_pospar_symbols_and_pospar_values(params, expected_symbols, expected_values): + """Check SymmetryConstraints.pospar_symbols and_pospar_values()""" + sg225 = GetSpaceGroup(225) + eau = ExpandAsymmetricUnit(sg225, [[0, 0, 0]]) + sc = SymmetryConstraints(sg225, eau.expandedpos) + sc.pospars = params + actual_symbols, actual_values = sc.pospar_symbols(), sc.pospar_values() + assert actual_symbols == expected_symbols + assert actual_values == expected_values + + if __name__ == "__main__": unittest.main() From 71b6a3fead185e71ae5e4405fb95895a59da394d Mon Sep 17 00:00:00 2001 From: stevenhua0320 Date: Sat, 28 Feb 2026 09:20:24 -0500 Subject: [PATCH 2/3] chore: rename the function to increase readability --- news/deprecate-symmetryutilities-6.rst | 8 ++++---- src/diffpy/structure/symmetryutilities.py | 18 +++++++++--------- tests/test_symmetryutilities.py | 12 ++++++------ 3 files changed, 19 insertions(+), 19 deletions(-) diff --git a/news/deprecate-symmetryutilities-6.rst b/news/deprecate-symmetryutilities-6.rst index c31ab91..b78e091 100644 --- a/news/deprecate-symmetryutilities-6.rst +++ b/news/deprecate-symmetryutilities-6.rst @@ -1,10 +1,10 @@ **Added:** * Added ``_find_constraints`` method in ``SymmetryConstraints`` class -* Added ``pospar_symbols`` method in ``SymmetryConstraints`` class -* Added ``pospar_values`` method in ``SymmetryConstraints`` class -* Added ``upar_symbols`` method in ``SymmetryConstraints`` class -* Added ``upar_values`` method in ``SymmetryConstraints`` class +* Added ``pos_parm_symbols`` method in ``SymmetryConstraints`` class +* Added ``pos_parm_values`` method in ``SymmetryConstraints`` class +* Added ``u_parm_symbols`` method in ``SymmetryConstraints`` class +* Added ``u_parm_values`` method in ``SymmetryConstraints`` class * Added ``u_formulas`` method in ``SymmetryConstraints`` class **Changed:** diff --git a/src/diffpy/structure/symmetryutilities.py b/src/diffpy/structure/symmetryutilities.py index 412882e..6e58e15 100644 --- a/src/diffpy/structure/symmetryutilities.py +++ b/src/diffpy/structure/symmetryutilities.py @@ -1224,9 +1224,9 @@ def posparSymbols(self): Please use 'diffpy.structure.SymmetryConstraints.pospar_symbols' instead. """ - return self.pospar_symbols() + return self.pos_parm_symbols() - def pospar_symbols(self): + def pos_parm_symbols(self): """Return list of standard position parameter symbols.""" return [n for n, v in self.pospars] @@ -1237,9 +1237,9 @@ def posparValues(self): Please use 'diffpy.structure.SymmetryConstraints.pospar_values' instead. """ - return self.pospar_values() + return self.pos_parm_values() - def pospar_values(self): + def pos_parm_values(self): """Return list of position parameters values.""" return [v for n, v in self.pospars] @@ -1265,7 +1265,7 @@ def positionFormulas(self, xyzsymbols=None): emsg = "Not enough symbols for %i position parameters" % len(self.pospars) raise SymmetryError(emsg) # build translation dictionary - trsmbl = dict(zip(self.pospar_symbols(), xyzsymbols)) + trsmbl = dict(zip(self.pos_parm_symbols(), xyzsymbols)) def translatesymbol(matchobj): return trsmbl[matchobj.group(0)] @@ -1307,9 +1307,9 @@ def UparSymbols(self): Please use 'diffpy.structure.SymmetryConstraints.upar_symbols' instead. """ - return self.upar_symbols() + return self.u_parm_symbols() - def upar_symbols(self): + def u_parm_symbols(self): """Return list of standard atom displacement parameter symbols.""" return [n for n, v in self.Upars] @@ -1324,7 +1324,7 @@ def UparValues(self): """ return [v for n, v in self.Upars] - def upar_values(self): + def u_parm_values(self): """Return list of atom displacement parameters values.""" return [v for n, v in self.Upars] @@ -1362,7 +1362,7 @@ def u_formulas(self, Usymbols=None): emsg = "Not enough symbols for %i U parameters" % len(self.Upars) raise SymmetryError(emsg) # build translation dictionary - trsmbl = dict(zip(self.upar_symbols(), Usymbols)) + trsmbl = dict(zip(self.u_parm_symbols(), Usymbols)) def translatesymbol(matchobj): return trsmbl[matchobj.group(0)] diff --git a/tests/test_symmetryutilities.py b/tests/test_symmetryutilities.py index ef5da84..8fd2d5c 100644 --- a/tests/test_symmetryutilities.py +++ b/tests/test_symmetryutilities.py @@ -912,9 +912,9 @@ def test_upar_symbols(self): pos = [[0, 0, 0]] Uijs = numpy.zeros((1, 3, 3)) sc1 = SymmetryConstraints(sg1, pos, Uijs) - self.assertEqual(6, len(sc1.upar_symbols())) + self.assertEqual(6, len(sc1.u_parm_symbols())) sc225 = SymmetryConstraints(sg225, pos, Uijs) - self.assertEqual(["U110"], sc225.upar_symbols()) + self.assertEqual(["U110"], sc225.u_parm_symbols()) return def test_UparValues(self): @@ -940,11 +940,11 @@ def test_upar_values(self): pos = [[0, 0, 0]] Uijs = [[[0.1, 0.4, 0.5], [0.4, 0.2, 0.6], [0.5, 0.6, 0.3]]] sc1 = SymmetryConstraints(sg1, pos, Uijs) - duv = 0.1 * numpy.arange(1, 7) - sc1.upar_values() + duv = 0.1 * numpy.arange(1, 7) - sc1.u_parm_values() self.assertAlmostEqual(0, max(numpy.fabs(duv)), places) sc225 = SymmetryConstraints(sg225, pos, Uijs) - self.assertEqual(1, len(sc225.upar_values())) - self.assertAlmostEqual(0.2, sc225.upar_values()[0], places) + self.assertEqual(1, len(sc225.u_parm_values())) + self.assertAlmostEqual(0.2, sc225.u_parm_values()[0], places) return def test_posparSymbols_and_posparValues(self): @@ -1108,7 +1108,7 @@ def test_pospar_symbols_and_pospar_values(params, expected_symbols, expected_val eau = ExpandAsymmetricUnit(sg225, [[0, 0, 0]]) sc = SymmetryConstraints(sg225, eau.expandedpos) sc.pospars = params - actual_symbols, actual_values = sc.pospar_symbols(), sc.pospar_values() + actual_symbols, actual_values = sc.pos_parm_symbols(), sc.pos_parm_values() assert actual_symbols == expected_symbols assert actual_values == expected_values From 820a3d6b2027e964666e91fd4382f27c6c88b324 Mon Sep 17 00:00:00 2001 From: stevenhua0320 Date: Sat, 28 Feb 2026 09:22:00 -0500 Subject: [PATCH 3/3] chore: rename the api in the docstring --- src/diffpy/structure/symmetryutilities.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/diffpy/structure/symmetryutilities.py b/src/diffpy/structure/symmetryutilities.py index 6e58e15..b596e17 100644 --- a/src/diffpy/structure/symmetryutilities.py +++ b/src/diffpy/structure/symmetryutilities.py @@ -1222,7 +1222,7 @@ def posparSymbols(self): """'diffpy.structure.SymmetryConstraints.posparSymbols' is deprecated and will be removed in version 4.0.0. - Please use 'diffpy.structure.SymmetryConstraints.pospar_symbols' instead. + Please use 'diffpy.structure.SymmetryConstraints.pos_parm_symbols' instead. """ return self.pos_parm_symbols() @@ -1235,7 +1235,7 @@ def posparValues(self): """'diffpy.structure.SymmetryConstraints.posparValues' is deprecated and will be removed in version 4.0.0. - Please use 'diffpy.structure.SymmetryConstraints.pospar_values' instead. + Please use 'diffpy.structure.SymmetryConstraints.pos_parm_values' instead. """ return self.pos_parm_values() @@ -1305,7 +1305,7 @@ def UparSymbols(self): """'diffpy.structure.SymmetryConstraints.UparSymbols' is deprecated and will be removed in version 4.0.0. - Please use 'diffpy.structure.SymmetryConstraints.upar_symbols' instead. + Please use 'diffpy.structure.SymmetryConstraints.u_parm_symbols' instead. """ return self.u_parm_symbols() @@ -1319,7 +1319,7 @@ def UparValues(self): """'diffpy.structure.SymmetryConstraints.UparValues' is deprecated and will be removed in version 4.0.0. - Please use 'diffpy.structure.SymmetryConstraints.upar_values' + Please use 'diffpy.structure.SymmetryConstraints.u_parm_values' instead. """ return [v for n, v in self.Upars]