fix: stop RegexTupleManager answering dunder probes with a regex

RegexTupleManager.__getattr__ returned the EMPTY_REGEX default for *any*
unknown attribute, including the dunder names Python's machinery probes
for. copy.deepcopy does getattr(obj, "__deepcopy__", None) to detect a
custom deep-copy hook; it received EMPTY_REGEX (a truthy re.Pattern)
instead of None, then tried to call it -> "re.Pattern object is not
callable". The same trap applied to copy.copy, inspect.unwrap, etc.

Reject dunder-shaped names with AttributeError so those probes see the
attribute as absent. Non-dunder unknown keys still get the EMPTY_REGEX
default, preserving existing behavior.

With deepcopy now working for the config managers, drop the
_clone_config_collection workaround in the test conftest (and its
now-stale comment) in favor of copy.deepcopy.

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

Author: derek73

nameparser/config/__init__.py

@@ -147,6 +147,13 @@ def __reduce__(self) -> tuple[type, tuple[()], Mapping[str, T]]:
 
 class RegexTupleManager(TupleManager[re.Pattern[str]]):
     def __getattr__(self, attr: str) -> re.Pattern[str]:
+        # Dunder names are Python's protocol probes (copy.deepcopy looks up
+        # __deepcopy__, inspect.unwrap looks up __wrapped__, ...), never regex
+        # keys. Report them as genuinely absent; otherwise the EMPTY_REGEX
+        # default is mistaken for a real protocol hook — e.g. copy.deepcopy
+        # tries to call the returned re.Pattern and raises TypeError.
+        if attr.startswith("__") and attr.endswith("__"):
+            raise AttributeError(attr)
         return self.get(attr, EMPTY_REGEX)
 
 

tests/conftest.py

@@ -1,10 +1,9 @@
+import copy
 from collections.abc import Iterator
 
 import pytest
 
-from nameparser.config import CONSTANTS, SetManager, TupleManager
-
-ConfigCollection = SetManager | TupleManager
+from nameparser.config import CONSTANTS
 
 # Scalar (non-collection) config attributes that individual tests mutate on the
 # global CONSTANTS singleton. Several tests change these without restoring them;
@@ -38,20 +37,6 @@
 )
 
 
-def _clone_config_collection(value: ConfigCollection) -> ConfigCollection:
-    """Return an independent copy of a config collection manager.
-
-    ``copy.deepcopy`` is not used because ``RegexTupleManager`` carries compiled
-    patterns that its ``__reduce__`` cannot round-trip. Rebuilding from the
-    manager's own contents copies the container while sharing the (immutable)
-    elements, which is all the snapshot needs.
-    """
-    if isinstance(value, SetManager):
-        return SetManager(set(value))
-    # TupleManager / RegexTupleManager are dict subclasses.
-    return type(value)(dict(value))
-
-
 @pytest.fixture(autouse=True, params=['', None], ids=['default', 'none'])
 def empty_attribute_default(request: pytest.FixtureRequest) -> Iterator[str | None]:
     """Run every test under both empty_attribute_default settings, isolating global config.
@@ -66,7 +51,7 @@ def empty_attribute_default(request: pytest.FixtureRequest) -> Iterator[str | No
     """
     scalar_snapshot = {attr: getattr(CONSTANTS, attr) for attr in _SCALAR_CONFIG_ATTRS}
     collection_snapshot = {
-        attr: _clone_config_collection(getattr(CONSTANTS, attr))
+        attr: copy.deepcopy(getattr(CONSTANTS, attr))
         for attr in _COLLECTION_CONFIG_ATTRS
     }
     CONSTANTS.empty_attribute_default = request.param

tests/test_constants.py

@@ -1,3 +1,4 @@
+import copy
 import pickle
 
 from nameparser import HumanName
@@ -159,6 +160,36 @@ def test_pickle_roundtrip_preserves_regex_manager_subclass(self) -> None:
         self.assertEqual(type(restored.regexes), RegexTupleManager)
         self.assertEqual(restored.regexes.does_not_exist, EMPTY_REGEX)
 
+    def test_regexes_deepcopy_roundtrip(self) -> None:
+        """copy.deepcopy of a RegexTupleManager must round-trip.
+
+        __getattr__ answered every unknown name with the EMPTY_REGEX default,
+        including the __deepcopy__ probe copy.deepcopy issues. copy then
+        mistook that re.Pattern for a deep-copy hook and tried to call it.
+        """
+        c = Constants()
+
+        dup = copy.deepcopy(c.regexes)
+
+        self.assertEqual(type(dup), RegexTupleManager)
+        self.assertEqual(dict(dup), dict(c.regexes))
+        # The EMPTY_REGEX default still applies to genuinely unknown keys.
+        self.assertEqual(dup.does_not_exist, EMPTY_REGEX)
+
+    def test_regextuplemanager_ignores_dunder_lookups(self) -> None:
+        """Unknown dunder names report as absent, not as the EMPTY_REGEX default.
+
+        Dunder names are Python's protocol probes (copy.deepcopy looks up
+        __deepcopy__, inspect.unwrap looks up __wrapped__, ...), never config
+        keys. Answering them with a regex breaks that machinery.
+        """
+        c = Constants()
+        sentinel = object()
+
+        self.assertEqual(getattr(c.regexes, '__deepcopy__', sentinel), sentinel)
+        # A normal (non-dunder) unknown key still yields the EMPTY_REGEX default.
+        self.assertEqual(c.regexes.unknown_key, EMPTY_REGEX)
+
     def test_unpickle_legacy_state_with_property_key(self) -> None:
         """Pickles written by older versions must still load.