fix: guard base TupleManager dunder probes; test HumanName deepcopy

Two follow-ups to the copy/pickle round-trip fixes:

- TupleManager.__getattr__ returned None for any missing attribute, so
  hasattr(tm, '__anydunder__') was always True. copy.deepcopy tolerated
  this (it reads None as "absent"), but hasattr-then-call probes would
  break. Apply the same dunder guard as RegexTupleManager so the base is
  consistent and hasattr is honest.

- Add HumanName deepcopy tests. HumanName has no custom copy hooks, so
  copy.deepcopy(name) recurses into .C.regexes and previously raised
  TypeError for every name; the RegexTupleManager dunder guard fixed it,
  and these tests lock that in (round-trip equality + instance-config
  isolation).

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

Author: derek73

nameparser/config/__init__.py

@@ -126,6 +126,13 @@ class TupleManager(dict[str, T]):
     '''
 
     def __getattr__(self, attr: str) -> T | None:
+        # Dunder names are Python's protocol probes (copy looks up __deepcopy__,
+        # inspect.unwrap looks up __wrapped__, ...), never config keys. Report
+        # them as genuinely absent so hasattr() is honest and those probes work;
+        # otherwise the dict default is mistaken for a real protocol hook. See
+        # RegexTupleManager.__getattr__ for the concrete failure this prevents.
+        if attr.startswith("__") and attr.endswith("__"):
+            raise AttributeError(attr)
         return self.get(attr)
 
     __setattr__ = dict.__setitem__

tests/test_constants.py

@@ -2,7 +2,7 @@
 import pickle
 
 from nameparser import HumanName
-from nameparser.config import Constants, RegexTupleManager, SetManager
+from nameparser.config import Constants, RegexTupleManager, SetManager, TupleManager
 from nameparser.config.regexes import EMPTY_REGEX
 
 from tests.base import HumanNameTestBase
@@ -190,6 +190,23 @@ def test_regextuplemanager_ignores_dunder_lookups(self) -> None:
         # A normal (non-dunder) unknown key still yields the EMPTY_REGEX default.
         self.assertEqual(c.regexes.unknown_key, EMPTY_REGEX)
 
+    def test_tuplemanager_ignores_dunder_lookups(self) -> None:
+        """Base TupleManager must report unknown dunder names as absent too.
+
+        It returned None for any missing attribute, so `hasattr(tm, '__x__')`
+        was always True — a landmine for any probe that does hasattr-then-call.
+        Guarding dunders keeps the base consistent with RegexTupleManager.
+        """
+        c = Constants()
+        tm = c.capitalization_exceptions  # a plain TupleManager
+        sentinel = object()
+
+        self.assertEqual(type(tm), TupleManager)
+        self.assertFalse(hasattr(tm, '__deepcopy__'))
+        self.assertEqual(getattr(tm, '__wrapped__', sentinel), sentinel)
+        # A normal (non-dunder) unknown key still returns the None default.
+        self.assertEqual(tm.unknown_key, None)
+
     def test_unpickle_legacy_state_with_property_key(self) -> None:
         """Pickles written by older versions must still load.
 

tests/test_python_api.py

@@ -1,3 +1,4 @@
+import copy
 import pickle
 import re
 
@@ -66,6 +67,31 @@ def test_name_instance_pickle_preserves_instance_config(self) -> None:
         restored.full_name = "Chancellor Jane Smith"
         self.assertEqual(restored.title, "Chancellor")
 
+    def test_name_instance_deepcopy(self) -> None:
+        """copy.deepcopy of a HumanName must round-trip.
+
+        HumanName has no custom copy hooks, so deepcopy recurses into its
+        Constants (`.C`), and previously into `.C.regexes`, whose __getattr__
+        answered copy's __deepcopy__ probe with a re.Pattern — making
+        deepcopy of *any* HumanName raise TypeError.
+        """
+        hn = HumanName("Dr. John P. Doe-Ray, CLU")
+
+        dup = copy.deepcopy(hn)
+
+        self.assertEqual(str(dup), str(hn))
+
+    def test_name_instance_deepcopy_isolates_instance_config(self) -> None:
+        """A deep-copied HumanName with its own config must be independent."""
+        hn = HumanName("Smith, Dr. John", None)
+        hn.C.titles.add('chancellor')
+
+        dup = copy.deepcopy(hn)
+        dup.C.titles.add('marker')
+
+        self.assertIn('chancellor', dup.C.titles)
+        self.assertNotIn('marker', hn.C.titles)
+
     def test_comparison(self) -> None:
         hn1 = HumanName("Doe-Ray, Dr. John P., CLU, CFP, LUTC")
         hn2 = HumanName("Dr. John P. Doe-Ray, CLU, CFP, LUTC")