nameparser 2.4.1__tar.gz → 2.4.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nameparser
-Version: 2.4.1
+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.1 → nameparser-2.4.2}/nameparser/_pipeline/_classify.py

@@ -62,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
 
@@ -134,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
@@ -334,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.1 → 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.1 → nameparser-2.4.2}/nameparser/_pipeline/_vocab.py

@@ -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,
@@ -224,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))
 
 

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

@@ -7,7 +7,7 @@
 #: 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, 1)
+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.

{nameparser-2.4.1 → 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.1 → nameparser-2.4.2/nameparser.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nameparser
-Version: 2.4.1
+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.1 → nameparser-2.4.2}/tests/v2/test_cldr_agreement.py

@@ -18,7 +18,7 @@ from types import ModuleType
 
 import pytest
 
-from nameparser import parse
+from nameparser import locales, parse
 
 _TOOLS = Path(__file__).parents[2] / "tools" / "differential"
 
@@ -206,3 +206,72 @@ def test_an_unspaced_role_is_expected_in_text_order() -> None:
         {"given": "セシリア", "given2": "ローズ", "surname": "ブラウン"},
         "ブラウン・ローズ・セシリア")
     assert agreement.same(roles["given_names"], "ローズ セシリア", "ブラウン・ローズ・セシリア")
+
+
+# -- the locale view (#672) --------------------------------------------------
+
+def test_every_locale_pack_is_measured_or_listed_as_having_no_cldr_file() -> None:
+    # A new pack must add its CLDR files to LOCALE_FILES or say it has
+    # none; otherwise it goes unmeasured by omission.
+    mapped = set(agreement.LOCALE_FILES.values())
+    assert not mapped & agreement.NO_CLDR
+    assert mapped | agreement.NO_CLDR == {code.upper() for code in locales.available()}
+
+
+def test_every_mapped_cldr_file_has_renderings() -> None:
+    # A misspelled file in the table would measure nothing and pass.
+    files = {row["file"] for row in agreement.load_rows()}
+    assert set(agreement.LOCALE_FILES) <= files
+
+
+def test_the_locale_view_parses_with_the_pack() -> None:
+    # A view that fell back to the default parser would record the
+    # default's disagreements and still pass its own ratchet. 王小明 is
+    # one unspaced Han token: only ZH segments it.
+    row = {"file": "zh", "label": "nativeG", "order": "surnameFirst",
+           "text": "王小明", "shape": 4, "fields": {"surname": "王", "given": "小明"}}
+    assert agreement.disagreements([row], locale=True) == {}
+    assert agreement.disagreements([row]) != {}
+
+
+def test_a_pack_parser_keeps_the_family_first_order_of_its_shape() -> None:
+    # Latin text: no script decides the order, so only the FAMILY_FIRST
+    # base the pack is applied over can read Ivanov as the family.
+    name = agreement.parse_rendering("Ivanov Ivan", 4, "RU")
+    assert (name.family, name.given) == ("Ivanov", "Ivan")
+
+
+def test_a_recorded_entry_whose_file_left_the_table_is_reported_gone() -> None:
+    # No pack's check reads such an entry, so without this it would sit
+    # in the record unguarded -- and survive every re-record.
+    [message] = agreement.unmapped({"zh/nativeG/givenFirst": {}, "xx/nativeG/sorting": {}})
+    assert message.startswith("gone: xx/nativeG/sorting")
+    assert agreement.unmapped(agreement.read_record(agreement.LOCALE_RECORD)) == []
+
+
+def test_a_re_record_drops_entries_whose_file_left_the_table(
+        tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    # The carry-over that keeps an unmeasured pack's entries must not
+    # keep an unmapped file's too.
+    record = tmp_path / "locales.json"
+    agreement.write_record({"xx/nativeG/sorting": {"text": "X"}}, record)
+    monkeypatch.setattr(agreement, "LOCALE_RECORD", record)
+    monkeypatch.setattr(agreement, "RECORD", tmp_path / "default.json")
+    assert agreement.main(["--record"]) == 0
+    assert "xx/nativeG/sorting" not in agreement.read_record(record)
+
+
+@pytest.mark.parametrize("pack", [
+    pytest.param(pack, marks=pytest.mark.skipif(
+        not agreement.pack_available(pack),
+        reason=f"needs {agreement._EXTRAS.get(pack)}; CI's ja-extra job runs it"))
+    for pack in sorted(set(agreement.LOCALE_FILES.values()))])
+def test_each_pack_still_agrees_with_cldr_where_it_did(pack: str) -> None:
+    problems = agreement.locale_changes(
+        agreement.load_rows(), pack, agreement.read_record(agreement.LOCALE_RECORD))
+    assert not problems, "\n".join([
+        *problems[:40],
+        f"{len(problems)} change(s) against "
+        f"tools/differential/cldr_agreement_locales.json for {pack}.",
+        f"If every one is intended, re-record with `{agreement.RECORD_COMMAND}` "
+        "and say why in the commit."])

{nameparser-2.4.1 → nameparser-2.4.2}/tests/v2/test_parser.py

@@ -1962,6 +1962,34 @@ _NFD_ROWS = [
     "Janez Novak, Ž.Š.Č.",
     "Janez Novak, Žž.Šš.",
     "Smith, Ž.Š. Jones",
+    # #665: a period-marked initial (`\w\.`) beside a connective, in
+    # each slot and comma shape -- a lone one read alike before the fix
+    "É. y É. Smith",
+    "Й. John Smith",
+    "Ana É. y Luis",
+    "Smith, É. y É.",
+    ", É. y É.",
+    "(Bob), É. y É.",
+    # ... and the one-letter connective written in two code points:
+    # three words (P3's carve-out keeps it a name word), four words
+    # (it joins), one case, and after a comma
+    "John й Smith",
+    "JOHN Й SMITH",
+    "john й smith",
+    "Ivan й Petrov Sidorov",
+    "Smith, John й Jones",
+    # ... and the veto on scripts that write no initials (#320), asked
+    # of the composed spelling too: decomposed hangul is conjoining
+    # jamo, outside every _NO_INITIALS range, so composing the initial
+    # shape alone made a decomposed '씨.' an initial (a title or a
+    # given name). Spaced or after a comma, since an UNSPACED
+    # decomposed hangul name is not split (docs/usage.rst) and so has
+    # no composed twin to match
+    "김민준, 씨.",
+    "김 민준 씨.",
+    "김 민준, 씨.",
+    ", 씨.",
+    "김. 민준",
 ]
 _NFD_POLICIES = [
     Policy(),
@@ -1976,6 +2004,15 @@ def _composed_roles(parser: Parser, text: str) -> dict[str, str]:
             for k, v in parser.parse(text).as_dict().items()}
 
 
+def _composed_reading(parser: Parser, text: str) -> tuple[object, ...]:
+    """The roles, the reports' kinds and initials(), composed: #665's
+    `John й Smith` differed in its report as well as its fields."""
+    name = parser.parse(text)
+    return (_composed_roles(parser, text),
+            [a.kind for a in name.ambiguities],
+            unicodedata.normalize("NFC", name.initials()))
+
+
 @pytest.mark.parametrize("policy", _NFD_POLICIES,
                          ids=["default", "family-first", "family-first-given-last",
                               "caps-everywhere"])
@@ -1996,13 +2033,43 @@ def test_a_decomposed_abbreviation_reads_as_its_composed_twin(
     two-letter rows pass there; the two-letter rows exist for the caps
     fix's own length count, which counted code points the first time
     (`John Smith, MÁ` read as a pair composed and a credential
-    decomposed, found in the review of 08c0dd60)."""
+    decomposed, found in the review of 08c0dd60).
+
+    #665 added sixteen rows and compares kinds and initials() too.
+    Recorded control, measured 2026-10-13 against f9b2b81c's
+    nameparser/: 38 rows x 4 policies = 152 twin cases plus the four
+    direct tests, of which 41 fail -- the six initial rows under all
+    four policies (24; the same 24 with only `is_initial_shaped`'s
+    compose reverted), the three-word `й` rows (12; `_pieces`'
+    carve-out alone), `김. 민준` (4), and the one-case report test
+    below (1; either `_classify` width site alone). The other four
+    hangul rows pass there: they guard the fix itself, failing (with
+    `김. 민준`, 20 in all) when `in_initialless_script`'s compose
+    alone is reverted, since the composed initial shape without the
+    composed veto made a decomposed '씨.' an initial. `Ivan й Petrov
+    Sidorov` and `Smith, John й Jones` pass everywhere and pin parity
+    only."""
     composed = unicodedata.normalize("NFC", text)
     decomposed = unicodedata.normalize("NFD", text)
     assert decomposed != composed
     parser = Parser(policy=policy)
-    assert (_composed_roles(parser, decomposed)
-            == _composed_roles(parser, composed))
+    assert (_composed_reading(parser, decomposed)
+            == _composed_reading(parser, composed))
+
+
+def test_a_decomposed_conjunction_reports_as_its_composed_twin() -> None:
+    """#665: the one-case report on a letter that is both a connective
+    and an initial (rules.md#P3) counted code points, so it is reached
+    by `й` only once a caller marks it ambiguous -- no default entry is
+    decomposable."""
+    parser = Parser(lexicon=Lexicon.default().add(
+        conjunctions_ambiguous={"й"}))
+    text = "ivan й petrov"
+    composed = parser.parse(text)
+    assert [a.kind for a in composed.ambiguities] == [
+        AmbiguityKind.CONJUNCTION_OR_INITIAL]
+    assert (_composed_reading(parser, unicodedata.normalize("NFD", text))
+            == _composed_reading(parser, text))
 
 
 def test_a_decomposed_caps_credential_is_still_a_suffix() -> None:

{nameparser-2.4.1 → nameparser-2.4.2}/tests/v2/test_rules_doc.py

@@ -145,12 +145,22 @@ def test_example(rule: Rule, example: Example) -> None:
         assert actual == example.value
 
 
-def test_the_h2_nfd_example_is_still_decomposed() -> None:
-    """#652: rules.md#H2's NFD example is the only executable witness
-    of the encoding clause, and an editor or formatter that
-    NFC-normalizes the file turns it into the composed case, which
-    always worked and still passes. Its bytes are z + U+030C."""
+@pytest.mark.parametrize("decomposed", [
+    "inž.",  # H2's abbreviation shape (#652): z + U+030C
+    "John й Smith",  # P3's one-letter connective (#665)
+    "É. y É. Smith",  # P3's initial beside a connective (#665)
+    "김. 민준",  # H2's script veto on hangul typed as jamo (#665)
+])
+def test_the_nfd_examples_are_still_decomposed(decomposed: str) -> None:
+    """The decomposed example lines in rules.md are the only executable
+    witnesses of its encoding clauses (H2, P3), and an editor or
+    formatter that NFC-normalizes the file turns each into the
+    composed case, which always worked and still passes. Each entry
+    here is typed decomposed, which the first assert checks so that
+    normalizing this file cannot hollow the test out either."""
+    import unicodedata
     from pathlib import Path
+    assert not unicodedata.is_normalized("NFC", decomposed)
     text = (Path(__file__).parents[2] / "docs" / "design" / "rules.md"
             ).read_text(encoding="utf-8")
-    assert "inž." in text, "H2's NFD example was recomposed"
+    assert decomposed in text, f"the NFD example {decomposed!r} was recomposed"