nameparser 2.7.0__tar.gz → 2.8.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nameparser
-Version: 2.7.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
@@ -35,27 +35,39 @@ 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.**
+
+⚠️ **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
+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 +139,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.1}/README.rst

@@ -7,27 +7,39 @@ 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.**
+
+⚠️ **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
+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 +111,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.1}/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.
@@ -529,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
@@ -712,27 +716,80 @@ _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]]:
-    # 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,
@@ -786,9 +843,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 +895,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
@@ -878,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
@@ -921,19 +1015,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 +1082,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()
@@ -1050,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
@@ -1376,7 +1491,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 +1547,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.1}/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