nameparser 2.7.0__tar.gz → 2.8.0__tar.gz

{nameparser-2.7.0/nameparser.egg-info → nameparser-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nameparser
-Version: 2.7.0
+Version: 2.8.0
 Summary: A simple Python module for parsing human names into their individual components.
 Author-email: Derek Gulbranson <derek73@gmail.com>
 License-Expression: LGPL-2.1-or-later
@@ -35,27 +35,30 @@ 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.7 is out.** It is the first release working towards
-the new language and vocabulary model described in the `vocabulary
-model RFC <https://github.com/derek73/python-nameparser/blob/master/docs/design/vocabulary-model-rfc.md>`__.
-It introduces more nuanced handling of titles and particles
-(``Chief Justice John Roberts`` reads the title ``Chief Justice``,
-while ``Justice Smith`` keeps the given name ``Justice``), adjusts the
-default vocabulary to better align with example name corpora, and
-surfaces alternative name readings in the published API. The `release log
+📣 **nameparser 2.8 is out, the last 2.x feature release.**
+
+⚠️ **HumanName is deprecated, and 3.0 removes it.** From 2.8 the 1.x
+compatibility layer — ``HumanName``, ``Constants`` and the shared
+``CONSTANTS`` — emits a ``DeprecationWarning`` where your code
+constructs it, loads it from a pickle, or changes the shared
+``CONSTANTS``. It keeps working through 2.x; ``parse()`` is the
+replacement, and `Coming from 1.x`_ below says where to start. After
+2.8 the 2.x line takes fixes only, and new work goes into 3.0.
+
+2.8 also carries on 2.7's reading of titles that are also given names:
+a title only inside a title phrase, so ``Queen Latifah`` keeps the
+given name ``Queen`` while ``Her Majesty Queen Elizabeth`` reads the
+title. The `release log
 <https://nameparser.readthedocs.io/en/latest/release_log.html>`__ has
-the details.
+the details. Please `open an
+issue <https://github.com/derek73/python-nameparser/issues>`__ for anything
+that parses wrong.
 
 Chinese, Japanese and Korean names written in their own scripts are read
 family-first, unspaced Korean names are split against the census surname
 list, and CJK honorifics are recognized. See `East Asian names
 <https://nameparser.readthedocs.io/en/latest/usage.html#east-asian-names>`__.
 
-Existing ``HumanName`` code from 1.x keeps working through 2.x, and most
-of it needs no changes; see `Coming from 1.x`_ below. Please `open an
-issue <https://github.com/derek73/python-nameparser/issues>`__ for anything
-that parses wrong.
-
 Installation
 ------------
 
@@ -127,8 +130,10 @@ Learn more
 Coming from 1.x
 ----------------
 
-``HumanName`` and ``CONSTANTS`` keep working in 2.0 — same imports, same
-attributes, same mutation API. What 2.0 removes is the batch of
+``HumanName`` and ``CONSTANTS`` keep working through 2.x — same imports,
+same attributes, same mutation API — and warn from 2.8 on, since 3.0
+removes them. Run your tests under ``python -W error::DeprecationWarning``
+to find the sites; a read of ``CONSTANTS`` does not warn. What 2.0 removes is the batch of
 deprecations 1.3 and 1.4 announced, so if your test suite runs clean on
 1.4 under ``python -W error::DeprecationWarning``, you are nearly done.
 Two things that check will not catch: four removals 1.4 never warned

{nameparser-2.7.0 → nameparser-2.8.0}/README.rst

@@ -7,27 +7,30 @@ 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.7 is out.** It is the first release working towards
-the new language and vocabulary model described in the `vocabulary
-model RFC <https://github.com/derek73/python-nameparser/blob/master/docs/design/vocabulary-model-rfc.md>`__.
-It introduces more nuanced handling of titles and particles
-(``Chief Justice John Roberts`` reads the title ``Chief Justice``,
-while ``Justice Smith`` keeps the given name ``Justice``), adjusts the
-default vocabulary to better align with example name corpora, and
-surfaces alternative name readings in the published API. The `release log
+📣 **nameparser 2.8 is out, the last 2.x feature release.**
+
+⚠️ **HumanName is deprecated, and 3.0 removes it.** From 2.8 the 1.x
+compatibility layer — ``HumanName``, ``Constants`` and the shared
+``CONSTANTS`` — emits a ``DeprecationWarning`` where your code
+constructs it, loads it from a pickle, or changes the shared
+``CONSTANTS``. It keeps working through 2.x; ``parse()`` is the
+replacement, and `Coming from 1.x`_ below says where to start. After
+2.8 the 2.x line takes fixes only, and new work goes into 3.0.
+
+2.8 also carries on 2.7's reading of titles that are also given names:
+a title only inside a title phrase, so ``Queen Latifah`` keeps the
+given name ``Queen`` while ``Her Majesty Queen Elizabeth`` reads the
+title. The `release log
 <https://nameparser.readthedocs.io/en/latest/release_log.html>`__ has
-the details.
+the details. Please `open an
+issue <https://github.com/derek73/python-nameparser/issues>`__ for anything
+that parses wrong.
 
 Chinese, Japanese and Korean names written in their own scripts are read
 family-first, unspaced Korean names are split against the census surname
 list, and CJK honorifics are recognized. See `East Asian names
 <https://nameparser.readthedocs.io/en/latest/usage.html#east-asian-names>`__.
 
-Existing ``HumanName`` code from 1.x keeps working through 2.x, and most
-of it needs no changes; see `Coming from 1.x`_ below. Please `open an
-issue <https://github.com/derek73/python-nameparser/issues>`__ for anything
-that parses wrong.
-
 Installation
 ------------
 
@@ -99,8 +102,10 @@ Learn more
 Coming from 1.x
 ----------------
 
-``HumanName`` and ``CONSTANTS`` keep working in 2.0 — same imports, same
-attributes, same mutation API. What 2.0 removes is the batch of
+``HumanName`` and ``CONSTANTS`` keep working through 2.x — same imports,
+same attributes, same mutation API — and warn from 2.8 on, since 3.0
+removes them. Run your tests under ``python -W error::DeprecationWarning``
+to find the sites; a read of ``CONSTANTS`` does not warn. What 2.0 removes is the batch of
 deprecations 1.3 and 1.4 announced, so if your test suite runs clean on
 1.4 under ``python -W error::DeprecationWarning``, you are nearly done.
 Two things that check will not catch: four removals 1.4 never warned

{nameparser-2.7.0 → nameparser-2.8.0}/nameparser/_config_shim.py

@@ -4,7 +4,7 @@ re-exports these names from the swap
 commit onward; the whole module is deleted in 3.0 with the facade.
 
 Layering: facade layer -- may import anything public; here that's
-``nameparser.util`` for ``lc()``, ``nameparser.config.regexes`` for
+``nameparser.util`` for ``lc()`` (as ``_lc``, the name that does not warn), ``nameparser.config.regexes`` for
 the read-only regexes proxy's underlying compiled patterns, and
 ``nameparser._lexicon``/``_policy``/``_parser`` for the ``_snapshot()``
 translation and the shared parser cache.
@@ -20,12 +20,16 @@ that cycle.
 """
 from __future__ import annotations
 
+import copy
 import functools
+import re
+import sys
 import warnings
 from collections.abc import (
     Callable, ItemsView, Iterable, Iterator, KeysView, Mapping, Set,
     ValuesView,
 )
+from types import FrameType
 from typing import NamedTuple, Self
 
 from nameparser._lexicon import (
@@ -33,7 +37,7 @@ from nameparser._lexicon import (
 )
 from nameparser._parser import Parser
 from nameparser._policy import PatronymicRule, Policy
-from nameparser.util import lc
+from nameparser.util import _lc as lc
 
 
 #: The eight multi-word entries the pre-2.0 DEFAULT vocabulary shipped.
@@ -712,12 +716,64 @@ _UNSET = object()
 _UNSET_KWARG = object()
 
 
+#: The migration guide every 2.8 removal message points at.
+MIGRATION_GUIDE = "https://nameparser.readthedocs.io/en/latest/migrate.html"
+
+# The 2.8 removal messages (decisions/3-0-reevaluations, 2026-10-28).
+# Each names code that type-checks and runs, pinned by
+# tests/v2/test_deprecations.py, and each opens with a fixed phrase
+# pyproject's filterwarnings ignores by message.
 _SHARED_MUTATION_MESSAGE = (
     "mutating the shared CONSTANTS singleton is deprecated and will be "
-    "removed in 3.0; build a Lexicon/Policy (or a private Constants "
-    "passed as HumanName(constants=...)) instead. See the migration "
-    "guide."
+    "removed in 3.0 with HumanName and Constants; configure a Parser "
+    "instead, e.g. Parser(lexicon=Lexicon.default().add(titles={'dean'})). "
+    f"See {MIGRATION_GUIDE}"
+)
+CONSTANTS_DEPRECATION = (
+    "Constants is deprecated and will be removed in 3.0 with HumanName; "
+    "configure a Parser instead, e.g. "
+    "Parser(lexicon=Lexicon.default().add(titles={'dean'})). "
+    f"See {MIGRATION_GUIDE}"
+)
+CONSTANTS_PICKLE_DEPRECATION = (
+    "Constants pickles stop loading in 3.0, when Constants is removed; "
+    "pickle a Parser instead, e.g. "
+    "Parser(lexicon=Lexicon.default().add(titles={'dean'})). "
+    f"See {MIGRATION_GUIDE}"
 )
+#: one message per manager class, keyed by name, for
+#: nameparser.config.__getattr__
+MANAGER_DEPRECATIONS = {
+    name: (
+        f"nameparser.config.{name} is deprecated and will be removed in "
+        f"3.0 with Constants; Lexicon fields take plain sets, e.g. "
+        f"Lexicon.default().add(titles={{'dean'}}). See {MIGRATION_GUIDE}"
+    )
+    for name in ("SetManager", "TupleManager", "RegexTupleManager")
+}
+
+
+def _quiet_setstate(new: object, state: dict[str, object], base: type,
+                    message: str) -> None:
+    """Restore a copy through its class's own ``__setstate__``.
+
+    ``copy.copy``/``copy.deepcopy`` reconstruct through ``__setstate__``,
+    which since 2.8 warns that a pickle was loaded, and a copy is no
+    load. ``base``'s own hook restores privately; a subclass's override
+    is called, as it was before 2.8, with only the load warning
+    filtered, by message. The filter is taken only then: entering
+    ``catch_warnings`` clears every module's warnings registry, so on
+    every copy it would re-show warnings the caller's filters show once
+    per line. A copy of the shared ``CONSTANTS`` stays quiet, as before:
+    a ``HumanName`` built on the copy still warns.
+    """
+    if type(new).__setstate__ is base.__setstate__:  # type: ignore[attr-defined]
+        new._restore(state)  # type: ignore[attr-defined]
+        return
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", message=re.escape(message),
+                                category=DeprecationWarning)
+        new.__setstate__(state)  # type: ignore[attr-defined]
 
 
 def _default_vocab() -> dict[str, frozenset[str]]:
@@ -786,9 +842,11 @@ class Constants:
 
     The module-level ``CONSTANTS`` singleton (below) has ``_shared``
     flipped to ``True``: any mutation reached through it emits
-    ``DeprecationWarning`` pointing at ``Lexicon``/``Policy`` and
-    ``HumanName(constants=...)``. A private ``Constants()`` never
-    warns -- only the shared instance is on the 3.0 removal path.
+    ``DeprecationWarning`` pointing at ``Lexicon``/``Policy``. Since 2.8
+    constructing a ``Constants``, copying one with ``copy()`` and
+    loading one from a pickle warn too, since the whole class goes in
+    3.0; the singleton is built without the warning, so importing
+    ``nameparser`` stays quiet.
     """
 
     _shared = False  # the CONSTANTS singleton flips this to True
@@ -836,6 +894,41 @@ class Constants:
         regexes: object = _UNSET_KWARG,
         patronymic_name_order: bool = False,
         middle_name_as_last: bool = False,
+    ) -> None:
+        # every construction warns, at the caller's line; the warnings
+        # registry, not a flag here, dedups repeats from one line
+        # (decisions/3-0-reevaluations, 2026-10-28)
+        warnings.warn(CONSTANTS_DEPRECATION, DeprecationWarning,
+                      stacklevel=2)
+        self._init(
+            prefixes=prefixes, suffix_acronyms=suffix_acronyms,
+            suffix_not_acronyms=suffix_not_acronyms,
+            suffix_acronyms_ambiguous=suffix_acronyms_ambiguous,
+            titles=titles, first_name_titles=first_name_titles,
+            conjunctions=conjunctions, bound_first_names=bound_first_names,
+            non_first_name_prefixes=non_first_name_prefixes,
+            capitalization_exceptions=capitalization_exceptions,
+            regexes=regexes, patronymic_name_order=patronymic_name_order,
+            middle_name_as_last=middle_name_as_last)
+
+    def _init(
+        self,
+        *,
+        prefixes: Iterable[str] | object = _UNSET_KWARG,
+        suffix_acronyms: Iterable[str] | object = _UNSET_KWARG,
+        suffix_not_acronyms: Iterable[str] | object = _UNSET_KWARG,
+        suffix_acronyms_ambiguous: Iterable[str] | object = _UNSET_KWARG,
+        titles: Iterable[str] | object = _UNSET_KWARG,
+        first_name_titles: Iterable[str] | object = _UNSET_KWARG,
+        conjunctions: Iterable[str] | object = _UNSET_KWARG,
+        bound_first_names: Iterable[str] | object = _UNSET_KWARG,
+        non_first_name_prefixes: Iterable[str] | object = _UNSET_KWARG,
+        capitalization_exceptions:
+            Mapping[str, str] | Iterable[tuple[str, str]] | object
+            = _UNSET_KWARG,
+        regexes: object = _UNSET_KWARG,
+        patronymic_name_order: bool = False,
+        middle_name_as_last: bool = False,
     ) -> None:
         # v1.4 parity constructor kwargs (#238/#242/#244 hardening); the
         # signature is spelled out rather than **kwargs so an unknown
@@ -921,19 +1014,20 @@ class Constants:
         """
 
     def _bump(self) -> None:
-        # stacklevel=3 is exact for the direct scalar-assignment path
-        # (user code -> Constants.__setattr__ -> here) and lands one
-        # frame short -- inside the manager's own add()/remove()/
-        # __setitem__ -- for the indirect manager-mutation path (user
-        # code -> manager method -> _changed() -> here), since a
-        # single warn() call can't be exact for both call depths at
-        # once. Either way the warning still fires from this module,
-        # not the manager's true caller, which is enough: only the
-        # DeprecationWarning's presence/category/message are load-
-        # bearing (see the specified test), not the reported line.
+        # A fixed stacklevel lands on the caller only for one call depth:
+        # a scalar arrives through __setattr__, a set's add() through
+        # _changed(), a dict's update() and |= through __setitem__ per
+        # key. Walk out of this module instead, as _lexicon's
+        # _warn_dead_entry does, so the warning names the caller's line;
+        # attributed here, Python's default filters hid it.
         if self._shared:
+            level = 2
+            frame: FrameType | None = sys._getframe(1)
+            while (frame is not None
+                   and frame.f_globals.get("__name__") == __name__):
+                frame, level = frame.f_back, level + 1
             warnings.warn(_SHARED_MUTATION_MESSAGE, DeprecationWarning,
-                          stacklevel=3)
+                          stacklevel=level)
         object.__setattr__(self, "_generation", self._generation + 1)
 
     def __setattr__(self, name: str, value: object) -> None:
@@ -987,7 +1081,27 @@ class Constants:
         v1 (which deepcopied __dict__): attributes OUTSIDE the known
         field surface -- e.g. ad-hoc names stashed on the instance --
         are not carried by copy() or pickling; only the enumerated
-        fields survive."""                          # #260
+        fields survive. Warns since 2.8, as construction does: a copy
+        is a new private ``Constants``, and ``CONSTANTS.copy()`` builds
+        one without calling the constructor."""      # #260
+        warnings.warn(CONSTANTS_DEPRECATION, DeprecationWarning,
+                      stacklevel=2)
+        return self._copy()
+
+    def __copy__(self) -> Constants:
+        new = object.__new__(type(self))
+        _quiet_setstate(new, self.__getstate__(), Constants,
+                        CONSTANTS_PICKLE_DEPRECATION)
+        return new
+
+    def __deepcopy__(self, memo: dict[int, object]) -> Constants:
+        new = object.__new__(type(self))
+        memo[id(self)] = new
+        _quiet_setstate(new, copy.deepcopy(self.__getstate__(), memo),
+                        Constants, CONSTANTS_PICKLE_DEPRECATION)
+        return new
+
+    def _copy(self) -> Constants:
         # An independent instance with its own generation counter and
         # its own manager callbacks -- not a shared-state alias like a
         # naive attribute-for-attribute copy would produce. v1's copy()
@@ -1376,7 +1490,22 @@ class Constants:
         # DROPPED (#255: empty is always '' in 2.0).
         state = {k: v for k, v in state.items()
                  if k != "empty_attribute_default"}
-        self.__init__()  # type: ignore[misc]  # defaults, then overlay
+        warnings.warn(CONSTANTS_PICKLE_DEPRECATION, DeprecationWarning,
+                      stacklevel=2)
+        self._restore(state)
+
+    def _restore(self, state: dict[str, object]) -> None:
+        # defaults, then overlay. A subclass's own __init__ runs here as
+        # it did before 2.8; its super().__init__() would warn that a
+        # Constants was constructed, which a restore is not
+        if type(self).__init__ is Constants.__init__:
+            self._init()
+        else:
+            with warnings.catch_warnings():
+                warnings.filterwarnings(
+                    "ignore", message=re.escape(CONSTANTS_DEPRECATION),
+                    category=DeprecationWarning)
+                self.__init__()  # type: ignore[misc]
         # (managers re-wrapped below so _on_change points at THIS
         # instance, not whatever produced the incoming state)
         managers: dict[str, SetManager] = {}
@@ -1417,5 +1546,7 @@ class Constants:
                 object.__setattr__(self, name, state[name])
 
 
-CONSTANTS = Constants()
+# built past __init__, so importing nameparser never warns
+CONSTANTS = object.__new__(Constants)
+CONSTANTS._init()
 object.__setattr__(CONSTANTS, "_shared", True)

{nameparser-2.7.0 → nameparser-2.8.0}/nameparser/_facade.py

@@ -7,6 +7,7 @@ Layering: facade layer -- may import anything public plus _render.
 """
 from __future__ import annotations
 
+import copy
 import dataclasses
 import warnings
 from collections.abc import Iterator, Mapping
@@ -29,7 +30,8 @@ from typing import Any
 import nameparser.config  # noqa: F401
 
 import nameparser._render as _render
-from nameparser._config_shim import CONSTANTS, Constants, _cached_parser
+from nameparser._config_shim import (CONSTANTS, MIGRATION_GUIDE, Constants,
+                                     _cached_parser, _quiet_setstate)
 from nameparser._lexicon import _normalize, _spells_an_initial
 from nameparser._parser import Parser
 from nameparser._types import (FOLDED_TAG, UNCLASSIFIED_TAG,
@@ -60,6 +62,19 @@ _V1_HOOKS = (
 # whole module is deleted with the facade layer in 3.0.
 _WARNED_SUBCLASSES: set[type] = set()
 
+# The 2.8 removal messages (decisions/3-0-reevaluations, 2026-10-28);
+# the code each offers is pinned by tests/v2/test_deprecations.py.
+HUMANNAME_DEPRECATION = (
+    "HumanName is deprecated and will be removed in 3.0; use "
+    "nameparser.parse(text), whose fields are given and family where "
+    f"HumanName has first and last. See {MIGRATION_GUIDE}"
+)
+HUMANNAME_PICKLE_DEPRECATION = (
+    "HumanName pickles stop loading in 3.0, when HumanName is removed; "
+    "store parse(text).as_dict() or the original string instead. "
+    f"See {MIGRATION_GUIDE}"
+)
+
 
 def _empty_parsed() -> ParsedName:
     return ParsedName(original="", tokens=(), ambiguities=())
@@ -71,7 +86,8 @@ class HumanName:
     resolved from the bound ``Constants`` shim (dirty-tracked via its
     ``_generation``). Keeps every v1 spelling (``first``/``last`` over
     the core ``given``/``family``); the v1 parsing hooks are never
-    called (#280). Deleted with the facade layer in 3.0.
+    called (#280). Deprecated since 2.8, warning at every construction,
+    and deleted with the facade layer in 3.0.
     """
 
     def __init__(
@@ -101,6 +117,12 @@ class HumanName:
             raise TypeError(
                 f"constants must be a Constants instance, got {constants!r}"
             )
+        # every construction warns, at the caller's line (a subclass's
+        # super().__init__() is its author's line); never once per
+        # process, so a dependency's first HumanName cannot consume the
+        # warning meant for the caller's own
+        warnings.warn(HUMANNAME_DEPRECATION, DeprecationWarning,
+                      stacklevel=2)
         self._warn_overridden_hooks()
         self._C = constants
         self._snapshot_gen = -1  # forces first resolve
@@ -151,7 +173,8 @@ class HumanName:
                 f"{cls.__name__} overrides v1 parsing hooks "
                 f"({', '.join(overridden)}) that the 2.0 facade never "
                 f"calls; parsing is delegated to the core Parser. "
-                f"Migrate to the Lexicon/Policy API. See "
+                f"Migrate to the Lexicon/Policy API; HumanName is "
+                f"removed in 3.0. See "
                 f"https://github.com/derek73/python-nameparser/issues/280",
                 DeprecationWarning, stacklevel=3)
 
@@ -888,6 +911,28 @@ class HumanName:
         return state
 
     def __setstate__(self, state: dict[str, Any]) -> None:
+        # unpickling skips __init__, so the construction warning never
+        # reaches a pickle; this one does, at the pickle.loads line
+        warnings.warn(HUMANNAME_PICKLE_DEPRECATION, DeprecationWarning,
+                      stacklevel=2)
+        self._restore(state)
+
+    def __copy__(self) -> HumanName:
+        # copy.copy/deepcopy go through the state hooks, a subclass's
+        # included, and a copy is no pickle load (_quiet_setstate)
+        new = object.__new__(type(self))
+        _quiet_setstate(new, self.__getstate__(), HumanName,
+                        HUMANNAME_PICKLE_DEPRECATION)
+        return new
+
+    def __deepcopy__(self, memo: dict[int, object]) -> HumanName:
+        new = object.__new__(type(self))
+        memo[id(self)] = new
+        _quiet_setstate(new, copy.deepcopy(self.__getstate__(), memo),
+                        HumanName, HUMANNAME_PICKLE_DEPRECATION)
+        return new
+
+    def _restore(self, state: dict[str, Any]) -> None:
         c = state.get("C")
         self._C = CONSTANTS if c is None else c
         self._snapshot_gen = -1

{nameparser-2.7.0 → nameparser-2.8.0}/nameparser/_pipeline/_post_rules.py

@@ -506,7 +506,7 @@ def post_rules(state: ParseState) -> ParseState:
     # it, and the one name word of a name read family-first. The comma
     # named no given part, and the order places a word nothing else
     # decided (O5), so the title decides as it does in 'Sir John'
-    # ('Elizabeth II, Queen' reads as 'Queen Elizabeth II'), unless
+    # ('John III, Sir' reads as 'Sir John III'), unless
     # something else settled the word (_family_settled).
     elif (titles and families and not givens and not middles
             and not _family_settled(state, tokens, families)

{nameparser-2.7.0 → nameparser-2.8.0}/nameparser/_pipeline/_vocab.py

@@ -1487,7 +1487,8 @@ def title_readings(texts: Sequence[str], folded: Sequence[str],
     of `title_modifiers` is a title only with a head title behind it in
     its run of titles: any title that is not a modifier, or a word H2's
     shape reads as one, before 'of' ('Mother Superior of the Convent'),
-    or in the object of 'of' or 'the' there (decision 10 of
+    behind a title that attaches to it in `title_phrases` ('Princess
+    Royal', #913), or in the object of 'of' or 'the' there (decision 10 of
     decisions/vocabulary-model). Only the leading run is the head: a
     modifier outside it is read as listed, one ending the name being
     H5's. A
@@ -1558,7 +1559,10 @@ def title_readings(texts: Sequence[str], folded: Sequence[str],
                 and ((head and i < lead) or (n in contested and n not in titles))):
             reading[i] = behind or linked[i] or (
                 i < last and folded[i + 1] in _PHRASE_LINKS
-                and folded[i + 1] in conjunctions)
+                and folded[i + 1] in conjunctions) or (
+                # a title before it that attaches to it ('Princess Royal')
+                i > 0 and reading[i - 1]
+                and f"{folded[i - 1]} {n}" in phrases)
             behind = reading[i]
         elif reading[i] or (head and is_title_shaped(texts[i], lexicon)):
             behind = True

{nameparser-2.7.0 → nameparser-2.8.0}/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, 7, 0)` is already
-#: true here while 2.7.0 is unreleased. Compare `__version__` instead
+#: cannot carry the dev marker, so `VERSION >= (2, 8, 0)` is already
+#: true here while 2.8.0 is unreleased. Compare `__version__` instead
 #: where that distinction matters.
-VERSION = (2, 7, 0)
+VERSION = (2, 8, 0)
 #: 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.7.0.dev0, which sorts above 2.6.0 and BELOW 2.7.0, so an install
+#: 2.8.0.dev0, which sorts above 2.7.0 and BELOW 2.8.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.8.0/nameparser/config/__init__.py

@@ -0,0 +1,76 @@
+"""v1 import-path preservation (mechanisms.md#CONFIG-SHIM-SNAPSHOT):
+the Constants shim
+lives in nameparser._config_shim.
+
+Two unrelated things share this package. The names re-exported below --
+``Constants``, ``CONSTANTS``, ``SetManager``, ``TupleManager``,
+``RegexTupleManager`` -- are v1 compatibility surface, and go with the
+rest of the facade in 3.0. The vocabulary data modules beside them
+(:mod:`~nameparser.config.titles`, :mod:`~nameparser.config.particles`,
+...) are not compatibility surface at all: they are the word lists the
+2.0 :class:`~nameparser.Lexicon` is built from, they are named for its
+fields since 2.2 (#293), and its documentation cross-references them.
+Since 2.6 the word lists (all but ``surnames.py``) re-export sets
+compiled from the per-word TOML files in ``nameparser/vocab/`` (#737).
+
+``RegexTupleManager`` is served from the shim purely for pickle
+compatibility (through ``__getattr__`` since 2.8, so loading such a blob
+warns here too): a v1.4 ``Constants`` blob's ``regexes`` field was
+pickled as ``nameparser.config.RegexTupleManager(...)``, and unpickling
+resolves and reconstructs that nested object before
+``Constants.__setstate__`` ever runs. Without this name, loading such a
+blob raises ``AttributeError`` looking up the class, not a clean
+compatibility failure.
+"""
+# Maintainer note, deliberately outside the docstring: the vocabulary
+# DATA modules keep this package as their home in 3.0 (decided
+# 2026-10-28, decisions/3-0-reevaluations); only the five shim names
+# below go. Constants and CONSTANTS are imported eagerly -- Constants
+# warns at construction, the CONSTANTS singleton when mutated -- while
+# the three managers resolve through __getattr__ so that each caller's
+# read warns, at the caller's line, and nameparser's own reads (from
+# _config_shim directly) stay quiet. The bridge follows
+# config/_deprecated.py's alias_getattr: the hooks sit in the `else` of
+# a TYPE_CHECKING guard, since a module __getattr__ mypy can see turns
+# off its missing-attribute checking for the whole module, and __dir__
+# lists the managers, or autodoc's member scan drops them.
+import sys as _sys
+import warnings as _warnings
+from typing import TYPE_CHECKING
+
+import nameparser._config_shim as _config_shim
+from nameparser._config_shim import CONSTANTS as CONSTANTS
+from nameparser._config_shim import Constants as Constants
+
+if TYPE_CHECKING:
+    from nameparser._config_shim import RegexTupleManager as RegexTupleManager
+    from nameparser._config_shim import SetManager as SetManager
+    from nameparser._config_shim import TupleManager as TupleManager
+else:
+    def __getattr__(name: str) -> object:
+        # PEP 562. Per read, never cached into globals, so every
+        # reading site warns (why _deprecated.py never caches either).
+        # A v1.4 Constants pickle names nameparser.config.
+        # RegexTupleManager and SetManager, so loading one warns here as
+        # well as in Constants.__setstate__ -- correct, since 3.0
+        # refuses that blob.
+        message = _config_shim.MANAGER_DEPRECATIONS.get(name)
+        if message is None:
+            raise AttributeError(
+                f"module {__name__!r} has no attribute {name!r}")
+        # `from nameparser.config import SetManager` reads the name
+        # twice: importlib's _handle_fromlist probes a PACKAGE's
+        # fromlist with hasattr() first, then the import statement
+        # reads it. Warning on the probe too would report one import
+        # twice.
+        if _sys._getframe(1).f_code.co_name != "_handle_fromlist":
+            _warnings.warn(message, DeprecationWarning, stacklevel=2)
+        return getattr(_config_shim, name)
+
+    def __dir__() -> list[str]:
+        # the union, as _deprecated.py's __dir__ explains
+        return sorted(set(globals()) | set(_config_shim.MANAGER_DEPRECATIONS))
+
+# a star import reads __all__ alone, so listing the managers routes
+# each through __getattr__ and warns, rather than dropping them unwarned
+__all__ = ["CONSTANTS", "Constants", "RegexTupleManager", "SetManager", "TupleManager"]