Give every config entry point the decode hint, not three of five

Reviewing the commit that added the hint found it had done to itself
exactly what it was fixing: bytes reached Lexicon's vocabulary fields
and Policy's collection fields with a decode hint, while
capitalization_exceptions and name_order still reported the cryptic
byte value ("name_order elements must be Role members, got 103" -- 103
is 'g'). Guarding one member of a family and leaving its siblings is
the most repeated defect on this branch; that is now three rounds.

Also widened to bytearray and memoryview. bytes was the only binary
type checked, so memoryview(b'ab') still surfaced "got 97".

One shared _reject_buffer() in _lexicon, called from both entry points,
and the same check on all three Policy/PolicyPatch sites. The tests
are parametrized over every entry point x every buffer type rather than
one example each -- a per-example test is what let the gap through.

The perf-shape coverage table said "at n=200"; the test runs at 800.
Re-measured: the columns are identical at both, so the note now cites
the base it is actually describing.

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

Author: derek73

nameparser/_lexicon.py

@@ -97,6 +97,21 @@ def _title_key(words: Iterable[str]) -> str:
     return " ".join(filter(None, (_normalize(w) for w in words)))
 
 
+def _reject_buffer(value: object, label: str, plural: str) -> None:
+    """Binary sequences iterate to INTS, so every downstream entry check
+    reports a byte value -- "must be strings, got 100" for b'dr', where
+    100 is 'd'. That names neither the cause nor the fix. v1 shipped a
+    decode hint for this (#238), and parse() and the facade both carry
+    one, so no config entry point should be the odd one out.
+    """
+    if isinstance(value, (bytes, bytearray, memoryview)):
+        raise TypeError(
+            f"{label} must be an iterable of {plural}, not "
+            f"{type(value).__name__} -- decode first, e.g. "
+            f"raw.decode('utf-8')"
+        )
+
+
 def _normset(entries: Iterable[str], field_name: str) -> frozenset[str]:
     # Reject a bare str before iterating: iterating "dr" would silently
     # yield the single characters {'d', 'r'} -- the set(str) footgun on
@@ -106,16 +121,7 @@ def _normset(entries: Iterable[str], field_name: str) -> frozenset[str]:
             f"Lexicon.{field_name} must be an iterable of strings, "
             f"not a bare string"
         )
-    # bytes iterate to INTS, so without this the entry check below
-    # reports "entries must be strings, got 100" -- the byte value of
-    # 'd', naming neither the cause nor the fix. v1 shipped a decode
-    # hint for exactly this (#238); parse() and the facade carry one,
-    # so the config surface should not be the odd one out.
-    if isinstance(entries, (bytes, bytearray)):
-        raise TypeError(
-            f"Lexicon.{field_name} must be an iterable of strings, not "
-            f"bytes -- decode first, e.g. raw.decode('utf-8')"
-        )
+    _reject_buffer(entries, f"Lexicon.{field_name}", "strings")
     # A Mapping would silently contribute only its keys; a dict here
     # almost always means the caller confused this field with
     # capitalization_exceptions.
@@ -170,6 +176,7 @@ def _normpairs(
             "capitalization_exceptions must be a mapping or an "
             "iterable of (key, value) pairs, not a bare string"
         )
+    _reject_buffer(raw, "capitalization_exceptions", "(key, value) pairs")
     pairs = raw.items() if isinstance(raw, Mapping) else raw
     try:
         pairs = iter(pairs)

nameparser/_policy.py

@@ -98,6 +98,12 @@ def _reject_bare_string_order(value: object) -> None:
             f"name_order must be an iterable of three Roles, not a "
             f"mapping: {value!r}"
         )
+    if isinstance(value, (bytes, bytearray, memoryview)):
+        raise TypeError(
+            f"name_order must be an iterable of three Roles, not "
+            f"{type(value).__name__} -- decode first, e.g. "
+            f"raw.decode('utf-8')"
+        )
 
 
 def _reject_str_and_mapping(value: object, field_name: str) -> None:
@@ -118,10 +124,11 @@ def _reject_str_and_mapping(value: object, field_name: str) -> None:
     # bytes iterate to ints, so the entry check would report a byte
     # value and name neither the cause nor the fix; same decode hint
     # Lexicon and parse() give.
-    if isinstance(value, (bytes, bytearray)):
+    if isinstance(value, (bytes, bytearray, memoryview)):
         raise TypeError(
-            f"{field_name} must be an iterable of strings, not bytes -- "
-            f"decode first, e.g. raw.decode('utf-8')"
+            f"{field_name} must be an iterable of strings, not "
+            f"{type(value).__name__} -- decode first, e.g. "
+            f"raw.decode('utf-8')"
         )
     if isinstance(value, Mapping):
         # Name the way out, not just the harm. "contributes only its

tests/v2/test_benchmark.py

@@ -45,17 +45,17 @@ def test_facade_thousand_names_under_a_second() -> None:
 # loop. Cheap per unit, so a superlinear stage shows up as growth rather
 # than as a slow parse.
 #
-# What each DIMENSION is covered by, at n=200 (measure before pruning a
-# shape that looks redundant -- several differ only in a column you
-# cannot see from the string):
+# What each DIMENSION is covered by, measured at _BASE. Several shapes
+# differ only in a column you cannot see from the string, so measure
+# before pruning one that looks redundant:
 #
 #   dimension                 covered by
 #   token count               all nine
 #   piece count               unmatched_*, plain_tokens, commas, titles
 #   SEGMENT count             commas ONLY -- deleting it leaves every
 #                             segment-keyed regression unguarded
-#   intra-piece accumulation  particles (199-token piece),
-#                             conjunctions (200) -- the merge() quadratic
+#   intra-piece accumulation  particles (one 799-token piece),
+#                             conjunctions (800) -- the merge() quadratic
 #   masked-span count         delimiter_pairs, quote_pairs (0 pieces:
 #                             everything is consumed as a delimited run)
 _SHAPES = {

tests/v2/test_lexicon.py

@@ -444,12 +444,22 @@ def test_remove_error_offers_the_removal_remedy_too() -> None:
         lex.remove(particles={"van"})
 
 
-@pytest.mark.parametrize("value", [b"dr", bytearray(b"dr")])
-def test_vocab_field_rejects_bytes_with_a_decode_hint(value: object) -> None:
-    # bytes iterate to INTS, so the generic entry check reported
-    # "entries must be strings, got 100" -- the byte value of 'd',
-    # naming neither the cause nor the fix. v1 shipped a decode hint
-    # for exactly this (#238); parse() and the facade already carry
-    # one, so the config surface should not be the odd one out.
+@pytest.mark.parametrize("value", [b"dr", bytearray(b"dr"), memoryview(b"dr")])
+@pytest.mark.parametrize("build", [
+    lambda v: Lexicon(titles=v),
+    lambda v: Lexicon.empty().add(titles=v),
+    lambda v: Lexicon(capitalization_exceptions=v),
+])
+def test_every_lexicon_entry_point_rejects_a_buffer_with_a_decode_hint(
+        build: Callable[[object], object], value: object) -> None:
+    # Binary sequences iterate to INTS, so the generic entry check
+    # reported "entries must be strings, got 100" -- the byte value of
+    # 'd', naming neither the cause nor the fix. v1 shipped a decode
+    # hint for exactly this (#238).
+    #
+    # Every entry point, because the first version of this fix covered
+    # the vocabulary fields and left capitalization_exceptions behind:
+    # guarding one member of a family and not its siblings is the
+    # single most repeated defect on this branch.
     with pytest.raises(TypeError, match="decode"):
-        Lexicon(titles=value)          # type: ignore[arg-type]
+        build(value)

tests/v2/test_policy.py

@@ -396,9 +396,13 @@ def test_a_pair_mapping_is_accepted_through_items(cls: type) -> None:
 
 
 @pytest.mark.parametrize("cls", [Policy, PolicyPatch])
-@pytest.mark.parametrize("value", [b" - ", bytearray(b" - ")])
-def test_collection_fields_reject_bytes_with_a_decode_hint(
-        cls: type, value: object) -> None:
-    # Same cryptic int message as Lexicon had: bytes iterate to ints.
+@pytest.mark.parametrize("value", [b" - ", bytearray(b" - "), memoryview(b" - ")])
+@pytest.mark.parametrize(
+    "field", ["extra_suffix_delimiters", "nickname_delimiters",
+              "maiden_delimiters", "patronymic_rules", "name_order"])
+def test_every_field_rejects_a_buffer_with_a_decode_hint(
+        cls: type, field: str, value: object) -> None:
+    # Same cryptic int message Lexicon had, and name_order was the one
+    # field the first pass missed.
     with pytest.raises(TypeError, match="decode"):
-        cls(extra_suffix_delimiters=value)
+        cls(**{field: value})