nameparser 2.4.2__tar.gz → 2.6.0__tar.gz

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

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: nameparser
-Version: 2.4.2
+Version: 2.6.0
 Summary: A simple Python module for parsing human names into their individual components.
 Author-email: Derek Gulbranson <derek73@gmail.com>
-License: LGPL
+License-Expression: LGPL-2.1-or-later
 Keywords: names,parser
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
@@ -36,14 +35,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.6 is out.** It keeps surnames that earlier releases
+read as credentials (``Luo Si``, ``Maria de Sa``, ``Ram Bahadur B.K.``),
+reads ``Wm`` and ``Md`` as the given names they abbreviate, recognizes more credentials after a comma
+(``John Smith, MBChB``), and adds an opt-in reading for names with two
+family names (``Gabriel García Márquez``). 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.6.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.6 is out.** It keeps surnames that earlier releases
+read as credentials (``Luo Si``, ``Maria de Sa``, ``Ram Bahadur B.K.``),
+reads ``Wm`` and ``Md`` as the given names they abbreviate, recognizes more credentials after a comma
+(``John Smith, MBChB``), and adds an opt-in reading for names with two
+family names (``Gabriel García Márquez``). 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.6.0}/nameparser/_config_shim.py

@@ -1048,6 +1048,7 @@ class Constants:
         from nameparser.config.maiden_markers import MAIDEN_MARKERS
         from nameparser.config.suffixes import GLUED_HONORIFICS
         from nameparser.config.surnames import KOREAN_SURNAMES
+        from nameparser.config.titles import AFTER_GIVEN_TITLES
         # Every set field and every capitalization_exceptions key passes
         # _v1_matchable BEFORE any set algebra below: an entry v1 could
         # never match, or one Lexicon folds to empty (#582), is dropped
@@ -1109,7 +1110,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
@@ -1160,8 +1161,8 @@ class Constants:
                 particles=particles,
                 # complement translation: v1 marks the never-given subset;
                 # v2 marks the may-be-given subset. The trailing union keeps
-                # a config v1 accepted: particles.py asserts its own data has
-                # no word in both NON_GIVEN_NAME_PARTICLES and
+                # a config v1 accepted: the vocabulary build refuses a
+                # shipped word in both NON_GIVEN_NAME_PARTICLES and
                 # BOUND_GIVEN_NAMES, but nothing stops a caller adding one at
                 # runtime, and v1 then lets the bound rule win (leading "dos
                 # Santos Silva" parses first="dos Santos"). Treating such a
@@ -1207,6 +1208,14 @@ class Constants:
                 # stops mattering, the same rule ambiguous_acronyms gets
                 # against suffix_acronyms above.
                 honorific_tails=GLUED_HONORIFICS & suffix_words,
+                # likewise no v1 manager: the salutations ending a given
+                # part are 2.6 behavior (#835), so they ride in the
+                # snapshot only, and the one v1 knob that reaches them is
+                # deleting the title. Lexicon does not check this pair
+                # (classify reads a member only where it is a title too),
+                # so the intersection is kept for `_snapshot() ==
+                # Lexicon.default()` legibility, as conjunctions_ambiguous'.
+                after_given_titles=AFTER_GIVEN_TITLES & titles,
                 # TupleManager is dict[str, object] (v1 parity: values were
                 # never statically str-typed); every real entry is a str,
                 # same assumption _DelimiterManager's sentinel lookup makes.

{nameparser-2.4.2 → nameparser-2.6.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,10 +700,11 @@ 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
-            # word is one, which are not acting as particles there"
-            # -- nothing survived
-            # the filter, so the whole group is particles. The
+            # rules/R3: "A part whose every word is a particle initials
+            # those particles: they are not acting as particles there"
+            # -- the Except bullet this quote opens; nothing survived
+            # the filter, so the whole group is particles
+            # (decisions/R3). The
             # facade's twin of the core's
             # UNJOINED_TAG. NOT pinned against it by the case runners,
             # which compare the seven role fields only (Case carries

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

@@ -25,7 +25,7 @@ _VOCAB_FIELDS = (
     "titles", "given_name_titles", "suffix_acronyms", "suffix_words",
     "suffix_acronyms_ambiguous", "particles", "particles_ambiguous",
     "conjunctions", "conjunctions_ambiguous", "bound_given_names",
-    "maiden_markers", "surnames", "honorific_tails",
+    "maiden_markers", "surnames", "honorific_tails", "after_given_titles",
 )
 
 #: (marker, base, why) triples. Each marker QUALIFIES how entries of
@@ -55,21 +55,19 @@ _VOCAB_FIELDS = (
 #:   as a tail would peel a period-gated word off a real name), and
 #:   nothing needs the acronym half: the shipped tails are CJK
 #:   honorifics, which are words.
-#:   The same relation is asserted a second time in config/suffixes.py,
-#:   over the raw GLUED_HONORIFICS/SUFFIX_WORDS constants at
-#:   import. The two are not redundant in the way they look: that one
-#:   is an `assert`, stripped under `python -O`, while the check here
-#:   raises unconditionally -- so under -O this is what still holds the
-#:   SHIPPED vocabulary to the invariant, as it is the only thing that
-#:   ever held a caller's own.
+#:   The shipped vocabulary holds the relation by construction: its
+#:   build puts a word in GLUED_HONORIFICS only through an `attached`
+#:   property on a word reading (tools/vocab/build.py). The check here
+#:   is the only thing that holds a caller's own.
 #:
-#: Two fields are deliberately NOT here and have no check of their own.
+#: Three fields are deliberately NOT here and have no check of their own.
 #: given_name_titles -- see the note in __post_init__ for why every
 #: attempt at one rejected working configurations. conjunctions_ambiguous
 #: -- an orphan is never consulted because both the classify fork and
 #: its ambiguity emitter require the base entry as well, so an orphan
 #: decides nothing, and AGENTS.md's invariants rule guards harm, not
-#: no-ops.
+#: no-ops. after_given_titles -- the same: classify tags a word from it
+#: only where the word is in titles too, so an orphan is never read.
 _SUBSET_FIELDS = (
     ("particles_ambiguous", "particles",
      "an orphan emits a spurious particle-or-given ambiguity"),
@@ -129,7 +127,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 +150,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 +173,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 +193,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 +222,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 +245,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 +540,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 +580,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 +597,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 +642,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 +673,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
@@ -690,6 +690,15 @@ class Lexicon:
     #: vocabulary is. Full default list:
     #: :data:`~nameparser.config.suffixes.GLUED_HONORIFICS`.
     honorific_tails: frozenset[str] = frozenset()
+    #: Salutations that read as a title where one ENDS the given part
+    #: after a family comma, written bare: "Doe, Jane Mrs" reads title
+    #: "Mrs" where an office or rank word there stays a middle name
+    #: ("Doe, John King"), rules/H8. A period-marked title word reads as
+    #: a title there whether listed here or not (rules/H5). Entries need
+    #: not also be in ``titles``; one that is not is never consulted.
+    #: Full default list:
+    #: :data:`~nameparser.config.titles.AFTER_GIVEN_TITLES`.
+    after_given_titles: frozenset[str] = frozenset()
     #: Lowercase word -> case mask used by capitalized(): the word's
     #: own letters and digits, each in the case it takes ("phd" ->
     #: "PhD"), laid over the word as written, so the one entry
@@ -737,9 +746,10 @@ class Lexicon:
         # the expensive one -- three working configurations broken
         # across two attempts. Do not add a third.
         #
-        # The v2 form of particles.py's NON_GIVEN_NAME_PARTICLES-disjoint-
-        # from-BOUND_GIVEN_NAMES assertion. That module guards its own
-        # data at import; this guards vocabulary a caller supplies.
+        # The v2 form of the vocabulary build's check that a bound given
+        # name which is also a particle may be given (tools/vocab/build.py,
+        # check 9). The build guards the shipped data; this guards
+        # vocabulary a caller supplies.
         contradictory = (
             self.bound_given_names & self.particles) - self.particles_ambiguous
         if contradictory:
@@ -945,7 +955,8 @@ def _default_lexicon() -> Lexicon:
         SUFFIX_WORDS,
     )
     from nameparser.config.surnames import KOREAN_SURNAMES
-    from nameparser.config.titles import GIVEN_NAME_TITLES, TITLES
+    from nameparser.config.titles import (
+        AFTER_GIVEN_TITLES, GIVEN_NAME_TITLES, TITLES)
 
     # every vocabulary constant is a frozenset since #293, so each one
     # feeds its strictly-typed frozenset[str] field as it stands -- and
@@ -973,6 +984,7 @@ def _default_lexicon() -> Lexicon:
         maiden_markers=MAIDEN_MARKERS,
         surnames=KOREAN_SURNAMES,
         honorific_tails=GLUED_HONORIFICS,
+        after_given_titles=AFTER_GIVEN_TITLES,
         # pass canonical pair-tuples so this strictly-typed call site never
         # feeds a Mapping to the tuple-annotated field; __post_init__
         # still tolerates a Mapping at runtime for interactive use

{nameparser-2.4.2 → nameparser-2.6.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 bullet "The one exception to totality"):
     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
@@ -215,12 +215,12 @@ class Parser:
             dropped = set(state.dropped)
             # Force the role BEFORE the entry pass: it keys on
             # Role.SUFFIX, and a bare value's sub-parse reads its words
-            # as a name ('MD PhD' is a title and a family there), so
+            # as a name ('RA PhD' is a title and a family there), so
             # inside the sub-parse it joined nothing. The sub-parse's
             # 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.6.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/P8, #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/P8: "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