Why does nested serialization behavior change between versions? WHY!?

qcelemental/datum.py

@@ -3,7 +3,7 @@
 """
 
 from decimal import Decimal
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Union
 from typing_extensions import Annotated
 
 import numpy as np
@@ -22,10 +22,28 @@ def cast_complex(v: Any, nxt: SerializerFunctionWrapHandler) -> str:
  """Special helper to serialize NumPy arrays before serializing"""
  if isinstance(v, complex):
  return f'{nxt((v.real, v.imag))}'
- return f'{nxt(v)}'
+ return nxt(v)
+
+
+def preserve_decimal(v: Any, nxt: SerializerFunctionWrapHandler) -> Union[str, Decimal]:
+ """
+ Ensure Decimal types are preserved on the way out
+
+ This arose because Decimal was serialized to string and "dump" is equal to "serialize" in v2 pydantic
+ https://docs.pydantic.dev/latest/migration/#changes-to-json-schema-generation
+ """
+ if isinstance(v, Decimal):
+ return v
+ return nxt(v)
 
 
-AnyArrayComplex = Annotated[Any, WrapSerializer(cast_ndarray), WrapSerializer(cast_complex)]
+# Serializers are pop'd out of the list in FILO (right to left)
+AnyArrayComplex = Annotated[
+ Any,
+ WrapSerializer(cast_ndarray, when_used="json"),
+ WrapSerializer(cast_complex, when_used="json"),
+ WrapSerializer(preserve_decimal)
+]
 
 
 class Datum(BaseModel):

qcelemental/info/dft_info.py

@@ -68,4 +68,4 @@ def get(name: str) -> DFTFunctionalInfo:
  name = name.replace(x, "")
  break
 
- return dftfunctionalinfo.functionals[name].copy()
+ return dftfunctionalinfo.functionals[name].model_copy()

qcelemental/models/basemodels.py

@@ -37,6 +37,7 @@ class ProtoModel(BaseModel):
  model_config = ExtendedConfigDict(
  frozen=True,
  extra="forbid",
+ populate_by_name=True, # Allows using alias to populate
  serialize_default_excludes=set(),
  serialize_skip_defaults=False,
  force_skip_defaults=False

qcelemental/models/basis.py

@@ -217,10 +217,10 @@ def _check_atom_map(cls, v, info):
 
  @field_validator("nbf")
  @classmethod
- def _check_nbf(cls, v, values):
+ def _check_nbf(cls, v, info):
  # Bad construction, pass on errors
  try:
- nbf = cls._calculate_nbf(values["atom_map"], values["center_data"])
+ nbf = cls._calculate_nbf(info.data["atom_map"], info.data["center_data"])
  except KeyError:
  return v
 

qcelemental/models/molecule.py

@@ -576,7 +576,7 @@ def orient_molecule(self):
  r"""
  Centers the molecule and orients via inertia tensor before returning a new Molecule
  """
- return Molecule(orient=True, **self.dict())
+ return Molecule(orient=True, **self.model_dump())
 
  def compare(self, other):
  warnings.warn(
@@ -600,10 +600,14 @@ def __eq__(self, other):
 
  return self.get_hash() == other.get_hash()
 
- def dict(self, *args, **kwargs):
+ def dict(self, **kwargs):
+ warnings.warn('The `dict` method is deprecated; use `model_dump` instead.', DeprecationWarning)
+ return self.model_dump(**kwargs)
+
+ def model_dump(self, **kwargs) -> Dict[str, Any]:
  kwargs["by_alias"] = True
  kwargs["exclude_unset"] = True
- return super().model_dump(*args, **kwargs)
+ return super().model_dump(**kwargs)
 
  def pretty_print(self):
  r"""Print the molecule in Angstroms. Same as :py:func:`print_out` only always in Angstroms.
@@ -790,7 +794,7 @@ def to_string( # type: ignore
 
  Suggest psi4 --> psi4frag and psi4 route to to_string
  """
- molrec = from_schema(self.dict(), nonphysical=True)
+ molrec = from_schema(self.model_dump(), nonphysical=True)
  return to_string(
  molrec,
  dtype=dtype,
@@ -1291,7 +1295,7 @@ def align(
  "atomic_numbers": solution.align_atoms(concern_mol.atomic_numbers),
  "mass_numbers": solution.align_atoms(concern_mol.mass_numbers),
  }
- adict = {**concern_mol.dict(), **aupdate}
+ adict = {**concern_mol.model_dump(), **aupdate}
 
  # preserve intrinsic symmetry with lighter truncation
  amol = Molecule(validate=True, **adict, geometry_noise=13)
@@ -1415,7 +1419,7 @@ def scramble(
  "atomic_numbers": perturbation.align_atoms(ref_mol.atomic_numbers),
  "mass_numbers": perturbation.align_atoms(ref_mol.mass_numbers),
  }
- cdict = {**ref_mol.dict(), **cupdate}
+ cdict = {**ref_mol.model_dump(), **cupdate}
 
  # preserve intrinsic symmetry with lighter truncation
  cmol = Molecule(validate=True, **cdict, geometry_noise=13)

qcelemental/models/procedures.py

@@ -84,7 +84,7 @@ class OptimizationInput(ProtoModel):
 
  def __repr_args__(self) -> "ReprArgs":
  return [
- ("model", self.input_specification.model.dict()),
+ ("model", self.input_specification.model.model_dump()),
  ("molecule_hash", self.initial_molecule.get_hash()[:7]),
  ]
 

qcelemental/models/results.py

@@ -607,8 +607,8 @@ def _assert2d_nao_x(cls, v, info):
  "scf_fock_b",
  )
  @classmethod
- def _assert2d(cls, v, values):
- bas = values.get("basis", None)
+ def _assert2d(cls, v, info):
+ bas = info.data.get("basis", None)
 
  # Do not raise multiple errors
  if bas is None:

qcelemental/molutil/test_molutil.py

@@ -54,8 +54,8 @@ def test_relative_geoms_align_free(request):
  do_shift=True, do_rotate=True, do_resort=False, do_plot=False, verbose=2, do_test=True
  )
 
- rmolrec = qcel.molparse.from_schema(s22_12.dict())
- cmolrec = qcel.molparse.from_schema(cmol.dict())
+ rmolrec = qcel.molparse.from_schema(s22_12.model_dump())
+ cmolrec = qcel.molparse.from_schema(cmol.model_dump())
  assert compare_molrecs(rmolrec, cmolrec, atol=1.0e-4, relative_geoms="align")
 
 
@@ -68,8 +68,8 @@ def test_relative_geoms_align_fixed(request):
  do_shift=False, do_rotate=False, do_resort=False, do_plot=False, verbose=2, do_test=True
  )
 
- rmolrec = qcel.molparse.from_schema(s22_12.dict())
- cmolrec = qcel.molparse.from_schema(cmol.dict())
+ rmolrec = qcel.molparse.from_schema(s22_12.model_dump())
+ cmolrec = qcel.molparse.from_schema(cmol.model_dump())
  assert compare_molrecs(rmolrec, cmolrec, atol=1.0e-4, relative_geoms="align")
 
 

qcelemental/tests/test_model_results.py

@@ -495,7 +495,7 @@ def test_result_derivatives_array(request):
 def test_model_dictable(result_data_fixture, optimization_data_fixture, smodel):
  if smodel == "molecule":
  model = qcel.models.Molecule
- data = result_data_fixture["molecule"].dict()
+ data = result_data_fixture["molecule"].model_dump()
 
  elif smodel == "atomicresultproperties":
  model = qcel.models.AtomicResultProperties
@@ -514,7 +514,7 @@ def test_model_dictable(result_data_fixture, optimization_data_fixture, smodel):
  data = optimization_data_fixture
 
  instance = model(**data)
- assert model(**instance.dict())
+ assert model(**instance.model_dump())
 
 
 def test_result_model_deprecations(result_data_fixture, optimization_data_fixture):

qcelemental/tests/test_molecule.py

@@ -38,7 +38,7 @@
 
 
 def test_molecule_data_constructor_numpy():
- water_psi = water_dimer_minima.copy()
+ water_psi = water_dimer_minima.model_copy()
  ele = np.array(water_psi.atomic_numbers).reshape(-1, 1)
  npwater = np.hstack((ele, water_psi.geometry * qcel.constants.conversion_factor("Bohr", "angstrom")))
 
@@ -53,10 +53,10 @@ def test_molecule_data_constructor_numpy():
 
 
 def test_molecule_data_constructor_dict():
- water_psi = water_dimer_minima.copy()
+ water_psi = water_dimer_minima.model_copy()
 
  # Check the JSON construct/deconstruct
- water_from_json = Molecule.from_data(water_psi.dict())
+ water_from_json = Molecule.from_data(water_psi.model_dump())
  assert water_psi == water_from_json
 
  water_from_json = Molecule.from_data(water_psi.json(), "json")
@@ -134,16 +134,16 @@ def test_molecule_np_constructors():
 
 
 def test_molecule_compare():
- water_molecule2 = water_molecule.copy()
+ water_molecule2 = water_molecule.model_copy()
  assert water_molecule2 == water_molecule
 
- water_molecule3 = water_molecule.copy(update={"geometry": (water_molecule.geometry + np.array([0.1, 0, 0]))})
+ water_molecule3 = water_molecule.model_copy(update={"geometry": (water_molecule.geometry + np.array([0.1, 0, 0]))})
  assert water_molecule != water_molecule3
 
 
 def test_water_minima_data():
  # Give it a name
- mol_dict = water_dimer_minima.dict()
+ mol_dict = water_dimer_minima.model_dump()
  mol_dict["name"] = "water dimer"
  mol = Molecule(orient=True, **mol_dict)
 
@@ -174,7 +174,7 @@ def test_water_minima_data():
 
 
 def test_water_minima_fragment():
- mol = water_dimer_minima.copy()
+ mol = water_dimer_minima.model_copy()
  frag_0 = mol.get_fragment(0, orient=True)
  frag_1 = mol.get_fragment(1, orient=True)
  assert frag_0.get_hash() == "5f31757232a9a594c46073082534ca8a6806d367" # pragma: allowlist secret
@@ -194,12 +194,12 @@ def test_water_minima_fragment():
 
 
 def test_pretty_print():
- mol = water_dimer_minima.copy()
+ mol = water_dimer_minima.model_copy()
  assert isinstance(mol.pretty_print(), str)
 
 
 def test_to_string():
- mol = water_dimer_minima.copy()
+ mol = water_dimer_minima.model_copy()
  assert isinstance(mol.to_string("psi4"), str)
 
 
@@ -365,21 +365,21 @@ def test_water_orient():
 
 
 def test_molecule_errors_extra():
- data = water_dimer_minima.dict(exclude_unset=True)
+ data = water_dimer_minima.model_dump(exclude_unset=True)
  data["whatever"] = 5
  with pytest.raises(Exception):
  Molecule(**data, validate=False)
 
 
 def test_molecule_errors_connectivity():
- data = water_molecule.dict()
+ data = water_molecule.model_dump()
  data["connectivity"] = [(-1, 5, 5)]
  with pytest.raises(Exception):
  Molecule(**data)
 
 
 def test_molecule_errors_shape():
- data = water_molecule.dict()
+ data = water_molecule.model_dump()
  data["geometry"] = list(range(8))
  with pytest.raises(Exception):
  Molecule(**data)
@@ -388,7 +388,7 @@ def test_molecule_errors_shape():
 def test_molecule_json_serialization():
  assert isinstance(water_dimer_minima.json(), str)
 
- assert isinstance(water_dimer_minima.dict(encoding="json")["geometry"], list)
+ assert isinstance(water_dimer_minima.model_dump(encoding="json")["geometry"], list)
 
  assert water_dimer_minima == Molecule.from_data(water_dimer_minima.model_dump_json(), dtype="json")
 
@@ -521,10 +521,10 @@ def test_molecule_repeated_hashing():
  h1 = mol.get_hash()
  assert mol.get_molecular_formula() == "H2O2"
 
- mol2 = Molecule(orient=False, **mol.dict())
+ mol2 = Molecule(orient=False, **mol.model_dump())
  assert h1 == mol2.get_hash()
 
- mol3 = Molecule(orient=False, **mol2.dict())
+ mol3 = Molecule(orient=False, **mol2.model_dump())
  assert h1 == mol3.get_hash()
 
 
@@ -694,7 +694,7 @@ def test_sparse_molecule_fields(mol_string, extra_keys):
  if extra_keys is not None:
  expected_keys |= extra_keys
 
- diff_keys = mol.dict().keys() ^ expected_keys
+ diff_keys = mol.model_dump().keys() ^ expected_keys
  assert len(diff_keys) == 0, f"Diff Keys {diff_keys}"
 
 
@@ -703,11 +703,11 @@ def test_sparse_molecule_connectivity():
  A bit of a weird test, but because we set connectivity it should carry through.
  """
  mol = Molecule(symbols=["He", "He"], geometry=[0, 0, -2, 0, 0, 2], connectivity=None)
- assert "connectivity" in mol.dict()
- assert mol.dict()["connectivity"] is None
+ assert "connectivity" in mol.model_dump()
+ assert mol.model_dump()["connectivity"] is None
 
  mol = Molecule(symbols=["He", "He"], geometry=[0, 0, -2, 0, 0, 2])
- assert "connectivity" not in mol.dict()
+ assert "connectivity" not in mol.model_dump()
 
 
 def test_bad_isotope_spec():

qcelemental/tests/test_molparse_from_string.py

@@ -109,7 +109,7 @@ def test_psi4_qm_1a():
  assert compare_molrecs(fullans, final["qm"], tnm() + ": full")
 
  kmol = Molecule.from_data(subject)
- _check_eq_molrec_minimal_model([], kmol.dict(), fullans)
+ _check_eq_molrec_minimal_model([], kmol.model_dump(), fullans)
 
 
 def test_psi4_qm_1ab():
@@ -150,7 +150,7 @@ def test_psi4_qm_1c():
  assert compare_molrecs(fullans, final["qm"], tnm() + ": full")
 
  kmol = Molecule.from_data(subject)
- _check_eq_molrec_minimal_model([], kmol.dict(), fullans)
+ _check_eq_molrec_minimal_model([], kmol.model_dump(), fullans)
 
 
 def test_psi4_qm_1d():
@@ -346,7 +346,7 @@ def test_psi4_qm_2a():
  kmol = Molecule.from_data(subject)
  _check_eq_molrec_minimal_model(
  ["fragments", "fragment_charges", "fragment_multiplicities", "mass_numbers", "masses", "atom_labels", "real"],
- kmol.dict(),
+ kmol.model_dump(),
  fullans,
  )
 

qcelemental/tests/test_molutil.py

@@ -54,8 +54,8 @@ def test_relative_geoms_align_free(request):
  do_shift=True, do_rotate=True, do_resort=False, do_plot=False, verbose=2, do_test=True
  )
 
- rmolrec = qcel.molparse.from_schema(s22_12.dict())
- cmolrec = qcel.molparse.from_schema(cmol.dict())
+ rmolrec = qcel.molparse.from_schema(s22_12.model_dump())
+ cmolrec = qcel.molparse.from_schema(cmol.model_dump())
  assert compare_molrecs(rmolrec, cmolrec, atol=1.0e-4, relative_geoms="align")
 
 
@@ -68,8 +68,8 @@ def test_relative_geoms_align_fixed(request):
  do_shift=False, do_rotate=False, do_resort=False, do_plot=False, verbose=2, do_test=True
  )
 
- rmolrec = qcel.molparse.from_schema(s22_12.dict())
- cmolrec = qcel.molparse.from_schema(cmol.dict())
+ rmolrec = qcel.molparse.from_schema(s22_12.model_dump())
+ cmolrec = qcel.molparse.from_schema(cmol.model_dump())
  assert compare_molrecs(rmolrec, cmolrec, atol=1.0e-4, relative_geoms="align")