Small cleanups from the review sweep

_lexicon.__setstate__: compute the drift set once per field instead of
three times, in _VOCAB_FIELDS declaration order rather than alphabetized
by formatted string, and drop the intermediate dict that existed only to
host a cast.

_types.ParsedName.__post_init__: nest the token-subset check under the
ambiguities guard rather than giving one local two types to skip work
the loop already skips.

_config_shim: inline a local used once.

tests: drop a bare-string __setstate__ test fully subsumed by the
parametrized case above it, and stop parsing the same input twice in
the unmatched-close assertion.

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

Author: derek73

nameparser/_types.py

@@ -380,17 +380,19 @@ def __post_init__(self) -> None:
         # stray delimiters does), and the linear form made construction
         # quadratic in their product. Set membership uses the same value
         # equality the tuple scan did -- Token is frozen and hashable.
-        known = set(self.tokens) if self.ambiguities else ()
-        for amb in self.ambiguities:
-            for tok in amb.tokens:
-                # membership is by Token's value equality, not identity:
-                # this only guarantees a value-equal token exists in
-                # self.tokens, not that `tok` IS one of those objects.
-                if tok not in known:
-                    raise ValueError(
-                        f"Ambiguity token {tok.text!r} is not a subset of "
-                        f"this ParsedName's tokens"
-                    )
+        if self.ambiguities:
+            known = set(self.tokens)
+            for amb in self.ambiguities:
+                for tok in amb.tokens:
+                    # membership is by Token's value equality, not
+                    # identity: this only guarantees a value-equal token
+                    # exists in self.tokens, not that `tok` IS one of
+                    # those objects.
+                    if tok not in known:
+                        raise ValueError(
+                            f"Ambiguity token {tok.text!r} is not a "
+                            f"subset of this ParsedName's tokens"
+                        )
 
     def __bool__(self) -> bool:
         return bool(self.tokens)

tests/v2/pipeline/test_extract.py

@@ -194,9 +194,10 @@ def test_unmatched_close_is_reported(text: str, char: str) -> None:
     # the scan is opener-driven, so a close with no open to its left was
     # never in its search space and went unreported -- even though the
     # AmbiguityKind docstring promises "or closed without opening"
-    kinds = [a.kind for a in parse(text).ambiguities]
-    assert kinds == [AmbiguityKind.UNBALANCED_DELIMITER]
-    assert char in parse(text).ambiguities[0].detail
+    ambiguities = parse(text).ambiguities
+    assert [a.kind for a in ambiguities] == [
+        AmbiguityKind.UNBALANCED_DELIMITER]
+    assert char in ambiguities[0].detail
 
 
 def test_word_final_apostrophe_is_not_an_unbalanced_delimiter() -> None:

tests/v2/test_facade.py

@@ -326,19 +326,6 @@ def test_setstate_rejects_malformed_component_lists(bad: object) -> None:
         loaded.__setstate__(state)
 
 
-def test_setstate_rejects_a_bare_string_component_list() -> None:
-    # a genuine v1 pickle stores lists, but __setstate__ reads foreign
-    # state: a bare str is iterable, so entry.split() over its
-    # CHARACTERS silently produced a plausible-looking wrong name
-    # ("John" -> first "J o h n") instead of failing at the load site
-    n = HumanName("John Smith")
-    state = n.__getstate__()
-    state["first_list"] = "John"
-    loaded = HumanName.__new__(HumanName)
-    with pytest.raises(TypeError, match="first_list"):
-        loaded.__setstate__(state)
-
-
 def test_setstate_restores_a_foreign_multi_word_suffix_entry() -> None:
     # the parametrized round-trip tests above go through v2's own
     # __getstate__, which is self-consistent by construction. The case