lsst-pex-config 29.2025.3500__tar.gz → 29.2025.4500__tar.gz

{lsst_pex_config-29.2025.3500/python/lsst_pex_config.egg-info → lsst_pex_config-29.2025.4500}/PKG-INFO

@@ -1,19 +1,18 @@
 Metadata-Version: 2.4
 Name: lsst-pex-config
-Version: 29.2025.3500
+Version: 29.2025.4500
 Summary: A flexible configuration system using Python files.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
-License: BSD 3-Clause License, GPLv3+
+License-Expression: BSD-3-Clause OR GPL-3.0-or-later
 Project-URL: Homepage, https://github.com/lsst/pex_config
 Keywords: lsst
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: BSD License
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Astronomy
 Requires-Python: >=3.10.0
 Description-Content-Type: text/x-rst

{lsst_pex_config-29.2025.3500 → lsst_pex_config-29.2025.4500}/pyproject.toml

@@ -6,20 +6,20 @@ build-backend = "setuptools.build_meta"
 name = "lsst-pex-config"
 requires-python = ">=3.10.0"
 description = "A flexible configuration system using Python files."
-license = {text = "BSD 3-Clause License, GPLv3+"}
+license = "BSD-3-Clause OR GPL-3.0-or-later"
+license-files = ["COPYRIGHT", "LICENSE", "gpl-v3.0.txt", "bsd_license.txt"]
 readme = "README.rst"
 authors = [
     {name="Rubin Observatory Data Management", email="dm-admin@lists.lsst.org"},
 ]
 classifiers = [
     "Intended Audience :: Science/Research",
-    "License :: OSI Approved :: BSD License",
-    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Topic :: Scientific/Engineering :: Astronomy",
 ]
 keywords = ["lsst"]
@@ -43,7 +43,6 @@ where = ["python"]
 
 [tool.setuptools]
 zip-safe = true
-license-files = ["COPYRIGHT", "LICENSE", "gpl-v3.0.txt", "bsd_license.txt"]
 
 [tool.setuptools.package-data]
 "lsst.pex.config" = ["py.typed"]

{lsst_pex_config-29.2025.3500 → lsst_pex_config-29.2025.4500}/python/lsst/pex/config/config.py

@@ -700,6 +700,14 @@ class Field(Generic[FieldTypeVar]):
         """
         return self.__get__(instance)
 
+    def _copy_storage(self, old: Config, new: Config) -> Any:
+        """Copy the storage for this field in the given field into an object
+        suitable for storage in a new copy of that config.
+
+        Any frozen storage should be unfrozen.
+        """
+        return copy.deepcopy(old._storage[self.name])
+
     @overload
     def __get__(
         self, instance: None, owner: Any = None, at: Any = None, label: str = "default"
@@ -1055,6 +1063,30 @@ class Config(metaclass=ConfigMeta):  # type: ignore
         instance.update(__at=at, **kw)
         return instance
 
+    def copy(self) -> Config:
+        """Return a deep copy of this config.
+
+        Notes
+        -----
+        The returned config object is not frozen, even if the original was.
+        If a nested config object is copied, it retains the name from its
+        original hierarchy.
+
+        Nested objects are only shared between the new and old configs if they
+        are not possible to modify via the config's interfaces (e.g. entries
+        in the the history list are not copied, but the lists themselves are,
+        so modifications to one copy do not modify the other).
+        """
+        instance = object.__new__(type(self))
+        instance._frozen = False
+        instance._name = self._name
+        instance._history = {k: list(v) for k, v in self._history.items()}
+        instance._imports = set(self._imports)
+        # Important to set up storage last, since fields sometimes store
+        # proxy objects that reference their parent (especially for history).
+        instance._storage = {k: self._fields[k]._copy_storage(self, instance) for k in self._storage}
+        return instance
+
     def __reduce__(self):
         """Reduction for pickling (function with arguments to reproduce).
 

{lsst_pex_config-29.2025.3500 → lsst_pex_config-29.2025.4500}/python/lsst/pex/config/configChoiceField.py

@@ -30,7 +30,6 @@ __all__ = ["ConfigChoiceField"]
 
 import collections.abc
 import copy
-import weakref
 from typing import Any, ForwardRef, overload
 
 from .callStack import getCallStack, getStackFrame
@@ -63,13 +62,19 @@ class SelectionSet(collections.abc.MutableSet):
     history.
     """
 
-    def __init__(self, dict_, value, at=None, label="assignment", setHistory=True):
+    def __init__(
+        self,
+        dict_: ConfigInstanceDict,
+        value: Any,
+        at=None,
+        label: str = "assignment",
+        setHistory: bool = True,
+    ):
         if at is None:
             at = getCallStack()
         self._dict = dict_
         self._field = self._dict._field
-        self._config_ = weakref.ref(self._dict._config)
-        self.__history = self._config._history.setdefault(self._field.name, [])
+        self._history = self._dict._config._history.setdefault(self._field.name, [])
         if value is not None:
             try:
                 for v in value:
@@ -78,20 +83,13 @@ class SelectionSet(collections.abc.MutableSet):
                         self._dict.__getitem__(v, at=at)
             except TypeError as e:
                 msg = f"Value {value} is of incorrect type {_typeStr(value)}. Sequence type expected"
-                raise FieldValidationError(self._field, self._config, msg) from e
+                raise FieldValidationError(self._field, self._dict._config, msg) from e
             self._set = set(value)
         else:
             self._set = set()
 
         if setHistory:
-            self.__history.append((f"Set selection to {self}", at, label))
-
-    @property
-    def _config(self) -> Config:
-        # Config Fields should never outlive their config class instance
-        # assert that as such here
-        assert self._config_() is not None
-        return self._config_()
+            self._history.append((f"Set selection to {self}", at, label))
 
     def add(self, value, at=None):
         """Add a value to the selected set.
@@ -104,7 +102,7 @@ class SelectionSet(collections.abc.MutableSet):
                 optional
             Stack frames for history recording.
         """
-        if self._config._frozen:
+        if self._dict._config._frozen:
             raise FieldValidationError(self._field, self._config, "Cannot modify a frozen Config")
 
         if at is None:
@@ -114,7 +112,7 @@ class SelectionSet(collections.abc.MutableSet):
             # invoke __getitem__ to make sure it's present
             self._dict.__getitem__(value, at=at)
 
-        self.__history.append((f"added {value} to selection", at, "selection"))
+        self._history.append((f"added {value} to selection", at, "selection"))
         self._set.add(value)
 
     def discard(self, value, at=None):
@@ -128,8 +126,8 @@ class SelectionSet(collections.abc.MutableSet):
                 optional
             Stack frames for history recording.
         """
-        if self._config._frozen:
-            raise FieldValidationError(self._field, self._config, "Cannot modify a frozen Config")
+        if self._dict._config._frozen:
+            raise FieldValidationError(self._field, self._dict._config, "Cannot modify a frozen Config")
 
         if value not in self._dict:
             return
@@ -137,7 +135,7 @@ class SelectionSet(collections.abc.MutableSet):
         if at is None:
             at = getCallStack()
 
-        self.__history.append((f"removed {value} from selection", at, "selection"))
+        self._history.append((f"removed {value} from selection", at, "selection"))
         self._set.discard(value)
 
     def __len__(self):
@@ -177,9 +175,9 @@ class ConfigInstanceDict(collections.abc.Mapping[str, Config]):
         (that is, ``typemap[name]``).
     """
 
-    def __init__(self, config, field):
+    def __init__(self, config: Config, field: ConfigChoiceField):
         collections.abc.Mapping.__init__(self)
-        self._dict = {}
+        self._dict: dict[str, Config] = {}
         self._selection = None
         self._config = config
         self._field = field
@@ -187,6 +185,18 @@ class ConfigInstanceDict(collections.abc.Mapping[str, Config]):
         self.__doc__ = field.doc
         self._typemap = None
 
+    def _copy(self, config: Config) -> ConfigInstanceDict:
+        result = type(self)(config, self._field)
+        result._dict = {k: v.copy() for k, v in self._dict.items()}
+        result._history.extend(self._history)
+        result._typemap = self._typemap
+        if self._selection is not None:
+            if self._field.multi:
+                result._selection = SelectionSet(result._dict, self._selection._set)
+            else:
+                result._selection = self._selection
+        return result
+
     @property
     def types(self):
         return self._typemap if self._typemap is not None else self._field.typemap
@@ -544,6 +554,13 @@ class ConfigChoiceField(Field[ConfigInstanceDict]):
         else:
             instanceDict._setSelection(value, at=at, label=label)
 
+    def _copy_storage(self, old: Config, new: Config) -> Any:
+        instance_dict: ConfigInstanceDict | None = old._storage.get(self.name)
+        if instance_dict is not None:
+            return instance_dict._copy(new)
+        else:
+            return None
+
     def rename(self, instance):
         instanceDict = self.__get__(instance)
         fullname = _joinNamePath(instance._name, self.name)

{lsst_pex_config-29.2025.3500 → lsst_pex_config-29.2025.4500}/python/lsst/pex/config/configDictField.py

@@ -24,10 +24,13 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
+from __future__ import annotations
 
 __all__ = ["ConfigDictField"]
 
-from .callStack import getCallStack, getStackFrame
+from collections.abc import Mapping
+
+from .callStack import StackFrame, getCallStack, getStackFrame
 from .comparison import compareConfigs, compareScalars, getComparisonName
 from .config import Config, FieldValidationError, _autocast, _joinNamePath, _typeStr
 from .dictField import Dict, DictField
@@ -51,11 +54,33 @@ class ConfigDict(Dict[str, Config]):
         Stack frame for history recording. Will be calculated if `None`.
     label : `str`, optional
         Label to use for history recording.
+    setHistory : `bool`, optional
+        Whether to append to the history record.
     """
 
-    def __init__(self, config, field, value, at, label):
-        Dict.__init__(self, config, field, value, at, label, setHistory=False)
-        self.history.append(("Dict initialized", at, label))
+    def __init__(
+        self,
+        config: Config,
+        field: ConfigDictField,
+        value: Mapping[str, Config] | None,
+        *,
+        at: list[StackFrame] | None,
+        label: str,
+        setHistory: bool = True,
+    ):
+        Dict.__init__(self, config, field, value, at=at, label=label, setHistory=False)
+        if setHistory:
+            self.history.append(("Dict initialized", at, label))
+
+    def _copy(self, config: Config) -> Dict:
+        return type(self)(
+            config,
+            self._field,
+            {k: v._copy() for k, v in self._dict.items()},
+            at=None,
+            label="copy",
+            setHistory=False,
+        )
 
     def __setitem__(self, k, x, at=None, label="setitem", setHistory=True):
         if self._config._frozen:

{lsst_pex_config-29.2025.3500 → lsst_pex_config-29.2025.4500}/python/lsst/pex/config/configField.py

@@ -243,6 +243,13 @@ class ConfigField(Field[FieldTypeVar]):
         value = self.__get__(instance)
         return value.toDict()
 
+    def _copy_storage(self, old: Config, new: Config) -> Any:
+        value: Config | None = old._storage.get(self.name)
+        if value is not None:
+            return value.copy()
+        else:
+            return None
+
     def validate(self, instance):
         """Validate the field (for internal use only).
 

{lsst_pex_config-29.2025.3500 → lsst_pex_config-29.2025.4500}/python/lsst/pex/config/configurableActions/_configurableAction.py

@@ -62,3 +62,8 @@ class ConfigurableAction(Config):
 
     def __call__(self, *args: Any, **kwargs: Any) -> Any:
         raise NotImplementedError("This method should be overloaded in subclasses")
+
+    def copy(self) -> ConfigurableAction:
+        result = super().copy()
+        result.identity = self.identity
+        return result

{lsst_pex_config-29.2025.3500 → lsst_pex_config-29.2025.4500}/python/lsst/pex/config/configurableActions/_configurableActionStructField.py

@@ -165,12 +165,18 @@ class ConfigurableActionStruct(Generic[ActionTypeVar]):
         object.__setattr__(self, "_field", field)
         object.__setattr__(self, "_history", [])
 
-        self.history.append(("Struct initialized", at, label))
+        if at is not None:
+            self.history.append(("Struct initialized", at, label))
 
         if value is not None:
             for k, v in value.items():
                 setattr(self, k, v)
 
+    def _copy(self, config: Config) -> ConfigurableActionStruct:
+        result = ConfigurableActionStruct(config, self._field, self._attrs, at=None, label="copy")
+        result.history.extend(self.history)
+        return result
+
     @property
     def _config(self) -> Config:
         # Config Fields should never outlive their config class instance
@@ -391,6 +397,13 @@ class ConfigurableActionStructField(Field[ActionTypeVar]):
 
         return dict_
 
+    def _copy_storage(self, old: Config, new: Config) -> ConfigurableActionStruct:
+        struct: ConfigurableActionStruct | None = old._storage.get(self.name)
+        if struct is not None:
+            return struct._copy(new)
+        else:
+            return None
+
     def save(self, outfile, instance):
         actionStruct = self.__get__(instance)
         fullname = _joinNamePath(instance._name, self.name)

{lsst_pex_config-29.2025.3500 → lsst_pex_config-29.2025.4500}/python/lsst/pex/config/configurableField.py

@@ -34,7 +34,7 @@ import weakref
 from collections.abc import Mapping
 from typing import Any, Generic, overload
 
-from .callStack import getCallStack, getStackFrame
+from .callStack import StackFrame, getCallStack, getStackFrame
 from .comparison import compareConfigs, getComparisonName
 from .config import (
     Config,
@@ -57,9 +57,9 @@ class ConfigurableInstance(Generic[FieldTypeVar]):
         Config to proxy.
     field : `~lsst.pex.config.ConfigurableField`
         Field to use.
-    at : `list` of `~lsst.pex.config.callStack.StackFrame` or `None`, optional
+    at : `list` of `~lsst.pex.config.callStack.StackFrame` or `None`
         Stack frame for history recording. Will be calculated if `None`.
-    label : `str`, optional
+    label : `str`
         Label to use for history recording.
 
     Notes
@@ -74,7 +74,7 @@ class ConfigurableInstance(Generic[FieldTypeVar]):
     using the ``target`` property.
     """
 
-    def __initValue(self, at, label):
+    def __initValue(self, at: list[StackFrame] | None, label: str, setHistory: bool = True):
         """Construct value of field.
 
         Notes
@@ -94,7 +94,7 @@ class ConfigurableInstance(Generic[FieldTypeVar]):
     def __init__(self, config, field, at=None, label="default"):
         object.__setattr__(self, "_config_", weakref.ref(config))
         object.__setattr__(self, "_field", field)
-        object.__setattr__(self, "__doc__", config)
+        object.__setattr__(self, "__doc__", field.doc)
         object.__setattr__(self, "_target", field.target)
         object.__setattr__(self, "_ConfigClass", field.ConfigClass)
         object.__setattr__(self, "_value", None)
@@ -107,6 +107,16 @@ class ConfigurableInstance(Generic[FieldTypeVar]):
         history = config._history.setdefault(field.name, [])
         history.append(("Targeted and initialized from defaults", at, label))
 
+    def _copy(self, parent: Config) -> ConfigurableInstance:
+        result = object.__new__(ConfigurableInstance)
+        object.__setattr__(result, "_config_", weakref.ref(parent))
+        object.__setattr__(result, "_field", self._field)
+        object.__setattr__(result, "__doc__", self.__doc__)
+        object.__setattr__(result, "_target", self._target)
+        object.__setattr__(result, "_ConfigClass", self._ConfigClass)
+        object.__setattr__(result, "_value", self._value.copy())
+        return result
+
     @property
     def _config(self) -> Config:
         # Config Fields should never outlive their config class instance
@@ -430,6 +440,13 @@ class ConfigurableField(Field[ConfigurableInstance[FieldTypeVar]]):
         value = self.__get__(instance)
         return value.toDict()
 
+    def _copy_storage(self, old: Config, new: Config) -> ConfigurableInstance | None:
+        instance: ConfigurableInstance | None = old._storage.get(self.name)
+        if instance is not None:
+            return instance._copy(new)
+        else:
+            return None
+
     def validate(self, instance):
         value = self.__get__(instance)
         value.validate()

{lsst_pex_config-29.2025.3500 → lsst_pex_config-29.2025.4500}/python/lsst/pex/config/dictField.py

@@ -34,7 +34,7 @@ import weakref
 from collections.abc import Iterator, Mapping
 from typing import Any, ForwardRef, Generic, TypeVar, cast
 
-from .callStack import getCallStack, getStackFrame
+from .callStack import StackFrame, getCallStack, getStackFrame
 from .comparison import compareScalars, getComparisonName
 from .config import (
     Config,
@@ -71,7 +71,16 @@ class Dict(collections.abc.MutableMapping[KeyTypeVar, ItemTypeVar]):
         Whether to append to the history record.
     """
 
-    def __init__(self, config, field, value, at, label, setHistory=True):
+    def __init__(
+        self,
+        config: Config,
+        field: DictField,
+        value: Mapping[KeyTypeVar, ItemTypeVar],
+        *,
+        at: list[StackFrame] | None,
+        label: str,
+        setHistory: bool = True,
+    ):
         self._field = field
         self._config_ = weakref.ref(config)
         self._dict = {}
@@ -100,6 +109,9 @@ class Dict(collections.abc.MutableMapping[KeyTypeVar, ItemTypeVar]):
     """History (read-only).
     """
 
+    def _copy(self, config: Config) -> Dict:
+        return type(self)(config, self._field, self._dict.copy(), at=None, label="copy", setHistory=False)
+
     def __getitem__(self, k: KeyTypeVar) -> ItemTypeVar:
         return self._dict[k]
 
@@ -403,6 +415,13 @@ class DictField(Field[Dict[KeyTypeVar, ItemTypeVar]], Generic[KeyTypeVar, ItemTy
         value = self.__get__(instance)
         return dict(value) if value is not None else None
 
+    def _copy_storage(self, old: Config, new: Config) -> Dict[KeyTypeVar, ItemTypeVar] | None:
+        value: Dict[KeyTypeVar, ItemTypeVar] | None = old._storage[self.name]
+        if value is not None:
+            return value._copy(new)
+        else:
+            return None
+
     def _compare(self, instance1, instance2, shortcut, rtol, atol, output):
         """Compare two fields for equality.
 

{lsst_pex_config-29.2025.3500 → lsst_pex_config-29.2025.4500}/python/lsst/pex/config/history.py

@@ -252,7 +252,10 @@ def format(config, name=None, writeSourceLine=True, prefix="", verbose=False):
     fullname = f"{config._name}.{name}" if config._name is not None else name
     msg.append(_colorize(re.sub(r"^root\.", "", fullname), "NAME"))
     for value, output in outputs:
-        line = prefix + _colorize(f"{value:<{valueLength}}", "VALUE") + " "
+        if value is not None:
+            line = prefix + _colorize(f"{value:<{valueLength}}", "VALUE") + " "
+        else:
+            line = prefix + _colorize("None", "VALUE") + " "
         for i, vt in enumerate(output):
             if writeSourceLine:
                 vt[0][0] = f"{vt[0][0]:<{sourceLength}}"

{lsst_pex_config-29.2025.3500 → lsst_pex_config-29.2025.4500}/python/lsst/pex/config/listField.py

@@ -25,14 +25,16 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+from __future__ import annotations
+
 __all__ = ["ListField"]
 
 import collections.abc
 import weakref
-from collections.abc import Iterable, MutableSequence
+from collections.abc import Iterable, MutableSequence, Sequence
 from typing import Any, Generic, overload
 
-from .callStack import getCallStack, getStackFrame
+from .callStack import StackFrame, getCallStack, getStackFrame
 from .comparison import compareScalars, getComparisonName
 from .config import (
     Config,
@@ -73,7 +75,15 @@ class List(collections.abc.MutableSequence[FieldTypeVar]):
         `ListField.itemCheck` method of the ``field`` parameter.
     """
 
-    def __init__(self, config, field, value, at, label, setHistory=True):
+    def __init__(
+        self,
+        config: Config,
+        field: ListField,
+        value: Sequence[FieldTypeVar],
+        at: list[StackFrame] | None,
+        label: str,
+        setHistory: bool = True,
+    ):
         self._field = field
         self._config_ = weakref.ref(config)
         self._history = self._config._history.setdefault(self._field.name, [])
@@ -133,6 +143,9 @@ class List(collections.abc.MutableSequence[FieldTypeVar]):
     """Read-only history.
     """
 
+    def _copy(self, config: Config) -> List:
+        return type(self)(config, self._field, self._list.copy(), at=None, label="copy", setHistory=False)
+
     def __contains__(self, x):
         return x in self._list
 
@@ -463,6 +476,13 @@ class ListField(Field[List[FieldTypeVar]], Generic[FieldTypeVar]):
         value = self.__get__(instance)
         return list(value) if value is not None else None
 
+    def _copy_storage(self, old: Config, new: Config) -> List[FieldTypeVar] | None:
+        value: List[FieldTypeVar] | None = old._storage[self.name]
+        if value is not None:
+            return value._copy(new)
+        else:
+            return None
+
     def _compare(self, instance1, instance2, shortcut, rtol, atol, output):
         """Compare two config instances for equality with respect to this
         field.

lsst_pex_config-29.2025.4500/python/lsst/pex/config/version.py

@@ -0,0 +1,2 @@
+__all__ = ["__version__"]
+__version__ = "29.2025.4500"

{lsst_pex_config-29.2025.3500 → lsst_pex_config-29.2025.4500/python/lsst_pex_config.egg-info}/PKG-INFO

@@ -1,19 +1,18 @@
 Metadata-Version: 2.4
 Name: lsst-pex-config
-Version: 29.2025.3500
+Version: 29.2025.4500
 Summary: A flexible configuration system using Python files.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
-License: BSD 3-Clause License, GPLv3+
+License-Expression: BSD-3-Clause OR GPL-3.0-or-later
 Project-URL: Homepage, https://github.com/lsst/pex_config
 Keywords: lsst
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: BSD License
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Astronomy
 Requires-Python: >=3.10.0
 Description-Content-Type: text/x-rst

{lsst_pex_config-29.2025.3500 → lsst_pex_config-29.2025.4500}/tests/test_Config.py

@@ -639,6 +639,61 @@ except ImportError:
             else:
                 self.assertEqual(v, v1)
 
+    def test_copy(self):
+        """Test the copy method."""
+        self.comp.freeze()
+        copy1 = self.comp.copy()
+        copy1.c.f = 6.0
+        self.assertEqual(copy1.c.f, 6.0)
+        self.assertEqual(self.comp.c.f, 0.0)
+        copy1.r["AAA"].i = 1
+        self.assertEqual(copy1.r["AAA"].i, 1)
+        self.assertIsNone(self.comp.r["AAA"].i)
+        copy1.r["AAA"].f = 2.0
+        self.assertEqual(copy1.r["AAA"].f, 2.0)
+        self.assertEqual(self.comp.r["AAA"].f, 3.0)
+        copy1.r["AAA"].c = "World"
+        self.assertEqual(copy1.r["AAA"].c, "World")
+        self.assertEqual(self.comp.r["AAA"].c, "Hello")
+        copy1.r["AAA"].r = 4.0
+        self.assertEqual(copy1.r["AAA"].r, 4.0)
+        self.assertEqual(self.comp.r["AAA"].r, 3.0)
+        copy1.r["AAA"].ll.append(4)
+        self.assertEqual(copy1.r["AAA"].ll, [1, 2, 3, 4])
+        self.assertEqual(self.comp.r["AAA"].ll, [1, 2, 3])
+        copy1.r["AAA"].d["key2"] = "value2"
+        self.assertEqual(copy1.r["AAA"].d, {"key": "value", "key2": "value2"})
+        self.assertEqual(self.comp.r["AAA"].d, {"key": "value"})
+        copy1.r.name = "BBB"
+        self.assertEqual(copy1.r.name, "BBB")
+        self.assertEqual(self.comp.r.name, "AAA")
+        copy1.p.name = None
+        self.assertIsNone(copy1.p.name)
+        self.assertEqual(self.comp.p.name, "BBB")
+        # Copy again to avoid shortcuts for default nested objects.
+        copy1.freeze()
+        copy2 = copy1.copy()
+        copy2.c.f = 7.0
+        self.assertEqual(copy2.c.f, 7.0)
+        self.assertEqual(copy1.c.f, 6.0)
+        self.assertEqual(self.comp.c.f, 0.0)
+        copy2.r["AAA"].ll.append(5)
+        self.assertEqual(copy2.r["AAA"].ll, [1, 2, 3, 4, 5])
+        self.assertEqual(copy1.r["AAA"].ll, [1, 2, 3, 4])
+        self.assertEqual(self.comp.r["AAA"].ll, [1, 2, 3])
+        del copy2.r["AAA"].d["key"]
+        self.assertEqual(copy2.r["AAA"].d, {"key2": "value2"})
+        self.assertEqual(copy1.r["AAA"].d, {"key": "value", "key2": "value2"})
+        self.assertEqual(self.comp.r["AAA"].d, {"key": "value"})
+        copy2.r.name = "AAA"
+        self.assertEqual(copy2.r.name, "AAA")
+        self.assertEqual(copy1.r.name, "BBB")
+        self.assertEqual(self.comp.r.name, "AAA")
+        copy2.p.name = "AAA"
+        self.assertEqual(copy2.p.name, "AAA")
+        self.assertIsNone(copy1.p.name)
+        self.assertEqual(self.comp.p.name, "BBB")
+
 
 if __name__ == "__main__":
     unittest.main()

{lsst_pex_config-29.2025.3500 → lsst_pex_config-29.2025.4500}/tests/test_configurableActions.py

@@ -251,6 +251,25 @@ class ConfigurableActionsTestCase(unittest.TestCase):
         config = configClass()
         self.assertEqual(config.toDict(), {"actions": {"test1": {"var": 0}}, "singleAction": {"var": 0}})
 
+    def test_copy(self):
+        """Test copying a Config with ConfigurableActions."""
+        config_cls = self._createConfig(default={"test1": ActionTest1}, singleDefault=ActionTest1)
+        config = config_cls()
+        copy1 = config.copy()
+        copy1.actions.test2 = ActionTest2
+        self.assertEqual(tuple(copy1.actions.fieldNames), ("test1", "test2"))
+        self.assertEqual(copy1.actions.test2.var, 1)
+        self.assertEqual(tuple(config.actions.fieldNames), ("test1",))
+        copy1.actions.test1.var = 50
+        self.assertEqual(copy1.actions.test1.var, 50)
+        self.assertEqual(config.actions.test1.var, 0)
+        copy2 = copy1.copy()
+        copy2.actions.test3 = ActionTest3()
+        self.assertEqual(tuple(copy2.actions.fieldNames), ("test1", "test2", "test3"))
+        self.assertEqual(tuple(copy1.actions.fieldNames), ("test1", "test2"))
+        self.assertEqual(tuple(config.actions.fieldNames), ("test1",))
+        self.assertEqual(copy2.actions.test3.var, 3)
+
 
 if __name__ == "__main__":
     unittest.main()

{lsst_pex_config-29.2025.3500 → lsst_pex_config-29.2025.4500}/tests/test_configurableField.py

@@ -157,6 +157,21 @@ class ConfigurableFieldTest(unittest.TestCase):
         with self.assertRaises(pexConf.UnexpectedProxyUsageError):
             pickle.dumps(c.c2)
 
+    def test_copy(self):
+        """Test copying a frozen ConfigurableField."""
+        c1 = Config2()
+        c1.freeze()
+        c2 = c1.copy()
+        c2.c1.f = 6.0
+        self.assertEqual(c2.c1.f, 6.0)
+        self.assertEqual(c1.c1.f, 5.0)
+        c2.freeze()
+        c3 = c2.copy()
+        c3.c1.f = 7.0
+        self.assertEqual(c3.c1.f, 7.0)
+        self.assertEqual(c2.c1.f, 6.0)
+        self.assertEqual(c1.c1.f, 5.0)
+
 
 if __name__ == "__main__":
     unittest.main()

{lsst_pex_config-29.2025.3500 → lsst_pex_config-29.2025.4500}/tests/test_dictField.py

@@ -193,7 +193,7 @@ class DictFieldTest(unittest.TestCase):
         keys2 = ["X", "Y", "Z", "a", "b", "c", "d", "e"]
 
         c1 = Config1()
-        c1.d4 = {k: "" for k in keys1}
+        c1.d4 = dict.fromkeys(keys1, "")
         for k in keys2:
             c1.d4[k] = ""
 

{lsst_pex_config-29.2025.3500 → lsst_pex_config-29.2025.4500}/tests/test_registry.py

@@ -111,7 +111,7 @@ class ConfigTest(unittest.TestCase):
 
     def testReplace(self):
         """Test replacement in registry (should always fail)."""
-        self.assertRaises(Exception, self.registry.register, "foo1", self.fooAlg2Class)
+        self.assertRaises(RuntimeError, self.registry.register, "foo1", self.fooAlg2Class)
         self.assertEqual(self.registry["foo1"], self.fooAlg1Class)
 
     def testNesting(self):

lsst_pex_config-29.2025.3500/python/lsst/pex/config/version.py

@@ -1,2 +0,0 @@
-__all__ = ["__version__"]
-__version__ = "29.2025.3500"