Reject bare strings and 2-char string elements in TupleManager

TupleManager (and RegexTupleManager) inherited dict.__init__ unchanged, so
string inputs behaved inconsistently with the guarded SetManager (#238):
TupleManager('ab') raised a cryptic dict-internals ValueError naming no
argument, and TupleManager(['ab', 'cd']) silently shredded into
{'a': 'b', 'c': 'd'} since a 2-character string is a valid dict-update
sequence element. Give TupleManager its own __init__ that rejects a bare
str/bytes argument and any str/bytes element within an iterable, mirroring
SetManager's error-message style.

Fixes #242

Author: derek73

nameparser/config/__init__.py

@@ -276,6 +276,42 @@ class TupleManager(dict[str, T]):
     1.3.0 these constants were tuples of pairs.
     '''
 
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        # dict.__init__ accepts a bare str/bytes as an iterable-of-pairs
+        # argument (each character iterates further, and dict() only
+        # complains once it hits a "pair" of the wrong length) and accepts an
+        # iterable of 2-character strings as if each one were a (key, value)
+        # pair, silently shredding it -- mirrors SetManager's guard against
+        # the same class of mistake (#238), applied to the mapping
+        # constructor's own failure modes (#242).
+        if args:
+            arg = args[0]
+            if isinstance(arg, bytes):
+                raise TypeError(
+                    "expected a mapping or iterable of (key, value) pairs, got a "
+                    f"single bytes; decode it first: [{arg!r}.decode()]"
+                )
+            if isinstance(arg, str):
+                raise TypeError(
+                    "expected a mapping or iterable of (key, value) pairs, got a "
+                    f"single str; wrap it in a list: [{arg!r}]"
+                )
+            if not isinstance(arg, Mapping):
+                checked = []
+                for item in arg:
+                    if isinstance(item, (str, bytes)):
+                        raise TypeError(
+                            "expected (key, value) pairs, got a "
+                            f"{'bytes' if isinstance(item, bytes) else 'str'} "
+                            f"element {item!r}; a 2-character string silently "
+                            "splits into a key and a value"
+                        )
+                    checked.append(item)
+                arg = checked
+            super().__init__(arg, **kwargs)
+        else:
+            super().__init__(**kwargs)
+
     def __getattr__(self, attr: str) -> T | None:
         # Otherwise the dict default (None) is mistaken for a real protocol hook.
         if _is_dunder(attr):

tests/test_constants.py

@@ -178,6 +178,35 @@ def test_set_manager_non_str_elements_raise_typeerror(self) -> None:
         with pytest.raises(TypeError, match=r"expected str elements"):
             SetManager(['dr']) | [1]  # type: ignore[list-item]
 
+    def test_tuplemanager_bare_string_raises_typeerror(self) -> None:
+        # dict(['ab', 'cd']) shreds each 2-char string into a key/value pair
+        # silently -- and dict('ab') itself raises a cryptic "dictionary update
+        # sequence element #0 has length 1; 2 is required" naming no argument
+        # and suggesting no fix (#242)
+        with pytest.raises(TypeError, match=r"wrap it in a list"):
+            TupleManager('ab')
+
+    def test_tuplemanager_bytes_raises_with_decode_hint(self) -> None:
+        with pytest.raises(TypeError, match=r"decode it first"):
+            TupleManager(b'ab')  # type: ignore[arg-type]
+
+    def test_tuplemanager_string_element_raises_typeerror(self) -> None:
+        # the silent variant: an iterable of 2-character strings is a valid
+        # dict-update sequence, so each one shreds into a key/value pair
+        with pytest.raises(TypeError, match=r"key and a value"):
+            TupleManager(['ab', 'cd'])
+
+    def test_constants_capitalization_exceptions_string_elements_raise(self) -> None:
+        with pytest.raises(TypeError, match=r"key and a value"):
+            Constants(capitalization_exceptions=['ii'])
+
+    def test_tuplemanager_accepts_mapping_and_pairs(self) -> None:
+        # the guard must not reject the two legitimate constructor shapes
+        tm = TupleManager({'a': '1'})
+        self.assertEqual(tm.a, '1')
+        tm2 = TupleManager([('b', '2')])
+        self.assertEqual(tm2.b, '2')
+
     def test_remove_title(self) -> None:
         hn = HumanName("Hon Solo", constants=None)
         start_len = len(hn.C.titles)