nameparser 2.4.0__tar.gz → 2.4.2__tar.gz

{nameparser-2.4.0/nameparser.egg-info → nameparser-2.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nameparser
-Version: 2.4.0
+Version: 2.4.2
 Summary: A simple Python module for parsing human names into their individual components.
 Author-email: Derek Gulbranson <derek73@gmail.com>
 License: LGPL

{nameparser-2.4.0 → nameparser-2.4.2}/nameparser/_facade.py

@@ -709,8 +709,8 @@ class HumanName:
             # which compare the seven role fields only (Case carries
             # no initials column); the covering test is
             # tests/test_initials.py::test_initials_middle_name_all_prefixes,
-            # and since #484 the differential compares initials() on
-            # both surfaces for names whose roles agree. _split_last
+            # and tools/differential/snapshot.jsonl records initials()
+            # on both surfaces for every corpus name. _split_last
             # already applies the same guard to the base, which is why
             # last_base was never empty here.
             return [_render._first_letter(w) for w in words]

{nameparser-2.4.0 → nameparser-2.4.2}/nameparser/_pipeline/_classify.py

@@ -52,6 +52,7 @@ is what lets the fork be reported without being taken.
 """
 from __future__ import annotations
 
+import unicodedata
 
 from nameparser._lexicon import _normalize, _spells_an_initial
 from nameparser._policy import CapsSuffixes
@@ -61,8 +62,8 @@ from nameparser._pipeline._state import (
 )
 from nameparser._types import AmbiguityKind, Role
 from nameparser._pipeline._vocab import (
-    caps_shape_candidate, is_initial, is_one_case, period_joined_vocab,
-    suffix_as_written, tag_marker_runs,
+    caps_shape_candidate, composed_len, is_initial, is_one_case,
+    period_joined_vocab, suffix_as_written, tag_marker_runs,
 )
 from nameparser._pipeline._pieces import own_words
 
@@ -133,9 +134,14 @@ def _tags_for(token: WorkToken, n: str, state: ParseState,
     # written wholly in one case, where nothing says so — where the
     # letter is one the vocabulary marks as reading both ways"
     # (#383/#479; history: decisions.md#P3)
-    single_letter_connective = (len(token.text) == 1
+    # one letter as the writer sees it: a decomposed 'й' is two code
+    # points (#665), so non-ASCII text is counted composed, after the
+    # C-level tests have declined everything else
+    single_letter_connective = (n in lex.conjunctions
                                 and token.text.upper() != token.text.lower()
-                                and n in lex.conjunctions)
+                                and (len(token.text) == 1
+                                     or not token.text.isascii()
+                                     and composed_len(token.text) == 1))
     if single_letter_connective and one_case_own:
         # No case evidence, so the vocabulary decides. No namespaced
         # tag beside it: the emitted ambiguity IS the record of the
@@ -229,7 +235,8 @@ def _tags_for(token: WorkToken, n: str, state: ParseState,
                 # C: a listed member ('John Smith, MA'), and a word that
                 # is not alphabetic capitals ('John Smith, Ph. D.')
                 and n not in lex.suffix_acronyms_ambiguous
-                and token.text.isalpha() and token.text.isupper()
+                and (token.text.isalpha() and token.text.isupper()
+                     or not unicodedata.is_normalized("NFC", token.text))
                 and caps_shape_candidate(token.text, lex, state.policy,
                                          one_case)):
             # #516's all-caps half: an unlisted word written in capitals
@@ -332,10 +339,12 @@ def classify(state: ParseState) -> ParseState:
         # site (mechanisms.md#AMBIGUITY-AT-THE-DECISION-SITE), per
         # token -- 'e and e' reports twice.
         if (one_case and "initial" in token.tags
-                and len(token.text) == 1
                 and folded[i] in state.lexicon.conjunctions_ambiguous
                 and folded[i] in state.lexicon.conjunctions
-                and i < clause_at and token.role is None):
+                and i < clause_at and token.role is None
+                and (len(token.text) == 1
+                     or not token.text.isascii()
+                     and composed_len(token.text) == 1)):
             ambiguities.append(PendingAmbiguity(
                 AmbiguityKind.CONJUNCTION_OR_INITIAL,
                 f"{token.text!r} is both a connective and an initial; "

{nameparser-2.4.0 → nameparser-2.4.2}/nameparser/_pipeline/_comma.py

@@ -27,6 +27,7 @@ Policy.unlisted_caps_suffixes.
 """
 from __future__ import annotations
 
+import unicodedata
 from collections.abc import Sequence
 
 from nameparser._lexicon import _normalize
@@ -40,8 +41,8 @@ from nameparser._pipeline._state import (
 )
 from nameparser._pipeline._vocab import (
     D, PH, caps_shape_candidate, claimed_as_non_name, delimiter_cores,
-    is_paired_initials, is_single_letter_numeral, is_wholly_suffix,
-    name_word_count, surname_unit_facts, unit_ends, written_as_a_name,
+    composed_len, is_caps_word, is_paired_initials, is_single_letter_numeral,
+    is_wholly_suffix, name_word_count, surname_unit_facts, unit_ends, written_as_a_name,
 )
 from nameparser._policy import CapsSuffixes
 from nameparser._types import AmbiguityKind, Role
@@ -217,8 +218,11 @@ def decide(state: ParseState) -> ParseState:
     maybe = [p[0] for p in p1 if len(p) == 1
              and (AMBIGUOUS_ACRONYM_TAG in (tags := tokens[p[0]].tags)
                   or ("vocab:suffix" not in tags
-                      and tokens[p[0]].text.isalpha()
-                      and tokens[p[0]].text.isupper()))]
+                      and (tokens[p[0]].text.isalpha()
+                           and tokens[p[0]].text.isupper()
+                           or not unicodedata.is_normalized(
+                               "NFC", tokens[p[0]].text)
+                           and is_caps_word(tokens[p[0]].text))))]
     # The part is read ONCE: here where it holds no word of the class,
     # after the count below where it does, with the words the count
     # licensed (a read here and a second after licensing threw the first
@@ -307,7 +311,7 @@ def decide(state: ParseState) -> ParseState:
                     continue
                 text = tokens[i].text
                 if not (is_paired_initials(text)
-                        or (i in caps and len(text) == 2)):
+                        or (i in caps and composed_len(text) == 2)):
                     continue
                 if speaker < 0:
                     speaker = next(
@@ -375,7 +379,8 @@ def decide(state: ParseState) -> ParseState:
         member_set = frozenset(members)
         pairs = [k for k, p in enumerate(p1) if p[0] in member_set
                  and (is_paired_initials(tokens[p[0]].text)
-                      or (p[0] in caps and len(tokens[p[0]].text) == 2))]
+                      or (p[0] in caps
+                      and composed_len(tokens[p[0]].text) == 2))]
         # spoken for by each other only: every class word a pair, and
         # only titles among the other words in front of the first
         pair_only = (len(pairs) >= 2 and len(pairs) == len(members)

{nameparser-2.4.0 → nameparser-2.4.2}/nameparser/_pipeline/_extract.py

@@ -38,7 +38,9 @@ from nameparser._lexicon import Lexicon, _normalize
 from nameparser._pipeline._state import (
     COMMA_CHARS, ParseState, PendingAmbiguity, copy_with,
 )
-from nameparser._pipeline._vocab import maiden_marker_run
+from nameparser._pipeline._vocab import (
+    comma_follows_marker, maiden_marker_run,
+)
 from nameparser._types import AmbiguityKind, Role, Span
 
 
@@ -76,9 +78,12 @@ def _maiden_marked(content: str, lexicon: Lexicon) -> bool:
     itself rather than reading the tags classify will set. The two
     questions are deliberately not the same one: this splits on
     WHITESPACE, so a marker the writer glued to punctuation is not one
-    here ('née,'); the tokenizer splits that comma off and classify
-    still tags the token, which is what keeps _group's Role.MAIDEN
-    filter reachable. Sharing the PREDICATE does not merge the two
+    here ('née,') -- nor to classify, since #653 keeps a clause's comma
+    on its word. A nakaguro still divides the two: the tokenizer splits
+    '旧姓・田中' at it (rules.md#T2) and classify tags '旧姓', which is
+    what keeps _group's Role.MAIDEN filter reachable (cases.py's
+    marker_divided_by_a_nakaguro_keeps_the_clause_a_nickname). Sharing
+    the PREDICATE does not merge the two
     questions -- each hands it a different sequence of words."""
     words = content.split()
     # A one-word clause cannot satisfy the condition whatever the
@@ -88,7 +93,8 @@ def _maiden_marked(content: str, lexicon: Lexicon) -> bool:
     if len(words) < 2:
         return False
     run = maiden_marker_run(words, lexicon.maiden_markers)
-    return run > 0 and len(words) > run
+    return (run > 0 and len(words) > run
+            and not comma_follows_marker(words[run]))
 
 
 # rules.md#N2: "a quote whose open and close are the same character
@@ -164,8 +170,8 @@ def _unmatched(open_: str, offset: int) -> tuple[int, PendingAmbiguity]:
 
 
 # rules.md#N1: "a clause enclosed by a configured nickname delimiter
-# pair reads as the nickname and is lifted out of the name; an empty
-# enclosure is simply dropped"
+# pair reads as the nickname and is lifted out of the name" (its
+# punctuation is tokenize's half of the rule)
 # rules.md#M1: "with a delimiter pair configured for maiden names, its
 # enclosed clause reads as the maiden name" (history: decisions.md#M1)
 def extract_delimited(state: ParseState) -> ParseState:

{nameparser-2.4.0 → nameparser-2.4.2}/nameparser/_pipeline/_group.py

@@ -78,7 +78,7 @@ from nameparser._pipeline._state import (
 import nameparser._pipeline._comma as _comma
 from nameparser._pipeline._vocab import D, PH
 from nameparser._pipeline._vocab import (
-    delimiter_cores,
+    comma_follows_marker, delimiter_cores,
 )
 from nameparser._types import AmbiguityKind, Role
 
@@ -1523,8 +1523,11 @@ def group(state: ParseState) -> ParseState:
             # test, since the tokens inside a clause are contiguous in
             # index order -- a clause holding nothing but its marker
             # keeps its words, exactly as a one-token "(Nee)" does.
+            # rules.md#M3: "a marker followed by a comma is no marker"
+            # -- asked of the same word extract's M3 test asks it of
             if (first + run < len(tokens)
-                    and tokens[first + run].span.end <= clause.end):
+                    and tokens[first + run].span.end <= clause.end
+                    and not comma_follows_marker(tokens[first + run].text)):
                 dropped.extend(range(first, first + run))
     return copy_with(
         state, tokens=tuple(tokens), pieces=tuple(all_pieces),

{nameparser-2.4.0 → nameparser-2.4.2}/nameparser/_pipeline/_pieces.py

@@ -52,6 +52,7 @@ helper.
 """
 from __future__ import annotations
 
+import unicodedata
 from collections.abc import (
     Callable, Container, Iterable, Mapping, Sequence, Set)
 from typing import NamedTuple
@@ -314,6 +315,10 @@ def join_connectives(pieces: list[list[int]], ptags: list[set[str]],
             continue
         if letter_stays and len(pieces[k]) == 1:
             text = tokens[pieces[k][0]].text
+            if not text.isascii():
+                # a decomposed 'й' is one letter in two code points
+                # (#665); compose it, as the lookup does
+                text = unicodedata.normalize("NFC", text)
             if len(text) == 1 and text.isalpha():
                 k += 1
                 continue

{nameparser-2.4.0 → nameparser-2.4.2}/nameparser/_pipeline/_script_segment.py

@@ -255,8 +255,8 @@ def _is_post_nominal(state: ParseState, i: int) -> bool:
 # classification rather than cut into 박사 + 님, which is what the
 # same input gives when the step is removed. '선생님' is post-nominal
 # entire with no name word behind it, so the scan yields no site at
-# all and the token stays whole. Both are contract-tier corpus names
-# and rules.md#W2 example lines; decisions.md#cjk-comma-demotion
+# all and the token stays whole. Both are corpus names and
+# rules.md#W2 example lines; decisions.md#cjk-comma-demotion
 # carries the forced-predicate measurement behind them.
 def _peel_site(state: ParseState, flat: Sequence[int],
                tails: frozenset[str]) -> tuple[int, int] | None:

{nameparser-2.4.0 → nameparser-2.4.2}/nameparser/_pipeline/_tokenize.py

@@ -3,7 +3,8 @@
 Consumes: original, masked (regions to skip), extracted (regions that
 tokenize with a pre-set role).
 Produces: tokens (span-sorted WorkTokens; text always == original
-slice), comma_offsets (segmentation points; never tokens),
+slice), comma_offsets (segmentation points of the main stream; a comma
+there is never a token, one inside an extracted region is word text),
 interpunct_offsets (间隔号 transcription markers, #298; never tokens).
 Reads: Policy.strip_emoji, Policy.strip_bidi.
 
@@ -110,7 +111,12 @@ def _tokenize_region(state: ParseState, start: int, end: int,
     tok_start: int | None = None
     for i in range(start, end):
         ch = text[i]
-        is_separator = ch in COMMA_CHARS or _ignorable(ch, state)
+        # rules.md#N1: "a comma inside it kept as written — the comma
+        # divides nothing there" -- a comma separates only where it
+        # records a segmentation offset, the main stream; inside an
+        # extracted region it is the clause's text, like ';' (#653)
+        is_separator = ((record_offsets and ch in COMMA_CHARS)
+                        or _ignorable(ch, state))
         if ch == _INTERPUNCT:
             # Region-local flanks: a B7 at a region edge stays token
             # text, and the bound also stops a custom delimiter's
@@ -155,8 +161,8 @@ def tokenize(state: ParseState) -> ParseState:
     for start, end in zip(boundaries[::2], boundaries[1::2]):
         _tokenize_region(state, start, end, None, True, tokens, commas,
                          interpuncts)
-    # extracted regions: pre-set role, commas and interpuncts are mere
-    # separators
+    # extracted regions: pre-set role; a comma is word text there and an
+    # interpunct a mere separator, neither recording an offset
     for role, inner in state.extracted:
         _tokenize_region(state, inner.start, inner.end, role, False,
                          tokens, commas, interpuncts)

{nameparser-2.4.0 → nameparser-2.4.2}/nameparser/_pipeline/_vocab.py

@@ -51,7 +51,7 @@ from nameparser._lexicon import (
 )
 from nameparser._policy import (CapsSuffixes, Policy, Script, _JA_SCRIPTS, _NO_INITIALS,
                                 _SCRIPT_RANGES, _script_matcher)
-from nameparser._pipeline._state import WorkToken, comma_bucket
+from nameparser._pipeline._state import COMMA_CHARS, WorkToken, comma_bucket
 
 # Ported verbatim from v1 (nameparser/config/regexes.py "initial") minus
 # its empty-string alternative -- WorkToken text is never empty. Kept in
@@ -143,7 +143,18 @@ def _drop_kana_voicing_marks(text: str) -> str:
 # vetoes the whole word -- 'Kim김.' is refused as a title along with
 # '田中.' -- and that is deliberate: a word carrying a script with no
 # abbreviations is not wearing an abbreviation's period.
-in_initialless_script = _script_matcher(*_NO_INITIALS, whole=False)
+_has_initialless_char = _script_matcher(*_NO_INITIALS, whole=False)
+
+
+def in_initialless_script(text: str) -> bool:
+    """Whether TEXT holds a character of a script that writes no
+    initials (#320), asked of the composed spelling: a decomposed
+    hangul syllable is conjoining jamo, which no _NO_INITIALS range
+    holds, so '씨.' typed decomposed escaped the veto every shape test
+    beside it reads composed (#665). ASCII answers without the
+    matcher's frame, as the callers' own `isascii()` gates do."""
+    return (not text.isascii()
+            and _has_initialless_char(unicodedata.normalize("NFC", text)))
 
 
 # H2's own shape, text-level: an unlisted period-marked abbreviation,
@@ -159,12 +170,25 @@ in_initialless_script = _script_matcher(*_NO_INITIALS, whole=False)
 # the comma structure to a credential run
 # (mechanisms.md#ONE-PREDICATE-PER-QUESTION).
 #
-# Ported verbatim from v1 (nameparser/config/regexes.py
-# "period_abbreviation") -- layering forbids the config import; keep
-# in sync by hand (tests/v2/test_regex_sync.py, which reaches this
-# object through `_pieces._PERIOD_ABBREV`, an IMPORT of this one, not
-# a second definition -- the sync test's target name did not move).
-_PERIOD_ABBREV = re.compile(r'^[^\W\d_]{2,}\.$')
+# The shape shared with config's "period_abbreviation" (layering
+# forbids the config import; keep in sync by hand -- the pattern TEXT
+# is what tests/v2/test_regex_sync.py compares, reaching this object
+# through `_pieces._PERIOD_ABBREV`, an IMPORT of this one, not a second
+# definition -- the sync test's target name did not move). It is
+# composed from `_LETTER` below, so the text is v1's plus the marks.
+
+# `_LETTER` is the letter every shape regex in this module spells
+# (`_PERIOD_ABBREV`, `_DOTTED`, `_CHUNKED`, `_PAIRED_INITIALS`): one
+# letter (a word character that is not a digit or underscore) plus the
+# combining marks written after it (#652). `inž.` typed as i, n, z,
+# U+030C, '.' is the same word as the composed one, and `\w` alone ends
+# it at the z. `_MARKS` is the general combining blocks -- what NFD of
+# a Latin, Greek or Cyrillic letter produces -- and not the marks that
+# only some scripts write (Indic vowel signs, Arabic and Hebrew
+# points); rules.md#H2's Accepted clause owns that limit.
+_MARKS = '[\u0300-\u036f\u1ab0-\u1aff\u1dc0-\u1dff\u20d0-\u20ff\ufe20-\ufe2f]'
+_LETTER = r'[^\W\d_]' + _MARKS + '*'
+_PERIOD_ABBREV = re.compile(r'^(?:' + _LETTER + r'){2,}\.$')
 
 
 # rules.md#H2: "an abbreviation opening the part of the name that
@@ -211,7 +235,15 @@ def is_initial_shaped(text: str) -> bool:
     name want is_initial (#320). The two answers differ only inside
     _NO_INITIALS scripts, where '씨.' is initial-SHAPED but is not an
     initial -- see assign's roman-numeral fork, the shape caller, for
-    what picking the wrong one costs."""
+    what picking the wrong one costs.
+
+    Asked of the composed spelling, as `_render` asks it (#542): `\\w`
+    does not match a combining mark, so a decomposed 'É.' is three
+    characters to the pattern and no initial (#665). Composing rather
+    than widening keeps the pattern v1-verbatim, and both calls are
+    C-level, so the predicate costs no frame it did not before."""
+    if not text.isascii():
+        text = unicodedata.normalize("NFC", text)
     return bool(_INITIAL.fullmatch(text))
 
 
@@ -363,13 +395,13 @@ def ambiguous_lean(text: str, one_case: bool) -> Lean | None:
     return "name"
 
 
-_DOTTED = re.compile(r"(?:[^\W\d_]\.)+")
+_DOTTED = re.compile(r"(?:" + _LETTER + r"\.)+")
 # #544: the CHUNKED spelling -- two or more runs of letters, each
 # closed by a period ('M.Eng.', 'L.Ac.'). Both callers compare the
 # period-free letters against the listed member, so the chunks must
 # spell it; one chunk ('Ma.', 'Ed.') is the single trailing period and
 # stays outside the gate.
-_CHUNKED = re.compile(r"(?:[^\W\d_]+\.){2,}")
+_CHUNKED = re.compile(r"(?:(?:" + _LETTER + r")+\.){2,}")
 
 
 def _dotted(text: str) -> bool:
@@ -389,7 +421,7 @@ def _dotted(text: str) -> bool:
 # a given and a middle initial are written run together ('M.J.',
 # 'G.J.'). The trailing period is optional, as `period_joined_vocab`'s
 # shape verdict lets it be.
-_PAIRED_INITIALS = re.compile(r"[^\W\d_]\.[^\W\d_]\.?")
+_PAIRED_INITIALS = re.compile(_LETTER + r"\." + _LETTER + r"\.?")
 
 
 def is_paired_initials(text: str) -> bool:
@@ -651,13 +683,35 @@ def caps_shape_candidate(text: str, lexicon: Lexicon, policy: Policy,
     AMBIGUOUS_ACRONYM_TAG test), so a listed member never pays for
     the call.
     """
-    if not (policy.unlisted_caps_suffixes is not CapsSuffixes.OFF
-            and one_case is False
-            and len(text) >= 2 and text.isalpha() and text.isupper()):
+    if (policy.unlisted_caps_suffixes is CapsSuffixes.OFF
+            or one_case is not False):
+        return False
+    if not text.isascii():
+        text = unicodedata.normalize("NFC", text)
+    if not (len(text) >= 2 and text.isalpha() and text.isupper()):
         return False
     return not in_any_wordlist(_normalize(text), lexicon)
 
 
+def is_caps_word(text: str) -> bool:
+    """Whether TEXT is alphabetic capitals once NFC-composed: `isalpha()`
+    is False for a combining mark, so the decomposed spelling of
+    'ŽŠČ' would otherwise not be a caps word (#652). Callers test the
+    text as written inline first, in C, and call this only for text
+    that is not NFC (`unicodedata.is_normalized`, also C), so composed
+    text pays no frame."""
+    composed = unicodedata.normalize("NFC", text)
+    return composed.isalpha() and composed.isupper()
+
+
+def composed_len(text: str) -> int:
+    """The length of TEXT in letters as the writer sees them: code
+    points once NFC-composed. A caps word admitted decomposed (#652)
+    is longer than its composed twin, and the two-letter pair test
+    (`John Smith, MÁ`) counts letters."""
+    return len(text if text.isascii() else unicodedata.normalize("NFC", text))
+
+
 def in_any_wordlist(n: str, lexicon: Lexicon) -> bool:
     """Whether the folded word `n` is in ANY of the lexicon's wordlists
     (`_lexicon._VOCAB_FIELDS`, the whole roster): the caps shape's
@@ -1167,6 +1221,33 @@ def maiden_marker_run(words: Sequence[str], markers: frozenset[str]) -> int:
     return 0
 
 
+
+# rules.md#M3: "a marker followed by a comma is no marker"
+def comma_follows_marker(word: str) -> bool:
+    """Whether `word`, the one standing after a marker run inside a
+    delimited clause, opens with a comma -- standing alone (' , ') or
+    glued to the name after it (' ,Jones'). A comma glued to the marker
+    itself ('née,') needs no test: that word is no marker to begin with,
+    the vocabulary storing no comma. The one predicate for extract's M3
+    test over whitespace words and group's M1 drop over tokens, which
+    since #653 hold the same comma
+    (mechanisms.md#ONE-PREDICATE-PER-QUESTION).
+
+    The comma need not be the word's first character, only the first
+    that is a comma or a letter or digit. A whitespace word can open
+    with what the tokenizer drops or divides at -- a bidi mark, an
+    emoji, a nakaguro -- so '\u200f, Jones' is a comma-led WORD only
+    past its mark, while the token group asks about is ',' already;
+    reading past the rest makes the two sites agree by construction
+    (#653's second review)."""
+    for ch in word:
+        if ch in COMMA_CHARS:
+            return True
+        if ch.isalnum():
+            return False
+    return False
+
+
 def tag_marker_runs(tokens: Sequence[WorkToken], comma_offsets: Sequence[int],
                     markers: frozenset[str],
                     folded: Sequence[str] | None = None) -> dict[int, str]:

{nameparser-2.4.0 → nameparser-2.4.2}/nameparser/_version.py

@@ -4,16 +4,16 @@
 #:
 #: Bumped when a cycle OPENS, not when it ships, so the tree says what
 #: it is building. Note the cost of the tuple being purely numeric: it
-#: cannot carry the dev marker, so `VERSION >= (2, 4, 0)` is already
-#: true here while 2.4.0 is unreleased. Compare `__version__` instead
+#: cannot carry the dev marker, so `VERSION >= (2, 5, 0)` is already
+#: true here while 2.5.0 is unreleased. Compare `__version__` instead
 #: where that distinction matters.
-VERSION = (2, 4, 0)
+VERSION = (2, 4, 2)
 #: PEP 440 pre-release/dev segment appended to the numeric version, or
 #: "" for a final release. Joined WITHOUT a dot ("2.0.0rc1", not
 #: "2.0.0.rc1"); setuptools reads __version__ as the package version.
 #:
 #: "dev" through the cycle, cleared at release. It normalizes to
-#: 2.4.0.dev0, which sorts above 2.3.0 and BELOW 2.4.0, so an install
+#: 2.5.0.dev0, which sorts above 2.4.0 and BELOW 2.5.0, so an install
 #: from master can never masquerade as the release it precedes.
 PRE_RELEASE = ""
 __version__ = ".".join(map(str, VERSION)) + PRE_RELEASE

{nameparser-2.4.0 → nameparser-2.4.2}/nameparser/config/_invariants.py

@@ -30,9 +30,8 @@ asserting things with the parser's own fold makes the constant's
 hygiene depend on the parser, and the question worth asking is not
 "is this entry pre-folded" but "does ``Lexicon`` store it unchanged".
 That is one assertion over ``_PHRASE_FIELDS`` in
-``tests/v2/test_ledger_guards.py``, the suite that already imports the
-parser's fold for exactly this purpose, and it is where an entry
-written ``'z. domu'`` is caught.
+``tests/v2/test_lexicon.py``, and it is where an entry written
+``'z. domu'`` is caught.
 """
 from __future__ import annotations
 

{nameparser-2.4.0 → nameparser-2.4.2}/nameparser/config/regexes.py

@@ -15,6 +15,14 @@ re_emoji = re.compile(
 # as nothing but stick to name parts and break equality/lookups.
 re_bidi = re.compile('[\u061C\u200E\u200F\u202A-\u202E\u2066-\u2069]+')
 
+# Combining marks (Unicode Mn) are not \w, so a letter written as a base
+# plus a mark (NFD `inž.`) must carry them explicitly or the shape
+# rules read a decomposed name differently from its composed twin
+# (#652). Same class as _pipeline/_vocab.py's _MARKS; test_regex_sync
+# compares the two class strings and pins `period_abbreviation`
+# against `_vocab`'s copy.
+_MARKS = '[\u0300-\u036f\u1ab0-\u1aff\u1dc0-\u1dff\u20d0-\u20ff\ufe20-\ufe2f]'
+
 EMPTY_REGEX = re.compile('')
 
 REGEXES = {
@@ -52,7 +60,8 @@ REGEXES = {
         r'^(оглу|оглы|оғлу|ўғли|угли|кызы|гызы|қызы|қизи|улы|ұлы|уулу)$',
         re.I,
     ),
-    "period_abbreviation": re.compile(r'^[^\W\d_]{2,}\.$'),
+    "period_abbreviation": re.compile(
+        r'^(?:[^\W\d_]' + _MARKS + r'*){2,}\.$'),
 }
 """
 All regular expressions used by the parser are precompiled and stored in the config.

{nameparser-2.4.0 → nameparser-2.4.2}/nameparser/config/titles.py

@@ -672,7 +672,6 @@ TITLES = GIVEN_NAME_TITLES | {
     'sgt',
     'sgtmaj',
     'sgtmajmc',
-    'shehu',
     'sheikh',
     'sheriff',
     'siddha',

{nameparser-2.4.0 → nameparser-2.4.2/nameparser.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nameparser
-Version: 2.4.0
+Version: 2.4.2
 Summary: A simple Python module for parsing human names into their individual components.
 Author-email: Derek Gulbranson <derek73@gmail.com>
 License: LGPL

{nameparser-2.4.0 → nameparser-2.4.2}/nameparser.egg-info/SOURCES.txt

@@ -83,20 +83,23 @@ tests/v2/conftest.py
 tests/v2/rules_doc.py
 tests/v2/test_benchmark.py
 tests/v2/test_cases.py
+tests/v2/test_cldr_agreement.py
+tests/v2/test_cldr_corpus.py
 tests/v2/test_cli.py
 tests/v2/test_config_aliases.py
 tests/v2/test_config_shim.py
 tests/v2/test_contracts.py
+tests/v2/test_corpora.py
 tests/v2/test_differential.py
 tests/v2/test_doc_citations.py
 tests/v2/test_doc_spellings.py
 tests/v2/test_facade.py
 tests/v2/test_facade_cases.py
 tests/v2/test_layering.py
-tests/v2/test_ledger_guards.py
 tests/v2/test_lexicon.py
 tests/v2/test_locale.py
 tests/v2/test_locales.py
+tests/v2/test_name_usage_tool.py
 tests/v2/test_order_correspondence.py
 tests/v2/test_parser.py
 tests/v2/test_policy.py
@@ -106,6 +109,7 @@ tests/v2/test_render.py
 tests/v2/test_reprs.py
 tests/v2/test_rules_doc.py
 tests/v2/test_rules_doc_grammar.py
+tests/v2/test_snapshot.py
 tests/v2/test_types.py
 tests/v2/pipeline/__init__.py
 tests/v2/pipeline/test_assemble.py

{nameparser-2.4.0 → nameparser-2.4.2}/tests/test_initials.py

@@ -292,22 +292,9 @@ class InitialsTestCase(HumanNameTestBase):
         # 'y' outside the marked set is still the connective.
         hn = HumanName("maria y lopez")
         self.m(hn.initials(), "m. y. l.", hn)
-        # These two are among #528's four movers, and the #528 ledger
-        # rule's own name_regex (a literal alternation, in
-        # tools/differential/expected_since_1.4.0.toml) covers all four
-        # names by itself -- but only "john e jones" also has a row in
-        # _CROSS_RULE_WINNERS (tests/v2/test_ledger_guards.py) and
-        # _RECORDED_DIFFS (tools/differential/compare.py): those two
-        # Python dicts, keyed by the LEDGER FILENAME rather than
-        # anything stored in the TOML, record that
-        # "fix(initials-per-word) a connective run initials each word"
-        # also reaches "john e jones" through its lowercase ' e ' and
-        # contests the name with #528's rule. "jones, john e" has no
-        # row in either: that connective-run rule's operative half is a
-        # `(?=\s)` lookahead requiring whitespace AFTER the letter, and
-        # a letter at the end of the string can never satisfy it -- so
-        # the comma form is a distinct shape from the space-written
-        # form even though both give the same initials() answer.
+        # These two are among #528's four movers, written once with
+        # the letter mid-name and once at the end after a comma: both
+        # give the same initials() answer by different routes.
         hn = HumanName("john e jones")
         self.m(hn.initials(), "j. e. j.", hn)
         hn = HumanName("jones, john e")

nameparser-2.4.2/tests/v2/_differential_fixtures.py

@@ -0,0 +1,55 @@
+"""Shared handles on tools/differential/: its corpora and its modules.
+
+Neither is importable the ordinary way: `tools/` is outside
+`testpaths` and is not a package, so its modules are loaded by path,
+and the corpora are data files.
+
+Not a conftest: these are constants and plain helpers, not fixtures in
+pytest's sense, and several modules want them by name.
+"""
+import importlib.util
+import json
+from pathlib import Path
+from types import ModuleType
+
+_TOOLS = Path(__file__).parents[2] / "tools" / "differential"
+
+
+def _entry_name(raw: object) -> str:
+    """A corpus line's name, whichever format the line uses: a bare
+    JSON string or an object carrying "name"."""
+    if isinstance(raw, str):
+        return raw
+    assert isinstance(raw, dict) and isinstance(raw.get("name"), str), raw
+    return raw["name"]
+
+
+#: Corpus files _CORPUS_NAMES leaves out. corpus_cldr.jsonl
+#: (2026-10-12): about 1,900 fictional CLDR renderings whose ground
+#: truth the agreement ratchet in test_cldr_agreement.py enforces. The
+#: tests reading _CORPUS_NAMES carry counts measured over the names the
+#: corpora held before it arrived.
+_UNMEASURED_CORPORA = frozenset({"corpus_cldr.jsonl"})
+
+#: Every corpus name, deduplicated, except the files in
+#: _UNMEASURED_CORPORA.
+_CORPUS_NAMES = sorted({
+    _entry_name(json.loads(line))
+    for path in sorted(_TOOLS.glob("corpus*.jsonl"))
+    if path.name not in _UNMEASURED_CORPORA
+    for line in path.read_text(encoding="utf-8").splitlines() if line.strip()})
+
+
+def load_tool(stem: str) -> ModuleType:
+    """A module from tools/differential/, loaded by path.
+
+    `tools/` is outside testpaths, and adding it would run
+    --doctest-modules over the corpus builders, so these are imported
+    this way rather than made importable. None has import-time side
+    effects: each main() is behind a __name__ guard."""
+    spec = importlib.util.spec_from_file_location(
+        f"differential_{stem}", _TOOLS / f"{stem}.py")
+    assert spec is not None and spec.loader is not None, stem
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module