nameparser 2.4.2__tar.gz → 2.5.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nameparser
-Version: 2.4.2
+Version: 2.5.0
 Summary: A simple Python module for parsing human names into their individual components.
 Author-email: Derek Gulbranson <derek73@gmail.com>
 License: LGPL
@@ -36,14 +36,13 @@ nameparser parses human names into seven fields — title, given, middle,
 family, suffix, nickname, maiden. Results are immutable, configuration is
 composable, and locale packs are opt-in.
 
-📣 **nameparser 2.4 is out.** It uses letter case to read post-nominal
-credentials much more reliably — ``Jack MA`` is Jack with an MA and
-``Jack Ma`` is the surname Ma, and ``Jane Smith, PhD MA`` keeps both
-credentials together — recognizes more naming conventions (Catalan,
-Irish, Finnish, Malay and others), and writes credentials the usual way
-when it repairs case. The `release log
-<https://nameparser.readthedocs.io/en/latest/release_log.html>`__ has the
-details.
+📣 **nameparser 2.5 is out.** It reads junior and senior written in 45
+languages (``Antonio Pavlović mlađi``), keeps a title written before a
+family comma out of the surname (``Dr. Smith, John``), reads Chinese and
+Japanese credential and office words (``田中社長``), and gives a lone first
+name followed by V, I or X its last name back (``Malcolm X``). The `release
+log <https://nameparser.readthedocs.io/en/latest/release_log.html>`__ has
+the details.
 
 Chinese, Japanese and Korean names written in their own scripts are read
 family-first, unspaced Korean names are split against the census surname

{nameparser-2.4.2 → nameparser-2.5.0}/README.rst

@@ -7,14 +7,13 @@ nameparser parses human names into seven fields — title, given, middle,
 family, suffix, nickname, maiden. Results are immutable, configuration is
 composable, and locale packs are opt-in.
 
-📣 **nameparser 2.4 is out.** It uses letter case to read post-nominal
-credentials much more reliably — ``Jack MA`` is Jack with an MA and
-``Jack Ma`` is the surname Ma, and ``Jane Smith, PhD MA`` keeps both
-credentials together — recognizes more naming conventions (Catalan,
-Irish, Finnish, Malay and others), and writes credentials the usual way
-when it repairs case. The `release log
-<https://nameparser.readthedocs.io/en/latest/release_log.html>`__ has the
-details.
+📣 **nameparser 2.5 is out.** It reads junior and senior written in 45
+languages (``Antonio Pavlović mlađi``), keeps a title written before a
+family comma out of the surname (``Dr. Smith, John``), reads Chinese and
+Japanese credential and office words (``田中社長``), and gives a lone first
+name followed by V, I or X its last name back (``Malcolm X``). The `release
+log <https://nameparser.readthedocs.io/en/latest/release_log.html>`__ has
+the details.
 
 Chinese, Japanese and Korean names written in their own scripts are read
 family-first, unspaced Korean names are split against the census surname

{nameparser-2.4.2 → nameparser-2.5.0}/nameparser/_config_shim.py

@@ -1109,7 +1109,7 @@ class Constants:
         # tests/v2/test_config_shim.py::test_snapshot_field_translation)
         # A capitalization_exceptions value that does not spell its key
         # is the one DECIDED exception to this method's never-raise
-        # rule (#459, decisions.md#R4 and #3-0-reevaluations).
+        # rule (#459, decisions/R4 and #3-0-reevaluations).
         # _normpairs raises _MaskValueError for exactly that shape, and
         # the except clause re-spells its offered fix for a v1 caller.
         # Caught by TYPE, so every other Lexicon error passes through

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

@@ -271,7 +271,7 @@ class HumanName:
         """Re-capitalize the current parse against the bound lexicon.
         force=None reads the bound Constants' render default
         (force_mixed_case_capitalization); the core's capitalized()
-        implements the one-case gate (rules.md#R5, suffixes left out
+        implements the one-case gate (rules/R5, suffixes left out
         since #492) -- not
         re-implemented here."""
         self._resolve()
@@ -511,7 +511,7 @@ class HumanName:
         # answers -- the same fallback _render._cap_word takes for the
         # same tokens and through the same helper, which is why the
         # helper is imported rather than the predicate rewritten
-        # (decisions.md#R4 for why one question and not two: whether a
+        # (decisions/R4 for why one question and not two: whether a
         # word is a connective is a fact the word can answer alone,
         # whether a particle is acting as one is a fact about the part).
         #
@@ -533,7 +533,7 @@ class HumanName:
                 and UNJOINED_CONJUNCTION_TAG not in tok.tags)
 
     def _split_last(self) -> tuple[list[str], list[str]]:
-        # rules.md#R2: "a name part whose every word is particle
+        # rules/R2: "a name part whose every word is particle
         # vocabulary is a part where none of them is doing a
         # particle's work" -- the all-particle guard
         # below is this rule, and predates its statement: v1 assumed a
@@ -617,7 +617,7 @@ class HumanName:
         #
         # Particles are NOT decided per token: _is_particle stays a
         # live vocabulary lookup, as _render._cap_word keeps it --
-        # rules.md#R4 draws this boundary per question, not per field.
+        # rules/R4 draws this boundary per question, not per field.
         self._resolve()
         if tokens is None:
             # STRING PATH. split() rather than split(" ") because
@@ -700,7 +700,7 @@ class HumanName:
             if got or not words or not all(self._is_particle(w)
                                            for w in words):
                 return got
-            # rules.md#R3: "except the particles of a part whose every
+            # rules/R3: "except the particles of a part whose every
             # word is one, which are not acting as particles there"
             # -- nothing survived
             # the filter, so the whole group is particles. The

{nameparser-2.4.2 → nameparser-2.5.0}/nameparser/_lexicon.py

@@ -129,7 +129,7 @@ _PHRASE_FIELDS = ("given_name_titles", "maiden_markers")
 #: it is roman five -- suffix -- where 'V.' stays a middle
 #: initial through that same carve-out; 'Jr。' simply reaches its
 #: entry, and 'Dr。' its title.
-#: decisions.md#cjk-full-stops carries the measurements.
+#: decisions/cjk-full-stops carries the measurements.
 FULL_STOPS = ".．。｡"
 
 
@@ -152,7 +152,7 @@ def _normalize(word: str) -> str:
 
     NFC, since #322, and only for a non-ASCII word (ASCII is already
     NFC, and this runs per token on the parse path --
-    decisions.md#parse-cost). NFD hangul decomposes to jamo and missed
+    decisions/parse-cost). NFD hangul decomposes to jamo and missed
     every vocabulary entry; composing at lookup AND at storage keeps
     the two symmetric, and no shipped entry changes under it (measured
     2026-09-09: fold every string member of every Lexicon.default()
@@ -175,7 +175,7 @@ def _normalize(word: str) -> str:
         word = stripped
 
 
-# rules.md#P7: "A one-letter word written with its period is an
+# rules/P7: "A one-letter word written with its period is an
 # initial and not a particle"
 def _spells_an_initial(n: str, text: str) -> bool:
     """Whether `text` is ONE letter written with its period ('Ó.',
@@ -195,7 +195,7 @@ def _spells_an_initial(n: str, text: str) -> bool:
     -- its script table is _policy's, which this module may not import
     -- so a caller's one-character particle in such a script, written
     with a period, is vetoed where is_initial would call it no initial
-    (decisions.md#P7). No shipped particle is one character of those
+    (decisions/P7). No shipped particle is one character of those
     scripts."""
     return len(n) == 1 and text[-1] == "."
 
@@ -224,7 +224,7 @@ def _fold_words(words: Iterable[str]) -> list[str]:
 
     map/filter rather than a comprehension: both are C calls where a
     comprehension is a Python frame on 3.11, and this runs on the parse
-    path for every name carrying a title run (decisions.md#parse-cost).
+    path for every name carrying a title run (decisions/parse-cost).
     """
     return list(filter(None, map(_normalize, words)))
 
@@ -247,7 +247,7 @@ def _run_addresses_by_given(words: Iterable[str],
 
     Two sites ask it and they must agree -- post_rules for H1, group
     for the P5 licence -- because a run read two ways is a rule
-    contradicting itself (decisions.md#P5, the 2026-08-22 #369 entry).
+    contradicting itself (decisions/P5, the 2026-08-22 #369 entry).
     One predicate, so they cannot drift.
 
     The WHOLE run's key, or that key's LAST word (#489): a run is
@@ -542,7 +542,7 @@ def _normpairs(
         # punctuation marks which letters are joined into one run
         # (_render._apply_mask reads that) and is never written into
         # the word. A raise, not a warning: a mismatched value used to
-        # be SUBSTITUTED for the word, and rules.md#R4: "Repair
+        # be SUBSTITUTED for the word, and rules/R4: "Repair
         # changes case and nothing else", so there is no reading of
         # one that repair can honor.
         if _alnum(_normalize(v)) != _alnum(normalized_key):
@@ -582,8 +582,8 @@ class Lexicon:
     #: Pre-nominal titles ("dr", "sir", "capt", ...). Full default
     #: list: :data:`~nameparser.config.titles.TITLES`.
     titles: frozenset[str] = frozenset()
-    #: Titles whose single following name reads as a GIVEN name
-    #: ("sheikh", "sister", ...) rather than a family name. Full
+    #: Titles whose single name word, before or after them, reads as a
+    #: GIVEN name ("sheikh", "sister", ...) rather than a family name. Full
     #: default list: :data:`~nameparser.config.titles.GIVEN_NAME_TITLES`.
     given_name_titles: frozenset[str] = frozenset()
     #: Post-nominal acronym suffixes, matched with or without periods
@@ -599,7 +599,7 @@ class Lexicon:
     #: outright; written bare, capitals decide in a mixed-case name
     #: ("Jack MA" is the credential, "Jack Ma" keeps his family name)
     #: and otherwise the word counts as a suffix only where a name
-    #: word is left beside it ("John Smith ma"), rules.md#S2. Full
+    #: word is left beside it ("John Smith ma"), rules/S6 and rules/S4. Full
     #: default list:
     #: :data:`~nameparser.config.suffixes.SUFFIX_ACRONYMS_AMBIGUOUS`.
     suffix_acronyms_ambiguous: frozenset[str] = frozenset()
@@ -644,8 +644,10 @@ class Lexicon:
     #: decided by the writing instead and never consults this set, and
     #: neither does a caseless letter (Arabic و), which has no case to
     #: read. A member additionally reports
-    #: :attr:`~nameparser.AmbiguityKind.CONJUNCTION_OR_INITIAL`; a
-    #: non-member reports nothing, its reading not being in doubt.
+    #: :attr:`~nameparser.AmbiguityKind.CONJUNCTION_OR_INITIAL` where a
+    #: name word of its part follows it (with none, it connects
+    #: nothing); a non-member reports nothing, its reading not being in
+    #: doubt.
     #: Full default list:
     #: :data:`~nameparser.config.conjunctions.CONJUNCTIONS_AMBIGUOUS`.
     #: Entries need not also be in ``conjunctions``; one that is not is
@@ -673,8 +675,8 @@ class Lexicon:
     #: (:data:`~nameparser.config.surnames.KOREAN_SURNAMES`); Chinese
     #: surnames ship in locales.ZH because Han segmentation is opt-in.
     surnames: frozenset[str] = frozenset()
-    #: Honorifics that may be peeled off the END of a name token
-    #: (#308), matched longest-first: 田中さん splits into 田中 and さん
+    #: Honorifics, and credential, office and generational words, that
+    #: may be peeled off the END of a name token (#308, #707), matched longest-first: 田中さん splits into 田中 and さん
     #: before the tokens are classified. Every entry must also be a
     #: :attr:`suffix_words` entry -- the peeled tail is claimed by
     #: suffix classification like any other post-nominal. Deliberately

{nameparser-2.4.2 → nameparser-2.5.0}/nameparser/_parser.py

@@ -41,7 +41,7 @@ class Parser:
     vocabulary DECLINES, so a locale pack's surnames always win where
     they match; returning None declines in turn and the token stays
     whole. Two promises narrow when one is supplied (the first is
-    rules.md#A1's Accepted clause):
+    rules/A1's Accepted clause):
     parse-totality gains its one exception -- an exception raised by
     the segmenter propagates, because a user-supplied callable's own
     error is a user-code error, not a content error -- and this Parser
@@ -220,7 +220,7 @@ class Parser:
             # tags are KEPT, "joined" included: a within-piece mark
             # (the Ph. D. merge) is role-blind and right for every
             # role, and a clear was measured and backed out --
-            # decisions.md#C1 (2026-09-06 #511) carries the rest: the
+            # decisions/R1 (2026-09-06 #511) carries the rest: the
             # between-piece mark that rides onto a non-suffix role, and
             # which views read it. Dropped tokens keep their role: the
             # pass filters them by index and assemble omits them.
@@ -228,7 +228,7 @@ class Parser:
                 tok if i in dropped
                 else dataclasses.replace(tok, role=role)
                 for i, tok in enumerate(state.tokens))
-            # rules.md#R1: "a run of post-nominals written with spaces
+            # rules/R1: "a run of post-nominals written with spaces
             # renders with spaces, and one written with commas keeps
             # them" -- the same pass post_rules runs last, over the
             # value's own comma offsets, so the harvest carries exactly
@@ -346,13 +346,13 @@ def parser_for(*locales: Locale, base: Parser | None = None,
             # a subclass with extra mandatory args would break this rewrap
             raise type(exc)(
                 f"while applying locale {loc.code!r}: {exc}") from exc
-    # rules.md#D1: "constructing a parser that activates division for
+    # rules/D1: "constructing a parser that activates division for
     # scripts with no covering surnames and no segmenter warns at
     # construction, naming the dead scripts and each way out"
-    # (history: decisions.md#D1)
-    # rules.md#D2: "applying a locale pack wraps any such error with
+    # (history: decisions/D1)
+    # rules/D2: "applying a locale pack wraps any such error with
     # the locale's code, so a stacked configuration names which layer
-    # broke" (history: decisions.md#D2)
+    # broke" (history: decisions/D2)
     # Construction warnings (the segmenterless-activation check in
     # Parser.__post_init__) re-emit from THIS frame: its stacklevel is
     # sized for direct Parser(...) construction, and through this

{nameparser-2.4.2 → nameparser-2.5.0}/nameparser/_pipeline/_assemble.py

@@ -2,7 +2,8 @@
 
 Consumes: tokens (all roles set), dropped, ambiguities (by index;
 one carrying ``field_tail`` is worded from its word's final role,
-#626).
+#626), and segments, for the part a withdrawn connective report's
+letter ends (rules/P3, #721).
 Produces: a validated ParsedName -- the constructor re-checks every
 invariant (span order/bounds, ambiguity subset), so a pipeline bug
 that would produce an invalid result dies HERE, not in a renderer
@@ -20,16 +21,16 @@ tests/v2/pipeline/test_assemble.py.
 """
 from __future__ import annotations
 
-from nameparser._pipeline._state import FIELD_READING, ParseState
+from nameparser._pipeline._state import FIELD_READING, NAME_ROLES, ParseState
 from nameparser._types import (
     Ambiguity, AmbiguityKind, ParsedName, Role, Token,
 )
 
 
-# rules.md#A2: "a name with no name content parses to the empty
+# rules/A2: "a name with no name content parses to the empty
 # name — every field empty, false as a boolean — while ambiguities
 # born from its punctuation survive on the empty result"
-# (history: decisions.md#A2)
+# (history: decisions/A2)
 def assemble(state: ParseState) -> ParsedName:
     dropped = set(state.dropped)
     final: dict[int, Token] = {}
@@ -74,6 +75,7 @@ def assemble(state: ParseState) -> ParsedName:
     if contentless:
         final = {}
     ambiguities = []
+    segment_of: dict[int, tuple[int, ...]] | None = None
     for pending in state.ambiguities:
         materialized = tuple(final[i] for i in pending.indices
                              if i in final)
@@ -85,7 +87,7 @@ def assemble(state: ParseState) -> ParsedName:
             # referents did not lose a contest, they were discarded
             # wholesale, and the report still describes the input.
             continue
-        # rules.md#A1: "a report names the reading the parse took, so
+        # rules/A1: "a report names the reading the parse took, so
         # a report whose fork the rest of the parse then resolved to
         # NEITHER branch is withdrawn rather than carried beside a
         # reading it contradicts". classify's connective-or-initial
@@ -114,6 +116,23 @@ def assemble(state: ParseState) -> ParsedName:
                 and any(t.role in (Role.SUFFIX, Role.TITLE)
                         for t in materialized)):
             continue
+        # rules/P3: "unless no name word of its part stands to its
+        # right" -- nothing after the letter in its segment, or only
+        # suffixes, titles, a maiden clause or a nickname: it connects
+        # nothing, so the report goes (#721). Asked here for the reason
+        # above: the roles are final. Where the letter is also a
+        # numeral the fork read, its own report (rules/S10) is the one
+        # left, so one token never carries both. Built only for a
+        # connective report, so other names pay nothing.
+        if pending.kind is AmbiguityKind.CONJUNCTION_OR_INITIAL:
+            if segment_of is None:
+                segment_of = {j: seg for seg in state.segments
+                              for j in seg}
+            i = pending.indices[0]
+            if not any(j > i and j in final
+                       and final[j].role in NAME_ROLES
+                       for j in segment_of.get(i, ())):
+                continue
         detail = pending.detail
         if pending.field_tail is not None:
             # A report naming a field, in a name emptied above (no