fix: preserve Constants customizations across a pickle round-trip (#167)

__setstate__ passed the entire __getstate__ dict to __init__ as the
`prefixes` positional argument, so every collection silently reverted to
its module default on unpickling and `prefixes` ended up holding the
config attribute names. Restore each saved attribute via setattr instead.

__getstate__ now serializes the instance's own state (the __init__
collections plus any instance-level scalar overrides) rather than a
dir()-based sweep that also pulled in the computed
suffixes_prefixes_titles property (which has no setter and would break
__setstate__).

Tests: round-trip now preserves added/removed titles and prefixes and
instance scalar overrides; both fail against the previous implementation.
Add an assertNotIn shim to the test base.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: derek73

nameparser/config/__init__.py

@@ -274,11 +274,22 @@ def __repr__(self) -> str:
         return "<Constants() instance>"
 
     def __setstate__(self, state: Mapping[str, Any]) -> None:
-        Constants.__init__(self, state)
+        # Restore each saved attribute directly. The previous implementation
+        # passed the whole state dict to __init__ as the ``prefixes`` argument,
+        # which silently reverted every collection to its module default on
+        # unpickling.
+        self._pst = None
+        for name, value in state.items():
+            setattr(self, name, value)
 
     def __getstate__(self) -> Mapping[str, Any]:
-        attrs = [x for x in dir(self) if not x.startswith('_')]
-        return dict([(a, getattr(self, a)) for a in attrs])
+        # Pickle only the instance's own configuration: the collections built in
+        # __init__ plus any instance-level scalar overrides. Class-level scalar
+        # defaults are restored by the class itself, and underscore-prefixed
+        # names such as the ``_pst`` cache are private and rebuilt on demand.
+        # The computed ``suffixes_prefixes_titles`` property must not be
+        # serialized — it has no setter and would break __setstate__.
+        return {k: v for k, v in self.__dict__.items() if not k.startswith('_')}
 
 
 #: A module-level instance of the :py:class:`Constants()` class.

tests/base.py

@@ -38,3 +38,6 @@ def assertFalse(self, expr: object, msg: object = None) -> None:
 
     def assertIn(self, member: object, container: object, msg: object = None) -> None:
         assert member in container, msg  # type: ignore[operator]
+
+    def assertNotIn(self, member: object, container: object, msg: object = None) -> None:
+        assert member not in container, msg  # type: ignore[operator]

tests/test_constants.py

@@ -1,3 +1,5 @@
+import pickle
+
 from nameparser import HumanName
 from nameparser.config import Constants
 
@@ -104,3 +106,35 @@ def test_add_constant_with_explicit_encoding(self) -> None:
         c = Constants()
         c.titles.add_with_encoding(b'b\351ck', encoding='latin_1')
         self.assertIn('béck', c.titles)
+
+    def test_pickle_roundtrip_preserves_customizations(self) -> None:
+        """A pickled Constants must restore its customized collections.
+
+        Regression test: __setstate__ previously passed the whole state dict
+        to __init__ as the `prefixes` argument, so every collection silently
+        reverted to its module default on unpickling.
+        """
+        c = Constants()
+        c.titles.add('customtitle')
+        c.prefixes.add('customprefix')
+        c.titles.remove('hon')
+
+        # Safe: round-tripping a Constants the test just built, not untrusted data.
+        restored = pickle.loads(pickle.dumps(c))
+
+        self.assertIn('customtitle', restored.titles)
+        self.assertIn('customprefix', restored.prefixes)
+        self.assertNotIn('hon', restored.titles)
+        # The contributing collections must match the original exactly.
+        self.assertEqual(set(restored.titles), set(c.titles))
+        self.assertEqual(set(restored.prefixes), set(c.prefixes))
+
+    def test_pickle_roundtrip_preserves_instance_scalar_override(self) -> None:
+        """An instance-level scalar override must survive a pickle round-trip."""
+        c = Constants()
+        c.empty_attribute_default = None
+
+        # Safe: round-tripping a Constants the test just built, not untrusted data.
+        restored = pickle.loads(pickle.dumps(c))
+
+        self.assertEqual(restored.empty_attribute_default, None)