Fix bare string to SetManager silently shredding into characters

Every set-backed Constants argument is annotated Iterable[str], which a
bare str satisfies — as an iterable of its characters. SetManager's
set(elements) then silently replaced the whole default set with single
characters (Constants(titles='dr') -> titles == {'d', 'r'}), producing
wrong parses with no error anywhere. The type system cannot catch this,
so it must be a runtime check.

Reject str and bytes in SetManager.__init__ with a TypeError that
includes the wrap-it-in-a-list fix, covering all nine set-backed
Constants arguments and direct SetManager construction in one place.
All internal call sites pass module-level tuples/sets, and pickling
restores SetManager by state without re-running __init__, so only the
buggy input path is affected.

Closes #238

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: derek73

docs/release_log.rst

@@ -1,6 +1,7 @@
 Release Log
 ===========
 * 1.3.0 - Unreleased
+    - Fix a bare string passed to a set-backed ``Constants`` argument (e.g. ``Constants(titles='dr')``) or to ``SetManager`` being silently split into single characters, replacing the default set and producing wrong parses with no error; it now raises ``TypeError`` with the suggested fix (wrap it in a list) (closes #238)
     - Fix the ``constants`` constructor argument silently discarding ``Constants`` *subclass* instances: the exact-type check replaced them with fresh defaults, throwing away the caller's configuration. Subclass instances are now used as given; anything that is neither ``None`` nor a ``Constants`` instance now raises ``TypeError`` instead of being silently swapped for defaults (closes #226)
     - Fix ``IndexError`` in ``initials()``/``initials_list()`` when a ``*_list`` attribute was assigned directly with an element containing unnormalized whitespace (e.g. ``name.middle_list = ['Q  R']``), bypassing the parser's whitespace normalization (closes #232)
     - Fix ``HumanName`` acting as its own iterator with a stored cursor: breaking out of a loop, iterating in nested loops, or calling ``len(name)`` mid-loop corrupted subsequent iteration; ``iter(name)`` now returns a fresh independent iterator each time. ``next(name)`` on the instance itself (undocumented) now raises ``TypeError`` — call ``next(iter(name))`` instead (closes #225)

nameparser/config/__init__.py

@@ -66,6 +66,13 @@ class SetManager(Set):
     _on_change: Callable[[], None] | None
 
     def __init__(self, elements: Iterable[str]) -> None:
+        # a bare string is an iterable of its characters, so set(elements)
+        # would silently build a set of single characters (#238)
+        if isinstance(elements, (str, bytes)):
+            raise TypeError(
+                "expected an iterable of strings, got a single "
+                f"{type(elements).__name__}; wrap it in a list: [{elements!r}]"
+            )
         self.elements = set(elements)
         # Optional invalidation hook, wired by an owning Constants so that
         # in-place add()/remove() can clear its cached suffixes_prefixes_titles

tests/test_constants.py

@@ -45,6 +45,19 @@ def test_constants_class_instead_of_instance_raises_with_hint(self) -> None:
         with pytest.raises(TypeError, match=r"did you mean Constants\(\)"):
             HumanName("John Doe", constants=Constants)  # type: ignore[arg-type]
 
+    def test_constants_bare_string_kwarg_raises_typeerror(self) -> None:
+        # a bare string is an iterable of its characters, so set('dr') would
+        # silently replace the default titles with {'d', 'r'} (#238); the
+        # type system can't catch this because str satisfies Iterable[str]
+        with pytest.raises(TypeError, match=r"wrap it in a list"):
+            Constants(titles='dr')
+
+    def test_set_manager_bare_string_raises_typeerror(self) -> None:
+        with pytest.raises(TypeError, match=r"wrap it in a list"):
+            SetManager('dr')
+        with pytest.raises(TypeError, match=r"wrap it in a list"):
+            SetManager(b'dr')  # type: ignore[arg-type]
+
     def test_remove_title(self) -> None:
         hn = HumanName("Hon Solo", constants=None)
         start_len = len(hn.C.titles)