fix: harden cache invalidation, pickle restore, and test coverage

- SetManager.remove() only fires _on_change when an element was actually
  removed, avoiding unnecessary cache churn on no-op calls
- _CachedUnionMember.__set__ raises TypeError for non-SetManager values
  instead of silently skipping hook wiring (which would break invalidation)
- Constants.__setstate__ guards against malformed/truncated pickle state
  using _CachedUnionMember introspection, matching __getstate__'s approach
- Add comment to __init__ explaining the descriptor-assignment ordering
  dependency that establishes _pst
- UnicodeDecodeError fallback in base.py now preserves actual/expected
  in the assertion message
- Replace duplicate add-title test with pickle round-trip callback test

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: derek73

nameparser/config/__init__.py

@@ -117,10 +117,12 @@ def remove(self, *strings: str) -> Self:
         Remove the lower case and no-period version of the string arguments from the set.
         Returns ``self`` for chaining.
         """
+        changed = False
         for s in strings:
             if (lower := lc(s)) in self.elements:
                 self.elements.remove(lower)
-        if self._on_change:
+                changed = True
+        if changed and self._on_change:
             self._on_change()
         return self
 
@@ -200,11 +202,15 @@ def __get__(self, obj: 'Constants | None', objtype: type | None = None) -> 'SetM
         return getattr(obj, self._attr)
 
     def __set__(self, obj: 'Constants', value: SetManager) -> None:
+        if not isinstance(value, SetManager):
+            raise TypeError(
+                f"Expected a SetManager instance, got {type(value).__name__!r}. "
+                "Wrap your iterable: SetManager(['mr', 'ms'])"
+            )
         previous = getattr(obj, self._attr, None)
         if isinstance(previous, SetManager):
             previous._on_change = None  # detach the replaced manager so it no longer invalidates
-        if isinstance(value, SetManager):
-            value._on_change = obj._invalidate_pst
+        value._on_change = obj._invalidate_pst
         obj._invalidate_pst()
         setattr(obj, self._attr, value)
 
@@ -316,6 +322,9 @@ def __init__(self,
                  capitalization_exceptions: TupleManager[str] | Iterable[tuple[str, str]] = CAPITALIZATION_EXCEPTIONS,
                  regexes: RegexTupleManager | TupleManager[re.Pattern[str]] | Iterable[tuple[str, re.Pattern[str]]] = REGEXES
                  ) -> None:
+        # These four descriptor assignments call _CachedUnionMember.__set__, which
+        # calls _invalidate_pst() and establishes self._pst. They must come before
+        # any read of suffixes_prefixes_titles.
         self.prefixes = SetManager(prefixes)
         self.suffix_acronyms = SetManager(suffix_acronyms)
         self.suffix_not_acronyms = SetManager(suffix_not_acronyms)
@@ -355,6 +364,16 @@ def __setstate__(self, state: Mapping[str, Any]) -> None:
             if isinstance(getattr(type(self), name, None), property):
                 continue
             setattr(self, name, value)
+        # Verify each descriptor-backed attr was restored. Without this, a missing
+        # key surfaces later as AttributeError: 'Constants' object has no attribute
+        # '_prefixes' — the private mangled name, not the public one, making it
+        # very hard to diagnose.
+        for attr in (n for n, v in vars(type(self)).items() if isinstance(v, _CachedUnionMember)):
+            if not hasattr(self, '_' + attr):
+                raise ValueError(
+                    f"Pickle state is missing required field {attr!r}. "
+                    "The state blob may be truncated or from an incompatible version."
+                )
 
     def __getstate__(self) -> Mapping[str, Any]:
         # Pickle the instance's own configuration: the collections built in

tests/base.py

@@ -25,7 +25,7 @@ def m(self, actual: T, expected: T, hn: HumanName) -> None:
                 hn,
             )
         except UnicodeDecodeError:
-            assert actual == expected_
+            assert actual == expected_, f"actual={actual!r} != expected={expected_!r}"
 
     def assertEqual(self, first: object, second: object, msg: object = None) -> None:
         assert first == second, msg

tests/test_constants.py

@@ -277,12 +277,14 @@ def test_suffixes_prefixes_titles_reflects_add_suffix_not_acronym(self) -> None:
         c.suffix_not_acronyms.add('xsfx')
         self.assertIn('xsfx', c.suffixes_prefixes_titles)
 
-    def test_suffixes_prefixes_titles_reflects_add_after_initial_read(self) -> None:
-        """suffixes_prefixes_titles must reflect mutations even after the cache has been primed."""
+    def test_pickle_roundtrip_rewires_invalidation_callbacks(self) -> None:
+        """Mutations on a deserialized Constants must still invalidate the cache."""
         c = Constants()
-        _ = c.suffixes_prefixes_titles  # prime the cache
-        c.titles.add('emerita')
-        self.assertIn('emerita', c.suffixes_prefixes_titles)
+        # Safe: round-tripping a Constants the test just built, not untrusted data.
+        restored = pickle.loads(pickle.dumps(c))
+        _ = restored.suffixes_prefixes_titles  # prime the cache
+        restored.titles.add('posttitle')
+        self.assertIn('posttitle', restored.suffixes_prefixes_titles)
 
     def test_is_rootname_consistent_with_is_title(self) -> None:
         """is_rootname must return False for words recognised by is_title."""