nameparser 2.8.0__tar.gz → 2.8.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nameparser
-Version: 2.8.0
+Version: 2.8.1
 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
@@ -37,6 +37,15 @@ composable, and locale packs are opt-in.
 
 📣 **nameparser 2.8 is out, the last 2.x feature release.**
 
+⚠️ **2.8.1 adds three more DeprecationWarnings** for things 3.0 changes:
+configuring a ``Lexicon`` through its set fields
+(``Lexicon.default().add(titles={"dean"})``), reading the vocabulary
+constants in ``nameparser.config`` (``TITLES`` and the rest, all but
+``surnames``), and ``nameparser.config.regexes``. A test run that turns
+warnings into errors (``-W error``, or pytest's ``filterwarnings =
+error``) fails where your code does any of these; see the `migration
+guide <https://nameparser.readthedocs.io/en/stable/migrate.html#deprecated-in-2-8-1>`__.
+
 ⚠️ **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

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

@@ -9,6 +9,15 @@ composable, and locale packs are opt-in.
 
 📣 **nameparser 2.8 is out, the last 2.x feature release.**
 
+⚠️ **2.8.1 adds three more DeprecationWarnings** for things 3.0 changes:
+configuring a ``Lexicon`` through its set fields
+(``Lexicon.default().add(titles={"dean"})``), reading the vocabulary
+constants in ``nameparser.config`` (``TITLES`` and the rest, all but
+``surnames``), and ``nameparser.config.regexes``. A test run that turns
+warnings into errors (``-W error``, or pytest's ``filterwarnings =
+error``) fails where your code does any of these; see the `migration
+guide <https://nameparser.readthedocs.io/en/stable/migrate.html#deprecated-in-2-8-1>`__.
+
 ⚠️ **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

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

@@ -533,8 +533,8 @@ class _RegexesProxy:
     def _regexes() -> Mapping[str, object]:
         # deferred import: see the module docstring's note on why every
         # nameparser.config.<data module> import in this file is lazy
-        from nameparser.config.regexes import REGEXES
-        return REGEXES
+        from nameparser.config.regexes import _REGEXES
+        return _REGEXES
 
     #: dict methods this read-only proxy deliberately does not carry.
     #: Without this, __getattr__ reports them as missing regexes and
@@ -777,18 +777,19 @@ def _quiet_setstate(new: object, state: dict[str, object], base: type,
 
 
 def _default_vocab() -> dict[str, frozenset[str]]:
-    # v1 data modules stay the single vocabulary source through 2.x
+    # the compiled vocabulary, read from _compiled: the public modules'
+    # constants warn at a caller's read since 2.8.1 (#1007)
     # (same rule as Lexicon.default()).
-    from nameparser.config.bound_given_names import BOUND_GIVEN_NAMES
-    from nameparser.config.conjunctions import CONJUNCTIONS
-    from nameparser.config.particles import (
+    from nameparser.config._compiled import BOUND_GIVEN_NAMES
+    from nameparser.config._compiled import CONJUNCTIONS
+    from nameparser.config._compiled import (
         NON_GIVEN_NAME_PARTICLES, PARTICLES,
     )
-    from nameparser.config.suffixes import (
+    from nameparser.config._compiled import (
         SUFFIX_ACRONYMS, SUFFIX_ACRONYMS_AMBIGUOUS, SUFFIX_WORDS,
     )
     from nameparser.config._titles_2_6_0 import TITLES_2_6_0
-    from nameparser.config.titles import (
+    from nameparser.config._compiled import (
         GIVEN_NAME_TITLES, TITLES, TITLES_AMBIGUOUS)
     return {
         "prefixes": PARTICLES,
@@ -971,7 +972,7 @@ class Constants:
                 self, name,
                 SetManager(value, _on_change=self._bump, _field=name))  # type: ignore[arg-type]
         if capitalization_exceptions is _UNSET_KWARG:
-            from nameparser.config.capitalization import (
+            from nameparser.config._compiled import (
                 CAPITALIZATION_EXCEPTIONS,
             )
             capitalization_exceptions = CAPITALIZATION_EXCEPTIONS
@@ -1164,14 +1165,14 @@ class Constants:
         singleton -- only direct attribute mutation is on the 3.0
         removal path.
         """
-        from nameparser.config.conjunctions import CONJUNCTIONS_AMBIGUOUS
-        from nameparser.config.given_names import GIVEN_NAME_ABBREVIATIONS
-        from nameparser.config.maiden_markers import MAIDEN_MARKERS
-        from nameparser.config.suffixes import (
+        from nameparser.config._compiled import CONJUNCTIONS_AMBIGUOUS
+        from nameparser.config._compiled import GIVEN_NAME_ABBREVIATIONS
+        from nameparser.config._compiled import MAIDEN_MARKERS
+        from nameparser.config._compiled import (
             AGNOMENS, GLUED_HONORIFICS, SUFFIX_WORDS_AMBIGUOUS)
         from nameparser.config.surnames import KOREAN_SURNAMES
         from nameparser.config._titles_2_6_0 import TITLES_2_6_0
-        from nameparser.config.titles import (
+        from nameparser.config._compiled import (
             AFTER_GIVEN_TITLES, TITLE_MODIFIERS, TITLE_PHRASES, TITLE_STYLES,
             TITLES_AMBIGUOUS)
         # Every set field and every capitalization_exceptions key passes

{nameparser-2.8.0 → nameparser-2.8.1}/nameparser/_lexicon.py

@@ -12,7 +12,7 @@ import functools
 import sys
 import unicodedata
 import warnings
-from collections.abc import Iterable, Mapping, Set
+from collections.abc import Iterable, Iterator, Mapping, Set
 from dataclasses import dataclass, field
 from types import FrameType, MappingProxyType
 from typing import cast
@@ -337,6 +337,101 @@ def _warn_dead_entry(message: str) -> None:
     warnings.warn(message, UserWarning, stacklevel=level)
 
 
+#: 2.8.1 (#754): the 3.0 migration guide's table of what each set field
+#: becomes. 3.0 configures a lexicon by reading -- what a word is -- and
+#: refuses these fields with a TypeError naming the readings for the
+#: words given, a translation this release does not attempt: it depends
+#: on the word's other readings, so the guide's row and 3.0's error are
+#: the sources.
+_FIELDS_GUIDE = ("https://nameparser.readthedocs.io/en/latest/migrate.html"
+                 "#lexicon-fields-readings")
+
+#: modules whose frames sit between a caller and a Lexicon's
+#: construction: this one (add, remove, __or__, __init__),
+#: dataclasses.replace and copy.replace
+_CONSTRUCTION_MODULES = (__name__, "dataclasses", "copy")
+
+
+def _outside_caller(
+        construction: bool,
+) -> tuple[int, Mapping[str, object] | None, str] | None:
+    """Where a set-field warning belongs: the stacklevel, counted from
+    the function that calls warnings.warn (itself called from the
+    method this asks for), of the first frame outside this module,
+    dataclasses and copy, with the locals of a dataclasses.replace
+    frame passed on the way and the replace the caller called
+    (``copy.replace()`` where a copy frame was passed, else
+    ``dataclasses.replace()``); or None where the library itself made the
+    call -- that frame inside nameparser (Lexicon.default(), the locale
+    packs, parser_for, the v1 facade), or, for a construction, a method
+    of this module building the lexicon: add() and remove() warn for
+    themselves, and __or__ is 3.0's own spelling.
+    """
+    level = 3
+    frame: FrameType | None = sys._getframe(2)
+    replacing: Mapping[str, object] | None = None
+    replace_call = "dataclasses.replace()"
+    while frame is not None:
+        module = frame.f_globals.get("__name__")
+        if module not in _CONSTRUCTION_MODULES:
+            break
+        if module == "copy":
+            replace_call = "copy.replace()"
+        code = frame.f_code.co_name
+        if (construction and module == __name__
+                and code not in ("__init__", "__post_init__")):
+            return None
+        if module == "dataclasses" and code in ("replace", "_replace"):
+            replacing = frame.f_locals
+        frame, level = frame.f_back, level + 1
+    caller = "" if frame is None else frame.f_globals.get("__name__", "")
+    if caller == "nameparser" or caller.startswith("nameparser."):
+        return None
+    return level, replacing, replace_call
+
+
+def _surnames_code(op: str, words: frozenset[str]) -> str:
+    """Code doing add() or remove()'s surnames edit the 3.0 way, which
+    runs quietly on 2.8.1 too; prose for a long list, whose code would
+    swamp the message."""
+    if len(words) > 5:
+        return (f"join a Lexicon holding those {len(words)} surnames to it "
+                f"with |" if op == "add" else
+                f"subtract those {len(words)} surnames from lexicon.surnames "
+                f"in dataclasses.replace()")
+    listed = "{" + ", ".join(map(repr, sorted(words))) + "}"
+    return (f"write lexicon | Lexicon(surnames=frozenset({listed}))"
+            if op == "add" else
+            f"write dataclasses.replace(lexicon, "
+            f"surnames=lexicon.surnames - {listed})")
+
+
+def _warn_set_fields(level: int, spelling: str, fields: Iterable[str],
+                     surnames: str = "") -> None:
+    """Warn at `level` (from _outside_caller) that `spelling`, a call,
+    writes `fields`, naming each and the guide row that replaces it.
+    surnames gets a sentence of its own, ending on `surnames`, the code
+    for the edit (_surnames_code): 3.0 keeps the field, and only add()
+    and remove() stop taking it."""
+    fields = list(fields)
+    internal = [name for name in fields if name != "surnames"]
+    parts = []
+    if internal:
+        parts.append(
+            f"{spelling} writes {', '.join(internal)}, which 3.0 makes "
+            f"internal and refuses with a TypeError naming the readings "
+            f"that replace it for the words given; the guide's \"Lexicon "
+            f"fields → readings\" table has a row for each field")
+    if "surnames" in fields:
+        parts.append(
+            f"3.0 keeps surnames a field, but {spelling} no longer takes "
+            f"it: {surnames}, which runs on 2.8.1 too")
+    warnings.warn(
+        f"Lexicon's set fields are deprecated (#754): {'; and '.join(parts)}. "
+        f"See {_FIELDS_GUIDE}",
+        DeprecationWarning, stacklevel=level)
+
+
 def _normset(
     entries: Iterable[str], field_name: str, warn: bool = True,
 ) -> frozenset[str]:
@@ -590,7 +685,15 @@ class Lexicon:
     matched against two adjacent title words (``"chief justice"``).
     Field docs below show examples, not full
     contents; inspect any field's shipped vocabulary directly, e.g.
-    ``Lexicon.default().conjunctions``."""
+    ``Lexicon.default().conjunctions``.
+
+    Deprecated since 2.8.1: 3.0 makes the set fields internal and
+    configures vocabulary by reading, so writing one here, through
+    ``add``, ``remove`` or ``dataclasses.replace`` warns. ``surnames``
+    and ``capitalization_exceptions`` stay fields in 3.0, so passing them
+    here or to ``dataclasses.replace`` is quiet, but ``add`` and
+    ``remove`` with ``surnames`` warn, since 3.0's take readings only;
+    see the migration guide's "Deprecated in 2.8.1"."""
 
     #: Pre-nominal titles ("dr", "sir", "capt", ...). Full default
     #: list: :data:`~nameparser.config.titles.TITLES`.
@@ -804,6 +907,41 @@ class Lexicon:
         default_factory=lambda: MappingProxyType({}))
 
     def __post_init__(self) -> None:
+        self._validate()
+        # 2.8.1 (#754): a caller's construction or dataclasses.replace()
+        # with a set field 3.0 refuses. Not from __setstate__, which runs
+        # _validate alone: loading a pickle writes no field.
+        where = _outside_caller(construction=True)
+        if where is not None:
+            self._warn_constructed(*where)
+
+    def _warn_constructed(self, level: int,
+                          replacing: Mapping[str, object] | None,
+                          replace_call: str) -> None:
+        # surnames is never named here: 3.0 accepts it in Lexicon() and
+        # dataclasses.replace(), as it does capitalization_exceptions
+        internal = [name for name in _VOCAB_FIELDS if name != "surnames"]
+        if replacing is None:
+            # a field left at its default is empty, so a non-empty one
+            # was passed
+            written = [name for name in internal if getattr(self, name)]
+            spelling = "Lexicon()"
+        else:
+            # dataclasses.replace() names the instance `obj`, and 3.13's
+            # dataclasses._replace (behind copy.replace) `self`; a field
+            # not passed is filled in with the instance's own value
+            old = replacing.get("obj", replacing.get("self"))
+            changes = replacing.get("changes")
+            if not isinstance(old, Lexicon) or not isinstance(changes, Mapping):
+                return
+            written = [name for name in internal if name in changes
+                       and changes[name] is not getattr(old, name)]
+            spelling = replace_call
+        if written:
+            # one more frame than __post_init__ itself
+            _warn_set_fields(level + 1, spelling, written)
+
+    def _validate(self) -> None:
         for name in _VOCAB_FIELDS:
             object.__setattr__(self, name, _normset(getattr(self, name), name))
         canonical = _normpairs(self.capitalization_exceptions)
@@ -949,7 +1087,7 @@ class Lexicon:
         # without changing its name, so an old pickle would otherwise
         # load a semantically inverted lexicon in silence. Rebuilds
         # _cap_map for free, which this used to do by hand.
-        self.__post_init__()
+        self._validate()
         # __post_init__ also normalizes, and quietly accepting a
         # rewritten value would make this a place where caller data
         # changes without a word. A pickle this library wrote is always
@@ -1038,28 +1176,53 @@ class Lexicon:
         return dataclasses.replace(self, **updates)  # type: ignore[arg-type]
 
     def add(self, **entries: Iterable[str]) -> Lexicon:
-        return self._edit("add", entries)
+        """A copy with each named field's words added. Deprecated since
+        2.8.1: 3.0's ``add`` takes readings, not fields."""
+        return self._edit_warning("add", entries)
 
     def remove(self, **entries: Iterable[str]) -> Lexicon:
-        return self._edit("remove", entries)
+        """A copy with each named field's words removed. Deprecated
+        since 2.8.1: 3.0's ``remove`` takes readings, not fields."""
+        return self._edit_warning("remove", entries)
+
+    def _edit_warning(self, op: str,
+                      entries: Mapping[str, Iterable[str]]) -> Lexicon:
+        # 2.8.1 (#754): 3.0's add() and remove() take readings, and
+        # refuse every field keyword, surnames included. The warning
+        # follows a successful edit, so a bad value raises its own
+        # error first. An iterator of surnames is read once here, so the
+        # warning can spell the edit and _edit still sees the words.
+        named = entries.get("surnames")
+        if isinstance(named, Iterator):
+            entries = {**entries, "surnames": tuple(named)}
+        edited = self._edit(op, entries)
+        if entries:
+            where = _outside_caller(construction=False)
+            if where is not None:
+                code = ("" if "surnames" not in entries else _surnames_code(
+                    op, _normset(entries["surnames"], "surnames", warn=False)))
+                _warn_set_fields(where[0], f"{op}()", entries, code)
+        return edited
 
 
 @functools.cache
 def _default_lexicon() -> Lexicon:
-    # v1 data modules are the single source of vocabulary through 2.x.
-    from nameparser.config.bound_given_names import BOUND_GIVEN_NAMES
-    from nameparser.config.given_names import GIVEN_NAME_ABBREVIATIONS
-    from nameparser.config.capitalization import CAPITALIZATION_EXCEPTIONS
-    from nameparser.config.conjunctions import (
+    # The compiled vocabulary, read from _compiled rather than the public
+    # nameparser.config modules, whose constants warn at a caller's read
+    # since 2.8.1 (#1007); surnames.py is not deprecated.
+    from nameparser.config._compiled import BOUND_GIVEN_NAMES
+    from nameparser.config._compiled import GIVEN_NAME_ABBREVIATIONS
+    from nameparser.config._compiled import CAPITALIZATION_EXCEPTIONS
+    from nameparser.config._compiled import (
         CONJUNCTIONS, CONJUNCTIONS_AMBIGUOUS)
-    from nameparser.config.maiden_markers import MAIDEN_MARKERS
-    from nameparser.config.particles import NON_GIVEN_NAME_PARTICLES, PARTICLES
-    from nameparser.config.suffixes import (
+    from nameparser.config._compiled import MAIDEN_MARKERS
+    from nameparser.config._compiled import NON_GIVEN_NAME_PARTICLES, PARTICLES
+    from nameparser.config._compiled import (
         AGNOMENS, GLUED_HONORIFICS, SUFFIX_ACRONYMS, SUFFIX_ACRONYMS_AMBIGUOUS,
         SUFFIX_WORDS, SUFFIX_WORDS_AMBIGUOUS,
     )
     from nameparser.config.surnames import KOREAN_SURNAMES
-    from nameparser.config.titles import (
+    from nameparser.config._compiled import (
         AFTER_GIVEN_TITLES, GIVEN_NAME_TITLES, TITLE_MODIFIERS, TITLE_PHRASES,
         TITLE_STYLES, TITLES, TITLES_AMBIGUOUS)
 

{nameparser-2.8.0 → nameparser-2.8.1}/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, 8, 0)` is already
-#: true here while 2.8.0 is unreleased. Compare `__version__` instead
+#: cannot carry the dev marker, so `VERSION >= (2, 8, 1)` is already
+#: true here while 2.8.1 is unreleased. Compare `__version__` instead
 #: where that distinction matters.
-VERSION = (2, 8, 0)
+VERSION = (2, 8, 1)
 #: 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.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.
+#: 2.8.1.dev0, which sorts above 2.8.0 and BELOW 2.8.1, so an install
+#: from the 2.x branch can never masquerade as the release it precedes.
 PRE_RELEASE = ""
 __version__ = ".".join(map(str, VERSION)) + PRE_RELEASE

{nameparser-2.8.0 → nameparser-2.8.1}/nameparser/config/__init__.py

@@ -7,11 +7,13 @@ Two unrelated things share this package. The names re-exported below --
 ``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).
+...) hold the word lists the 2.x :class:`~nameparser.Lexicon` is built
+from, named for its fields since 2.2 (#293); since 2.6 each (all but
+``surnames.py``) re-exports sets compiled from the per-word TOML files
+in ``nameparser/vocab/`` (#737). 3.0 removes them too, all but
+``surnames``, and since 2.8.1 reading one of their constants warns,
+naming what 3.0 offers in its place (#1007), as reading
+``nameparser.config.regexes`` does (#1008).
 
 ``RegexTupleManager`` is served from the shim purely for pickle
 compatibility (through ``__getattr__`` since 2.8, so loading such a blob
@@ -22,10 +24,11 @@ resolves and reconstructs that nested object before
 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
+# Maintainer note, deliberately outside the docstring: 3.0 removes the
+# five shim names below and the vocabulary DATA modules but surnames
+# (#1007, #1008, superseding decisions/3-0-reevaluations's 2026-10-28
+# entry, which kept the modules); the modules warn per constant since
+# 2.8.1. 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

{nameparser-2.8.0 → nameparser-2.8.1}/nameparser/config/_deprecated.py

@@ -46,10 +46,55 @@ _MESSAGE = (
     "use {new_module}.{new} instead."
 )
 
+#: 3.0's migration guide, which every 2.8.1 removal message points at:
+#: Read the Docs' "latest" builds master, the 3.0 cycle.
+MIGRATION_GUIDE = "https://nameparser.readthedocs.io/en/latest/migrate.html"
+
+# 2.8.1: the live names of a module 3.0 deletes (#1007, #1008). Every
+# message opens "nameparser.config.", names the removal and closes on
+# the guide; pyproject's filterwarnings ignores the family by message,
+# and tests/v2/test_removals_2_8_1.py asserts each one.
+_REMOVED_MESSAGE = (
+    "{module}.{name} is deprecated and will be removed in 3.0 ({issue}); "
+    "{replacement}. See {guide}"
+)
+
+
+def words_of(args: str, which: str = "") -> str:
+    """The replacement clause for a vocabulary constant: the 3.0 call
+    listing a kind's words (``Lexicon.words``, #1007). Without `which`
+    the call lists exactly the set's words over the default vocabulary
+    (checked against master, 2026-11-02); with it the call lists more or
+    other words, and `which` says what the set held instead."""
+    call = f"in 3.0, Lexicon.default().words({args})"
+    if not which:
+        return f"{call} lists the same words"
+    return (f"{call} lists every word of that kind, where this set held "
+            f"{which}; Lexicon.default().readings_of(word) says what one "
+            f"word is")
+
+
+def removal_message(module: str, name: str) -> str | None:
+    """The 2.8.1 removal message for ``module.name``, or ``None`` where
+    3.0 keeps the name. Reads the module's hook, so it warns nothing."""
+    hook = vars(importlib.import_module(module)).get("__getattr__")
+    removed: Mapping[str, str] = getattr(hook, "removed_messages", {})
+    return removed.get(name)
+
+
+def _quiet_value(module: str, name: str) -> Any:  # noqa: ANN401
+    loaded = importlib.import_module(module)
+    hook = vars(loaded).get("__getattr__")
+    held: Mapping[str, Any] = getattr(hook, "removed_values", {})
+    return held[name] if name in held else getattr(loaded, name)
+
 
 def alias_getattr(
     module: str,
     aliases: Mapping[str, tuple[str, str]],
+    removed: Mapping[str, str] | None = None,
+    namespace: dict[str, Any] | None = None,
+    issue: str = "#1007",
 ) -> tuple[Callable[[str], Any], Callable[[], list[str]]]:
     """Build the ``__getattr__``/``__dir__`` pair for a module carrying
     deprecated vocabulary names.
@@ -84,9 +129,33 @@ def alias_getattr(
     module: mypy reads no module ``__getattr__`` for the alias-bearing
     modules any more, and does not analyze the ``else`` branch it is
     assigned in. It stays ``Any`` as what ``getattr`` itself returns.
+
+    ``removed`` (2.8.1) maps each LIVE name 3.0 deletes to the clause
+    naming its 3.0 replacement, and ``namespace`` is the module's
+    ``globals()``: each such name is popped out of it into the hook, so
+    the module keeps its assignment statement -- which is where autodoc
+    finds the constant's documentation -- while every read reaches
+    ``__getattr__`` and warns at the reader's line. The library reads
+    these values from ``nameparser.config._compiled`` (and regexes.py's
+    ``_REGEXES``), never through here, so only a caller's read warns.
     """
+    removed = dict(removed or {})
+    values: dict[str, Any] = {}
+    if removed:
+        if namespace is None:
+            raise TypeError("alias_getattr: removed names need namespace=")
+        values = {name: namespace.pop(name) for name in removed}
+    messages = {
+        name: _REMOVED_MESSAGE.format(
+            module=module, name=name, issue=issue, replacement=replacement,
+            guide=MIGRATION_GUIDE)
+        for name, replacement in removed.items()}
 
     def __getattr__(name: str) -> Any:  # noqa: ANN401
+        if name in values:
+            # 2: the reading frame, as for an alias below
+            warnings.warn(messages[name], DeprecationWarning, stacklevel=2)
+            return values[name]
         target = aliases.get(name)
         if target is None:
             raise AttributeError(f"module {module!r} has no attribute {name!r}")
@@ -94,11 +163,18 @@ def alias_getattr(
         # resolved BEFORE warning, so a mistyped alias target fails as
         # a ModuleNotFoundError or an AttributeError from here rather
         # than first advising the reader to move to a path that does
-        # not exist.
-        value = getattr(importlib.import_module(new_module), new_name)
+        # not exist. Quietly: a target 3.0 removes too is held by its
+        # module's hook, whose own warning would name this file.
+        value = _quiet_value(new_module, new_name)
+        message = _MESSAGE.format(
+            module=module, old=name, new_module=new_module, new=new_name)
+        # one warning saying so, rather than advice to move to a name
+        # that warns in its turn
+        also = removal_message(new_module, new_name)
+        if also is not None:
+            message += " That name is removed in 3.0 too: " + also
         warnings.warn(
-            _MESSAGE.format(
-                module=module, old=name, new_module=new_module, new=new_name),
+            message,
             DeprecationWarning,
             # 2: the frame that touched the name -- for the
             # `from nameparser.config.prefixes import ...` form, the
@@ -126,7 +202,7 @@ def alias_getattr(
         # are still nameable, so they are what is left to list (#356).
         live = sys.modules.get(module)
         names = set(vars(live)) if live is not None else set()
-        return sorted(names | set(aliases))
+        return sorted(names | set(aliases) | set(values))
 
     # The table itself, reachable without tripping a warning. __all__ is
     # hand-written per module (it must stay in SOURCE order for autodoc,
@@ -137,5 +213,8 @@ def alias_getattr(
     # and no AttributeError. test_config_aliases
     # ::test_every_alias_table_row_reaches_star_import cross-checks them.
     __getattr__.deprecated_aliases = dict(aliases)  # type: ignore[attr-defined]
+    # the 2.8.1 removals, read by removal_message and _quiet_value
+    __getattr__.removed_messages = messages  # type: ignore[attr-defined]
+    __getattr__.removed_values = values  # type: ignore[attr-defined]
 
     return __getattr__, __dir__

{nameparser-2.8.0 → nameparser-2.8.1}/nameparser/config/bound_given_names.py

@@ -25,3 +25,18 @@ BOUND_GIVEN_NAMES: frozenset[str] = _compiled.BOUND_GIVEN_NAMES
 # the constant, is bound by a star import as though it were vocabulary
 # (#356).
 __all__ = ["BOUND_GIVEN_NAMES"]
+
+
+# 2.8.1: 3.0 deletes this module (#1007), so each constant is served by
+# __getattr__ and warns at the line that reads it, naming what 3.0
+# offers in its place (alias_getattr's docstring says how the
+# assignment above stays documented). The library reads _compiled, never
+# this module. Hidden from mypy as alias_getattr explains; goes in 3.0.
+from typing import TYPE_CHECKING  # noqa: E402
+
+from nameparser.config._deprecated import alias_getattr, words_of  # noqa: E402
+
+if not TYPE_CHECKING:
+    __getattr__, __dir__ = alias_getattr(__name__, {}, removed={
+        "BOUND_GIVEN_NAMES": words_of('kind="bound_given"'),
+    }, namespace=globals())

{nameparser-2.8.0 → nameparser-2.8.1}/nameparser/config/capitalization.py

@@ -44,3 +44,23 @@ its own. The map also carries the Irish patronymic particles ``ó``,
 (``de la Vega``), Irish writes these capitalized (``Liam Ó Murchú``),
 and a mask outranks the particle lowercase (rules/R4).
 """
+
+
+# 2.8.1: 3.0 deletes this module (#1007), so each constant is served by
+# __getattr__ and warns at the line that reads it, naming what 3.0
+# offers in its place (alias_getattr's docstring says how the
+# assignment above stays documented). The library reads _compiled, never
+# this module. Hidden from mypy as alias_getattr explains; goes in 3.0.
+from typing import TYPE_CHECKING  # noqa: E402
+
+from nameparser.config._deprecated import alias_getattr  # noqa: E402
+
+if not TYPE_CHECKING:
+    __getattr__, __dir__ = alias_getattr(__name__, {}, removed={
+        "CAPITALIZATION_EXCEPTIONS": "in 3.0, read Lexicon.default().capitalization_exceptions, which stays a field",
+    }, namespace=globals())
+
+# Star imports read __all__ and never the module __getattr__ -- see the
+# note in prefixes.py -- so without it a star import would bind none
+# of the names served above, silently.
+__all__ = ["CAPITALIZATION_EXCEPTIONS"]

{nameparser-2.8.0 → nameparser-2.8.1}/nameparser/config/conjunctions.py

@@ -24,3 +24,23 @@ Single-letter entries of :data:`CONJUNCTIONS` that read as an initial,
 not a connective, in a name written wholly in one case.
 """
 
+
+# 2.8.1: 3.0 deletes this module (#1007), so each constant is served by
+# __getattr__ and warns at the line that reads it, naming what 3.0
+# offers in its place (alias_getattr's docstring says how the
+# assignment above stays documented). The library reads _compiled, never
+# this module. Hidden from mypy as alias_getattr explains; goes in 3.0.
+from typing import TYPE_CHECKING  # noqa: E402
+
+from nameparser.config._deprecated import alias_getattr, words_of  # noqa: E402
+
+if not TYPE_CHECKING:
+    __getattr__, __dir__ = alias_getattr(__name__, {}, removed={
+        "CONJUNCTIONS": words_of('kind="conjunction"'),
+        "CONJUNCTIONS_AMBIGUOUS": words_of('kind="conjunction", may_be_initial=True'),
+    }, namespace=globals())
+
+# Star imports read __all__ and never the module __getattr__ -- see the
+# note in prefixes.py -- so without it a star import would bind none
+# of the names served above, silently.
+__all__ = ["CONJUNCTIONS", "CONJUNCTIONS_AMBIGUOUS"]

{nameparser-2.8.0 → nameparser-2.8.1}/nameparser/config/given_names.py

@@ -16,3 +16,18 @@ GIVEN_NAME_ABBREVIATIONS: frozenset[str] = _compiled.GIVEN_NAME_ABBREVIATIONS
 # Star imports read __all__ and never the module __getattr__ -- see the
 # note in prefixes.py.
 __all__ = ["GIVEN_NAME_ABBREVIATIONS"]
+
+
+# 2.8.1: 3.0 deletes this module (#1007), so each constant is served by
+# __getattr__ and warns at the line that reads it, naming what 3.0
+# offers in its place (alias_getattr's docstring says how the
+# assignment above stays documented). The library reads _compiled, never
+# this module. Hidden from mypy as alias_getattr explains; goes in 3.0.
+from typing import TYPE_CHECKING  # noqa: E402
+
+from nameparser.config._deprecated import alias_getattr, words_of  # noqa: E402
+
+if not TYPE_CHECKING:
+    __getattr__, __dir__ = alias_getattr(__name__, {}, removed={
+        "GIVEN_NAME_ABBREVIATIONS": words_of('kind="given"', "the given names whose reading carries same_as"),
+    }, namespace=globals())

{nameparser-2.8.0 → nameparser-2.8.1}/nameparser/config/maiden_markers.py

@@ -92,3 +92,23 @@ decisions/vocabulary-exclusions, Excluded (MAIDEN_MARKERS). The full participle
 rozená stays, being unambiguous; a caller who needs the abbreviation
 adds it to their own Lexicon.
 """
+
+
+# 2.8.1: 3.0 deletes this module (#1007), so each constant is served by
+# __getattr__ and warns at the line that reads it, naming what 3.0
+# offers in its place (alias_getattr's docstring says how the
+# assignment above stays documented). The library reads _compiled, never
+# this module. Hidden from mypy as alias_getattr explains; goes in 3.0.
+from typing import TYPE_CHECKING  # noqa: E402
+
+from nameparser.config._deprecated import alias_getattr, words_of  # noqa: E402
+
+if not TYPE_CHECKING:
+    __getattr__, __dir__ = alias_getattr(__name__, {}, removed={
+        "MAIDEN_MARKERS": words_of('kind="birth_marker"'),
+    }, namespace=globals())
+
+# Star imports read __all__ and never the module __getattr__ -- see the
+# note in prefixes.py -- so without it a star import would bind none
+# of the names served above, silently.
+__all__ = ["MAIDEN_MARKERS"]