Upload folder using huggingface_hub (part 5)

.gitattributes

@@ -151,3 +151,16 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/charset_normalizer/md.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/contourpy/_contourpy.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/cv2/cv2.abi3.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/deprecate/__pycache__/deprecation.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/fontTools/__pycache__/agl.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/fontTools/cffLib/__pycache__/__init__.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/fontTools/cu2qu/cu2qu.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/fontTools/designspaceLib/__pycache__/__init__.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/fontTools/feaLib/__pycache__/ast.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/fontTools/feaLib/__pycache__/parser.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/fontTools/feaLib/lexer.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/fontTools/misc/bezierTools.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/fontTools/otlLib/__pycache__/builder.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/fontTools/pens/momentsPen.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/fontTools/qu2cu/qu2cu.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/fontTools/subset/__pycache__/__init__.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text

.venv/lib/python3.12/site-packages/deprecate/__pycache__/deprecation.cpython-312.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d02b9b23d8f486a52d5ac16476672a23d5352cef60b5bf8e0c3638201814b39f
+size 100575

.venv/lib/python3.12/site-packages/deprecate/_cli.py

@@ -0,0 +1,756 @@
+"""CLI entry point for pyDeprecate validation.
+
+Provides two entry points for scanning Python code for misconfigured ``@deprecated`` wrappers:
+
+- ``pydeprecate <subcommand> <path>`` — console script installed via ``pip install 'pyDeprecate[cli]'``
+- ``python -m deprecate <subcommand> <path>`` — module invocation of the same CLI
+
+Subcommands:
+    check   — Validate wrapper configuration and flag misconfigured, chain-forming, or positional-only-arg wrappers.
+    expiry  — Check for deprecated wrappers that have passed their scheduled ``remove_in`` deadline.
+    chains  — Detect deprecated wrappers whose ``target`` is itself a deprecated callable.
+    all     — Run all three checks in a single scan pass.
+    status  — Render a markdown deprecation table to stdout (and optionally save it to a file).
+
+"""
+
+import contextlib
+import functools
+import importlib.util
+import sys
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any, Optional
+
+from deprecate._pkg import (
+    _auto_detect_version,
+    _find_child_packages,
+    _is_package_dir,
+    _managed_sys_path,
+    _resolve_module_name,
+    _safe_module_name,
+)
+from deprecate.audit import (
+    DeprecationWrapperInfo,
+    TableStyle,
+    _check_expiry_for_callables,
+    find_deprecation_wrappers,
+    generate_deprecation_table,
+    validate_deprecation_chains,
+    validate_deprecation_expiry,
+)
+
+
+def _is_package_available(name: str) -> bool:
+    """Return True if *name* is importable without actually importing it."""
+    return importlib.util.find_spec(name) is not None
+
+
+def _print(msg: str, *, stderr: bool = False) -> None:
+    """Print a message, using Rich console when available.
+
+    Routes output through :class:`~rich.console.Console` when the ``rich``
+    package is installed, falling back to built-in :func:`print` otherwise.
+
+    Args:
+        msg: The message to print.
+        stderr: If ``True``, send the message to *stderr* instead of *stdout*.
+
+    """
+    if _Reporter._HAS_RICH:
+        _Reporter._console(stderr).print(msg, markup=False, highlight=False)
+    else:
+        std_ = sys.stderr if stderr else sys.stdout
+        print(msg, file=std_)
+
+
+def _scan_directory(path: str, include_members: bool = True) -> list[DeprecationWrapperInfo]:
+    """Scan a plain directory of top-level Python files.
+
+    Nested Python files in subdirectories are skipped unless they are part of an importable package layout. Plain
+    directories do not generally support dotted imports for nested modules, so this function only scans top-level
+    modules and warns when deeper files are present.
+
+    """
+    abs_path: Path = Path(path).resolve()
+    results: list[DeprecationWrapperInfo] = []
+
+    original_argv = sys.argv[:]
+    sys.argv = sys.argv[:1]  # hide CLI args from any module-level code (e.g. setup.py)
+    try:
+        for entry in sorted(abs_path.iterdir(), key=lambda ent: ent.name):
+            if not (entry.is_file() and entry.suffix == ".py" and not entry.name.startswith("__")):
+                continue
+            module_name: str = entry.stem
+            try:
+                results.extend(find_deprecation_wrappers(module_name, recursive=False, include_members=include_members))
+            except SystemExit:
+                _print(f"Skipping {module_name}: module-level code exited (not a library module)", stderr=True)
+            except Exception as e:
+                _print(f"Could not scan {module_name}: {e}", stderr=True)
+    finally:
+        sys.argv = original_argv
+
+    nested_python_files_found: bool = any(
+        not fpy.name.startswith("__") for fpy in abs_path.rglob("*.py") if fpy.parent != abs_path
+    )
+
+    if nested_python_files_found:
+        _print(
+            "Skipping nested Python files in plain directory scan. Use an importable package layout with '__init__.py'"
+            " files, or scan an importable module/package path instead.",
+            stderr=True,
+        )
+    return results
+
+
+def _scan_path(path: str, recursive: bool = True, include_members: bool = True) -> list[DeprecationWrapperInfo]:
+    """Scan a directory or importable module/package name for deprecated wrappers.
+
+    File paths are not accepted because ``find_deprecation_wrappers()`` expects an importable module or package name,
+    not a filesystem path.
+
+    """
+    pth: Path = Path(path)
+    if pth.is_dir():
+        if _is_package_dir(pth):
+            # package dir: resolve importable name from directory stem
+            return find_deprecation_wrappers(
+                Path(path).resolve().name, recursive=recursive, include_members=include_members
+            )
+        # Flat src-layout or project root: find package in direct children or src/ subdir.
+        child_pkgs = _find_child_packages(pth)
+        if len(child_pkgs) == 1:
+            return _scan_path(str(child_pkgs[0]), recursive=recursive, include_members=include_members)
+        return _scan_directory(path, include_members=include_members)
+    if pth.is_file():
+        raise ValueError(
+            f"File paths are not supported: {path!r}. Pass an importable module/package name or a directory instead."
+        )
+    return find_deprecation_wrappers(path, recursive=recursive, include_members=include_members)
+
+
+# ---------------------------------------------------------------------------
+# Reporter — all rich/plain dispatch in one namespace
+# ---------------------------------------------------------------------------
+
+
+class _Reporter:
+    _HAS_RICH: bool = _is_package_available("rich")
+    _out: Any = None
+    _err: Any = None
+    _rich_box: Any = None
+    _RichTable: Any = None
+
+    try:
+        from rich import box as _rich_box_import
+        from rich.console import Console as _RichConsole
+        from rich.table import Table as _RichTable_import
+
+        _rich_box = _rich_box_import
+        _RichTable = _RichTable_import
+        _out = _RichConsole()
+        _err = _RichConsole(stderr=True)
+    except ImportError:  # pragma: no cover
+        pass
+
+    @staticmethod
+    def _console(stderr: bool = False) -> Any:  # noqa: ANN401
+        """Return the Rich Console for stdout (default) or stderr."""
+        return _Reporter._err if stderr else _Reporter._out
+
+    @staticmethod
+    def _make_table(title: str, col: str, *, title_style: str, col_style: str) -> Any:  # noqa: ANN401
+        """Build a three-column Module/Function/<col> Rich table."""
+        table = _Reporter._RichTable(title=title, box=_Reporter._rich_box.ROUNDED, title_style=title_style)
+        table.add_column("Module", style="cyan")
+        table.add_column("Function", style="magenta")
+        table.add_column(col, style=col_style)
+        return table
+
+    @staticmethod
+    def _render_table(
+        title: str,
+        col: str,
+        *,
+        title_style: str,
+        col_style: str,
+        rows: list[tuple[str, ...]],
+        plain_prefix: str,
+    ) -> None:
+        """Render a three-column Module/Function/Detail table (rich or plain fallback)."""
+        if _Reporter._HAS_RICH:
+            table = _Reporter._make_table(title, col, title_style=title_style, col_style=col_style)
+            for row in rows:
+                table.add_row(*row)
+            _Reporter._console().print(table)
+        else:
+            _print(f"\n{plain_prefix}")
+            for mod, fn, detail in rows:
+                _print(f"\t- {mod}.{fn}: {detail}")
+
+    @staticmethod
+    def invalid_args(items: list[DeprecationWrapperInfo]) -> None:
+        """Report wrappers with invalid ``args_mapping`` keys."""
+        _Reporter._render_table(
+            "Invalid Argument Mappings",
+            "Invalid Args",
+            title_style="bold red",
+            col_style="red",
+            rows=[(r.module, r.function, ", ".join(r.invalid_args)) for r in items],
+            plain_prefix="[ERROR] Found functions with invalid argument mappings:",
+        )
+
+    @staticmethod
+    def identity_args_mappings(items: list[DeprecationWrapperInfo]) -> None:
+        """Report wrappers whose ``args_mapping`` maps an argument to itself."""
+        _Reporter._render_table(
+            "Identity Argument Mappings (arg -> arg)",
+            "Identity Args",
+            title_style="bold yellow",
+            col_style="yellow",
+            rows=[(r.module, r.function, ", ".join(r.identity_args_mapping)) for r in items],
+            plain_prefix="[WARNING] Found functions with identity argument mappings (arg -> arg):",
+        )
+
+    @staticmethod
+    def no_effect(items: list[DeprecationWrapperInfo]) -> None:
+        """Report wrappers that have no observable effect on callers."""
+
+        def _reasons(r: DeprecationWrapperInfo) -> str:
+            """Format the no-effect reasons for a single wrapper as a comma-separated string."""
+            parts = []
+            if r.empty_args_mapping:
+                parts.append("Empty mapping")
+            if r.self_reference:
+                parts.append("Self reference")
+            if r.all_identity:
+                parts.append("All identity mappings")
+            return ", ".join(parts)
+
+        _Reporter._render_table(
+            "No-Effect Wrappers (zero impact)",
+            "Reason",
+            title_style="bold yellow",
+            col_style="yellow",
+            rows=[(r.module, r.function, _reasons(r)) for r in items],
+            plain_prefix="[WARNING] Found deprecated wrappers with NO EFFECT (zero impact):",
+        )
+
+    @staticmethod
+    def chains(items: list[DeprecationWrapperInfo], *, error: bool = False) -> None:
+        """Report deprecated-to-deprecated forwarding chains; ``error=True`` renders in red."""
+        style = "bold red" if error else "bold yellow"
+        col_style = "red" if error else "yellow"
+        prefix = "[ERROR]" if error else "[WARNING]"
+        _Reporter._render_table(
+            "Deprecation Chains",
+            "Chain Type",
+            title_style=style,
+            col_style=col_style,
+            rows=[(r.module, r.function, r.chain_type.value if r.chain_type is not None else "") for r in items],
+            plain_prefix=f"{prefix} Found deprecated wrappers forming deprecation chains:",
+        )
+
+    @staticmethod
+    def expiry(expired: list[str]) -> None:
+        """Report deprecated wrappers that have passed their ``remove_in`` deadline."""
+        if _Reporter._HAS_RICH:
+            table = _Reporter._RichTable(
+                title="Expired Deprecated Wrappers", box=_Reporter._rich_box.ROUNDED, title_style="bold red"
+            )
+            table.add_column("Message", style="red")
+            for msg in expired:
+                table.add_row(msg)
+            _Reporter._console().print(table)
+        else:
+            _print("\n[ERROR] Found expired deprecated wrappers:")
+            for msg in expired:
+                _print(f"\t- {msg}")
+
+    @staticmethod
+    def positional_only_args(items: list[DeprecationWrapperInfo]) -> None:
+        """Report wrappers whose ``args_mapping`` remaps a kwarg to a POSITIONAL_ONLY constructor parameter."""
+        _Reporter._render_table(
+            "Positional-Only Constructor Args in args_mapping",
+            "Positional-Only Args",
+            title_style="bold yellow",
+            col_style="yellow",
+            rows=[(r.module, r.function, ", ".join(r.args_mapping_positional_only)) for r in items],
+            plain_prefix=(
+                "[WARNING] Found args_mapping entries targeting POSITIONAL_ONLY constructor parameters"
+                " (proxy falls back to setattr for these entries):"
+            ),
+        )
+
+    @staticmethod
+    def issues(results: list[DeprecationWrapperInfo], *, error_on_chains: bool = False) -> bool:
+        """Print categorised diagnostics and return whether any issues were found."""
+        invalid_args = [r for r in results if r.invalid_args]
+        identity_args_mappings = [r for r in results if r.identity_args_mapping]
+        no_effect = [r for r in results if r.no_effect]
+        chains = [r for r in results if r.chain_type is not None]
+        positional_only = [r for r in results if r.args_mapping_positional_only]
+
+        if not (invalid_args or identity_args_mappings or no_effect or chains or positional_only):
+            return False
+
+        if invalid_args:
+            _Reporter.invalid_args(invalid_args)
+        if identity_args_mappings:
+            _Reporter.identity_args_mappings(identity_args_mappings)
+        if no_effect:
+            _Reporter.no_effect(no_effect)
+        if chains:
+            _Reporter.chains(chains, error=error_on_chains)
+        if positional_only:
+            _Reporter.positional_only_args(positional_only)
+
+        return True
+
+
+def _do_expiry(path: str, version: Optional[str], recursive: bool) -> Optional[list[str]]:
+    """Run the expiry scan and return expired wrapper messages, or None when packaging is unavailable.
+
+    Caller is responsible for setting up ``sys.path`` via :func:`_managed_sys_path` before calling.
+
+    Args:
+        path: Package directory path or importable module name string.
+        version: Current package version for comparison, or None to auto-detect.
+        recursive: Scan submodules recursively.
+
+    Returns:
+        List of expired wrapper message strings (may be empty), or None when the
+        ``packaging`` library is unavailable (advisory — warning already printed to stderr).
+
+    """
+    module_name = _resolve_module_name(path)
+    try:
+        return validate_deprecation_expiry(module_name, version, recursive=recursive)
+    except ImportError as exc:
+        if _is_missing_packaging_import_error(exc):
+            _print(
+                "The 'expiry' subcommand requires the 'packaging' library.\n"
+                "Install it with: `pip install 'pyDeprecate[audit]'`",
+                stderr=True,
+            )
+            return None
+        if getattr(exc, "name", None) is not None:
+            # Python's import system sets ``exc.name`` when a module-level ``import`` statement
+            # fails — this is a broken import inside the user's package, not a version-detection
+            # failure.  Propagate so the caller gets the real error instead of the misleading
+            # "Could not determine version" message.
+            raise
+        _print(
+            "Could not determine the current package version automatically.\n"
+            "Pass --version explicitly, or ensure the package is installed and importable.\n\n"
+            f"Original error: {exc}",
+            stderr=True,
+        )
+        return None
+    # other exceptions propagate to cli()'s top-level handler around fire.Fire
+
+
+def _is_missing_packaging_import_error(error: ImportError) -> bool:
+    """Return True when an ImportError was caused by a missing packaging dependency.
+
+    Args:
+        error: The ImportError raised while trying to inspect expiry information.
+
+    Returns:
+        True if the error indicates that the ``packaging`` library is unavailable.
+
+    """
+    for exc in (error, getattr(error, "__cause__", None)):
+        if exc is None:
+            continue
+        name = getattr(exc, "name", None)
+        if isinstance(name, str) and (name == "packaging" or name.startswith("packaging.")):
+            return True
+    return "No module named 'packaging'" in str(error)
+
+
+# ---------------------------------------------------------------------------
+# Subcommand functions
+# ---------------------------------------------------------------------------
+
+
+def _print_scan_header(path: str, version: Optional[str] = None, *, user_provided: bool = False) -> None:
+    """Print a consistent scan header: scanning location, package name, and version."""
+    module = _safe_module_name(path)
+    _print(f"Scanning: {path}")
+    if version is not None:
+        source = "user-provided" if user_provided else "auto-detected"
+        _print(f"Package: {module}  Version: {version} ({source})")
+    else:
+        _print(f"Package: {module}")
+
+
+def cmd_check(
+    path: str = ".",
+    recursive: bool = True,
+    exit_zero: bool = False,
+    *,
+    _wrappers: Optional[list[DeprecationWrapperInfo]] = None,
+) -> int:
+    """Scan Python code for misconfigured ``@deprecated`` wrappers and deprecation chains.
+
+    Reports invalid argument mappings (exit 1), identity mappings, no-effect wrappers,
+    deprecation chains, and ``args_mapping`` entries targeting POSITIONAL_ONLY constructor
+    parameters (all advisory warnings only, exit 0). Use the ``chains`` subcommand for a
+    dedicated hard-error chain check.
+
+    Args:
+        path: Path to the module, package directory, or importable module name to scan.
+        recursive: Scan submodules recursively (default True). Pass ``--norecursive`` to scan top-level only.
+        exit_zero: Always exit 0 even if hard errors (invalid argument mappings) are found.
+            Useful for advisory CI steps that should report but never block.
+        _wrappers: Pre-scanned wrapper list. When provided, skips the scan step. Underscore
+            prefix hides this parameter from the Fire CLI (internal use by ``cmd_all`` only).
+
+    Returns:
+        0 on success or advisory-only issues; 1 when hard errors are found and ``exit_zero`` is False.
+
+    """
+    if _wrappers is None:
+        _print_scan_header(path)
+        with _managed_sys_path(path):
+            _wrappers = _scan_path(path, recursive=recursive)
+
+    if not _wrappers:
+        _print("No deprecated callables found.")
+        return 0
+
+    if _Reporter.issues(_wrappers, error_on_chains=False):
+        _print("\nIssues were found in deprecated wrappers.")
+    else:
+        _print("\nAll deprecated wrappers look correct!")
+
+    has_invalid = any(r.invalid_args for r in _wrappers)
+    return 1 if not exit_zero and has_invalid else 0
+
+
+def cmd_expiry(
+    path: str = ".",
+    version: Optional[str] = None,
+    recursive: bool = True,
+    exit_zero: bool = False,
+    *,
+    _wrappers: Optional[list[DeprecationWrapperInfo]] = None,
+) -> int:
+    """Check for deprecated wrappers that have passed their scheduled removal version.
+
+    Requires the ``packaging`` library: ``pip install 'pyDeprecate[audit]'``.
+    A missing ``packaging`` library is treated as advisory (returns 0 with a warning).
+
+    Args:
+        path: Path to the module, package directory, or importable module name to scan.
+        version: Current package version for comparison (e.g. ``"2.0.0"``). Auto-detected
+            from installed package metadata if not provided.
+        recursive: Scan submodules recursively (default True). Pass ``--norecursive`` to scan top-level only.
+        exit_zero: Always exit 0 even if expired wrappers are found.
+            Useful for advisory CI steps that should report but never block.
+        _wrappers: Pre-scanned wrapper list. When provided, skips the scan step and derives
+            expired wrappers via ``_check_expiry_for_callables``. Requires *version* to be
+            non-``None`` when set. Underscore prefix hides this parameter from the Fire CLI
+            (internal use by ``cmd_all`` only).
+
+    Returns:
+        0 on success or when the ``packaging`` library is unavailable; 1 when expired
+        wrappers are found and ``exit_zero`` is False.
+
+    """
+    # Fire auto-converts numeric-looking strings (e.g. "1.0" → float); normalise to str.
+    if version is not None:
+        version = str(version)
+    if _wrappers is None:
+        # Standalone path: full scan + version auto-detect inside _do_expiry.
+        resolved_version = version if version is not None else _auto_detect_version(_safe_module_name(path), path=path)
+        if resolved_version is None and version is None:
+            _print(
+                "Could not resolve the current package version automatically and no --version was given; "
+                "the expiry check runs without a resolved version and its result may be unreliable. "
+                "Pass --version explicitly for a definitive check.",
+                stderr=True,
+            )
+        _print_scan_header(path, resolved_version, user_provided=version is not None)
+        with _managed_sys_path(path):
+            raw = _do_expiry(path, resolved_version, recursive)
+        if raw is None:  # packaging unavailable — warning already printed to stderr
+            return 0
+        expired = raw
+    else:
+        # Pre-scanned path: derive expired list from wrappers directly.
+        if version is None:
+            _print("Cannot check expiry: version not resolved. Pass --version explicitly.", stderr=True)
+            return 0
+        try:
+            expired = _check_expiry_for_callables(_wrappers, version)
+        except ImportError:
+            _print(
+                "The 'expiry' subcommand requires the 'packaging' library.\n"
+                "Install it with: `pip install 'pyDeprecate[audit]'`",
+                stderr=True,
+            )
+            return 0
+    if not expired:
+        _print("No expired deprecated wrappers found.")
+        return 0
+    _Reporter.expiry(expired)
+    _print(f"\n{len(expired)} expired wrapper(s) found.")
+    return 0 if exit_zero else 1
+
+
+def cmd_chains(
+    path: str = ".",
+    recursive: bool = True,
+    exit_zero: bool = False,
+    *,
+    _wrappers: Optional[list[DeprecationWrapperInfo]] = None,
+) -> int:
+    """Detect deprecated wrappers whose ``target`` is itself a deprecated callable (chains).
+
+    Two chain kinds are detected: ``target`` (forwarding chain to another deprecated
+    callable) and ``stacked`` (composed argument mappings that should be collapsed).
+
+    Args:
+        path: Path to the module, package directory, or importable module name to scan.
+        recursive: Scan submodules recursively (default True). Pass ``--norecursive`` to scan top-level only.
+        exit_zero: Always exit 0 even if chains are found.
+            Useful for advisory CI steps that should report but never block.
+        _wrappers: Pre-scanned wrapper list. When provided, skips the scan step and filters
+            for ``chain_type is not None`` internally. Underscore prefix hides this parameter
+            from the Fire CLI (internal use by ``cmd_all`` only).
+
+    Returns:
+        0 when no chains are found or ``exit_zero`` is True; 1 when chains are found.
+
+    """
+    if _wrappers is None:
+        _print_scan_header(path)
+        with _managed_sys_path(path):
+            _wrappers = validate_deprecation_chains(_resolve_module_name(path), recursive=recursive)
+    chains = [r for r in _wrappers if r.chain_type is not None]
+    if not chains:
+        _print("No deprecation chains found.")
+        return 0
+    _Reporter.chains(chains, error=True)
+    _print(f"\n{len(chains)} deprecation chain(s) found.")
+    return 0 if exit_zero else 1
+
+
+def cmd_all(
+    path: str = ".",
+    version: Optional[str] = None,
+    recursive: bool = True,
+    exit_zero: bool = False,
+) -> int:
+    """Run all three checks then append a deprecation table.
+
+    Performs a single scan pass and distributes the wrappers to ``cmd_check``,
+    ``cmd_expiry``, and ``cmd_chains`` so the filesystem is only traversed once.
+    After all three checks complete, ``cmd_status`` is always called to append a
+    compact markdown deprecation table to the output.
+    Version is auto-detected from installed package metadata when not provided.
+    A missing ``packaging`` library skips the expiry check with a warning and does not
+    count as a hard error.
+
+    Args:
+        path: Path to the module, package directory, or importable module name to scan.
+        version: Current package version for expiry comparison (e.g. ``"2.0.0"``).
+            Auto-detected from installed package metadata if not provided.
+        recursive: Scan submodules recursively (default True). Pass ``--norecursive`` to scan top-level only.
+        exit_zero: Always exit 0 even if issues are found.
+            Useful for advisory CI steps that should report but never block.
+
+    Returns:
+        0 when all checks pass or ``exit_zero`` is True; 1 when any hard error is found.
+        The deprecation table is always appended regardless of pass/fail outcome.
+
+    """
+    if version is not None:
+        version = str(version)
+    version_path = path if Path(path).exists() else None
+    resolved_version = (
+        version if version is not None else _auto_detect_version(_safe_module_name(path), path=version_path)
+    )
+    _print_scan_header(path, resolved_version, user_provided=version is not None)
+    with _managed_sys_path(path):
+        wrappers = _scan_path(path, recursive=recursive)
+
+    # Sub-commands run with exit_zero=False so cmd_all sees their truthful exit codes;
+    # the user-facing --exit-zero is applied to the aggregate below.
+    check_code = cmd_check(path, recursive=recursive, exit_zero=False, _wrappers=wrappers)
+    expiry_code = cmd_expiry(path, version=resolved_version, recursive=recursive, exit_zero=False, _wrappers=wrappers)
+    chains_code = cmd_chains(path, recursive=recursive, exit_zero=False, _wrappers=wrappers)
+
+    # The status table is a display artifact appended after the three gates. Render it defensively:
+    # a table-rendering failure must never change the aggregate exit code the three checks produced.
+    try:
+        cmd_status(path, version=resolved_version, recursive=recursive, _wrappers=wrappers)
+    except Exception as exc:
+        _print(f"Could not render the deprecation table: {exc}", stderr=True)
+
+    has_errors = bool(check_code or expiry_code or chains_code)
+    return 0 if not has_errors or exit_zero else 1
+
+
+def cmd_status(
+    path: str = ".",
+    version: Optional[str] = None,
+    recursive: bool = True,
+    style: str = "compact",
+    include_members: bool = True,
+    output: Optional[str] = None,
+    *,
+    _wrappers: Optional[list[DeprecationWrapperInfo]] = None,
+) -> int:
+    """Print a markdown deprecation status table to stdout.
+
+    Scans the target package for deprecated wrappers and renders their lifecycle
+    status as a Markdown table. Standalone — runs no checks, always exits 0.
+    When ``--output`` is given, the table is also written to that file.
+
+    Args:
+        path: Path to the module, package directory, or importable module name to scan.
+        version: Current package version for lifecycle status (e.g. ``"2.0.0"``).
+            Auto-detected from installed package metadata if not provided.
+        recursive: Scan submodules recursively (default True). Pass ``--norecursive`` to scan top-level only.
+        style: Table format — ``compact`` (default) or ``matrix``.
+        include_members: Include deprecated class members such as methods and constructors (default True).
+        output: Optional file path to write the markdown table. The table is always
+            printed to stdout regardless of this flag.
+
+    Returns:
+        Always 0 — status table generation is not a pass/fail gate.
+
+    """
+    if version is not None:
+        version = str(version)
+    try:
+        table_style = TableStyle(style)
+    except ValueError:
+        valid = ", ".join(s.value for s in TableStyle)
+        _print(f"Invalid style {style!r}; falling back to 'compact'. Expected one of: {valid}.", stderr=True)
+        table_style = TableStyle.COMPACT
+
+    # Never resolve the importable module name eagerly: status "always exits 0" (it is not a
+    # pass/fail gate), so a plain directory without ``__init__.py`` — which ``check`` scans fine and
+    # for which ``_wrappers`` is already supplied by ``cmd_all`` — must not raise here. ``_safe_module_name``
+    # falls back to the raw path, used only as table metadata for version resolution.
+    module_name = _safe_module_name(path)
+    resolved_version = version if version is not None else _auto_detect_version(module_name, path=path)
+    if _wrappers is None:
+        _print_scan_header(path, resolved_version, user_provided=version is not None)
+        with _managed_sys_path(path):
+            _wrappers = _scan_path(path, recursive=recursive, include_members=include_members)
+    markdown = generate_deprecation_table(
+        module_name,
+        current_version=resolved_version,
+        style=table_style,
+        _wrappers=_wrappers,
+    )
+
+    if _Reporter._HAS_RICH:
+        from rich.markdown import Markdown
+
+        _Reporter._console().print(Markdown(markdown))
+    else:
+        _print(markdown)
+
+    if output is not None:
+        out_path = Path(output)
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(markdown, encoding="utf-8")
+        _print(f"→ Saved to: {out_path}", stderr=True)
+
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# CLI entry point
+# ---------------------------------------------------------------------------
+
+
+def _ensure_utf8_streams() -> None:
+    """Reconfigure stdout/stderr to UTF-8 on platforms where the default encoding may reject non-ASCII characters.
+
+    On Windows the default console codec (``charmap``) cannot encode Unicode emoji used by
+    :class:`~deprecate.audit.DeprecationStatus`.  Calling ``reconfigure`` before any output is written ensures emoji
+    reach the terminal (or CI log) without a :exc:`UnicodeEncodeError`.
+
+    The call is a no-op when the streams are already UTF-8 or when they lack a ``reconfigure`` method (binary streams,
+    pytest capture wrappers).
+
+    """
+    for stream in (sys.stdout, sys.stderr):
+        # ``encoding`` may be *present but None* (e.g. some redirected/binary-ish wrappers); ``getattr`` with a
+        # default only covers a missing attribute, so guard the ``None`` case with ``or "utf-8"`` before ``.lower()``.
+        encoding = (getattr(stream, "encoding", None) or "utf-8").lower()
+        if hasattr(stream, "reconfigure") and encoding != "utf-8":
+            with contextlib.suppress(Exception):
+                stream.reconfigure(encoding="utf-8")
+
+
+def cli() -> None:
+    """CLI entry point for pydeprecate.
+
+    The subcommand's integer return value becomes the process exit code, applied *after* ``fire.Fire``
+    returns. Raising ``SystemExit`` from inside the Fire trace would abort Fire's own unconsumed-argument
+    check, silently ignoring unknown or misspelled flags (exit 0 on typos); letting the trace complete
+    makes Fire report ``Could not consume arg`` and exit 2 for such flags. Acts as the single top-level
+    exception handler: unhandled exceptions from subcommands are converted to a non-zero exit with the
+    exception type and message (the type prefix guarantees a non-blank stderr line even when the exception
+    carries no message). SystemExit (Fire's ``--help`` and error exits) passes through unchanged.
+
+    A path whose name collides with a subcommand (``check``, ``expiry``, ``chains``, ``all``, ``status``) is
+    treated as that subcommand by the implicit-``check`` shim. Scan such a path explicitly, e.g.
+    ``pydeprecate check ./check``, so the leading token is the subcommand and the path is its argument.
+
+    """
+    _ensure_utf8_streams()
+    try:
+        import fire
+    except ImportError:
+        sys.exit("The 'pydeprecate' CLI requires the 'fire' package.\nInstall it with: pip install 'pyDeprecate[cli]'")
+
+    subcommands = {"check", "expiry", "chains", "all", "status"}
+    argv = sys.argv[1:]
+    if argv and argv[0] not in subcommands and argv[0] not in {"-h", "--help"}:
+        argv = ["check", *argv]
+
+    exit_code: Optional[int] = None
+
+    def _capture(fn: Callable[..., int]) -> Callable[..., None]:
+        """Record the cmd_* return code without returning it into the Fire trace.
+
+        Returning the int would make Fire print it and treat it as a further component to consume arguments against;
+        returning ``None`` keeps the output clean and lets Fire finish its trace.
+
+        """
+
+        @functools.wraps(fn)
+        def wrapper(*args: object, **kwargs: object) -> None:
+            nonlocal exit_code
+            exit_code = fn(*args, **kwargs)
+
+        return wrapper
+
+    try:
+        fire.Fire(
+            {
+                "check": _capture(cmd_check),
+                "expiry": _capture(cmd_expiry),
+                "chains": _capture(cmd_chains),
+                "all": _capture(cmd_all),
+                "status": _capture(cmd_status),
+            },
+            command=argv,
+        )
+    except Exception as exc:  # SystemExit is BaseException — Fire's own exits pass through untouched
+        # Prefix the exception type so an exception with an empty message still produces a non-blank stderr
+        # line (bare ``str(exc)`` on such exceptions exited 1 with nothing printed).
+        sys.exit(f"{type(exc).__name__}: {exc}")
+    # exit_code stays None when no subcommand ran (bare `pydeprecate` help) → return normally (exit 0).
+    if exit_code is not None:
+        sys.exit(exit_code)

.venv/lib/python3.12/site-packages/deprecate/_pkg.py

@@ -0,0 +1,348 @@
+"""Package and filesystem helpers for pyDeprecate's CLI.
+
+Internal utilities that resolve a package's version, locate package directories, and manage ``sys.path`` for scanning.
+
+Version resolution uses a local ``pyproject.toml`` (development checkout) when available, falling back to installed
+distribution metadata via ``importlib.metadata``.
+
+TOML parsing uses ``tomllib`` (stdlib on Python 3.11+) or ``tomli`` (backport, via ``pip install 'pyDeprecate[audit]'``
+on Python 3.9-3.10). When not available the helpers return ``None`` and callers fall back to ``importlib.metadata``.
+
+This module is private (no ``__all__``); its surface may change without notice.
+
+"""
+
+import importlib
+import importlib.metadata
+import os
+import sys
+import warnings
+from collections.abc import Generator
+from contextlib import contextmanager, suppress
+from pathlib import Path
+from typing import Any, Optional
+
+
+def _load_toml(path: str) -> dict[str, Any]:
+    r"""Load a TOML file using ``tomllib`` (Python 3.11+) or ``tomli`` (Python 3.10 backport).
+
+    Returns an empty dict on any failure (missing library, parse error, IO).
+
+    Examples:
+        >>> import os, tempfile
+        >>> with tempfile.NamedTemporaryFile(suffix=".toml", mode="w", delete=False) as f:
+        ...     _ = f.write('[project]\nname = "mypkg"\nversion = "1.2.3"\n')
+        ...     name = f.name
+        >>> _load_toml(name).get("project", {}).get("version")
+        '1.2.3'
+        >>> os.unlink(name)
+
+    """
+    try:
+        try:
+            import tomllib
+        except ImportError:
+            import tomli as tomllib  # Python 3.10 backport
+
+        with open(path, "rb") as fh:
+            return dict(tomllib.load(fh))
+    except Exception:
+        return {}
+
+
+def _version_from_dynamic(pkg_name: str, scan_path: str, pyproject_dir: str) -> Optional[str]:
+    """Import *pkg_name* and return its ``__version__``, or ``None`` on any failure.
+
+    Adds candidate import roots (scan dir, its parent, pyproject dir, ``src/``
+    sub-dir) to ``sys.path`` before importing, then restores the original
+    ``sys.path`` unconditionally via ``finally``.
+
+    Args:
+        pkg_name: Importable package name declared in ``[project].name``.
+        scan_path: File-system path originally passed to the CLI (used to
+            locate the package root).
+        pyproject_dir: Directory containing the ``pyproject.toml`` file.
+
+    Returns:
+        Version string from ``pkg.__version__`` or ``None``.
+
+    """
+    scan_root = os.path.abspath(scan_path) if os.path.isdir(scan_path) else os.path.dirname(os.path.abspath(scan_path))
+    original = list(sys.path)
+    added: list[str] = []
+    for root in (scan_root, os.path.dirname(scan_root), pyproject_dir, os.path.join(pyproject_dir, "src")):
+        if root and os.path.isdir(root) and root not in added:
+            added.append(root)
+            sys.path.insert(0, root)
+    try:
+        module = importlib.import_module(pkg_name)
+        version = getattr(module, "__version__", None)
+        return version if isinstance(version, str) else None
+    except Exception:
+        return None
+    finally:
+        sys.path[:] = original
+
+
+def _version_from_toml(toml_path: str, scan_path: str) -> Optional[str]:
+    """Extract ``[project].version`` from *toml_path*, or ``None``.
+
+    Falls back to importing the package for ``dynamic = ["version"]`` projects.
+
+    Args:
+        toml_path: Absolute path to a ``pyproject.toml`` file.
+        scan_path: Original file-system path passed to the CLI (forwarded to
+            :func:`_version_from_dynamic` for import-root resolution).
+
+    Returns:
+        Version string or ``None`` when not resolvable.
+
+    """
+    data = _load_toml(toml_path)
+    project = data.get("project", {})
+    if not project:
+        return None
+
+    version = project.get("version")
+    if isinstance(version, str):
+        return version
+
+    if "version" in project.get("dynamic", []):
+        pkg_name = project.get("name")
+        if isinstance(pkg_name, str) and pkg_name:
+            return _version_from_dynamic(pkg_name, scan_path, os.path.dirname(toml_path))
+
+    return None
+
+
+def _read_pyproject_version(path: str) -> Optional[str]:
+    """Return ``[project].version`` from the nearest ``pyproject.toml`` up to 2 levels above *path*.
+
+    Searches the directory itself, its parent, and its grandparent — stops
+    as soon as a resolvable version is found or the limit is reached.
+
+    Args:
+        path: File-system path to start the upward search from.
+
+    Returns:
+        Version string or ``None`` when not found within 2 levels.
+
+    """
+    candidate = os.path.abspath(path)
+    if not os.path.isdir(candidate):
+        candidate = os.path.dirname(candidate)
+    for _ in range(3):  # current dir + 2 levels up
+        toml_path = os.path.join(candidate, "pyproject.toml")
+        if os.path.isfile(toml_path):
+            version = _version_from_toml(toml_path, path)
+            if version is not None:
+                return version
+        parent = os.path.dirname(candidate)
+        if parent == candidate:
+            break
+        candidate = parent
+    return None
+
+
+def _auto_detect_version(module_name: str, path: Optional[str] = None) -> Optional[str]:
+    """Return the version for *module_name*, or ``None`` on any failure.
+
+    Priority order:
+
+    1. ``[project].version`` in the nearest ``pyproject.toml`` above *path* (reflects
+       local development checkouts whose version may differ from the installed dist).
+    2. ``importlib.metadata.version(module_name)`` — the installed distribution.
+
+    Args:
+        module_name: Importable package name whose installed version to look up.
+        path: Optional file-system path used to locate a local ``pyproject.toml``.
+            Only consulted when it actually exists on the filesystem; an importable
+            module *name* passed through here is ignored, because the walk-up from the
+            current working directory would otherwise pick up an unrelated project's
+            ``pyproject.toml`` version. When honored, the local file takes precedence
+            over installed metadata.
+
+    Returns:
+        Version string (e.g. ``"1.2.3"``) or ``None`` when the package is not
+        installed or the version cannot be determined.
+
+    """
+    # Guard: a bare module name (not an existing path) must not trigger the pyproject.toml
+    # walk-up — starting from cwd it would grab whatever unrelated project the caller is
+    # standing in, flipping expiry gates on a foreign version.
+    if path is not None and os.path.exists(path):
+        local_ver = _read_pyproject_version(path)
+        if local_ver is not None:
+            return local_ver
+    with suppress(Exception):
+        return importlib.metadata.version(module_name)
+    # The import name (deprecate, PIL, sklearn) often differs from the distribution name
+    # (pyDeprecate, Pillow, scikit-learn) that importlib.metadata.version() requires. Map the
+    # import package to its distribution and retry before giving up.
+    dist_name = _distribution_for_import(module_name)
+    if dist_name is not None:
+        try:
+            return importlib.metadata.version(dist_name)
+        except Exception:
+            return None
+    return None
+
+
+def _distribution_for_import(import_name: str) -> Optional[str]:
+    """Map a top-level import package name to its installed distribution name.
+
+    ``importlib.metadata.version`` needs the *distribution* name (``pyDeprecate``) while the CLI is
+    handed the *import* name (``deprecate``). Uses ``importlib.metadata.packages_distributions`` on
+    Python 3.11+ and falls back to scanning each distribution's ``top_level.txt`` on Python <3.11.
+
+    Args:
+        import_name: Importable (possibly dotted) package name; only the first component is used.
+
+    Returns:
+        The first distribution name that provides the top-level package, or ``None`` when no
+        installed distribution exposes it.
+
+    """
+    top_level = import_name.split(".")[0]
+    packages_distributions = getattr(importlib.metadata, "packages_distributions", None)
+    if callable(packages_distributions):
+        try:
+            distributions = packages_distributions().get(top_level)
+        except Exception:
+            return None
+        return distributions[0] if distributions else None
+    # Python <3.11: packages_distributions is unavailable — read top_level.txt from each distribution.
+    return _distribution_from_top_level(top_level)
+
+
+def _distribution_from_top_level(top_level: str) -> Optional[str]:
+    """Return the distribution whose ``top_level.txt`` lists *top_level* (Python <3.11 fallback)."""
+    try:
+        distributions = list(importlib.metadata.distributions())
+    except Exception:
+        return None
+    for dist in distributions:
+        try:
+            listed = dist.read_text("top_level.txt")
+        except Exception:
+            listed = None
+        if listed and top_level in listed.split():
+            try:
+                name = dist.metadata["Name"]
+            except KeyError:
+                continue
+            if name:
+                return name
+    return None
+
+
+def _is_package_dir(pth: Path) -> bool:
+    """Return True if *pth* is an importable package directory (contains ``__init__.py``)."""
+    return (pth / "__init__.py").exists()
+
+
+def _find_child_packages(pth: Path) -> list[Path]:
+    """Return package sub-directories of *pth*, checking ``src/`` when none found directly.
+
+    Resolution order:
+    1. Immediate child directories of ``pth/src/`` that contain ``__init__.py``
+       (standard ``src/``-layout projects take precedence).
+    2. If none, immediate child directories of *pth* that contain ``__init__.py``.
+
+    Args:
+        pth: Directory to search.
+
+    Returns:
+        List of :class:`~pathlib.Path` objects for each package directory found.
+
+    """
+    src_dir = pth / "src"
+    if src_dir.is_dir():
+        in_src = [c for c in src_dir.iterdir() if c.is_dir() and _is_package_dir(c)]
+        if in_src:
+            return in_src
+    return [c for c in pth.iterdir() if c.is_dir() and _is_package_dir(c)]
+
+
+@contextmanager
+def _managed_sys_path(path: str) -> Generator[None, None, None]:
+    """Context manager that prepends the import root to ``sys.path`` and restores it after scanning.
+
+    For package directories (containing ``__init__.py``), inserts the parent directory so the package name resolves as
+    an importable module. For plain directories, inserts the directory itself. Importable module name strings are passed
+    through unchanged.
+
+    Warning:
+        Not thread-safe. ``sys.path`` is a process-global list; concurrent use from multiple threads will corrupt
+        the restored state. Each scan should run in a dedicated process or be serialized via a lock.
+
+    """
+    abs_path: Path = Path(path).resolve()
+    original = list(sys.path)
+    if abs_path.is_dir():
+        if _is_package_dir(abs_path):
+            import_root = str(abs_path.parent)
+        else:
+            src_dir = abs_path / "src"
+            in_src = src_dir.is_dir() and any(c.is_dir() and _is_package_dir(c) for c in src_dir.iterdir())
+            import_root = str(src_dir) if in_src else str(abs_path)
+        sys.path.insert(0, import_root)
+    try:
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=DeprecationWarning, module="deprecate.*")
+            warnings.filterwarnings("ignore", category=FutureWarning, module="deprecate.*")
+            yield
+    finally:
+        sys.path[:] = original
+
+
+def _resolve_module_name(path: str) -> str:
+    """Convert a filesystem path to an importable module name.
+
+    Accepts a package directory (with ``__init__.py``) or an importable module
+    name string. Plain directories and individual ``.py`` files are not supported
+    because ``validate_deprecation_expiry`` and ``validate_deprecation_chains``
+    require an importable module name, not a filesystem path.
+
+    Args:
+        path: Package directory path or importable module name string.
+
+    Returns:
+        Importable module name string.
+
+    Raises:
+        ValueError: If path is a plain directory without ``__init__.py``, a ``.py``
+            file, or cannot be resolved to an importable module name.
+
+    """
+    pth = Path(path)
+    if pth.is_file():
+        raise ValueError(
+            f"File paths are not supported: {path!r}. Pass an importable module/package name or a directory instead."
+        )
+    if pth.is_dir():
+        if _is_package_dir(pth):
+            return pth.resolve().name
+        # Flat src-layout or project root: find package in direct children or src/ subdir.
+        child_pkgs = _find_child_packages(pth)
+        if len(child_pkgs) == 1:
+            return child_pkgs[0].name
+        if len(child_pkgs) > 1:
+            names = ", ".join(sorted(c.name for c in child_pkgs))
+            raise ValueError(
+                f"Directory {path!r} contains multiple packages ({names}). "
+                "Pass the specific package sub-directory instead."
+            )
+        raise ValueError(
+            f"Plain directories without '__init__.py' are not supported for expiry or chain checks: {path!r}. "
+            "Use an importable package layout with '__init__.py', or pass an importable module name instead."
+        )
+    return path
+
+
+def _safe_module_name(path: str) -> str:
+    """Return the importable module name for *path*, falling back to *path* itself."""
+    try:
+        return _resolve_module_name(path)
+    except ValueError:
+        return path

.venv/lib/python3.12/site-packages/deprecate/_types.py

@@ -0,0 +1,664 @@
+"""Shared type definitions for pyDeprecate.
+
+This module provides typed interfaces consumed by the decorator, proxy, and audit modules so that static analysers can
+catch schema mismatches at analysis time rather than silently returning ``None`` at runtime.
+
+"""
+
+import copy
+import threading
+import warnings
+from collections.abc import Mapping
+from dataclasses import dataclass, field, replace
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Callable, Literal, Optional, Protocol, Union, runtime_checkable
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeGuard
+
+
+class TargetMode(Enum):
+    """Selects ``@deprecated`` behaviour when no callable replacement is provided.
+
+    Attributes:
+        NOTIFY: Notify-only deprecation -- warn on every call; original body executes unchanged. Replaces
+            ``target=None``. Passing ``args_mapping`` or ``args_extra`` with this mode emits a :class:`UserWarning`
+            today; :class:`TypeError` is planned in ``v1.0``.
+        ARGS_REMAP: Deprecate argument names only -- warn only when deprecated argument names are passed; remaps
+            kwargs via ``args_mapping`` before calling the original body. Replaces ``target=True``. This mode is
+            strongly recommended with ``args_mapping``; omitting it emits a :class:`UserWarning` today, and
+            :class:`TypeError` is planned in ``v1.0``.
+        ATTRS_REMAP: Selective per-attribute deprecation -- warn only when a deprecated attribute alias listed in
+            ``attrs_mapping`` is accessed; all other attribute access is forwarded silently. Proxy-specific mode:
+            only valid for :func:`~deprecate.proxy.deprecated_class`; raises :class:`TypeError` on
+            :func:`~deprecate.deprecated` decorated functions/methods. Analogous to :attr:`ARGS_REMAP` but for
+            attribute access instead of call arguments. This mode is selected automatically when ``attrs_mapping``
+            is non-empty and no explicit ``target`` is provided.
+
+    Examples:
+        >>> from deprecate import TargetMode
+        >>> TargetMode.NOTIFY.value
+        'notify'
+        >>> TargetMode.ARGS_REMAP.value
+        'args_remap'
+        >>> TargetMode.ATTRS_REMAP.value
+        'attrs_remap'
+
+    """
+
+    NOTIFY = "notify"
+    ARGS_REMAP = "args_remap"
+    ATTRS_REMAP = "attrs_remap"
+
+    @classmethod
+    def _from_legacy(
+        cls,
+        target: Union[None, bool],
+        *,
+        stacklevel: Optional[int] = 3,
+    ) -> "TargetMode":
+        """Convert ``target`` sentinel (``None`` / ``True`` / ``False``) to :class:`~deprecate._types.TargetMode`.
+
+        Backwards-compatibility shim for the :func:`~deprecate.deprecated` decorator.  Each sentinel is mapped to its
+        modern equivalent and a deprecation warning is emitted.  Pass ``stacklevel=None`` to suppress all warnings.
+
+        Args:
+            target: Legacy sentinel — ``None`` → :attr:`~deprecate._types.TargetMode.NOTIFY`,
+                ``True`` → :attr:`~deprecate._types.TargetMode.ARGS_REMAP`,
+                ``False`` → :attr:`~deprecate._types.TargetMode.NOTIFY` (not a valid mode; :class:`TypeError` in v1.0).
+            stacklevel: Stack level forwarded to :func:`warnings.warn`.  Pass ``None`` to suppress all warnings
+                entirely.  Defaults to ``3``.
+
+        Returns:
+            The corresponding :class:`~deprecate._types.TargetMode` member.
+
+        Raises:
+            TypeError: If ``target`` is anything other than ``None``, ``True``, or ``False``.
+
+        Examples:
+            >>> TargetMode._from_legacy(None, stacklevel=None)
+            <TargetMode.NOTIFY: 'notify'>
+            >>> TargetMode._from_legacy(True, stacklevel=None)
+            <TargetMode.ARGS_REMAP: 'args_remap'>
+            >>> TargetMode._from_legacy(False, stacklevel=None)
+            <TargetMode.NOTIFY: 'notify'>
+
+        """
+        if target is None:
+            if stacklevel is not None:
+                warnings.warn(
+                    "target=None is deprecated since `v0.8`; use `TargetMode.NOTIFY` instead."
+                    " Will be removed in `v1.0`.",
+                    FutureWarning,
+                    stacklevel=stacklevel,
+                )
+            return cls.NOTIFY
+        if target is True:
+            if stacklevel is not None:
+                warnings.warn(
+                    "target=True is deprecated since `v0.8`; use `TargetMode.ARGS_REMAP` instead."
+                    " Will be removed in `v1.0`.",
+                    FutureWarning,
+                    stacklevel=stacklevel,
+                )
+            return cls.ARGS_REMAP
+        if target is False:
+            if stacklevel is not None:
+                warnings.warn(
+                    "`target=False` is not a valid deprecation mode and will be treated as `TargetMode.NOTIFY`."
+                    " This will be `TypeError` in `v1.0`.",
+                    UserWarning,
+                    stacklevel=stacklevel,
+                )
+            return cls.NOTIFY
+        raise TypeError(
+            f"`TargetMode._from_legacy` accepts only None, True, or False; got {type(target).__name__}: {target!r}."
+        )
+
+    @classmethod
+    def _from_legacy_proxy(
+        cls,
+        target: Any,  # noqa: ANN401
+        *,
+        args_mapping: Optional[Mapping[str, Optional[str]]] = None,
+        stacklevel: Optional[int] = 3,
+    ) -> "Union[Callable[..., Any], TargetMode, None]":
+        """Normalise a proxy-specific legacy ``target`` sentinel for :func:`~deprecate.proxy.deprecated_class`.
+
+        ``True`` and ``False`` are invalid for the proxy context and normalise to
+        :attr:`~deprecate._types.TargetMode.NOTIFY`
+        (or :attr:`~deprecate._types.TargetMode.ARGS_REMAP` when ``args_mapping`` is non-empty)
+        after emitting a warning.
+        All other values pass through unchanged.  Pass ``stacklevel=None`` to suppress warnings.
+
+        Args:
+            target: Raw ``target`` value from the caller.  Only ``True`` and ``False`` trigger normalisation;
+                any other value is returned as-is.
+            args_mapping: The ``args_mapping`` dict supplied to :func:`~deprecate.deprecated_class`, or ``None`` when
+                not provided. When ``target=True`` and ``args_mapping`` is non-empty the result is
+                :attr:`~deprecate._types.TargetMode.ARGS_REMAP` instead of
+                :attr:`~deprecate._types.TargetMode.NOTIFY`, and a :class:`FutureWarning` is emitted.
+            stacklevel: Stack level forwarded to :func:`warnings.warn`.  Pass ``None`` to suppress all warnings.
+                Defaults to ``3``.
+
+        Returns:
+            :attr:`~deprecate._types.TargetMode.ARGS_REMAP` when ``target=True`` and ``args_mapping`` is non-empty;
+            :attr:`~deprecate._types.TargetMode.NOTIFY` when ``target`` was ``True`` (without ``args_mapping``) or
+            ``False``; otherwise ``target`` unchanged.
+
+        Examples:
+            >>> TargetMode._from_legacy_proxy(True, stacklevel=None)
+            <TargetMode.NOTIFY: 'notify'>
+            >>> TargetMode._from_legacy_proxy(True, args_mapping={"old": "new"}, stacklevel=None)
+            <TargetMode.ARGS_REMAP: 'args_remap'>
+            >>> TargetMode._from_legacy_proxy(False, stacklevel=None)
+            <TargetMode.NOTIFY: 'notify'>
+            >>> TargetMode._from_legacy_proxy(None) is None
+            True
+            >>> TargetMode._from_legacy_proxy(TargetMode.NOTIFY)
+            <TargetMode.NOTIFY: 'notify'>
+
+        """
+        if target is True:
+            if args_mapping:
+                if stacklevel is not None:
+                    warnings.warn(
+                        "`target=True` with `args_mapping` will resolve to `TargetMode.ARGS_REMAP`."
+                        " Will be `TypeError` in `v1.0`.",
+                        FutureWarning,
+                        stacklevel=stacklevel,
+                    )
+                return cls.ARGS_REMAP
+            if stacklevel is not None:
+                warnings.warn(
+                    "`target=True` without `args_mapping` resolves to `TargetMode.NOTIFY`"
+                    " (warns on every access). Will be `TypeError` in `v1.0`.",
+                    FutureWarning,
+                    stacklevel=stacklevel,
+                )
+            return cls.NOTIFY
+        if target is False:
+            if stacklevel is not None:
+                warnings.warn(
+                    "`target=False` is not valid for `deprecated_class()`. Will be `TypeError` in `v1.0`.",
+                    UserWarning,
+                    stacklevel=stacklevel,
+                )
+            return cls.NOTIFY
+        return target
+
+    @classmethod
+    def _validate(
+        cls,
+        mode: "TargetMode",
+        source_name: str,
+        args_mapping: Optional[Mapping[str, Optional[str]]] = None,
+        args_extra: Optional[dict[str, Any]] = None,
+        *,
+        stacklevel: Optional[int] = 2,
+    ) -> bool:
+        """Validate :class:`~deprecate._types.TargetMode` against supplied configuration and emit misconfig warnings.
+
+        Checks three misconfiguration combinations and emits a :class:`UserWarning` for each one found.
+        These warnings will become :class:`TypeError` in ``v1.0``.
+
+        Misconfiguration warnings are always emitted via :func:`warnings.warn` with ``UserWarning`` — they are
+        construction-time guards independent of the runtime ``stream`` callable used for deprecation notices.
+
+        Args:
+            mode: The resolved :class:`~deprecate._types.TargetMode` to validate.
+            source_name: ``__name__`` of the decorated source callable, used in warning messages.
+            args_mapping: The ``args_mapping`` dict supplied to :func:`~deprecate.deprecated`, or ``None`` when not
+                provided.
+            args_extra: The ``args_extra`` dict supplied to :func:`~deprecate.deprecated`, or ``None`` when not
+                provided.
+            stacklevel: Stack level forwarded to :func:`warnings.warn` so that reported locations point at the
+                decorator application site.  Pass ``None`` to suppress all warnings.  Defaults to ``2``.
+
+        Returns:
+            ``True`` if any misconfiguration was detected, ``False`` if the configuration is valid.
+
+        Examples:
+            >>> TargetMode._validate(TargetMode.ARGS_REMAP, "my_func", args_mapping=None, stacklevel=None)
+            True
+            >>> TargetMode._validate(TargetMode.NOTIFY, "my_func", args_mapping={"old": "new"}, stacklevel=None)
+            True
+            >>> TargetMode._validate(TargetMode.NOTIFY, "my_func", args_extra={"bias": 1}, stacklevel=None)
+            True
+            >>> TargetMode._validate(TargetMode.NOTIFY, "my_func", stacklevel=None)
+            False
+
+        """
+        messages = []
+        if mode is cls.ARGS_REMAP and not args_mapping:
+            messages.append(
+                f"`@deprecated(target=TargetMode.ARGS_REMAP)` on `{source_name}` requires "
+                "`args_mapping` to specify which arguments are being renamed. Without it the "
+                "decorator has zero effect. This will be `TypeError` in `v1.0`."
+            )
+        if mode is cls.NOTIFY and args_mapping:
+            messages.append(
+                f"`@deprecated(target=TargetMode.NOTIFY)` on `{source_name}` ignores "
+                "`args_mapping`. Use `TargetMode.ARGS_REMAP` to rename arguments, or pass a "
+                "callable target to forward the call. This will be `TypeError` in `v1.0`."
+            )
+        if mode is cls.NOTIFY and args_extra:
+            messages.append(
+                f"`@deprecated(target=TargetMode.NOTIFY)` on `{source_name}` ignores "
+                "`args_extra`. Use a callable target to forward with extra arguments. "
+                "This will be `TypeError` in `v1.0`."
+            )
+        if stacklevel is not None:
+            for msg in messages:
+                warnings.warn(msg, UserWarning, stacklevel=stacklevel)
+        return bool(messages)
+
+    @classmethod
+    def _validate_proxy(
+        cls,
+        mode: "Union[TargetMode, Callable[..., Any], None]",
+        source_name: str,
+        attrs_mapping: Optional[Mapping[str, Optional[str]]] = None,
+        args_mapping: Optional[Mapping[str, Optional[str]]] = None,
+        args_extra: Optional[dict[str, Any]] = None,
+        *,
+        stacklevel: Optional[int] = 2,
+    ) -> bool:
+        """Validate proxy-specific configuration: ``attrs_mapping`` combinations.
+
+        Catches misconfiguration pairs involving ``attrs_mapping`` that the existing
+        :meth:`~deprecate._types.TargetMode._validate` does not cover (it handles only ``args_mapping`` /
+        ``args_extra`` and is used by the function-decorator path as well).
+
+        Misconfiguration warnings will become :class:`TypeError` in ``v1.0``.
+
+        Args:
+            mode: Resolved target (:class:`~deprecate._types.TargetMode` member, callable, or ``None``).
+            source_name: ``__name__`` of the decorated class, for warning messages.
+            attrs_mapping: The ``attrs_mapping`` dict passed to :func:`~deprecate.proxy.deprecated_class`, or
+                ``None``.
+            args_mapping: The ``args_mapping`` dict, forwarded here so we can detect the
+                ``ATTRS_REMAP + args_mapping`` combination.
+            args_extra: The ``args_extra`` dict, forwarded here so we can detect the
+                ``ATTRS_REMAP + args_extra`` combination — ``ATTRS_REMAP`` governs attribute access only and
+                does not honour call-time kwarg injection.
+            stacklevel: Forwarded to :func:`warnings.warn`. Pass ``None`` to suppress warnings. Defaults to ``2``.
+
+        Returns:
+            ``True`` if any misconfiguration was detected, ``False`` otherwise.
+
+        Examples:
+            >>> TargetMode._validate_proxy(TargetMode.NOTIFY, "Cls", attrs_mapping={"a": "b"}, stacklevel=None)
+            True
+            >>> TargetMode._validate_proxy(TargetMode.ATTRS_REMAP, "Cls", attrs_mapping=None, stacklevel=None)
+            True
+            >>> TargetMode._validate_proxy(TargetMode.ATTRS_REMAP, "Cls", attrs_mapping={}, stacklevel=None)
+            True
+            >>> TargetMode._validate_proxy(TargetMode.ATTRS_REMAP, "Cls", attrs_mapping={"a": "b"}, stacklevel=None)
+            False
+            >>> TargetMode._validate_proxy(
+            ...     TargetMode.ARGS_REMAP, "Cls",
+            ...     args_mapping={"old": "new"}, attrs_mapping={"a": "b"}, stacklevel=None,
+            ... )
+            True
+            >>> TargetMode._validate_proxy(
+            ...     TargetMode.ATTRS_REMAP, "Cls",
+            ...     args_mapping={"old": "new"}, attrs_mapping={"a": "b"}, stacklevel=None,
+            ... )
+            True
+            >>> TargetMode._validate_proxy(
+            ...     TargetMode.ATTRS_REMAP, "Cls",
+            ...     attrs_mapping={"a": "b"}, args_extra={"bias": 1}, stacklevel=None,
+            ... )
+            True
+
+        """
+        messages = []
+        if mode is cls.NOTIFY and attrs_mapping:
+            messages.append(
+                f"`deprecated_class(target=TargetMode.NOTIFY)` on `{source_name}` ignores "
+                "`attrs_mapping`. Drop one of them: `attrs_mapping` switches to selective per-attribute "
+                "warning, which contradicts NOTIFY's warn-on-every-access semantics. "
+                "This will be `TypeError` in `v1.0`."
+            )
+        if mode is cls.ARGS_REMAP and args_mapping and attrs_mapping:
+            messages.append(
+                f"`deprecated_class` on `{source_name}` has both `args_mapping` and `attrs_mapping` "
+                "configured with `target=TargetMode.ARGS_REMAP`. `ARGS_REMAP` governs call-time argument "
+                "renames only; `attrs_mapping` is inactive in this mode. "
+                "`DeprecationConfig.target` no longer reflects that `attrs_mapping` is also active. "
+                "Pass an explicit callable `target=<class>` to activate both mappings on the same proxy. "
+                "This will be `TypeError` in `v1.0`."
+            )
+        if mode is cls.ATTRS_REMAP and not attrs_mapping:
+            messages.append(
+                f"`deprecated_class(target=TargetMode.ATTRS_REMAP)` on `{source_name}` requires "
+                "`attrs_mapping` to specify which attribute names are deprecated. Without it the "
+                "proxy has zero selective effect. This will be `TypeError` in `v1.0`."
+            )
+        if mode is cls.ATTRS_REMAP and args_mapping:
+            messages.append(
+                f"`deprecated_class(target=TargetMode.ATTRS_REMAP)` on `{source_name}` ignores `args_mapping`. "
+                "`ATTRS_REMAP` only governs attribute access; argument renames on `__call__` are not applied. "
+                "Use `target=<class>` (with both mappings) or `TargetMode.ARGS_REMAP` (with `args_mapping` only). "
+                "This will be `TypeError` in `v1.0`."
+            )
+        if mode is cls.ATTRS_REMAP and args_extra:
+            messages.append(
+                f"`deprecated_class(target=TargetMode.ATTRS_REMAP)` on `{source_name}` ignores `args_extra`. "
+                "`ATTRS_REMAP` only governs attribute access; call-time kwarg injection is not applied. "
+                "Use `target=<class>` to forward calls with extra arguments. "
+                "This will be `TypeError` in `v1.0`."
+            )
+        if attrs_mapping is not None and len(attrs_mapping) == 0:
+            messages.append(
+                f"`deprecated_class` on `{source_name}` received `attrs_mapping={{}}` (empty dict). "
+                "An empty mapping has no effect — remove it or add deprecated attribute names. "
+                "This will be `TypeError` in `v1.0`."
+            )
+        if stacklevel is not None:
+            for msg in messages:
+                warnings.warn(msg, UserWarning, stacklevel=stacklevel)
+        return bool(messages)
+
+
+@dataclass(frozen=True)
+class DeprecationConfig:
+    """Static deprecation metadata attached to deprecated callables as ``__deprecated__``.
+
+    All fields are always set — both :func:`~deprecate.deprecated`-decorated functions and
+    :class:`~deprecate.proxy._DeprecatedProxy` objects use this unified schema.
+
+    Attributes:
+        deprecated_in: Version string when the callable was deprecated.
+        remove_in: Version string when the callable will be removed.
+        name: Display the name of the deprecated source (function or class name).
+        target: Normalised target — ``None`` (default), :attr:`~deprecate._types.TargetMode.NOTIFY`,
+            :attr:`~deprecate._types.TargetMode.ARGS_REMAP`, :attr:`~deprecate._types.TargetMode.ATTRS_REMAP`,
+            or a callable. Legacy sentinels (``True``/``False``) are normalised at decoration time and never
+            stored verbatim.
+        args_extra: Optional kwargs injected into forwarded calls; stored for audit visibility.
+        misconfigured: ``True`` when an invalid raw target sentinel (``False``) was passed at decoration time.
+            Audit tools surface this via
+            :attr:`~deprecate.audit.DeprecationWrapperInfo.misconfigured_target`.
+        docstring_style: Docstring notice output style when ``update_docstring=True``.
+        template_mgs: Optional custom warning-message template (``%``-style placeholders) that overrides the built-in
+            templates at warn time. ``None`` (default) keeps the built-in template selected for the active scenario.
+            Audit tools may surface this for introspection. See :func:`~deprecate.deprecation.deprecated` for the
+            available placeholders (e.g. ``%(source_name)s``, ``%(target_path)s``, ``%(deprecated_in)s``).
+        attrs_mapping: Optional mapping of deprecated attribute names to their canonical replacement names (or
+            ``None`` for warn-only).  Set by :func:`~deprecate.proxy.deprecated_class` when
+            selective per-attribute deprecation is enabled.  Non-``None`` redirect targets must be existing attribute
+            names on the target class when ``target`` is provided, or on the wrapped source class otherwise.
+            Non-cyclic chains are stored and surfaced by audit tooling.  ``None`` (default) means the proxy uses its
+            blanket-warning behaviour (every attribute access emits a warning).
+        args_mapping: Optional dict remapping argument names; values are a plain string (new argument name) or
+            ``None`` (drop the argument).
+        args_mapping_auto_expanded: Keys that were automatically copied from ``attrs_mapping`` into
+            ``args_mapping`` by the dataclass dual-surface expansion in
+            :class:`~deprecate.proxy._DeprecatedProxy`.  Empty tuple when no auto-expansion occurred.
+            Populated at decoration time; read by audit tools to distinguish user-supplied mappings from
+            auto-generated ones.
+        args_mapping_positional_only: ``args_mapping`` old-key names whose remapped target name is a
+            POSITIONAL_ONLY parameter in the target class constructor.  Calling the proxy with such
+            keys as keyword arguments would raise ``TypeError`` without the positional split applied
+            by the proxy call path (see :attr:`target_positional_only`).  Empty tuple when all
+            remapped targets are kwarg-accessible.  Populated at decoration time; surfaced by
+            :func:`~deprecate.audit.validate_mapping_compatibility`.
+        target_positional_only: Names of POSITIONAL_ONLY parameters on the forwarding target callable
+            used with :func:`~deprecate.deprecated`, including ``self`` and ``cls`` when they are
+            declared positional-only.  Non-empty when a ``@deprecated(target=fn)`` call found ``fn``
+            declares at least one positional-only parameter.  ``self`` and ``cls`` are excluded from
+            the :class:`UserWarning` message but included here so the split-dispatch gate fires even
+            when the only positional-only parameter is the instance or class receiver (e.g.
+            ``def __init__(self, /): ...``).  The call dispatcher splits these out of
+            ``resolved_kwargs`` and forwards them positionally so the target call does not raise
+            ``TypeError``.  For :class:`~deprecate.proxy._DeprecatedProxy` objects this holds the
+            POSITIONAL_ONLY parameter names of the *active* class constructor (target class when
+            configured, wrapped class otherwise) so the proxy call path can apply the same
+            positional split (see also :attr:`args_mapping_positional_only`).  Empty frozenset
+            for non-callable targets.
+        target_positional_only_order: Full parameter-name sequence of the forwarding target callable,
+            in declaration order.  Pre-computed at decoration time alongside
+            :attr:`target_positional_only` so the call dispatcher can iterate in declaration order
+            without calling ``inspect.signature`` on every dispatch.  Not included in ``repr``.
+            Empty tuple when ``target_positional_only`` is empty.
+        source_positional_only: Names of POSITIONAL_ONLY parameters declared by the decorated
+            *source* callable itself.  The wrapper converts positional args to kwargs internally,
+            so whenever the dispatcher invokes the source body (NOTIFY, ARGS_REMAP, and the
+            migrated-caller short-circuit) it must split these names back out of the resolved
+            kwargs and pass them positionally — otherwise every call would raise ``TypeError``.
+            Mirrors :attr:`target_positional_only` on the source side.  Empty frozenset when the
+            source declares no ``/``.
+        source_positional_only_order: Full parameter-name sequence of the decorated source in
+            declaration order; the source-side twin of :attr:`target_positional_only_order`.
+            Not included in ``repr``.  Empty tuple when :attr:`source_positional_only` is empty.
+        source_var_positional_prefix: Number of named positional parameters declared before the
+            source's ``*args``.  Used by the forwarding dispatcher to compute the surplus
+            positional tail (``args[prefix:]``) that must be forwarded to a callable target
+            rather than silently dropped.  ``0`` when the source declares no var-positional
+            parameter.
+        target_all_param_names: All parameter names of the forwarding target callable (including any
+            ``*args`` / ``**kwargs`` names), pre-computed at decoration time so the call-time kwarg
+            validation in :func:`~deprecate.deprecation._prepare_target_call` does not re-inspect the
+            target on every forwarded call.  ``None`` when facts are not precomputed (manual
+            ``DeprecationConfig`` construction or non-callable target); ``frozenset()`` for zero-arg
+            callables.  Internal call-time cache — excluded from ``repr`` and equality so audit output
+            and stored-config comparisons stay stable.
+        target_accepts_var_positional: ``True`` when the forwarding target declares ``*args``.  Pre-computed
+            decoration-time replacement for the per-call ``inspect.getfullargspec`` probe.  Internal cache —
+            excluded from ``repr`` and equality.
+        target_accepts_var_keyword: ``True`` when the forwarding target declares ``**kwargs``.  Pre-computed
+            decoration-time replacement for the per-call ``inspect.getfullargspec`` probe.  Internal cache —
+            excluded from ``repr`` and equality.
+
+    Note:
+        ``@dataclass(frozen=True)`` blocks attribute *rebinding* on the config object itself, but the
+        stored ``args_mapping`` and ``attrs_mapping`` dicts remain mutable.  Code that reads these fields
+        must not modify them in place; the decorator copies them defensively at decoration time.
+
+    """
+
+    deprecated_in: str = ""
+    remove_in: str = ""
+    name: str = ""
+    target: Optional[Union[Callable[..., Any], "TargetMode"]] = None
+    args_mapping: Optional[dict[str, Optional[str]]] = None
+    args_extra: Optional[dict[str, Any]] = None
+    misconfigured: bool = False
+    docstring_style: Literal["rst", "mkdocs"] = "rst"
+    template_mgs: Optional[str] = None
+    attrs_mapping: Optional[dict[str, Optional[str]]] = None
+    args_mapping_auto_expanded: tuple[str, ...] = field(default_factory=tuple)
+    args_mapping_positional_only: tuple[str, ...] = field(default_factory=tuple)
+    target_positional_only: frozenset[str] = field(default_factory=frozenset)
+    target_positional_only_order: tuple[str, ...] = field(default_factory=tuple, repr=False)
+    source_positional_only: frozenset[str] = field(default_factory=frozenset)
+    source_positional_only_order: tuple[str, ...] = field(default_factory=tuple, repr=False)
+    source_var_positional_prefix: int = 0
+    target_all_param_names: Optional[frozenset[str]] = field(default=None, repr=False, compare=False)
+    target_accepts_var_positional: bool = field(default=False, repr=False, compare=False)
+    target_accepts_var_keyword: bool = field(default=False, repr=False, compare=False)
+
+
+@runtime_checkable
+class _HasDeprecationMeta(Protocol):
+    """Structural type for any callable that carries ``__deprecated__`` metadata.
+
+    Both ``@deprecated``-decorated functions and :class:`~deprecate.proxy._DeprecatedProxy` instances satisfy this
+    protocol once the decorator has been applied.
+
+    Used as a TypeGuard target so that a ``hasattr`` guard narrows the type of an arbitrary callable to one whose
+    ``__deprecated__`` attribute is typed — eliminating the need for a ``cast`` after the guard.
+
+    """
+
+    __deprecated__: DeprecationConfig
+    __name__: str
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:  # noqa: ANN401
+        """Call the deprecated object."""
+        raise NotImplementedError
+
+
+def _has_deprecation_meta(obj: Any) -> "TypeGuard[_HasDeprecationMeta]":  # noqa: ANN401
+    """Return ``True`` if *obj* carries typed :class:`~deprecate._types.DeprecationConfig` metadata.
+
+    Using this as a guard narrows the type of *obj* from ``Any`` / ``Callable`` to
+    :class:`~deprecate._types._HasDeprecationMeta`,
+    allowing direct typed access to ``obj.__deprecated__`` without a ``cast``.
+
+    Args:
+        obj: Any object to test.
+
+    Returns:
+        ``True`` if ``__deprecated__`` exists and is a :class:`~deprecate._types.DeprecationConfig`;
+        ``False`` otherwise.
+
+    """
+    # ``getattr(..., default)`` only swallows ``AttributeError``; a foreign object encountered during a
+    # recursive audit scan whose ``__getattr__``/``__getattribute__`` raises something else (e.g. a lazy
+    # proxy raising ``RuntimeError``) would otherwise crash the whole scan. Treat any failure as "no meta".
+    try:
+        meta = getattr(obj, "__deprecated__", None)
+    except Exception:
+        return False
+    return isinstance(meta, DeprecationConfig)
+
+
+@dataclass
+class _ProxyConfig:
+    """Private mutable runtime state for :class:`~deprecate.proxy._DeprecatedProxy`.
+
+    This is an internal type — not exported from the package and not referenced outside of :mod:`deprecate.proxy`.
+
+    Attributes:
+        obj: The wrapped (source) object.
+        stream: Callable used to emit warnings, or ``None`` to suppress them.
+        num_warns: Maximum number of warnings to emit; ``-1`` means unlimited.
+        read_only: When ``True``, write operations through the proxy raise :class:`AttributeError`.
+        args_extra: Optional dict of extra keyword arguments merged into forwarded calls after ``args_mapping`` has
+            been applied. Ignored when the proxy is in :attr:`~deprecate._types.TargetMode.NOTIFY` mode.
+        template_mgs: Optional custom warning-message template (``%``-style placeholders) that overrides the built-in
+            templates at warn time. ``None`` (default) keeps the built-in templates. See
+            :func:`~deprecate.proxy.deprecated_class` for the placeholder catalogue.
+        attrs_mapping: Optional mapping of deprecated attribute names to their canonical replacement names (or
+            ``None`` for warn-only).  When set, the proxy emits warnings only on access to listed names and forwards
+            all other reads/writes/deletes silently.  See :func:`~deprecate.proxy.deprecated_class` for full semantics.
+        warned: Mutable counter tracking how many global (callable-level) warnings have been emitted so far.
+        warned_args: Per-argument warning counts for argument-level deprecations. Keys are deprecated argument names;
+            values are emission counts.
+        lock: Guards the warn-quota check-then-act sequence (read counter → decide to emit → increment) so that
+            concurrent first accesses cannot all pass the ``num_warns`` gate and each emit a warning.  Excluded from
+            ``repr`` and equality — it is runtime machinery, not state identity.  A fresh lock is created on copy /
+            deepcopy rather than transferring the original mutex state.
+
+    """
+
+    obj: Any
+    stream: Optional[Callable[..., None]]
+    num_warns: int
+    read_only: bool
+    args_extra: Optional[dict[str, Any]] = None
+    template_mgs: Optional[str] = None
+    attrs_mapping: Optional[dict[str, Optional[str]]] = None
+    warned: int = 0
+    warned_args: dict[str, int] = field(default_factory=dict)
+    lock: threading.Lock = field(default_factory=threading.Lock, repr=False, compare=False)
+
+    def __deepcopy__(self, memo: dict[int, Any]) -> "_ProxyConfig":
+        return replace(
+            self,
+            obj=copy.deepcopy(self.obj, memo),
+            warned_args=copy.deepcopy(self.warned_args, memo),
+            lock=threading.Lock(),  # fresh lock — mutex state is not transferable
+        )
+
+    def __getstate__(self) -> dict[str, Any]:
+        return {k: v for k, v in self.__dict__.items() if k != "lock"}
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        self.__dict__.update(state)
+        self.lock = threading.Lock()  # fresh lock — mutex state is not transferable
+
+
+@dataclass
+class _WrapperState:
+    """Private mutable runtime state for ``@deprecated``-decorated callables.
+
+    This is an internal type — not exported from the package and not referenced outside of :mod:`deprecate.deprecation`.
+
+    Attributes:
+        called: Total invocation count, including calls where the warning was suppressed.
+        warned_calls: Number of callable-level deprecation warnings emitted so far.
+        warned_args: Per-argument warning counts for argument-level deprecations. Keys are deprecated argument names;
+            values are emission counts.
+        warned_misconfigured: ``True`` after the one-time misconfiguration UserWarning has been emitted at call time.
+        lock: Guards the warn-quota check-then-act sequence (read counter → decide to emit → increment) so that
+            concurrent first calls cannot all pass the ``num_warns`` gate and each emit a warning.  Only the warn
+            path takes this lock; the ``called`` counter is a best-effort diagnostic and stays lock-free.  Excluded
+            from ``repr`` and equality — it is runtime machinery, not state identity.
+
+    """
+
+    called: int = 0
+    warned_calls: int = 0
+    warned_args: dict[str, int] = field(default_factory=dict)
+    warned_misconfigured: bool = False
+    lock: threading.Lock = field(default_factory=threading.Lock, repr=False, compare=False)
+
+
+@runtime_checkable
+class _DeprecatedCallable(Protocol):
+    """Structural type for a ``@deprecated``-decorated callable with mutable runtime state.
+
+    This protocol describes the shape of a function or method after the ``@deprecated`` decorator has been applied. It
+    includes both static metadata (``__deprecated__``) and mutable runtime state (``_state``).
+
+    Used to type-safely access ``_state`` on decorated callables without casting.
+
+    """
+
+    __deprecated__: DeprecationConfig
+    _state: _WrapperState
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:  # noqa: ANN401
+        """Call the deprecated callable."""
+        raise NotImplementedError
+
+
+@dataclass
+class _CallPlan:
+    """Resolved dispatch plan returned by :func:`deprecate.deprecation._build_call_plan`.
+
+    Captures the outcome of all decision-making shared between the sync and async wrappers in :func:`deprecated`: state
+    mutation, kwargs assembly, warning emission, target resolution.  The wrapper consumes this struct to decide whether
+    to invoke ``source`` or a forwarded target callable, and with which kwargs shape.
+
+    Attributes:
+        short_circuit: ``True`` when the wrapper must call ``source`` directly (no warning, no remap, no target
+            lookup) — this is the "migrated caller using the new arg name" fast path before any warning logic runs.
+            The wrapper calls ``source(**resolved_kwargs)`` for sources without ``*args``, or
+            ``source(*args, **original_kwargs)`` when the source declares a var-positional parameter so that
+            extra positional arguments are forwarded correctly.  When ``True``, :attr:`resolved_kwargs` equals the
+            kwargs after :func:`_update_kwargs_with_args`, before defaults / remap / extras are applied.
+        original_kwargs: A shallow copy of the wrapper's incoming ``kwargs`` (before positional args were converted to
+            keyword form).  Used by the var-positional branch when no argument-rename reason fired, so that the source
+            sees its original positional/keyword shape.
+        resolved_kwargs: Final kwargs after defaults injection, ``args_mapping`` remap, and ``args_extra`` merge when
+            the normal planning path runs.  On the :attr:`short_circuit` path, this instead holds the kwargs produced
+            immediately after :func:`_update_kwargs_with_args`, and that is what the wrapper passes to ``source``.
+        reason_argument: Subset of ``args_mapping`` whose old-arg names appeared in the caller's kwargs.  Non-empty
+            value means the argument-rename warning fired (or was suppressed by ``num_warns`` quota).  Empty when the
+            warning reason was callable-deprecation or when no rename was triggered.
+        target_func: Resolved target callable when forwarding is required, or ``None`` when the source body should be
+            invoked instead.  ``None`` for :attr:`TargetMode.NOTIFY` and :attr:`TargetMode.ARGS_REMAP`; a validated
+            callable when the user passed a forwarding target.
+
+    """
+
+    short_circuit: bool
+    original_kwargs: dict[str, Any]
+    resolved_kwargs: dict[str, Any]
+    reason_argument: dict[str, Optional[str]] = field(default_factory=dict)
+    target_func: Optional[Callable[..., Any]] = None

.venv/lib/python3.12/site-packages/deprecate/audit.py

@@ -0,0 +1,1537 @@
+"""Audit tools for deprecation lifecycle management.
+
+This module provides several complementary utilities for verifying the health of deprecated callables across a
+codebase. All are designed to be called from pytest or a CI script against an imported package.
+
+**Wrapper configuration** (:func:`~deprecate.audit.validate_deprecation_wrapper`,
+:func:`~deprecate.audit.find_deprecation_wrappers`):
+    Detect wrappers that have zero impact — invalid ``args_mapping`` keys, identity mappings, empty mappings, or a
+    ``target`` pointing back to the same wrapper.
+
+**Mapping compatibility** (:func:`~deprecate.audit.validate_mapping_compatibility`):
+    Detect :func:`~deprecate.proxy.deprecated_class` wrappers whose ``args_mapping`` remaps to POSITIONAL_ONLY
+    constructor params, silently degrading to ``setattr`` at call time.
+
+**Expiry enforcement** (:func:`~deprecate.audit.validate_deprecation_expiry`):
+    Detect wrappers whose ``remove_in`` version has been reached or passed, preventing zombie code from shipping past
+    its scheduled removal deadline.
+
+**Chain detection** (:func:`~deprecate.audit.validate_deprecation_chains`):
+    Detect wrappers whose ``target`` is itself a deprecated callable, forming a chain that users traverse
+    unnecessarily. Two chain kinds are reported via :class:`~deprecate.audit.ChainType`: ``TARGET`` (forwarding chain)
+    and ``STACKED`` (composed argument or attribute mappings).
+
+**Report generation** (:func:`~deprecate.audit.generate_deprecation_table`):
+    Generate a docs-friendly markdown summary from wrapper metadata.
+
+Results are returned as :class:`~deprecate.audit.DeprecationWrapperInfo` dataclasses, which carry both
+identification info and structured validation results for programmatic processing.
+
+!!! note
+    :func:`~deprecate.audit.validate_deprecation_expiry` requires the ``packaging`` library for PEP 440
+    version comparison. Install with: ``pip install pyDeprecate[audit]``
+
+Copyright (C) 2020-2026 Jiri Borovec <6035284+Borda@users.noreply.github.com>
+
+"""
+
+# Note: Proxy objects are discoverable via the generic ``callable(obj)`` +
+# ``hasattr(obj, "__deprecated__")`` scan in :func:`find_deprecation_wrappers` and
+# :func:`validate_deprecation_expiry`. The ``__deprecated__`` schema is now unified
+# across ``@deprecated`` and :class:`~deprecate.proxy._DeprecatedProxy` via
+# :class:`~deprecate._types.DeprecationConfig` — both always populate the ``name`` field,
+# so ``validate_deprecation_wrapper`` can read it correctly for proxy objects too.
+
+import enum
+import importlib
+import importlib.metadata
+import inspect
+import pkgutil
+import re
+import warnings
+from contextlib import suppress
+from dataclasses import dataclass, field, is_dataclass, replace
+from enum import Enum
+from functools import cached_property, wraps
+from typing import TYPE_CHECKING, Any, Callable, Optional, Union
+
+if TYPE_CHECKING:
+    from packaging.version import Version
+
+from deprecate._types import DeprecationConfig, TargetMode, _has_deprecation_meta
+from deprecate.deprecation import _DeprecatedProperty
+from deprecate.proxy import _DeprecatedProxy, deprecated_class
+from deprecate.utils import get_func_arguments_types_defaults
+
+
+class TableStyle(str, enum.Enum):
+    """Markdown table layout produced by :func:`~deprecate.audit.generate_deprecation_table`."""
+
+    COMPACT = "compact"
+    MATRIX = "matrix"
+
+
+class DeprecationStatus(str, enum.Enum):
+    """Lifecycle status labels used in the deprecation report's *Current Status* column.
+
+    Each member's value is the full display string (emoji + text) rendered in the table.
+    Using a ``str`` enum means members compare equal to their string values and can be
+    returned wherever a plain string is expected.
+
+    Members are *declared* from least to most urgent for readability, but this enum is **not orderable by
+    urgency**: because each value starts with an emoji, the inherited ``str`` ordering operators (``<``, ``>``)
+    compare Unicode codepoints of those emoji, not deprecation urgency. Do not rely on ``status_a > status_b``
+    to mean "more urgent" — compare members explicitly (``status is DeprecationStatus.PAST_REMOVAL_DATE``).
+    The ordering operators are overridden to raise ``TypeError`` so accidental comparisons fail loudly.
+
+    Examples:
+        >>> DeprecationStatus.ACTIVE_WARNING.value
+        '📢 Deprecation Active'
+        >>> DeprecationStatus.PAST_REMOVAL_DATE is DeprecationStatus.PAST_REMOVAL_DATE
+        True
+
+    """
+
+    SCHEDULED_DEPRECATION = "🕒 Scheduled Deprecation"  # current < deprecated_in
+    NO_REMOVAL_TARGET = "ℹ️ No Removal Target"  # remove_in not set
+    STATUS_UNKNOWN = "⚪ Status Unknown"  # current_version unavailable
+    INVALID_REMOVAL_TARGET = "⚪ Invalid Removal Target"  # remove_in unparsable
+    ACTIVE_WARNING = "📢 Deprecation Active"  # current < remove_in (different base)
+    REMOVAL_IMMINENT = "⏰ Removal Imminent"  # pre-release dev/a/b of remove_in base
+    REMOVE_BEFORE_RELEASE = "🔔 Remove Before Release"  # RC of the remove_in base release
+    PAST_REMOVAL_DATE = "💥 Past Removal Date"  # current >= remove_in
+
+    def __lt__(self, other: object) -> bool:
+        """Raise TypeError — urgency ordering is not meaningful for emoji-valued status labels."""
+        raise TypeError("'<' not supported between instances of 'DeprecationStatus' — compare by identity")
+
+    def __le__(self, other: object) -> bool:
+        """Raise TypeError — urgency ordering is not meaningful for emoji-valued status labels."""
+        raise TypeError("'<=' not supported between instances of 'DeprecationStatus' — compare by identity")
+
+    def __gt__(self, other: object) -> bool:
+        """Raise TypeError — urgency ordering is not meaningful for emoji-valued status labels."""
+        raise TypeError("'>' not supported between instances of 'DeprecationStatus' — compare by identity")
+
+    def __ge__(self, other: object) -> bool:
+        """Raise TypeError — urgency ordering is not meaningful for emoji-valued status labels."""
+        raise TypeError("'>=' not supported between instances of 'DeprecationStatus' — compare by identity")
+
+
+def _normalize_version_string(version: str) -> str:
+    """Normalize non-standard version strings before PEP 440 parsing.
+
+    Newer ``packaging`` (>=22) is strict PEP 440 and rejects real-world strings that omit trailing digits
+    on pre/post/dev release labels (e.g. ``"1.8.0.dev"``, ``"1.8.0dev"``, ``"1.8.0.post"``). This helper
+    performs the minimum normalization needed to make such strings parseable, then defers everything else
+    (label aliasing like ``alpha`` -> ``a``, case folding, separator handling) to ``packaging.Version``.
+
+    The transformation is conservative:
+
+    1. Strip a single leading ``v`` or ``V`` prefix (left-anchored, so only one leading ``v`` is removed).
+    2. Append ``0`` to bare pre/post/dev labels that lack a trailing digit. Labels recognized:
+       ``dev``, ``rc``, ``a``, ``b``, ``c``, ``alpha``, ``beta``, ``preview``, ``post``.
+
+    The label normalization runs only over the *public* part of the version — any PEP 440 local segment
+    (everything after ``+``) is split off first and re-attached verbatim, so a legitimate local like
+    ``1.2.3+cuda`` is never mangled into ``1.2.3+cuda0`` by the trailing-``a`` label rule.
+
+    No other transformations are applied — case, separators, and label aliases pass through unchanged
+    so ``packaging.Version`` can apply its own canonicalization.
+
+    Args:
+        version: Raw version string, possibly missing trailing digits on labels.
+
+    Returns:
+        Normalized version string ready to be passed to ``packaging.version.Version``.
+
+    Examples:
+        >>> _normalize_version_string("1.8.0.dev")
+        '1.8.0.dev0'
+        >>> _normalize_version_string("1.8.0dev")
+        '1.8.0dev0'
+        >>> _normalize_version_string("1.8.0.post")
+        '1.8.0.post0'
+        >>> _normalize_version_string("v1.2.3")
+        '1.2.3'
+        >>> _normalize_version_string("1.8.0.RC1")
+        '1.8.0.RC1'
+        >>> _normalize_version_string("1.2.3")
+        '1.2.3'
+        >>> _normalize_version_string("1.2.3+cuda")
+        '1.2.3+cuda'
+        >>> _normalize_version_string("v1.8.0.dev+local.a")
+        '1.8.0.dev0+local.a'
+
+    """
+    # Split off any PEP 440 local segment (after ``+``) so the label regex never touches it; labels like
+    # ``post``/``dev`` never appear in a local segment, and running the rule over it mangles legit locals.
+    public, plus, local = version.partition("+")
+    # Strip a single left-anchored leading ``v``/``V`` (``lstrip("vV")`` would strip *all* leading v's).
+    normalized = re.sub(r"^[vV]", "", public)
+    # Append ``0`` to bare pre/post/dev labels with no trailing digit. The ordering of the alternatives
+    # matters: longer labels (``alpha``, ``beta``, ``preview``) must come before their single-letter
+    # forms (``a``, ``b``) so the regex prefers the longer match.
+    # Use a negative lookahead for ``[0-9]`` to detect "no trailing digit"; ``(?=$|[^A-Za-z0-9])``
+    # ensures the label is a whole token (e.g. ``dev`` but not ``develop``).
+    pattern = re.compile(
+        r"(?P<sep>\.?)(?P<label>alpha|beta|preview|post|dev|rc|a|b|c)(?![A-Za-z0-9])",
+        re.IGNORECASE,
+    )
+    normalized = pattern.sub(lambda m: f"{m.group('sep')}{m.group('label')}0", normalized)
+    return f"{normalized}{plus}{local}"
+
+
+def _parse_version(version_string: str) -> "Version":
+    """Parse a version string using the packaging library (PEP 440 compliant).
+
+    This function requires the 'packaging' library, which is available as an optional dependency via the 'audit'
+    extra: ``pip install pyDeprecate[audit]``
+
+    The packaging library provides robust PEP 440 version parsing and comparison, supporting pre-releases
+    (alpha/beta/rc), stable releases, post-releases, and development releases with proper ordering.
+
+    Inputs are first passed through :func:`_normalize_version_string`, which appends ``0`` to bare
+    pre/post/dev labels (e.g. ``"1.8.0.dev"`` becomes ``"1.8.0.dev0"``) so non-canonical-but-common
+    strings parse successfully under strict ``packaging`` (>=22).
+
+    Args:
+        version_string: Version string (e.g., "1.2.3", "2.0", "1.5.0a1", "1.5.0rc1", "1.5.0.post1").
+
+    Returns:
+        packaging.version.Version object that supports comparison operations.
+
+    Raises:
+        ImportError: If the packaging library is not installed.
+        ValueError: If the version string is not valid per PEP 440
+            (wraps ``packaging.version.InvalidVersion`` with additional context).
+
+    Example:
+        >>> import importlib; importlib.import_module("packaging")  # doctest: +ELLIPSIS
+        <module 'packaging' ...>
+        >>> v1 = _parse_version("1.2.3")
+        >>> v2 = _parse_version("2.0")
+        >>> v1 < v2
+        True
+        >>> _parse_version("1.5.0a1") < _parse_version("1.5.0")
+        True
+        >>> _parse_version("1.8.0.dev") < _parse_version("1.8.0")
+        True
+        >>> _parse_version("1.8.0.post") > _parse_version("1.8.0")
+        True
+
+    !!! note
+        Install the audit extra to use version comparison features:
+        ``pip install pyDeprecate[audit]``
+
+    """
+    try:
+        from packaging.version import InvalidVersion, Version
+    except ImportError as err:
+        raise ImportError(
+            "Version comparison requires the 'packaging' library. Install with: pip install pyDeprecate[audit]"
+        ) from err
+
+    try:
+        return Version(_normalize_version_string(version_string))
+    except InvalidVersion as err:
+        raise ValueError(
+            f"Failed to parse version '{version_string}'. Expected PEP 440 format "
+            f"(e.g., '1.2.3', '2.0', '1.5.0a1'). Error: {err}"
+        ) from err
+
+
+class ChainType(Enum):
+    """Type of deprecation chain detected by :func:`~deprecate.audit.validate_deprecation_chains`.
+
+    Attributes:
+        TARGET: The ``target`` argument is itself a callable decorated with :func:`~deprecate.deprecated`
+            (a forwarding chain). Fix by pointing directly to the final non-deprecated target.
+        STACKED: Arg mappings chain and must be composed/collapsed. Two sub-cases:
+            (a) Callable ``target`` is itself ``@deprecated(True, args_mapping=...)`` — the
+            caller's mapping feeds into the target's self-renaming, so both hops must be
+            collapsed into one. (b) Multiple ``@deprecated(True, args_mapping=...)`` decorators
+            are stacked on the same function and should be merged into a single decorator.
+            Also used when ``attrs_mapping`` values point at another deprecated attribute alias.
+
+    """
+
+    TARGET = "target"
+    STACKED = "stacked"
+
+
+@dataclass(frozen=True)
+class DeprecationWrapperInfo:
+    """Information about a deprecated wrapper and its validation results.
+
+    This dataclass represents a deprecated wrapper (a :func:`~deprecate.deprecated`-decorated function or a
+    :func:`~deprecate.proxy.deprecated_class`/:func:`~deprecate.proxy.deprecated_instance` proxy), containing both
+    identification info and validation results from :func:`~deprecate.audit.validate_deprecation_wrapper` or
+    :func:`~deprecate.audit.find_deprecation_wrappers`.
+
+    Attributes:
+        module: Module name where the wrapper is defined (empty for direct validation).
+        function: Wrapper name.
+        deprecated_info: The ``__deprecated__`` attribute from the decorator,
+            as a :class:`~deprecate._types.DeprecationConfig`.
+        invalid_args: List of ``args_mapping`` keys that don't exist in the wrapper's signature.
+        empty_args_mapping: True if ``args_mapping`` is None or empty (no argument remapping).
+        identity_args_mapping: List of args where key equals value (e.g., ``{'arg': 'arg'}``).
+        self_reference: True if target points to the same wrapper.
+        no_effect: True if wrapper has zero impact (combines all checks).
+        all_identity: True when every configured mapping is an identity mapping (key == value, non-empty).
+        chain_type: The kind of deprecation chain detected, or ``None`` if no chain.
+            See :class:`~deprecate.audit.ChainType` for values
+            (:attr:`~deprecate.audit.ChainType.TARGET` or :attr:`~deprecate.audit.ChainType.STACKED`).
+        misconfigured_target: True when the wrapper has an invalid target configuration:
+            ``target=False``, :attr:`~deprecate._types.TargetMode.NOTIFY` with ``args_mapping``, or
+            :attr:`~deprecate._types.TargetMode.ARGS_REMAP` with empty ``args_mapping``.
+        empty_deprecated_in: True when ``deprecated_in`` is empty. Missing ``remove_in`` alone is a valid use case
+            (many libraries deprecate without a scheduled removal date), so only the absence of ``deprecated_in``
+            is treated as a misconfiguration signal. CI pipelines can filter on this field to surface wrappers
+            that lack the introductory version metadata without crashing callers.
+        api_type: Inferred deprecated API type for report generation.
+            Possible values: ``callable``, ``args``, ``class``, ``dataclass``, ``dataclass attributes``,
+            ``data``, ``class constructor``, ``class constructor args``, ``class method``, ``class method args``,
+            ``classmethod``, ``classmethod args``, ``staticmethod``, ``staticmethod args``.
+        args_mapping_auto_expanded: ``args_mapping`` keys that were automatically copied from ``attrs_mapping``
+            by the dataclass dual-surface expansion at decoration time.  Empty list when no auto-expansion
+            occurred.  Read from :attr:`~deprecate._types.DeprecationConfig.args_mapping_auto_expanded`.
+        args_mapping_positional_only: ``args_mapping`` old-key names whose remapped target is a POSITIONAL_ONLY
+            constructor parameter.  Non-empty list signals that the proxy falls back to ``setattr`` for those
+            keys.  Use :func:`~deprecate.audit.validate_mapping_compatibility` to filter wrappers by this
+            field.  Read from :attr:`~deprecate._types.DeprecationConfig.args_mapping_positional_only`.
+        inner_order_property: ``True`` when the wrapper is a plain :class:`property` whose ``fget`` carries
+            ``@deprecated`` metadata — the *inner order* ``@property @deprecated`` (``@deprecated`` closer to
+            ``def``).  In this order only ``fget`` warns; any setter or deleter added afterwards is built from the
+            plain :class:`property` base and is silently unprotected.  The flag fires for every inner-order
+            property, including the getter-only shape, because the canonical order is the outer
+            ``@deprecated(...) @property`` (which produces a :class:`~deprecate.deprecation._DeprecatedProperty`
+            that re-wraps every rebound accessor).  CI pipelines can filter on this field to reject the silent
+            write/delete gap.  ``False`` for outer-order properties, non-property wrappers, and proxies.
+
+    Example:
+        >>> info = DeprecationWrapperInfo(
+        ...     module="my_package.module",
+        ...     function="old_function",
+        ...     deprecated_info=DeprecationConfig(deprecated_in="1.0", remove_in="2.0"),
+        ...     invalid_args=["nonexistent"],
+        ...     no_effect=True,
+        ... )
+        >>> info.function
+        'old_function'
+        >>> info.invalid_args
+        ['nonexistent']
+
+    """
+
+    module: str = ""
+    function: str = ""
+    deprecated_info: DeprecationConfig = field(default_factory=DeprecationConfig)
+    invalid_args: list[str] = field(default_factory=list)
+    empty_args_mapping: bool = False
+    identity_args_mapping: list[str] = field(default_factory=list)
+    self_reference: bool = False
+    no_effect: bool = False
+    misconfigured_target: bool = False
+    all_identity: bool = False
+    chain_type: Optional[ChainType] = None
+    empty_deprecated_in: bool = field(init=False, default=False)
+    api_type: str = field(repr=False, default="")
+    args_mapping_auto_expanded: list[str] = field(default_factory=list)
+    args_mapping_positional_only: list[str] = field(default_factory=list)
+    inner_order_property: bool = False
+
+    def __post_init__(self) -> None:
+        """Derive ``empty_deprecated_in`` from ``deprecated_info`` to keep them in sync."""
+        object.__setattr__(self, "empty_deprecated_in", not self.deprecated_info.deprecated_in)
+
+    @property
+    def empty_mapping(self) -> bool:
+        """Deprecated alias for :attr:`~deprecate.audit.DeprecationWrapperInfo.empty_args_mapping`.
+
+        !!! warning "Deprecated in 0.8"
+            Renamed to :attr:`~deprecate.audit.DeprecationWrapperInfo.empty_args_mapping`.
+            Will be removed in v1.0.
+
+        Note:
+            Python's default warning filter deduplicates per ``(message, category, module, lineno)``,
+            so accessing this property in a loop from the same call site emits at most one warning.
+
+        """
+        warnings.warn(
+            "'empty_mapping' was renamed to 'empty_args_mapping' in 0.8 and will be removed in 1.0.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.empty_args_mapping
+
+    @property
+    def identity_mapping(self) -> list[str]:
+        """Deprecated alias for :attr:`~deprecate.audit.DeprecationWrapperInfo.identity_args_mapping`.
+
+        !!! warning "Deprecated in 0.8"
+            Renamed to :attr:`~deprecate.audit.DeprecationWrapperInfo.identity_args_mapping`.
+            Will be removed in v1.0.
+
+        Note:
+            Python's default warning filter deduplicates per ``(message, category, module, lineno)``,
+            so accessing this property in a loop from the same call site emits at most one warning.
+
+        """
+        warnings.warn(
+            "'identity_mapping' was renamed to 'identity_args_mapping' in 0.8 and will be removed in 1.0.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.identity_args_mapping
+
+
+# ---------------------------------------------------------------------------
+# Backward-compatible constructor shim for DeprecationWrapperInfo
+#
+# ``empty_mapping`` and ``identity_mapping`` were renamed to
+# ``empty_args_mapping`` / ``identity_args_mapping`` in 0.8.  The
+# ``@property`` aliases above cover attribute *reads*; this shim patches
+# ``__init__`` so old keyword arguments emit ``DeprecationWarning`` and are
+# redirected to the new names rather than raising ``TypeError``.
+#
+# dataclasses.replace() merges all current field values with the caller's
+# changes before calling ``cls(**merged)``.  Passing an old name (e.g.
+# ``replace(info, empty_mapping=True)``) injects the old kwarg alongside
+# the auto-copied ``empty_args_mapping`` value.  The shim detects that
+# conflict and honours the old-name value (discards the auto-injected one).
+#
+# ADD field → add @property alias above + (old, new) pair in _dwi_compat_init.
+# RENAME/REMOVE field → update _dwi_compat_init accordingly.
+# ---------------------------------------------------------------------------
+_dwi_orig_init = DeprecationWrapperInfo.__init__
+
+
+@wraps(_dwi_orig_init)
+def _dwi_compat_init(self: DeprecationWrapperInfo, *args: object, **kwargs: object) -> None:
+    """Wrap the auto-generated ``__init__`` to accept legacy constructor kwargs."""
+    for old, new in (
+        ("empty_mapping", "empty_args_mapping"),
+        ("identity_mapping", "identity_args_mapping"),
+    ):
+        if old in kwargs:
+            warnings.warn(
+                f"'{old}' was renamed to '{new}' in 0.8 and will be removed in 1.0."
+                " Update your code to use the new name.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            old_value = kwargs.pop(old)  # always remove old kwarg so it isn't forwarded
+            if new in kwargs:
+                # Both names present — common via dataclasses.replace() which auto-injects
+                # the current field value under the new name.  Honour the old-name value
+                # (the caller's explicit intent) and discard the auto-injected value.
+                kwargs.pop(new)
+            kwargs[new] = old_value
+    _dwi_orig_init(self, *args, **kwargs)  # type: ignore[arg-type]
+
+
+DeprecationWrapperInfo.__init__ = _dwi_compat_init  # type: ignore[method-assign]
+
+
+def _getmembers_static_compat(obj: Any) -> list[tuple[str, Any]]:  # noqa: ANN401
+    """Return members without triggering dynamic ``getattr`` side effects.
+
+    Uses ``inspect.getmembers_static`` when available (Python 3.11+). For Python
+    3.9/3.10 compatibility, falls back to ``dir()`` + ``inspect.getattr_static``.
+
+    """
+    getmembers_static = getattr(inspect, "getmembers_static", None)
+    if callable(getmembers_static):
+        return getmembers_static(obj)
+
+    names = dir(obj)
+    members: list[tuple[str, Any]] = []
+    for name in names:
+        with suppress(AttributeError):
+            members.append((name, inspect.getattr_static(obj, name)))
+    return sorted(members, key=lambda item: item[0])
+
+
+def _detect_chain_type(
+    dep_info: DeprecationConfig,
+    func: Callable,
+    target: Any,  # noqa: ANN401
+    _is_args_remap: bool,
+) -> Optional[ChainType]:
+    """Return the chain type when target or attrs_mapping forms a deprecation chain, else None."""
+    chain_type: Optional[ChainType] = None
+    if callable(target) and _has_deprecation_meta(target):
+        wrp_depr_tgt = target.__deprecated__.target
+        chain_type = ChainType.STACKED if wrp_depr_tgt is TargetMode.ARGS_REMAP else ChainType.TARGET
+    elif _is_args_remap:
+        wrapped = getattr(func, "__wrapped__", None)
+        # ``target`` is always a ``TargetMode`` (or callable/None) after normalization — the legacy
+        # ``target is True`` sentinel can no longer reach here, so only ARGS_REMAP marks a stacked chain.
+        if (
+            wrapped is not None
+            and _has_deprecation_meta(wrapped)
+            and wrapped.__deprecated__.target is TargetMode.ARGS_REMAP
+        ):
+            chain_type = ChainType.STACKED
+    attrs_mapping = dep_info.attrs_mapping
+    has_chained_attrs = attrs_mapping is not None and any(
+        v is not None and v in attrs_mapping for v in attrs_mapping.values()
+    )
+    if chain_type is None and has_chained_attrs:
+        chain_type = ChainType.STACKED
+    return chain_type
+
+
+def _validate_args_mapping(
+    func: Callable,
+    args_mapping: Optional[dict[str, Optional[str]]],
+) -> tuple[list[str], list[str], bool]:
+    """Return (invalid_args, identity_args_mapping, all_identity) for the given mapping."""
+    if not args_mapping:
+        return [], [], False
+    if isinstance(func, _DeprecatedProxy):
+        invalid_args: list[str] = []
+    else:
+        func_args = [arg[0] for arg in get_func_arguments_types_defaults(func)]
+        invalid_args = [arg for arg in args_mapping if arg not in func_args]
+    identity_args_mapping = [arg for arg, val in args_mapping.items() if arg == val]
+    all_identity = len(identity_args_mapping) == len(args_mapping) > 0
+    return invalid_args, identity_args_mapping, all_identity
+
+
+def validate_deprecation_wrapper(func: Callable) -> DeprecationWrapperInfo:
+    """Validate if a deprecated wrapper configuration is effective.
+
+    This is a development tool to check if deprecated wrappers are configured correctly and will have the intended
+    effect. It examines the ``__deprecated__`` attribute set by the :func:`~deprecate.deprecated` decorator and
+    identifies
+    configurations that would result in zero impact:
+
+    - args_mapping keys that don't exist in the function's signature
+    - Empty or None args_mapping (no argument remapping)
+    - Identity mappings where key equals value (e.g., {'arg': 'arg'})
+    - Target pointing to the same function (self-reference)
+    - target=None with no args_mapping (just warns, no forwarding)
+
+    Args:
+        func: The decorated function to validate. Must have a ``__deprecated__`` attribute set by the ``@deprecated``
+            decorator.
+
+    Returns:
+        :class:`~deprecate.audit.DeprecationWrapperInfo`: Dataclass with validation results:
+            - function: Name of the wrapper being validated
+            - deprecated_info: The typed :class:`~deprecate._types.DeprecationConfig` metadata from ``__deprecated__``
+            - invalid_args: List of args_mapping keys not in wrapper signature
+            - empty_args_mapping: True if args_mapping is None or empty
+            - identity_args_mapping: List of args where key equals value (no effect)
+            - self_reference: True if target is the same as the wrapper
+            - no_effect: True if wrapper has zero impact (all checks combined)
+            - empty_deprecated_in: True when ``deprecated_in`` is absent or empty
+
+    Raises:
+        ValueError: If the wrapper has missing or invalid ``__deprecated__`` metadata (expected
+            :class:`~deprecate._types.DeprecationConfig`).
+
+    Example:
+        >>> from deprecate import TargetMode, deprecated, validate_deprecation_wrapper
+        >>> def new_implementation(value: int) -> int:
+        ...     return value * 2
+        >>>
+        >>> @deprecated(target=new_implementation, deprecated_in="1.0", args_mapping={"old_val": "value"})
+        ... def old_func(old_val: int) -> int:
+        ...     pass
+        >>>
+        >>> # Valid mapping to different function - has effect
+        >>> result = validate_deprecation_wrapper(old_func)
+        >>> result.no_effect
+        False
+        >>> result.invalid_args
+        []
+
+        >>> @deprecated(target=TargetMode.ARGS_REMAP, deprecated_in="1.0", args_mapping={"arg": "arg"})
+        ... def identity_func(arg: int) -> int:
+        ...     return arg
+        >>>
+        >>> # Identity mapping with self-deprecation - no effect
+        >>> result = validate_deprecation_wrapper(identity_func)
+        >>> result.identity_args_mapping
+        ['arg']
+        >>> result.no_effect
+        True
+
+    Note:
+        Use this function during development or in CI to ensure deprecation decorators are configured meaningfully.
+        Invalid configurations won't cause runtime errors but will silently have no effect.
+
+    """
+    if not _has_deprecation_meta(func):
+        raise ValueError(
+            f"Function {getattr(func, '__name__', func)} has missing or invalid `__deprecated__` metadata. "
+            "Expected `DeprecationConfig`; ensure it is decorated with `@deprecated`."
+        )
+
+    dep_info = func.__deprecated__
+    args_mapping = dep_info.args_mapping
+    target = dep_info.target
+    _is_args_remap = target is TargetMode.ARGS_REMAP
+    _is_notify = target is TargetMode.NOTIFY
+
+    # Self-reference: the wrapper forwards to itself. For a proxy the wrapper object is the proxy while its
+    # deprecated target is the *wrapped* object, so ``target is func`` never matches — compare against
+    # ``func.wrapped`` too. A proxy is self-referential only when there is *no* active remapping:
+    # a proxy with non-empty ``args_mapping`` or ``attrs_mapping`` still performs meaningful transformation
+    # and must not be flagged as a no-op.
+    self_reference = target is not None and (
+        target is func
+        or (
+            isinstance(func, _DeprecatedProxy)
+            and target is func.wrapped
+            and not dep_info.args_mapping
+            and not dep_info.attrs_mapping
+        )
+    )
+    empty_args_mapping = not args_mapping
+    chain_type = _detect_chain_type(dep_info, func, target, _is_args_remap)
+    invalid_args, identity_args_mapping, all_identity = _validate_args_mapping(func, args_mapping)
+
+    # NOTIFY (target=None) is NOT no_effect — it still emits deprecation warnings.
+    # When target is a different function, there's ALWAYS an effect (forwarding).
+    is_self_deprecation = _is_args_remap or self_reference
+    no_effect = self_reference or (is_self_deprecation and (empty_args_mapping or all_identity))
+
+    # Construction-time `target=False` is captured in DeprecationConfig.misconfigured by the
+    # decorator/proxy before normalisation; NOTIFY ignores args_mapping; ARGS_REMAP needs args_mapping.
+    misconfigured_target = (
+        bool(getattr(dep_info, "misconfigured", False))
+        or (_is_notify and bool(args_mapping))
+        or (_is_args_remap and empty_args_mapping)
+    )
+
+    function = dep_info.name or getattr(func, "__name__", str(func))
+
+    return DeprecationWrapperInfo(
+        function=function,
+        deprecated_info=dep_info,
+        invalid_args=invalid_args,
+        empty_args_mapping=empty_args_mapping,
+        identity_args_mapping=identity_args_mapping,
+        self_reference=self_reference,
+        no_effect=no_effect,
+        misconfigured_target=misconfigured_target,
+        all_identity=all_identity,
+        chain_type=chain_type,
+        args_mapping_auto_expanded=list(getattr(dep_info, "args_mapping_auto_expanded", ())),
+        args_mapping_positional_only=list(getattr(dep_info, "args_mapping_positional_only", ())),
+    )
+
+
+def _check_deprecated_wrapper_expiry(func: Callable, current_version: str) -> None:
+    """Check if a deprecated wrapper has passed its scheduled removal version.
+
+    This is an internal helper function used by :func:`~deprecate.audit.validate_deprecation_expiry`.
+    It verifies that deprecated code is actually removed when it reaches its scheduled removal deadline.
+
+    The function validates that the wrapper is properly decorated, extracts the removal version from its metadata,
+    and compares it against the current version using semantic versioning. If the current version is greater than or
+    equal to the scheduled removal version, it raises an AssertionError indicating the code must be deleted.
+
+    Args:
+        func: The deprecated callable to check. Must have a ``__deprecated__`` attribute set by the ``@deprecated``
+            decorator.
+        current_version: The current version of the package (e.g., "2.0.0"). Should follow PEP 440 versioning
+            conventions.
+
+    Raises:
+        ValueError: If the wrapper has missing or invalid ``__deprecated__`` metadata (expected
+            :class:`~deprecate._types.DeprecationConfig`).
+        ValueError: If the ``remove_in`` field is missing from the deprecation metadata.
+        AssertionError: If the current version is greater than or equal to the scheduled removal version, indicating
+            the code should have been removed.
+
+    """
+    # First validate that the wrapper has proper deprecation metadata
+    info = validate_deprecation_wrapper(func)
+
+    # Extract the remove_in version from the metadata
+    remove_in = info.deprecated_info.remove_in
+    if not remove_in:
+        raise ValueError(
+            f"Callable `{info.function}` does not have a 'remove_in' version specified in its deprecation metadata."
+        )
+
+    # Parse both versions for proper semantic version comparison
+    # Let ImportError propagate with its helpful install message
+    try:
+        current_ver = _parse_version(current_version)
+    except ValueError as err:
+        raise ValueError(f"Invalid current_version '{current_version}': {err}") from err
+
+    try:
+        remove_ver = _parse_version(remove_in)
+    except ValueError as err:
+        raise ValueError(f"Invalid remove_in '{remove_in}' for callable `{info.function}`: {err}") from err
+
+    # Check if the current version has reached or passed the removal deadline
+    if current_ver >= remove_ver:
+        raise AssertionError(
+            f"Callable `{info.function}` was scheduled for removal in version {remove_in} "
+            f"but still exists in version {current_version}. Please delete this deprecated code."
+        )
+
+
+def _get_package_version(package_name: str) -> str:
+    """Auto-detect the installed version of a package.
+
+    This private helper function attempts to retrieve the version of an installed package using importlib.metadata,
+    with a fallback to checking the package's ``__version__`` attribute. This is useful for automatically detecting
+    the current version of a package when checking deprecation expiry.
+
+    Args:
+        package_name: Name of the package to get the version for (e.g., "numpy", "mypackage").
+
+    Returns:
+        The version string of the installed package.
+
+    Raises:
+        ImportError: If the package is not installed or version cannot be determined.
+
+    """
+    # Try importlib.metadata first (standard approach for installed packages)
+    with suppress(Exception):
+        return importlib.metadata.version(package_name)
+
+    # Fall back to checking __version__ attribute
+    with suppress(Exception):
+        module = importlib.import_module(package_name)
+        if hasattr(module, "__version__"):
+            return module.__version__
+
+    # If both methods fail, raise an informative error
+    raise ImportError(
+        f"Could not determine version for package '{package_name}'. "
+        f"Ensure the package is installed and has version metadata."
+    )
+
+
+def _check_expiry_for_callables(results: list[DeprecationWrapperInfo], current_version: str) -> list[str]:
+    """Apply expiry comparison to pre-scanned wrapper results.
+
+    Shared implementation used by :func:`validate_deprecation_expiry` and the CLI's single-scan path. Keeps the
+    error message format in one place.
+
+    Args:
+        results: Pre-scanned wrapper info list.
+        current_version: Current package version string for comparison (PEP 440).
+
+    Returns:
+        List of expiry error messages for callables that have passed their removal deadline.
+
+    Raises:
+        ImportError: If the ``packaging`` library is not installed.
+
+    """
+    current_ver = _parse_version(current_version)
+    expired = []
+    for info in results:
+        remove_in = info.deprecated_info.remove_in
+        if not remove_in:
+            continue
+        try:
+            remove_ver = _parse_version(remove_in)
+        except ValueError:
+            # An unparsable ``remove_in`` (e.g. a typo) would make the wrapper permanently un-expirable and the
+            # batch gate would never flag it. Warn per skip so the misconfiguration is visible rather than silent
+            # — the single-callable path raises; here a warning keeps the batch scan going for the rest.
+            warnings.warn(
+                f"Callable `{info.function}` has an unparsable `remove_in` version `{remove_in}`; "
+                "its expiry cannot be checked until the version string is fixed.",
+                stacklevel=2,
+            )
+            continue
+        if current_ver >= remove_ver:
+            expired.append(
+                f"Callable `{info.function}` was scheduled for removal in version {remove_in}"
+                f" but still exists in version {current_version}. Please delete this deprecated code."
+            )
+    return expired
+
+
+def validate_deprecation_expiry(
+    module: Union[Any, str],  # noqa: ANN401
+    current_version: Optional[str] = None,
+    recursive: bool = True,
+    include_members: bool = True,
+) -> list[str]:
+    """Check all deprecated callables in a module/package for expired removal deadlines.
+
+    This enforcement tool scans an entire module or package for deprecated functions and checks if any have passed
+    their scheduled removal version. It's designed for CI/CD pipelines to automatically detect and report zombie code
+    across a codebase.
+
+    The function uses :func:`~deprecate.audit.find_deprecation_wrappers` to discover all deprecated wrappers,
+    then checks each one against
+    the current version. Any wrappers that have reached or passed their removal deadline are collected and reported.
+
+    Args:
+        module: A Python module or package to scan. Can be:
+            - Imported module object (e.g., ``import my_package; validate_deprecation_expiry(my_package, "2.0")``)
+            - String module path (e.g., ``validate_deprecation_expiry("my_package.submodule", "2.0")``)
+        current_version: The current version of your package to compare against removal deadlines (e.g., ``"2.0.0"``).
+            If None, attempts to auto-detect the version using the package name from the module path (e.g.,
+            ``"mypackage"`` extracts ``mypackage`` as package name).
+        recursive: If True (default), recursively scan submodules. If False, only scan the top-level module.
+        include_members: If True (default), also scan deprecated class members (methods, constructors,
+            classmethods, staticmethods, properties) — matching the discovery default of
+            :func:`~deprecate.audit.find_deprecation_wrappers`, so the enforcement gate sees everything
+            discovery and reporting see.
+
+    Returns:
+        List of error messages for callables that have expired (past their removal deadline).
+        Empty list if all deprecated callables are still within their deprecation period.
+
+    Example:
+        >>> # Check a specific module with version before any deadlines
+        >>> from deprecate import validate_deprecation_expiry
+        >>> expired = validate_deprecation_expiry("tests.collection_deprecate", "0.1", recursive=False)
+        >>> len(expired)
+        0
+
+        >>> # Check with version past some removal deadlines
+        >>> expired = validate_deprecation_expiry("tests.collection_deprecate", "0.5", recursive=False)
+        >>> print(len(expired))  # Some functions and class members have remove_in <= "0.5"
+        31
+
+    !!! note
+        - Skips callables without a ``remove_in`` field (warnings only, no removal deadline)
+        - Skips callables that cannot be imported or accessed
+        - Emits a ``UserWarning`` (rather than silently skipping) for callables with an unparsable ``remove_in``
+        - Uses semantic versioning comparison (e.g., "1.2.3" vs "2.0.0")
+        - Intended for automated checks in CI/CD pipelines
+        - Can be integrated into test suites or pre-commit hooks
+
+    """
+    # Determine module name for auto-version detection
+    module_name = module if isinstance(module, str) else getattr(module, "__name__", None)
+
+    # Auto-detect version if not provided
+    if current_version is None:
+        if not module_name:
+            raise ValueError(
+                "Cannot auto-detect version: module object has no __name__ attribute. "
+                "Please provide current_version explicitly."
+            )
+        # Extract package name (first component of module path)
+        package_name = module_name.split(".")[0]
+        current_version = _get_package_version(package_name)
+
+    # Validate current_version upfront for fail-fast feedback before the module scan.
+    try:
+        _parse_version(current_version)
+    except ValueError as err:
+        raise ValueError(f"Invalid current_version '{current_version}': {err}") from err
+
+    # Handle string module path
+    if isinstance(module, str):
+        module = importlib.import_module(module)
+
+    return _check_expiry_for_callables(
+        find_deprecation_wrappers(module, recursive=recursive, include_members=include_members), current_version
+    )
+
+
+def _scan_callable(
+    obj: Any,  # noqa: ANN401
+    module_name: str,
+    qualified_name: str,
+    *,
+    member_name: Optional[str] = None,
+    descriptor_kind: Optional[str] = None,
+) -> Optional[DeprecationWrapperInfo]:
+    """Emit a result if ``obj`` carries ``__deprecated__`` metadata."""
+    if _has_deprecation_meta(obj):
+        info = validate_deprecation_wrapper(obj)
+        api_type = _classify_wrapper_api_type(obj, info, member_name=member_name, descriptor_kind=descriptor_kind)
+        return replace(info, module=module_name, function=qualified_name, api_type=api_type)
+    return None
+
+
+def _descriptor_underlying_callables(obj: Any) -> tuple[Any, ...]:  # noqa: ANN401
+    """Return the underlying callable(s) from a descriptor, or a 1-tuple of *obj* for plain callables.
+
+    Centralises the descriptor-unwrapping logic shared by :func:`_member_has_deprecation_meta` and
+    :func:`_scan_class` so each descriptor type is handled in exactly one place.
+
+    Args:
+        obj: A raw class member — may be a ``classmethod``, ``staticmethod``, ``property``,
+            ``cached_property``, or a plain callable.
+
+    Returns:
+        A tuple of the underlying callable objects.  Empty when ``obj`` is a ``cached_property``
+        with no ``func`` attribute (degenerate case).
+
+    Examples:
+        >>> import warnings
+        >>> _descriptor_underlying_callables(classmethod(warnings.warn))  # doctest: +ELLIPSIS
+        (<built-in function warn>,)
+        >>> _descriptor_underlying_callables(staticmethod(warnings.warn))
+        (<built-in function warn>,)
+
+    """
+    if isinstance(obj, (classmethod, staticmethod)):
+        return (obj.__func__,)
+    if isinstance(obj, property):
+        return tuple(a for a in (obj.fget, obj.fset, obj.fdel) if a is not None)
+    if isinstance(obj, cached_property):
+        func = getattr(obj, "func", None)
+        return (func,) if func is not None else ()
+    return (obj,)
+
+
+def _member_has_deprecation_meta(obj: Any) -> bool:  # noqa: ANN401
+    """Return ``True`` if a class member — peeking through descriptors — carries ``__deprecated__`` metadata.
+
+    Descriptors store the deprecation metadata on the underlying callable (``classmethod``/``staticmethod``
+    ``__func__``, ``property`` accessors, ``cached_property`` ``func``), so a plain :func:`_has_deprecation_meta`
+    on the raw member would miss deprecated descriptors.
+
+    Args:
+        obj: The raw class member (possibly a descriptor) to inspect.
+
+    """
+    return any(_has_deprecation_meta(c) for c in _descriptor_underlying_callables(obj))
+
+
+def _scan_class(cls: Any, module_name: str, cls_name: str) -> list[DeprecationWrapperInfo]:  # noqa: ANN401
+    """Scan class members, peeking through descriptors."""
+    results: list[DeprecationWrapperInfo] = []
+    try:
+        members = _getmembers_static_compat(cls)
+    except (AttributeError, TypeError):
+        return results
+    for attr_name, obj in members:
+        # Skip private/dunder members that are *not* themselves deprecated. Deprecated private or dunder
+        # members (e.g. a deprecated ``_legacy`` method or ``__eq__``) still carry ``__deprecated__`` and must
+        # be surfaced so they can expire — only ``__init__`` is exempt.
+        if attr_name.startswith("_") and attr_name != "__init__" and not _member_has_deprecation_meta(obj):
+            continue
+        qualified = f"{cls_name}.{attr_name}"
+        result: Optional[DeprecationWrapperInfo] = None
+        if isinstance(obj, (classmethod, staticmethod)):
+            kind = "classmethod" if isinstance(obj, classmethod) else "staticmethod"
+            result = _scan_callable(obj.__func__, module_name, qualified, member_name=attr_name, descriptor_kind=kind)
+        elif isinstance(obj, property):
+            _prop_accessor = next(
+                (c for c in _descriptor_underlying_callables(obj) if _has_deprecation_meta(c)),
+                None,
+            )
+            if _prop_accessor is not None:
+                result = _scan_callable(_prop_accessor, module_name, qualified, member_name=attr_name)
+                # Inner-order ``@property @deprecated``: a *plain* ``property`` (not ``_DeprecatedProperty``)
+                # whose ``fget`` is deprecation-wrapped. Only ``fget`` warns; any setter/deleter rebound
+                # afterwards is built from the plain ``property`` base and stays silent. Flag every such
+                # wrapper (getter-only included) since the canonical form is outer ``@deprecated(...) @property``.
+                if (
+                    result is not None
+                    and not isinstance(obj, _DeprecatedProperty)
+                    and obj.fget is not None
+                    and _has_deprecation_meta(obj.fget)
+                ):
+                    result = replace(result, inner_order_property=True)
+        elif isinstance(obj, cached_property):
+            result = _scan_callable(obj.func, module_name, qualified, member_name=attr_name)
+        else:
+            result = _scan_callable(obj, module_name, qualified, member_name=attr_name)
+        if result is not None:
+            results.append(result)
+    return results
+
+
+def _reexport_module(obj: Any) -> Optional[str]:  # noqa: ANN401
+    """Return the defining module of a non-proxy deprecated wrapper, for re-export attribution.
+
+    ``functools.wraps`` preserves ``__module__`` on ``@deprecated`` functions, so a wrapper re-exported through another
+    package's ``__init__`` still reports the module it was defined in and can be attributed there rather than counted
+    once per importing module.
+
+    Proxies (:class:`~deprecate.proxy._DeprecatedProxy`) have no reliable defining module — normal lookup returns the
+    proxy class's own ``__module__`` and the wrapped object commonly lives in a different module than where the proxy
+    was created — so this returns ``None`` for them and the caller falls back to id-based dedup.
+
+    """
+    if isinstance(obj, _DeprecatedProxy):
+        return None
+    return getattr(obj, "__module__", None)
+
+
+def _same_top_package(mod_a: str, mod_b: str) -> bool:
+    """Return True when ``mod_a`` and ``mod_b`` share the same top-level package."""
+    return mod_a.split(".")[0] == mod_b.split(".")[0]
+
+
+def _scan_module(
+    mod: Any,  # noqa: ANN401
+    *,
+    include_members: bool,
+    seen: set[int],
+    attribute_to_defining_module: bool = True,
+) -> list[DeprecationWrapperInfo]:
+    """Scan a single module for deprecated functions and class members.
+
+    ``seen`` accumulates ``id()`` of every wrapper already recorded across the whole :func:`find_deprecation_wrappers`
+    run so a re-exported wrapper (the same object bound in more than one module) is reported once, not once per
+    importing module.
+
+    When ``attribute_to_defining_module`` is True (the default), wrappers whose ``__module__`` differs from ``mod_name``
+    but belongs to the same top-level package are skipped — they will be counted when the recursive walk reaches their
+    defining submodule.  Pass False when the defining submodule will not be visited (package scanned with
+    ``recursive=False``) so that re-exports visible on the public surface are not silently dropped.
+
+    """
+    results: list[DeprecationWrapperInfo] = []
+    try:
+        members = _getmembers_static_compat(mod)
+    except (AttributeError, TypeError, ImportError):
+        return results
+
+    mod_name = mod.__name__ if hasattr(mod, "__name__") else str(mod)
+    for name, obj in members:
+        if name.startswith("_"):
+            continue
+
+        if _has_deprecation_meta(obj):
+            # Attribute a re-exported wrapper to its defining module, not to every module that
+            # merely re-exports it. Non-proxy wrappers carry a reliable ``__module__``; proxies do
+            # not, so they fall through to the id-based dedup below.
+            # Guard 1 — only apply when a recursive walk will visit the defining module.
+            # Guard 2 — only skip when the defining module is in the same top-level package;
+            #   if ``__module__`` points to an external package (e.g. a ``functools.partial``
+            #   wrapper whose ``__module__`` was not propagated by ``functools.wraps``), the
+            #   defining module will never be visited and the wrapper would be dropped silently.
+            defining_module = _reexport_module(obj)
+            if (
+                attribute_to_defining_module
+                and defining_module is not None
+                and defining_module != mod_name
+                and _same_top_package(defining_module, mod_name)
+            ):
+                continue
+            if id(obj) in seen:
+                continue
+            seen.add(id(obj))
+            result = _scan_callable(obj, mod_name, name)
+            if result is not None:
+                results.append(result)
+        elif include_members and inspect.isclass(obj) and getattr(obj, "__module__", None) == mod_name:
+            results.extend(_scan_class(obj, mod_name, name))
+    return results
+
+
+def find_deprecation_wrappers(
+    module: Union[Any, str],  # noqa: ANN401
+    recursive: bool = True,
+    include_members: bool = True,
+) -> list[DeprecationWrapperInfo]:
+    """Scan a module or package for deprecated wrappers and validate them.
+
+    This is a development/CI tool to scan a codebase for all wrappers created with :func:`~deprecate.deprecated`,
+    :func:`~deprecate.deprecated_class`, or :func:`~deprecate.deprecated_instance` and validate that each wrapper
+    configuration is meaningful.
+    Returns comprehensive information about each deprecated wrapper including validation results that help identify
+    misconfigured wrappers.
+
+    Args:
+        module: A Python module or package to scan for deprecated wrappers. Can be:
+            - Imported module object (e.g., ``import my_package; find_deprecation_wrappers(my_package)``)
+            - String module path (e.g., ``find_deprecation_wrappers("my_package.submodule")``)
+        recursive: If True (default), recursively scan submodules. If False, only scan the top-level module.
+        include_members: If True, also scan deprecated methods and constructors defined on classes.
+
+    Returns:
+        List of :class:`~deprecate.audit.DeprecationWrapperInfo` dataclasses, one per deprecated wrapper found.
+        Each contains:
+            - module: Module name where the wrapper is defined
+            - function: Wrapper name
+            - deprecated_info: DeprecationConfig metadata from the decorator (``__deprecated__`` attribute)
+            - invalid_args: List of args_mapping keys not in wrapper signature
+            - empty_args_mapping: True if args_mapping is None or empty
+            - identity_args_mapping: List of identity mappings (key == value)
+            - self_reference: True if target points to same wrapper
+            - no_effect: True if wrapper has zero impact
+
+    Example:
+        >>> from deprecate import find_deprecation_wrappers
+        >>> from tests import collection_deprecate as my_package
+        >>>
+        >>> results = find_deprecation_wrappers(my_package)
+        >>> print(len(results) > 0)  # Should find deprecated wrappers
+        True
+        >>> # Also works with string module paths
+        >>> results = find_deprecation_wrappers("tests.collection_deprecate")
+        >>> print(len(results) > 0)
+        True
+
+        >>> # Filter to find only problematic wrappers
+        >>> problematic = [r for r in results if r.invalid_args or r.no_effect]
+        >>> print(len(results) > 0)  # May or may not have problematic ones
+        True
+
+    Note:
+        - Requires that the module be importable
+        - Recursive scans import every submodule of the package, executing their module-level code; packages
+          with heavy import-time work (GPU init, network access) make the scan correspondingly expensive
+        - Skips submodules that fail to import — any exception raised by module-level code is reported as a
+          ``UserWarning`` (``audit: skipped <module>: ...``) and the scan continues
+        - Inspects the ``__deprecated__`` attribute set by the :func:`~deprecate.deprecated` decorator
+        - Skips private/magic attributes and imports from other modules
+        - Uses static member inspection to avoid scan-time side effects from dynamic attribute access
+
+    """
+    results: list[DeprecationWrapperInfo] = []
+    # Track object identity across the whole scan so a wrapper re-exported through several modules
+    # (the standard packaging pattern) is recorded once, not once per importing module.
+    seen: set[int] = set()
+
+    # Handle string module path
+    if isinstance(module, str):
+        module = importlib.import_module(module)
+
+    # Disable the attribution filter only when the top module is a package AND recursive=False.
+    # In that case the submodules that own the re-exported wrappers will never be visited, so
+    # skipping re-exports would silently drop them.  For single-file modules or recursive package
+    # scans the old behaviour (attribute re-exports to their defining submodule) is preserved.
+    _is_package = hasattr(module, "__path__")
+    results.extend(
+        _scan_module(
+            module,
+            include_members=include_members,
+            seen=seen,
+            attribute_to_defining_module=not (_is_package and not recursive),
+        )
+    )
+
+    if recursive and _is_package:
+        try:
+            packages = list(
+                pkgutil.walk_packages(path=module.__path__, prefix=module.__name__ + ".", onerror=lambda x: None)
+            )
+        except (OSError, ImportError):
+            packages = []
+
+        for _importer, modname, _ispkg in packages:
+            # Submodule top-level code can raise anything at import time (RuntimeError, OSError, KeyError from
+            # env lookups, ...), not just ImportError. One broken submodule must not abort the whole scan — and
+            # with it every audit gate built on top — so catch broad Exception, keep the signal via a warning,
+            # and continue with the remaining submodules.
+            try:
+                submod = importlib.import_module(modname)
+            except Exception as exc:
+                warnings.warn(f"audit: skipped {modname}: {exc!r}", stacklevel=2)
+                continue
+            results.extend(_scan_module(submod, include_members=include_members, seen=seen))
+
+    return results
+
+
+def _resolve_table_version(
+    module: Union[Any, str],  # noqa: ANN401
+    *,
+    current_version: Optional[str],
+) -> tuple[Optional[str], Optional["Version"]]:
+    """Resolve report version string and optional parsed version object."""
+    module_name = module if isinstance(module, str) else getattr(module, "__name__", None)
+    resolved_version = current_version
+
+    if resolved_version is None and module_name:
+        with suppress(ImportError):
+            resolved_version = _get_package_version(module_name.split(".")[0])
+
+    if resolved_version is None:
+        return None, None
+
+    try:
+        return resolved_version, _parse_version(resolved_version)
+    except ImportError:
+        return resolved_version, None
+    except ValueError as err:
+        if current_version is not None:
+            raise ValueError(f"Invalid current_version '{current_version}': {err}") from err
+        return resolved_version, None
+
+
+def _safe_parse_version(version: str) -> Optional["Version"]:
+    """Best-effort version parser for report status evaluation."""
+    if not version:
+        return None
+    try:
+        return _parse_version(version)
+    except (ImportError, ValueError):
+        return None
+
+
+def _format_report_symbol(info: DeprecationWrapperInfo) -> str:
+    """Return a stable fully-qualified label for report rows."""
+    return f"{info.module}.{info.function}" if info.module else info.function
+
+
+def _format_report_target(target: Any) -> str:  # noqa: ANN401
+    """Format replacement target name for report rows."""
+    if target is None or target is TargetMode.NOTIFY:
+        return "—"
+    if isinstance(target, TargetMode):
+        return target.value
+    if isinstance(target, _DeprecatedProxy):
+        # A chained-proxy target (the New API is itself a deprecated alias). Bypass proxy
+        # ``__getattr__`` interception to read the static metadata directly — ``__deprecated__``
+        # is stored in the instance ``__dict__`` via ``object.__setattr__`` in ``_DeprecatedProxy.__init__``,
+        # so ``object.__getattribute__`` retrieves it without triggering forwarding logic.
+        return object.__getattribute__(target, "__deprecated__").name
+    if callable(target):
+        target_module = getattr(target, "__module__", "")
+        target_name = getattr(target, "__qualname__", getattr(target, "__name__", str(target)))
+        return f"{target_module}.{target_name}" if target_module else target_name
+    return str(target)
+
+
+def _classify_member_api_type(member_name: str, descriptor_kind: Optional[str], has_mapping: bool) -> str:
+    """Classify the API type for a deprecated class member (method, constructor, descriptor)."""
+    if member_name == "__init__":
+        return "class constructor args" if has_mapping else "class constructor"
+    if descriptor_kind == "classmethod":
+        return "classmethod args" if has_mapping else "classmethod"
+    if descriptor_kind == "staticmethod":
+        return "staticmethod args" if has_mapping else "staticmethod"
+    return "class method args" if has_mapping else "class method"
+
+
+def _classify_wrapper_api_type(
+    wrapped_obj: Any,  # noqa: ANN401
+    info: DeprecationWrapperInfo,
+    *,
+    member_name: Optional[str] = None,
+    descriptor_kind: Optional[str] = None,
+) -> str:
+    """Classify wrapper kind for markdown report rows."""
+    has_mapping = bool(info.deprecated_info.args_mapping)
+
+    if member_name is not None:
+        return _classify_member_api_type(member_name, descriptor_kind, has_mapping)
+
+    if isinstance(wrapped_obj, _DeprecatedProxy):
+        while isinstance(wrapped_obj, _DeprecatedProxy):
+            wrapped_obj = wrapped_obj.wrapped
+        if inspect.isclass(wrapped_obj):
+            if is_dataclass(wrapped_obj):
+                return "dataclass attributes" if has_mapping else "dataclass"
+            return "class"
+        return "data"
+
+    if inspect.isclass(wrapped_obj):
+        if is_dataclass(wrapped_obj):
+            return "dataclass attributes" if has_mapping else "dataclass"
+        return "class"
+
+    if has_mapping:
+        return "args"
+
+    return "callable"
+
+
+def _format_report_api_type(info: DeprecationWrapperInfo) -> str:
+    """Return api_type with backward-compatible fallback."""
+    if info.api_type:
+        return info.api_type
+    return "args" if info.deprecated_info.args_mapping else "callable"
+
+
+def _report_row_sort_key(info: DeprecationWrapperInfo) -> tuple[str, str, str, bool, str]:
+    """Sort report rows by module and symbol family, keeping args-variants adjacent."""
+    function = info.function or ""
+    top_level = function.split(".", maxsplit=1)[0] if function else ""
+    api_type = _format_report_api_type(info)
+    return (info.module or "", top_level, function, api_type.endswith(" args"), api_type)
+
+
+def _format_version(version: Optional[str], *, missing: str = "—") -> str:
+    """Format version values with a stable ``v`` prefix for report output."""
+    if not version:
+        return missing
+    # Strip a single left-anchored leading ``v``/``V`` (``lstrip`` would remove *all* leading v's).
+    return f"v{re.sub(r'^[vV]', '', version)}"
+
+
+def _get_deprecation_status(info: DeprecationWrapperInfo, current_version: Optional["Version"]) -> DeprecationStatus:
+    """Classify one deprecated symbol into a report lifecycle status."""
+    if current_version is None:
+        return (
+            DeprecationStatus.NO_REMOVAL_TARGET
+            if not info.deprecated_info.remove_in
+            else DeprecationStatus.STATUS_UNKNOWN
+        )
+
+    deprecated_in = _safe_parse_version(info.deprecated_info.deprecated_in)
+    if deprecated_in is not None and current_version < deprecated_in:
+        return DeprecationStatus.SCHEDULED_DEPRECATION
+
+    remove_in = info.deprecated_info.remove_in
+    if not remove_in:
+        return DeprecationStatus.NO_REMOVAL_TARGET
+
+    remove_version = _safe_parse_version(remove_in)
+    if remove_version is None:
+        return DeprecationStatus.INVALID_REMOVAL_TARGET
+
+    if current_version >= remove_version:
+        return DeprecationStatus.PAST_REMOVAL_DATE
+
+    # Pre-release of the same base release as remove_in gets an elevated status:
+    # dev/alpha/beta → REMOVAL_IMMINENT; rc → REMOVE_BEFORE_RELEASE.
+    # base_version strips pre/post/dev/local markers so "1.8" == "1.8.0" compare equal.
+    if current_version.is_prerelease:
+        try:
+            _VersionType = type(current_version)  # noqa: N806
+            same_base = _VersionType(current_version.base_version) == _VersionType(remove_version.base_version)
+        except Exception:
+            same_base = False
+        if same_base:
+            if current_version.pre is not None and current_version.pre[0] == "rc":
+                return DeprecationStatus.REMOVE_BEFORE_RELEASE
+            return DeprecationStatus.REMOVAL_IMMINENT
+
+    return DeprecationStatus.ACTIVE_WARNING
+
+
+def _format_matrix_row(info: DeprecationWrapperInfo, col_idx: dict[str, int], n_versions: int) -> str:
+    """Format one matrix-style table row for a deprecated wrapper."""
+    markers: list[str] = [" "] * n_versions
+    dep_in = info.deprecated_info.deprecated_in
+    rem_in = info.deprecated_info.remove_in
+    if dep_in and dep_in in col_idx:
+        markers[col_idx[dep_in]] = "D"
+    if rem_in and rem_in in col_idx:
+        i = col_idx[rem_in]
+        markers[i] = "R" if markers[i] == " " else "D/R"
+    return (
+        "| "
+        f"`{_format_report_symbol(info)}` | "
+        f"{_format_report_api_type(info)} | "
+        f"`{_format_report_target(info.deprecated_info.target)}` | " + " | ".join(markers) + " |"
+    )
+
+
+def generate_deprecation_table(
+    module: Union[Any, str],  # noqa: ANN401
+    current_version: Optional[str] = None,
+    recursive: bool = True,
+    style: Union[TableStyle, str] = TableStyle.COMPACT,
+    include_members: bool = True,
+    *,
+    _wrappers: Optional[list["DeprecationWrapperInfo"]] = None,
+) -> str:
+    """Generate a markdown table summarizing deprecated wrappers.
+
+    The table is derived from ``__deprecated__`` metadata and includes both
+    top-level wrappers and deprecated class members (methods/constructors).
+
+    Args:
+        module: Imported module/package object or string module path to scan.
+        current_version: Optional current package version for lifecycle status
+            evaluation in compact style. If ``None``, auto-detection is attempted
+            via the package name; status falls back to ``"⚪ Status Unknown"`` when
+            ``packaging`` is not installed.
+        recursive: If True (default), include submodules in the scan.
+        style: Table format — ``"compact"`` or ``"matrix"``.
+            - ``"compact"``: ``Original API | API Type | New API | Deprecated | Remove | Current Status``
+            - ``"matrix"``: ``Original API | API Type | New API | <all versions...>``, with markers
+              ``D`` (deprecated) and ``R`` (remove) in version columns.
+        include_members: If True (default), include deprecated class members (methods, constructors).
+
+    Returns:
+        Markdown string containing a formatted table. When a version is
+        resolvable (either from current_version or auto-detected), the
+        first line is an HTML comment <!-- Current version: X.Y -->
+        followed by the header row and alignment row. When no version can be
+        resolved, the first line is the header row directly.
+
+    Raises:
+        ValueError: If ``style`` is not ``"compact"`` or ``"matrix"``, or if
+            ``current_version`` is supplied but is not a valid PEP 440 version
+            string and ``packaging`` is installed.
+
+    Example:
+        >>> from tests import collection_deprecate as pkg
+        >>> report = generate_deprecation_table(pkg, recursive=False)
+        >>> report.splitlines()[0]
+        '| Original API | API Type | New API | Deprecated | Remove | Current Status |'
+
+    """
+    try:
+        style = TableStyle(style)
+    except ValueError as err:
+        raise ValueError(
+            f"Invalid style {style!r}. Expected one of: {', '.join(s.value for s in TableStyle)}."
+        ) from err
+
+    resolved_version, parsed_version = _resolve_table_version(module, current_version=current_version)
+    if _wrappers is None:
+        _wrappers = find_deprecation_wrappers(module, recursive=recursive, include_members=include_members)
+    wrappers = sorted(
+        _wrappers,
+        key=_report_row_sort_key,
+    )
+
+    if style == TableStyle.COMPACT:
+        rows = [
+            "| Original API | API Type | New API | Deprecated | Remove | Current Status |",
+            "| :--- | :--- | :--- | :---: | :---: | :--- |",
+        ]
+
+        for info in wrappers:
+            rows.append(
+                "| "
+                f"`{_format_report_symbol(info)}` | "
+                f"{_format_report_api_type(info)} | "
+                f"`{_format_report_target(info.deprecated_info.target)}` | "
+                f"{_format_version(info.deprecated_info.deprecated_in)} | "
+                f"{_format_version(info.deprecated_info.remove_in)} | "
+                f"{_get_deprecation_status(info, parsed_version).value} |"
+            )
+    else:
+        version_map: dict[str, Optional[Version]] = {}
+        for info in wrappers:
+            for version in (info.deprecated_info.deprecated_in, info.deprecated_info.remove_in):
+                if version and version not in version_map:
+                    version_map[version] = _safe_parse_version(version)
+
+        sorted_versions = sorted(
+            version_map,
+            key=lambda version: (
+                version_map[version] is None,
+                version_map[version] if version_map[version] is not None else version,
+            ),
+        )
+        version_headers = [_format_version(version) for version in sorted_versions]
+        header_row = "| Original API | API Type | New API | " + " | ".join(version_headers) + " |"
+        divider_row = "| :--- | :--- | :--- | " + " | ".join(":---:" for _ in version_headers) + " |"
+        col_idx = {v: i for i, v in enumerate(sorted_versions)}
+        n_versions = len(sorted_versions)
+        rows = [header_row, divider_row]
+
+        for info in wrappers:
+            rows.append(_format_matrix_row(info, col_idx, n_versions))
+
+    if resolved_version is not None:
+        rows.insert(0, f"<!-- Current version: {resolved_version} -->")
+
+    return "\n".join(rows)
+
+
+def validate_deprecation_chains(
+    module: Union[Any, str],  # noqa: ANN401
+    recursive: bool = True,
+) -> list[DeprecationWrapperInfo]:
+    """Validate that deprecated functions don't form chains with other deprecated code.
+
+    This is a developer utility that scans a module or package for deprecated functions that form chains in two ways:
+
+    1. **TARGET chains**: The ``target`` argument points to another deprecated callable instead of the final
+       non-deprecated implementation.
+    2. **STACKED chains**: Multiple ``@deprecated(target=TargetMode.ARGS_REMAP, ...)`` decorators are stacked on the
+       same function with argument mappings that should be collapsed, or a callable ``target`` is itself a
+       self-deprecation (``target=TargetMode.ARGS_REMAP``) requiring mapping composition.
+
+    Both types are wasteful: wrappers should point directly to the final (non-deprecated) implementation with
+    composed argument mappings.
+
+    Detection is based purely on decorator metadata (``__deprecated__`` attributes) — no source-code or AST
+    inspection is performed.
+
+    Args:
+        module: A Python module or package to scan for deprecation chains. Can be:
+            - Imported module object (e.g., ``import my_package; validate_deprecation_chains(my_package)``)
+            - String module path (e.g., ``validate_deprecation_chains("my_package.submodule")``)
+        recursive: If True (default), recursively scan submodules. If False, only scan the top-level module.
+
+    Returns:
+        List of :class:`~deprecate.audit.DeprecationWrapperInfo` where ``chain_type`` is not ``None``, i.e. every
+        deprecated wrapper that forms a chain (``ChainType.TARGET`` or ``ChainType.STACKED``).
+
+    Example:
+        >>> from deprecate import validate_deprecation_chains
+        >>> import tests.collection_chains as test_module
+        >>>
+        >>> issues = validate_deprecation_chains(test_module, recursive=False)
+        >>> len(issues) > 0  # Should find chains
+        True
+
+    Note:
+        - Only flags callees using the :func:`~deprecate.deprecated` decorator
+        - Uses :func:`~deprecate.audit.find_deprecation_wrappers` and inspects ``chain_type`` to detect chains
+
+    """
+    return [info for info in find_deprecation_wrappers(module, recursive=recursive) if info.chain_type is not None]
+
+
+def validate_mapping_compatibility(
+    module: Union[Any, str],  # noqa: ANN401
+    recursive: bool = True,
+) -> list[DeprecationWrapperInfo]:
+    """Return wrappers whose ``args_mapping`` remaps deprecated names to POSITIONAL_ONLY constructor params.
+
+    A non-empty ``args_mapping_positional_only`` on the returned ``DeprecationWrapperInfo`` means the
+    proxy falls back to ``setattr`` at call time instead of forwarding the remapped kwarg.  Use this
+    validator in CI to detect :func:`~deprecate.proxy.deprecated_class` configurations that silently
+    degrade to attribute assignment and may not behave as expected on all target class types.
+
+    Args:
+        module: A Python module or package to scan.  Accepts an imported module object or a dotted
+            module path string.
+        recursive: When ``True`` (default) recursively scan submodules.
+
+    Returns:
+        List of ``DeprecationWrapperInfo`` instances whose ``args_mapping_positional_only`` field is
+        non-empty.  Returns an empty list when no incompatibilities are found.
+
+    Examples:
+        >>> from deprecate import validate_mapping_compatibility
+        >>> import tests.collection_deprecate as col
+        >>> results = validate_mapping_compatibility(col, recursive=False)
+        >>> len(results) > 0  # DepPositionalOnly remaps to a POSITIONAL_ONLY param
+        True
+        >>> results[0].function
+        'DepPositionalOnly'
+
+    """
+    return [
+        info for info in find_deprecation_wrappers(module, recursive=recursive) if info.args_mapping_positional_only
+    ]
+
+
+# ---------------------------------------------------------------------------
+# Backward-compatibility shims — deprecated since 0.6, removed in 1.0
+# ---------------------------------------------------------------------------
+
+# Import delayed to avoid a module-level circular import cycle:
+# audit.py is imported by __init__.py before deprecation.py is available.
+from deprecate.deprecation import deprecated  # noqa: E402
+
+
+@deprecated(target=validate_deprecation_wrapper, deprecated_in="0.6", remove_in="1.0")
+def validate_deprecated_callable(func: Callable) -> DeprecationWrapperInfo:
+    """Use :func:`~deprecate.audit.validate_deprecation_wrapper` instead."""
+    return validate_deprecation_wrapper(func)
+
+
+@deprecated(target=find_deprecation_wrappers, deprecated_in="0.6", remove_in="1.0")
+def find_deprecated_callables(
+    module: Union[Any, str],  # noqa: ANN401
+    recursive: bool = True,
+) -> list[DeprecationWrapperInfo]:
+    """Use :func:`~deprecate.audit.find_deprecation_wrappers` instead."""
+    return find_deprecation_wrappers(module, recursive)
+
+
+@deprecated_class(target=DeprecationWrapperInfo, deprecated_in="0.6", remove_in="1.0")
+class DeprecatedCallableInfo:
+    """Deprecated name for :class:`~deprecate.audit.DeprecationWrapperInfo`, use that instead."""

.venv/lib/python3.12/site-packages/deprecate/docstring/__init__.py

@@ -0,0 +1,9 @@
+"""Docstring utilities for pyDeprecate.
+
+Sub-modules:
+
+- :mod:`deprecate.docstring.inject` — runtime docstring injection logic.
+- :mod:`deprecate.docstring.griffe_ext` — Griffe extension for mkdocstrings / MkDocs. *(beta)*
+- :mod:`deprecate.docstring.sphinx_ext` — Sphinx autodoc extension. *(beta)*
+
+"""

.venv/lib/python3.12/site-packages/deprecate/docstring/griffe_ext.py

@@ -0,0 +1,139 @@
+"""Griffe extension: expose runtime-modified docstrings to mkdocstrings.
+
+.. note::
+    **Beta feature** — the public API of this module (class name, hook method
+    signatures) may change in a minor release while it stabilises.
+
+``@deprecated(update_docstring=True)`` writes the deprecation notice into
+``fn.__doc__`` at decoration time.  Griffe — the engine used by mkdocstrings —
+reads docstrings from the source AST, so it never sees that runtime change.
+
+This extension bridges the gap: after Griffe has visited a module it imports
+the module at runtime and replaces every AST docstring whose callable carries
+a ``__deprecated__`` attribute (set by pyDeprecate) with the live ``__doc__``.
+
+Usage in ``mkdocs.yml``::
+
+    plugins:
+      - mkdocstrings:
+          handlers:
+            python:
+              options:
+                extensions:
+                  - deprecate.docstring.griffe_ext:RuntimeDocstrings
+
+Requirements:
+    ``griffe`` is a dependency of ``mkdocstrings[python]`` and will always be
+    present in an MkDocs environment that uses mkdocstrings.  Importing this
+    module without ``griffe`` installed is safe — ``RuntimeDocstrings`` simply
+    will not be defined.
+
+"""
+
+from __future__ import annotations
+
+import importlib
+import sys
+
+try:
+    import griffe
+except ImportError:
+    pass
+else:
+
+    class RuntimeDocstrings(griffe.Extension):
+        """Update Griffe docstrings to reflect decorator-modified ``__doc__``."""
+
+        def on_module(self, *, mod: griffe.Module, loader: griffe.GriffeLoader, **kwargs: object) -> None:
+            """Run after a module is fully loaded by Griffe.
+
+            For each function or method in *mod* that carries a ``__deprecated__`` attribute (set by pyDeprecate),
+            replace the Griffe docstring with the runtime value so that mkdocstrings renders the injected notice.
+
+            """
+            runtime_mod = self._import_module(mod)
+            if runtime_mod is None:
+                return
+
+            for name, obj in mod.members.items():
+                if isinstance(obj, griffe.Object):
+                    self._update_obj(obj, runtime_mod, name)
+
+        @staticmethod
+        def _import_module(mod: griffe.Module) -> object:
+            """Import *mod* at runtime, adding its package root to sys.path if needed.
+
+            griffe loads modules via its own search_paths which are not on sys.path, so a plain
+            ``importlib.import_module(mod.name)`` will fail for modules that live outside the installed packages (e.g. a
+            local ``demo.py``). We derive the package root from ``mod.filepath`` — walking up one level per dotted name
+            component so that both single-file modules (``demo``) and package sub-modules (``pkg.submod``) resolve
+            correctly — and temporarily add it to sys.path so the import can succeed.
+
+            """
+            # Fast path: module is already importable (installed package, etc.)
+            try:
+                return importlib.import_module(mod.name)
+            except (ImportError, ModuleNotFoundError):
+                pass
+
+            # Slow path: add the package root derived from mod.filepath.
+            filepath = getattr(mod, "filepath", None)
+            if filepath is None:
+                return None
+
+            import pathlib
+
+            # Walk up one level per name component so sys.path contains the
+            # *root* of the package tree, not a sub-directory.
+            # Examples (depth before __init__ adjustment):
+            #   "demo"     /project/demo.py           → depth=0, parents[0]=/project ✓
+            #   "pkg.sub"  /project/pkg/sub.py        → depth=1, parents[1]=/project ✓
+            # For packages the filepath points to __init__.py, adding one more
+            # level:
+            #   "pkg"      /project/pkg/__init__.py   → depth=0+1=1, parents[1]=/project ✓
+            #   "pkg.sub"  /project/pkg/sub/__init__.py → depth=1+1=2, parents[2]=/project ✓
+            p = pathlib.Path(filepath)
+            depth = len(mod.name.split(".")) - 1
+            if p.name == "__init__.py":
+                depth += 1
+            source_dir = str(p.parents[depth])
+            added = source_dir not in sys.path
+            if added:
+                sys.path.insert(0, source_dir)
+            try:
+                return importlib.import_module(mod.name)
+            except (ImportError, ModuleNotFoundError):
+                return None
+            finally:
+                if added:
+                    sys.path.remove(source_dir)
+
+        def _update_obj(self, obj: griffe.Object, parent: object, name: str) -> None:
+            """Patch obj with runtime deprecation metadata from the live import."""
+            runtime_obj = getattr(parent, name, None)
+            if runtime_obj is None:
+                return
+
+            if isinstance(obj, griffe.Function):
+                self._replace_docstring(obj, runtime_obj)
+            elif isinstance(obj, griffe.Class):
+                self._replace_docstring(obj, runtime_obj)
+                for member_name, member in obj.members.items():
+                    if isinstance(member, griffe.Object):
+                        self._update_obj(member, runtime_obj, member_name)
+
+        @staticmethod
+        def _replace_docstring(griffe_obj: griffe.Object, runtime_obj: object) -> None:
+            """Overwrite the Griffe docstring when the runtime ``__doc__`` differs."""
+            if not getattr(runtime_obj, "__deprecated__", None):
+                return
+            runtime_doc = getattr(runtime_obj, "__doc__", None)
+            if not runtime_doc:
+                return
+            if griffe_obj.docstring is None:
+                return
+            griffe_obj.docstring.value = runtime_doc
+            # Griffe caches parsed sections in docstring.__dict__["parsed"].
+            # If the cache was populated from the static source before this
+            # extension ran, it must be cleared so the next access re-parses from the updated value.
+            griffe_obj.docstring.__dict__.pop("parsed", None)

.venv/lib/python3.12/site-packages/deprecate/docstring/inject.py

@@ -0,0 +1,626 @@
+"""Helpers for annotating function docstrings with deprecation information.
+
+This module owns all logic that reads or modifies a callable's ``__doc__``
+attribute during deprecation decoration.  It supports both Google-style
+(``Args:`` / ``Arguments:``), NumPy-style (``Parameters`` + underline),
+and Sphinx-style (``:param ...:``) docstrings, plus MkDocs/Markdown output.
+
+Key Components:
+    - String constants (``TEMPLATE_DOC_*``) for reusable message fragments.
+    - Style normalizer: :func:`normalize_docstring_style`, :func:`_auto_detect_style`
+    - Section-aware insertion helpers: :func:`find_docstring_insertion_index`,
+      :func:`is_numpy_underline`
+    - Per-argument note builder: :func:`_build_arg_deprecation_note`
+    - Google-style section helpers: :func:`_find_google_args_section`,
+      :func:`_get_google_arg_indents`, :func:`_find_google_arg_line`
+    - Shared continuation-line helper: :func:`_find_entry_end`
+    - Annotators: :func:`_annotate_google_style_arg`,
+      :func:`_annotate_sphinx_style_arg`
+    - Notice builder: :func:`_build_general_notice_lines`
+    - Orchestrator: :func:`_update_docstring_with_deprecation`
+
+Copyright (C) 2020-2026 Jiri Borovec <6035284+Borda@users.noreply.github.com>
+
+"""
+
+import inspect
+import os
+import re
+import sys
+from typing import Literal, Optional, cast
+
+from deprecate._types import (
+    DeprecationConfig,
+    TargetMode,
+    _has_deprecation_meta,
+)
+
+#: Default templates for documentation with deprecated callable — RST/Sphinx style
+TEMPLATE_DOC_DEPRECATED_RST = [
+    ".. deprecated:: %(deprecated_in)s",
+    "   %(remove_text)s",
+    "   %(target_text)s",
+]
+#: Default templates for documentation with deprecated callable — MkDocs/Markdown style
+TEMPLATE_DOC_DEPRECATED_MKDOCS = [
+    '!!! warning "Deprecated in %(deprecated_in)s"',
+    "    %(remove_text)s",
+    "    %(target_text)s",
+]
+#: Inline docstring note for a deprecated argument — with ``deprecated_in`` version
+TEMPLATE_DOC_ARG_DEPRECATED_SINCE = "Deprecated since v%(deprecated_in)s \u2014 %(reason)s."
+#: Inline docstring note for a deprecated argument — without version information
+TEMPLATE_DOC_ARG_DEPRECATED = "Deprecated \u2014 %(reason)s."
+#: Suffix appended to arg deprecation note when ``remove_in`` is provided
+TEMPLATE_DOC_ARG_REMOVE = " Will be removed in v%(remove_in)s."
+#: Reason phrase used when the deprecated argument is simply removed
+TEMPLATE_DOC_ARG_REASON_REMOVED = "no longer used"
+#: Reason phrase used when the deprecated argument is renamed; ``%(new_arg)s`` is substituted
+TEMPLATE_DOC_ARG_REASON_RENAMED = "use `%(new_arg)s` instead"
+
+DOCSTRING_STYLE_ALIASES = {"auto": "auto", "rst": "rst", "mkdocs": "mkdocs", "markdown": "mkdocs"}
+SUPPORTED_DOCSTRING_STYLES: frozenset[str] = frozenset(DOCSTRING_STYLE_ALIASES)
+GOOGLE_DOCSTRING_SECTIONS = {
+    "args:",
+    "arguments:",
+    "attributes:",
+    "examples:",
+    "notes:",
+    "parameters:",
+    "raises:",
+    "returns:",
+    "warns:",
+    "yields:",
+}
+NUMPY_DOCSTRING_SECTIONS = {
+    "attributes",
+    "examples",
+    "methods",
+    "notes",
+    "other parameters",
+    "parameters",
+    "raises",
+    "returns",
+    "warns",
+    "yields",
+}
+
+
+def is_numpy_underline(line: str) -> bool:
+    """Return ``True`` when the line is a NumPy-style section underline."""
+    stripped = line.strip()
+    return len(stripped) >= 3 and all(char == "-" for char in stripped)
+
+
+def find_docstring_insertion_index(lines: list[str]) -> int:
+    """Find insertion index before first Google/NumPy section header."""
+    for idx, line in enumerate(lines):
+        if line.strip().lower() in GOOGLE_DOCSTRING_SECTIONS:
+            return idx
+        if (
+            idx + 1 < len(lines)
+            and line.strip().lower() in NUMPY_DOCSTRING_SECTIONS
+            and is_numpy_underline(lines[idx + 1])
+        ):
+            return idx
+    return len(lines)
+
+
+def _auto_detect_style() -> Literal["rst", "mkdocs"]:
+    """Detect documentation engine from environment or process name.
+
+    Resolution order:
+
+    1. ``DEPRECATE_DOCSTRING_STYLE`` env var — explicit override, takes highest priority.
+    2. ``sys.modules`` — ``mkdocs`` imported → MkDocs build in progress.
+    3. ``sys.argv[0]`` full path — ``mkdocs`` anywhere in the path string.
+    4. Default → ``"rst"``.
+
+    """
+    env_style = os.environ.get("DEPRECATE_DOCSTRING_STYLE", "").lower()
+    if env_style in ("mkdocs", "markdown"):
+        return "mkdocs"
+    if env_style == "rst":
+        return "rst"
+    # sys.modules check catches `python -m mkdocs` where argv[0] is __main__.py
+    if "mkdocs" in sys.modules:
+        return "mkdocs"
+    if sys.argv and "mkdocs" in sys.argv[0].lower():
+        return "mkdocs"
+    return "rst"
+
+
+def normalize_docstring_style(docstring_style: str) -> Literal["rst", "mkdocs"]:
+    """Validate and normalize docstring style aliases."""
+    if not isinstance(docstring_style, str):
+        raise ValueError(
+            "Invalid `docstring_style` value "
+            f"{docstring_style!r}. Supported styles are: {sorted(SUPPORTED_DOCSTRING_STYLES)!r}."
+        )
+    normalized_style = DOCSTRING_STYLE_ALIASES.get(docstring_style.lower())
+    if normalized_style is None:
+        raise ValueError(
+            "Invalid `docstring_style` value "
+            f"{docstring_style!r}. Supported styles are: {sorted(SUPPORTED_DOCSTRING_STYLES)!r}."
+        )
+    if normalized_style == "auto":
+        return _auto_detect_style()
+    return cast(Literal["rst", "mkdocs"], normalized_style)
+
+
+def _build_arg_deprecation_note(new_arg: Optional[str], deprecated_in: str, remove_in: str) -> str:
+    """Build an inline deprecation note string for a single deprecated argument.
+
+    Args:
+        new_arg: Replacement argument name, or ``None`` when the argument is simply removed.
+        deprecated_in: Version string when the argument was deprecated (e.g. ``"1.8"``).
+        remove_in: Version string when the argument will be removed (e.g. ``"1.9"``).
+
+    Returns:
+        A one-line deprecation note suitable for embedding in a docstring.
+
+    Example:
+        >>> _build_arg_deprecation_note(None, "1.8", "1.9")
+        'Deprecated since v1.8 — no longer used. Will be removed in v1.9.'
+        >>> _build_arg_deprecation_note("new_arg", "1.8", "1.9")
+        'Deprecated since v1.8 — use `new_arg` instead. Will be removed in v1.9.'
+
+    """
+    reason = TEMPLATE_DOC_ARG_REASON_RENAMED % {"new_arg": new_arg} if new_arg else TEMPLATE_DOC_ARG_REASON_REMOVED
+    template = TEMPLATE_DOC_ARG_DEPRECATED_SINCE if deprecated_in else TEMPLATE_DOC_ARG_DEPRECATED
+    note = template % {"deprecated_in": deprecated_in, "reason": reason}
+    if remove_in:
+        note += TEMPLATE_DOC_ARG_REMOVE % {"remove_in": remove_in}
+    return note
+
+
+def _find_google_args_section(lines: list[str]) -> tuple[int, int]:
+    """Return ``(section_start, section_indent)`` for a Google-style ``Args:`` header.
+
+    Scans *lines* for an ``Args:`` or ``Arguments:`` header and returns its line
+    index and leading indentation.  Returns ``(-1, 0)`` when not found.
+
+    The match is intentionally strict: a line qualifies only when it consists
+    of optional leading spaces followed by exactly ``Args:`` or ``Arguments:``
+    with nothing else on the line (no trailing text).  This avoids accidental
+    matches inside prose paragraphs.
+
+    See `Google Python Style Guide — Functions and Methods
+    <https://google.github.io/styleguide/pyguide.html#383-functions-and-methods>`_
+    for the ``Args:`` section specification.
+
+    Args:
+        lines: Docstring already split into individual lines.
+
+    Returns:
+        A 2-tuple ``(section_start, section_indent)``.
+
+    """
+    _section_re = re.compile(r"^\s*(Args|Arguments):\s*$")
+    for i, line in enumerate(lines):
+        if _section_re.match(line):
+            return i, len(line) - len(line.lstrip())
+    return -1, 0
+
+
+def _get_google_arg_indents(lines: list[str], section_start: int, section_indent: int) -> tuple[int, int]:
+    """Return ``(arg_indent, continuation_indent)`` for a Google-style Args section.
+
+    *arg_indent* is the column at which individual argument entries begin.
+    *continuation_indent* is the column used for continuation lines within an
+    argument entry (defaults to ``arg_indent + 4`` when not detectable).
+    Returns ``(-1, -1)`` when the section has no non-empty child lines.
+
+    Args:
+        lines: Docstring already split into individual lines.
+        section_start: Line index of the ``Args:`` / ``Arguments:`` header.
+        section_indent: Leading indentation of that header line.
+
+    Returns:
+        A 2-tuple ``(arg_indent, continuation_indent)``.
+
+    """
+    arg_indent = -1
+    for i in range(section_start + 1, len(lines)):
+        if lines[i].strip():
+            current_indent = len(lines[i]) - len(lines[i].lstrip())
+            if current_indent > section_indent:
+                arg_indent = current_indent
+            break
+
+    if arg_indent == -1:
+        return -1, -1
+
+    continuation_indent = arg_indent + 4
+    for i in range(section_start + 1, len(lines)):
+        line = lines[i]
+        if not line.strip():
+            continue
+        current_indent = len(line) - len(line.lstrip())
+        if current_indent <= section_indent:
+            break
+        if current_indent > arg_indent:
+            continuation_indent = current_indent
+            break
+
+    return arg_indent, continuation_indent
+
+
+def _find_google_arg_line(
+    lines: list[str], section_start: int, section_indent: int, arg_indent: int, arg_name: str
+) -> int:
+    """Return the line index of *arg_name* inside a Google-style Args section.
+
+    Returns ``-1`` when *arg_name* is not found within the section.
+
+    Args:
+        lines: Docstring already split into individual lines.
+        section_start: Line index of the ``Args:`` / ``Arguments:`` header.
+        section_indent: Leading indentation of that header line.
+        arg_indent: Leading indentation of argument entry lines.
+        arg_name: Name of the argument to locate.
+
+    Returns:
+        Line index of the matching argument entry, or ``-1``.
+
+    """
+    for i in range(section_start + 1, len(lines)):
+        line = lines[i]
+        if not line.strip():
+            continue
+        current_indent = len(line) - len(line.lstrip())
+        if current_indent <= section_indent:
+            break
+        if current_indent == arg_indent:
+            rest = line[arg_indent:]
+            has_arg_boundary = len(rest) > len(arg_name) and rest[len(arg_name)] in " :(,"
+            if rest == arg_name or (rest.startswith(arg_name) and has_arg_boundary):
+                return i
+    return -1
+
+
+def _find_entry_end(lines: list[str], entry_idx: int, entry_indent: int) -> int:
+    """Return the index of the last continuation line for a docstring entry.
+
+    Scans forward from *entry_idx + 1* and stops at the first blank line or
+    the first line whose indentation is ``<= entry_indent``.
+
+    Note:
+        A blank line within a multi-paragraph argument description is treated
+        as the entry boundary.  Only the content up to that blank line receives
+        the deprecation note; subsequent paragraphs are considered outside the
+        entry.
+
+    Args:
+        lines: Docstring already split into individual lines.
+        entry_idx: Line index of the entry's opening line.
+        entry_indent: Leading indentation of that opening line.
+
+    Returns:
+        Index of the last line belonging to the entry (>= *entry_idx*).
+
+    """
+    end_idx = entry_idx
+    for i in range(entry_idx + 1, len(lines)):
+        line = lines[i]
+        if not line.strip():
+            break
+        if len(line) - len(line.lstrip()) <= entry_indent:
+            break
+        end_idx = i
+    return end_idx
+
+
+def _annotate_google_style_arg(lines: list[str], arg_name: str, note: str) -> tuple[list[str], bool]:
+    """Find *arg_name* in a Google-style ``Args:`` section and insert *note* below it.
+
+    Supports both ``Args:`` and ``Arguments:`` section headers.  Returns the
+    original list unchanged when no matching section or argument entry is found.
+
+    Args:
+        lines: Docstring already split into individual lines.
+        arg_name: Name of the deprecated argument to locate.
+        note: Text to insert as a continuation line under the matched entry.
+
+    Returns:
+        A 2-tuple ``(new_lines, found)`` where *found* is ``True`` when the
+        argument was located and the note was successfully inserted.
+
+    The note is inserted as a continuation line directly after the matched entry:
+
+    .. code-block:: text
+
+    Args:
+            lr (float): Learning rate.
+            old_cfg (object): Old config.
+                Deprecated — use cfg instead.  # <-- inserted here
+
+    """
+    section_start, section_indent = _find_google_args_section(lines)
+    if section_start == -1:
+        return lines, False
+
+    arg_indent, continuation_indent = _get_google_arg_indents(lines, section_start, section_indent)
+    if arg_indent == -1:
+        return lines, False
+
+    arg_line_idx = _find_google_arg_line(lines, section_start, section_indent, arg_indent, arg_name)
+    if arg_line_idx == -1:
+        return lines, False
+
+    end_idx = _find_entry_end(lines, arg_line_idx, arg_indent)
+    # Idempotency guard: skip insertion when the note is already present under this arg entry.
+    if any(note in ln for ln in lines[arg_line_idx : end_idx + 1]):
+        return lines, True
+    note_line = " " * continuation_indent + note
+    new_lines = lines[: end_idx + 1] + [note_line] + lines[end_idx + 1 :]
+    return new_lines, True
+
+
+def _annotate_sphinx_style_arg(lines: list[str], arg_name: str, note: str) -> tuple[list[str], bool]:
+    """Find ``:param arg_name:`` in a Sphinx-style docstring and insert *note* below it.
+
+    Supports both ``:param arg_name:`` and ``:param SomeType arg_name:`` forms.
+    Returns the original list unchanged when no matching ``:param`` field is found.
+
+    Args:
+        lines: Docstring already split into individual lines.
+        arg_name: Name of the deprecated argument to locate.
+        note: Text to insert as a continuation line under the matched field.
+
+    Returns:
+        A 2-tuple ``(new_lines, found)`` where *found* is ``True`` when the
+        parameter was located and the note was successfully inserted.
+
+    The note is inserted as a continuation line directly after the matched field::
+
+        :param lr: Learning rate.
+        :param old_cfg: Old config.
+            Deprecated — use cfg instead.  # <-- inserted here
+        :returns: Result.
+
+    """
+    pattern = re.compile(r"^(\s*):param\s+(?:\S+\s+)?" + re.escape(arg_name) + r"\s*:")
+
+    param_line_idx = -1
+    param_indent = 0
+    for i, line in enumerate(lines):
+        m = pattern.match(line)
+        if m:
+            param_line_idx = i
+            param_indent = len(m.group(1))
+            break
+
+    if param_line_idx == -1:
+        return lines, False
+
+    end_idx = _find_entry_end(lines, param_line_idx, param_indent)
+    # Idempotency guard: skip insertion when the note is already present under this param entry.
+    if any(note in ln for ln in lines[param_line_idx : end_idx + 1]):
+        return lines, True
+    note_line = " " * (param_indent + 4) + note
+    new_lines = lines[: end_idx + 1] + [note_line] + lines[end_idx + 1 :]
+    return new_lines, True
+
+
+def _build_general_notice_lines(dep_info: DeprecationConfig) -> list[str]:
+    """Render the general deprecation notice lines for the given style.
+
+    Selects the RST (``.. deprecated::``) or MkDocs (``!!! warning``) template
+    based on ``dep_info.docstring_style``, substitutes ``deprecated_in``,
+    ``remove_in``, and the target reference, and omits template lines whose
+    placeholder resolves to an empty string.
+
+    Args:
+        dep_info: Frozen deprecation metadata attached to the decorated callable.
+
+    Returns:
+        A list of rendered notice lines (without leading body indentation).
+
+    """
+    remove_text = f"Will be removed in {dep_info.remove_in}." if dep_info.remove_in else ""
+    target_text_rst = ""
+    target_text_mkdocs = ""
+    if callable(dep_info.target):
+        full_target_name = f"{dep_info.target.__module__}.{dep_info.target.__name__}"
+        ref_type = "class" if inspect.isclass(dep_info.target) else "func"
+        target_text_rst = f"Use :{ref_type}:`{full_target_name}` instead."
+        target_text_mkdocs = f"Use `{full_target_name}` instead."
+
+    docstring_style = normalize_docstring_style(dep_info.docstring_style)
+    if docstring_style == "mkdocs":
+        template = TEMPLATE_DOC_DEPRECATED_MKDOCS
+        target_text = target_text_mkdocs
+    else:
+        template = TEMPLATE_DOC_DEPRECATED_RST
+        target_text = target_text_rst
+
+    result = []
+    for line in template:
+        if line.strip().endswith("%(remove_text)s") and not remove_text:
+            continue
+        if line.strip().endswith("%(target_text)s") and not target_text:
+            continue
+        result.append(
+            line % {"deprecated_in": dep_info.deprecated_in, "remove_text": remove_text, "target_text": target_text}
+        )
+    return result
+
+
+def _has_deprecation_block(doc_lines: list[str], block_lines: list[str]) -> bool:
+    """Return True if ``block_lines`` appears as a contiguous block in ``doc_lines``.
+
+    Lines are compared using ``.strip()`` to ignore leading/trailing whitespace.
+
+    """
+    if not block_lines:
+        return False
+    max_start = len(doc_lines) - len(block_lines)
+    if max_start < 0:
+        return False
+    first = block_lines[0].strip()
+    for start in range(max_start + 1):
+        if doc_lines[start].strip() != first:
+            continue
+        if all(doc_lines[start + offset].strip() == block_lines[offset].strip() for offset in range(len(block_lines))):
+            return True
+    return False
+
+
+def _inject_args_mapping_section(lines: list[str], dep_info: DeprecationConfig) -> tuple[list[str], bool]:
+    """Apply per-argument inline deprecation notes to docstring lines.
+
+    Returns ``(updated_lines, all_args_found)`` where ``all_args_found`` is ``True`` when every key in
+    ``dep_info.args_mapping`` was located in the docstring.
+
+    """
+    all_args_found = True
+    for arg_name, new_arg in (dep_info.args_mapping or {}).items():
+        note = _build_arg_deprecation_note(new_arg, dep_info.deprecated_in, dep_info.remove_in)
+        lines, found = _annotate_google_style_arg(lines, arg_name, note)
+        if not found:
+            lines, found = _annotate_sphinx_style_arg(lines, arg_name, note)
+        if not found:
+            all_args_found = False
+    return lines, all_args_found
+
+
+def _append_notice_after_inline_args(lines: list[str], body_indent: str, deprecation_lines: list[str]) -> list[str]:
+    """Append general deprecation notice after inline per-arg annotations."""
+    while lines and not lines[-1].strip():
+        lines.pop()
+    lines.append("")
+    lines.extend(body_indent + ln for ln in deprecation_lines)
+    return lines
+
+
+def _insert_notice_before_section(lines: list[str], body_indent: str, deprecation_lines: list[str]) -> str:
+    """Insert general deprecation notice before the first Google/NumPy section header."""
+    indented = [body_indent + ln for ln in deprecation_lines]
+    insert_idx = find_docstring_insertion_index(lines)
+    prefix = lines[:insert_idx]
+    suffix = lines[insert_idx:]
+    if prefix and prefix[-1].strip():
+        prefix.append("")
+    prefix.extend(indented)
+    if suffix:
+        while suffix and not suffix[-1].strip():  # Python 3.13 may leave trailing blanks
+            suffix.pop()
+        if suffix and suffix[0].strip():
+            prefix.append("")
+        prefix.extend(suffix)
+    return "\n".join(prefix)
+
+
+def _update_docstring_with_deprecation(wrapped_fn: object) -> None:
+    """Annotate a function's docstring with deprecation information.
+
+    Two paths are taken depending on whether ``args_mapping`` is set:
+
+    - **Inline arg path** (``args_mapping`` present): each deprecated argument is
+      located in the ``Args:`` / ``Arguments:`` (Google style) or ``:param``
+      (Sphinx style) section and a one-line deprecation note is inserted directly
+      beneath it.  When ``target`` is ``True`` (self-deprecation) and all deprecated
+      args are found, the function returns early and no general notice block is
+      added.  When ``target`` is a callable or ``None``, the general block is
+      always added after the inline annotations because the function itself is
+      deprecated.
+    - **General notice path** (no ``args_mapping``, or at least one arg was not
+      found in the docstring): a deprecation notice is inserted before the first
+      Google/NumPy section header (e.g. ``Args:``, ``Parameters``) when detected,
+      otherwise appended at the end of the docstring.  The notice format depends
+      on ``docstring_style``: Sphinx ``.. deprecated::`` directive (default
+      ``"rst"``) or MkDocs/Markdown admonition (``"mkdocs"``/``"markdown"``).
+
+    Args:
+        wrapped_fn: Function whose docstring should be updated. Must have
+            ``__deprecated__`` attribute set with deprecation metadata.
+
+    Returns:
+        None. Modifies the function's ``__doc__`` attribute in-place.
+
+    Metadata Used:
+        The function's ``__deprecated__`` attribute should be a
+        :class:`~deprecate._types.DeprecationConfig` instance with:
+        - deprecated_in: Version when deprecated
+        - remove_in: Version when will be removed
+        - target: Replacement callable (optional)
+        - args_mapping: Mapping of old → new argument names (optional)
+
+    Example:
+        General notice path — no ``args_mapping``:
+
+        >>> def new_func(): pass
+        >>> def old_func():
+        ...     '''Original docstring.'''
+        ...     pass
+        >>> old_func.__deprecated__ = DeprecationConfig(
+        ...     deprecated_in='1.0',
+        ...     remove_in='2.0',
+        ...     target=new_func,
+        ... )
+        >>> _update_docstring_with_deprecation(old_func)
+        >>> print(old_func.__doc__) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+        Original docstring.
+        <BLANKLINE>
+        .. deprecated:: 1.0
+           Will be removed in 2.0.
+           Use :func:`...new_func` instead.
+
+        Inline arg path — self-deprecation (``target=True``) with all args found:
+
+        >>> def fn_with_args(x: int, old_arg: str = "") -> str:
+        ...     '''Do something.
+        ...
+        ...     Args:
+        ...         x: The main input.
+        ...         old_arg: The old argument.
+        ...     '''
+        ...     return str(x)
+        >>> fn_with_args.__deprecated__ = DeprecationConfig(
+        ...     deprecated_in='1.0',
+        ...     remove_in='2.0',
+        ...     target=TargetMode.ARGS_REMAP,
+        ...     args_mapping={'old_arg': None},
+        ... )
+        >>> _update_docstring_with_deprecation(fn_with_args)
+        >>> 'Deprecated since v1.0' in fn_with_args.__doc__
+        True
+        >>> '.. deprecated::' in fn_with_args.__doc__
+        False
+
+    Note:
+        Does nothing if the function has no docstring or no ``__deprecated__`` attribute.
+        To preserve Google/NumPy parsing, the general notice is inserted before the
+        first section header (e.g. ``Args:`` or ``Parameters``) when detected.
+
+    """
+    if not hasattr(wrapped_fn, "__doc__") or not wrapped_fn.__doc__:
+        return
+    if not _has_deprecation_meta(wrapped_fn):
+        return
+    lines = wrapped_fn.__doc__.splitlines()
+    dep_info = wrapped_fn.__deprecated__
+
+    if dep_info.args_mapping:
+        lines, all_args_found = _inject_args_mapping_section(lines, dep_info)
+        # ARGS_REMAP (or legacy target=True) means only individual args are deprecated,
+        # not the function itself.
+        if all_args_found and dep_info.target is TargetMode.ARGS_REMAP:
+            wrapped_fn.__doc__ = inspect.cleandoc("\n".join(lines))
+            return
+
+    deprecation_lines = _build_general_notice_lines(dep_info)
+
+    # Guard idempotency by checking for the full deprecation block, not just the marker line.
+    if _has_deprecation_block(lines, deprecation_lines):
+        return
+    body_indent = next(
+        (line[: len(line) - len(line.lstrip())] for line in lines[1:] if line.strip()),
+        "",
+    )
+    if dep_info.args_mapping:
+        lines = _append_notice_after_inline_args(lines, body_indent, deprecation_lines)
+        wrapped_fn.__doc__ = inspect.cleandoc("\n".join(lines))
+    else:
+        wrapped_fn.__doc__ = inspect.cleandoc(_insert_notice_before_section(lines, body_indent, deprecation_lines))

.venv/lib/python3.12/site-packages/deprecate/docstring/sphinx_ext.py

@@ -0,0 +1,154 @@
+"""Sphinx autodoc extension: expose runtime-modified docstrings for _DeprecatedProxy.
+
+.. note::
+    **Beta feature** — the public API of this module (documenter class, priority
+    value) may change in a minor release while it stabilises.
+
+``@deprecated_class(update_docstring=True)`` writes the deprecation notice into
+the proxy's ``__doc__`` at decoration time.  Sphinx's autodoc sees the proxy as
+a non-class instance and renders it as ``"alias of <target>"`` without showing
+the docstring.
+
+This extension bridges the gap by registering a custom :class:`ClassDocumenter`
+that:
+
+1. Recognises :class:`~deprecate.proxy._DeprecatedProxy` objects via
+   :meth:`can_document_member`.
+2. Swaps the proxy for the underlying (wrapped) class so that Sphinx can
+   introspect members and build the correct signature.
+3. Returns the proxy's ``__doc__`` (which already contains the injected
+   ``.. deprecated::`` block) from :meth:`get_doc`, so the notice appears in
+   the rendered output.
+
+Usage in ``conf.py``::
+
+    extensions = [
+        'sphinx.ext.autodoc',
+        ...
+        'deprecate.docstring.sphinx_ext',
+    ]
+
+Requirements:
+    ``sphinx`` with ``sphinx.ext.autodoc`` is required.  Importing this module
+    without Sphinx installed is safe — the custom documenter is simply not
+    registered.
+
+
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+_logger = logging.getLogger(__name__)
+
+_PROXY_AVAILABLE: bool = False
+
+try:
+    from sphinx.ext.autodoc import ClassDocumenter
+    from sphinx.util.docstrings import prepare_docstring
+
+    _SPHINX_AVAILABLE = True
+except ImportError:  # pragma: no cover
+    _SPHINX_AVAILABLE = False
+
+
+if _SPHINX_AVAILABLE:
+    try:
+        from deprecate.proxy import _DeprecatedProxy
+
+        _PROXY_AVAILABLE = True
+    except ImportError:  # pragma: no cover
+        _PROXY_AVAILABLE = False
+
+    if _PROXY_AVAILABLE:
+
+        class _DeprecatedProxyClassDocumenter(ClassDocumenter):
+            """ClassDocumenter subclass that handles pyDeprecate ``_DeprecatedProxy`` objects.
+
+            Registered with a priority one step above the standard
+            :class:`~sphinx.ext.autodoc.ClassDocumenter` so that it is selected
+            whenever ``autoclass::`` is used on a :class:`~deprecate.proxy._DeprecatedProxy`
+            instance, while all ordinary classes continue to be handled by the
+            built-in documenter.
+
+            """
+
+            objtype = "class"
+            priority = ClassDocumenter.priority + 5
+
+            @classmethod
+            def can_document_member(
+                cls,
+                member: Any,  # noqa: ANN401
+                membername: str,
+                isattr: bool,
+                parent: Any,  # noqa: ANN401
+            ) -> bool:
+                """Return ``True`` for proxies and for all types the base class accepts."""
+                return isinstance(member, _DeprecatedProxy) or super().can_document_member(
+                    member, membername, isattr, parent
+                )
+
+            def import_object(self, raiseerror: bool = False) -> bool:
+                """Import the object and, when it is a proxy, swap it for the wrapped class.
+
+                The proxy's ``__doc__`` (which contains the injected deprecation notice) is saved in ``self._proxy_doc``
+                before the swap so that :meth:`get_doc` can return it verbatim.
+
+                ``doc_as_attr`` is reset to ``False`` after the swap because the base
+                :class:`~sphinx.ext.autodoc.ClassDocumenter` computes it using ``self.object.__name__``.  On a
+                :class:`~deprecate.proxy._DeprecatedProxy` that attribute is forwarded to the *target* class (via
+                ``__getattr__``), which makes Sphinx believe the object is an alias for that target and adds an ``alias
+                of …`` paragraph.  After the swap ``self.object`` is the real class whose ``__name__`` matches the
+                documented path, so ``doc_as_attr`` should be ``False``.
+
+                """
+                result = super().import_object(raiseerror=raiseerror)
+                # Use getattr/setattr to avoid mypy confusing the Sphinx-defined
+                # `object` attribute with the Python builtin `object` ([has-type]).
+                obj: Any = getattr(self, "object", None)
+                if result and isinstance(obj, _DeprecatedProxy):
+                    # Capture the proxy docstring (contains the .. deprecated:: block).
+                    self._proxy_doc: str = getattr(obj, "__doc__", "") or ""
+                    # Swap the proxy for the original wrapped class so that
+                    # ClassDocumenter can introspect members, __init__ signature, etc.
+                    if hasattr(obj, "_cfg"):
+                        self.object = obj._cfg.obj
+                    # Reset doc_as_attr: the base class set it to True because
+                    # proxy.__name__ (forwarded to the target) differed from the
+                    # documented name.  Now that we have swapped to the real class
+                    # the name matches and this is not an alias.
+                    self.doc_as_attr = False
+                return result
+
+            def get_doc(self) -> list[list[str]] | None:
+                """Return the proxy docstring so the deprecated block is rendered."""
+                proxy_doc: str = getattr(self, "_proxy_doc", "")
+                if proxy_doc:
+                    return [prepare_docstring(proxy_doc)]
+                return super().get_doc()
+
+
+def setup(app: Any) -> dict[str, Any]:  # noqa: ANN401
+    """Register the ``_DeprecatedProxy`` documenter with Sphinx.
+
+    Args:
+        app: The Sphinx application instance.
+
+    Returns:
+        Extension metadata dict consumed by Sphinx.
+
+    """
+    if _SPHINX_AVAILABLE and _PROXY_AVAILABLE:
+        app.setup_extension("sphinx.ext.autodoc")
+        # override=True is required because sphinx.ext.autodoc already registers
+        # ClassDocumenter for objtype="class" and the autoclass directive.
+        app.add_autodocumenter(_DeprecatedProxyClassDocumenter, override=True)
+    elif _SPHINX_AVAILABLE:
+        _logger.warning(
+            "deprecate.docstring.sphinx_ext: _DeprecatedProxy unavailable — "
+            "extension loaded but _DeprecatedProxyClassDocumenter not registered."
+        )
+    return {"version": "0.1", "parallel_read_safe": True}

.venv/lib/python3.12/site-packages/deprecate/proxy.py

@@ -0,0 +1,1765 @@
+"""Proxy utilities for deprecating Python object instances and classes.
+
+Provides :func:`~deprecate.proxy.deprecated_instance` for wrapping any Python object with
+transparent deprecation warnings and optional read-only enforcement, and
+:func:`~deprecate.proxy.deprecated_class` as a class-level decorator with optional target
+redirection.
+
+Typical use cases:
+
+- Deprecating module-level config dicts, constants, or legacy singletons
+  while still allowing reads during a migration window.
+- Deprecating an Enum or dataclass in favor of a replacement type, with
+  automatic forwarding of all attribute, item, and call access.
+
+Example:
+    >>> import warnings
+    >>> cfg = {"threshold": 0.5}
+    >>> proxy = deprecated_instance(cfg, deprecated_in="1.0", remove_in="2.0", stream=None)
+    >>> proxy["threshold"]
+    0.5
+
+    >>> proxy.get("threshold")
+    0.5
+
+"""
+
+import copy
+import inspect
+import math
+import operator
+import os
+import threading
+import types
+import warnings
+from collections.abc import Iterator
+from dataclasses import replace
+from typing import Any, Callable, Literal, Optional, SupportsIndex, Union, cast
+
+from deprecate._types import (
+    DeprecationConfig,
+    TargetMode,
+    _ProxyConfig,
+)
+from deprecate.deprecation import (
+    TEMPLATE_ARGUMENT_MAPPING,
+    TEMPLATE_WARNING_ARGUMENTS,
+    TEMPLATE_WARNING_CALLABLE,
+    TEMPLATE_WARNING_NO_TARGET,
+    _split_positional_only_kwargs,
+    _validate_template_mgs,
+    deprecation_warning,
+)
+from deprecate.docstring.inject import _update_docstring_with_deprecation, normalize_docstring_style
+from deprecate.utils import _apply_args_mapping_collisions, _get_args_mapping_positional_only_keys, _is_dataclass_target
+
+#: Stacklevel from inside ``_warn`` to the caller's frame.
+#: Chain: ``caller → __getattr__/__getitem__/__iter__/__call__ → _warn → stream → warnings.warn``.
+#: From ``warnings.warn`` upwards: ``1=_warn``, ``2=accessor``, ``3=caller``.
+#: Helpers one level deeper (e.g. ``_proxy_call_args_remap``) pass ``_extra_frames=1``.
+_DEFAULT_STACKLEVEL_TO_CALLER: int = 3
+
+
+def _is_dunder(name: str) -> bool:
+    """Return whether *name* is a dunder attribute name (``__x__``) — introspection machinery, not user API."""
+    return name.startswith("__") and name.endswith("__")
+
+
+class _DeprecatedProxy:
+    """Transparent proxy that emits deprecation warnings on attribute and item access.
+
+    Wraps any Python object and forwards all read operations (attribute lookup, subscript, iteration, calls) to the
+    underlying object — or to an optional *target* replacement — while emitting a configurable :class:`FutureWarning`.
+
+    In *read-only* mode any attempt to mutate the proxied object via ``__setitem__``, ``__delitem__``, or
+    ``__setattr__`` raises :class:`AttributeError`.
+
+    Use :func:`~deprecate.proxy.deprecated_instance` or :func:`~deprecate.proxy.deprecated_class` to create
+    instances rather than instantiating this class directly.
+
+    Args:
+        obj: The deprecated object to wrap (the *source*).
+        name: Display name used in the warning message.
+        deprecated_in: Version string when the object was deprecated.
+        remove_in: Version string when the object will be removed.
+        num_warns: Maximum number of warnings to emit. ``1`` (default) warns once; ``-1`` warns on every access.
+        stream: Callable used to emit warnings. Defaults to :data:`~deprecate.deprecation.deprecation_warning`
+            (:class:`FutureWarning`).  Pass ``None`` to suppress warnings.  **Note:** the built-in
+            stacklevel budget assumes *stream* is :func:`warnings.warn` itself or a C-level
+            :func:`functools.partial` of it; a Python-defined wrapper interposes an extra frame and
+            the warning will appear to originate inside :mod:`deprecate.proxy` rather than the caller.
+        template_mgs: Optional custom warning message template that overrides the built-in templates.  When ``None``
+            (default), the built-in template for the active scenario is used (callable-target, no-target, or
+            per-argument).  See :func:`~deprecate.proxy.deprecated_class` for the available ``%``-style placeholders.
+        read_only: If ``True``, raise :class:`AttributeError` on any write attempt through the proxy.
+            Only the following standard collection mutator names are intercepted: ``append``, ``clear``,
+            ``discard``, ``extend``, ``insert``, ``pop``, ``remove``, ``setdefault``, ``update``, ``add``.
+            Custom method names (e.g. ``register()``, ``reload()``, ``set_value()``) are not blocked.
+        target: Optional replacement object.  When set, all attribute, item, and call access is forwarded to *target*
+            instead of *obj*.
+        args_mapping: Optional dict remapping keyword argument names when the proxy is called.  Keys are old argument
+            names; values are new names, or ``None`` to drop the argument entirely.
+
+    Protocol forwarding:
+        Operator, conversion, context-manager, iteration, and subclassing protocols are forwarded to the active object
+        so the proxy stays transparent (arithmetic ``+ - * / // % ** @`` and their reflected/in-place forms, ordering
+        ``< <= > >=``, ``int()``/``float()``/``complex()``/``index()``, ``abs()``/``-``/``+``/``~``,
+        ``round()``/``math.trunc``/``floor``/``ceil``, ``reversed()``, ``os.fspath()``, ``format()``,
+        ``with``/``async with``, ``next()``/``async for``, ``await``, and ``class Child(DeprecatedAlias)`` via PEP 560
+        ``__mro_entries__``). Because implicit special-method lookup bypasses ``__getattr__``, any dunder *not* listed
+        here is not forwarded; a protocol the wrapped object does not implement raises the normal :class:`TypeError`
+        (binary operators return :data:`NotImplemented` so reflected operands and Python's error path are preserved).
+
+        **Warn policy** (consistent with ``__getitem__`` vs ``__len__``): operations that use or produce the wrapped
+        data warn once against the shared budget — arithmetic and its reflected/in-place forms, numeric/path
+        conversions, ``round``/``trunc``/``floor``/``ceil``, ``reversed``, ``next``, context entry (``__enter__`` /
+        ``__aenter__``), async iteration, and subclassing. Cheap structural probes stay silent — ordering comparisons,
+        ``format``, and context exit (``__exit__`` / ``__aexit__``) — mirroring the silent ``__eq__`` / ``__len__`` /
+        ``__str__``. In-place operators return the active object's own result, so a proxied value assigned via ``+=``
+        rebinds to that result rather than a re-wrapped proxy.
+
+    Known limitations:
+        **Structural ABC over-claim**: because dunder methods are installed unconditionally on the *type*
+        (implicit special-method lookup bypasses ``__getattr__`` and cannot be conditional per-instance),
+        ``isinstance(proxy, os.PathLike)`` returns ``True`` even when the wrapped object is not a path — then
+        ``os.fspath(proxy)`` raises ``TypeError``.  The same applies to ``Awaitable``, ``AsyncIterable``, and
+        any other structural ABC that keys on dunder presence.  Always check the *unwrapped* object's type
+        when using structural ABCs as a dispatch guard, or call ``type(deprecated_instance_proxy.__class__)``
+        to get the wrapped type (which is ``_DeprecatedProxy``).
+
+    """
+
+    @staticmethod
+    def _get_static_attr_owner(obj: Any) -> Any:  # noqa: ANN401
+        """Return the object whose attributes should be validated without dynamic lookup.
+
+        For proxy targets, validate against the same "active" object attribute access will ultimately reach (callable
+        target when configured, otherwise the wrapped source).
+
+        Defensive cycle guard: stacked-proxy chains are linear in normal use (the frozen
+        :class:`~deprecate._types.DeprecationConfig` prevents reassignment of ``target`` after construction),
+        but the guard breaks the loop on the unlikely case of a circular chain so this helper never blocks.
+
+        """
+        seen: set[int] = set()
+        while isinstance(obj, _DeprecatedProxy):
+            if id(obj) in seen:
+                break
+            seen.add(id(obj))
+            dep = object.__getattribute__(obj, "__deprecated__")
+            cfg = object.__getattribute__(obj, "_DeprecatedProxy__config")
+            target = dep.target
+            obj = target if target is not None and not isinstance(target, TargetMode) else cfg.obj
+        return obj
+
+    @classmethod
+    def _has_static_attribute(cls, obj: Any, name: str) -> bool:  # noqa: ANN401
+        """Return whether *name* exists without invoking ``__getattr__`` or descriptors."""
+        try:
+            inspect.getattr_static(cls._get_static_attr_owner(obj), name)
+        except AttributeError:
+            return False
+        return True
+
+    @staticmethod
+    def _target_display_name(target: Any, fallback: str) -> str:  # noqa: ANN401
+        """Return a warning-display name without triggering proxy ``__getattr__``."""
+        target_owner = _DeprecatedProxy._get_static_attr_owner(target)
+        return getattr(target_owner, "__name__", fallback)
+
+    @staticmethod
+    def _validate_attrs_mapping(
+        attrs_mapping: dict[str, Optional[str]],
+        obj: Any,  # noqa: ANN401
+        attr_check_obj: Any,  # noqa: ANN401
+    ) -> None:
+        """Validate ``attrs_mapping`` at decoration time.
+
+        Runs three checks against the configured mapping:
+
+        1. Reject true cycles in the redirect chain.
+        2. Confirm every non-``None`` redirect target attribute exists on *attr_check_obj* so
+           accessing a deprecated alias never raises :class:`AttributeError` on the first warning.
+        3. Confirm every warn-only key (``None`` value) exists on at least one of *attr_check_obj*
+           or *obj* — a key on neither would always raise :class:`AttributeError` on access.
+
+        Args:
+            attrs_mapping: The redirect map from deprecated attribute names to canonical names
+                (or ``None`` for warn-only).
+            obj: The wrapped source object — used as a fallback for warn-only key existence.
+            attr_check_obj: The class against which redirect targets are validated; the caller
+                pre-computes this from a concrete callable target, falling back to *obj* for
+                ``TargetMode`` values and legacy boolean sentinels.
+
+        Raises:
+            ValueError: If *attrs_mapping* contains a cycle, a missing redirect target, or a
+                warn-only key absent from both classes.
+
+        """
+        # Reject true cycles in ``attrs_mapping`` at decoration time. Non-cyclic chains are allowed at runtime
+        # and surfaced by audit as mapping chains.
+        cycle_starters: list[str] = []
+        for start in attrs_mapping:
+            visited: set[str] = {start}
+            current = attrs_mapping[start]
+            while current is not None and current in attrs_mapping:
+                if current in visited:
+                    cycle_starters.append(start)
+                    break
+                visited.add(current)
+                current = attrs_mapping[current]
+        if cycle_starters:
+            raise ValueError(
+                f"`attrs_mapping` has circular redirects — the redirect chain starting from"
+                f" {sorted(set(cycle_starters))} loops back to a previously visited key."
+                " Redirect chains must terminate at an attribute name that does not loop."
+            )
+        _DeprecatedProxy._validate_attrs_redirect_targets(attrs_mapping, attr_check_obj)
+        _DeprecatedProxy._validate_attrs_warn_only_keys(attrs_mapping, obj, attr_check_obj)
+
+    @staticmethod
+    def _validate_attrs_redirect_targets(
+        attrs_mapping: dict[str, Optional[str]],
+        attr_check_obj: Any,  # noqa: ANN401
+    ) -> None:
+        """Validate that every non-``None`` redirect target attribute exists on the class.
+
+        Ensures that accessing a deprecated alias never raises :class:`AttributeError` on the
+        first warning — every redirect target must resolve to an existing attribute on
+        *attr_check_obj* at decoration time.
+
+        Args:
+            attrs_mapping: The redirect map from deprecated attribute names to canonical names
+                (or ``None`` for warn-only).
+            attr_check_obj: The class against which non-``None`` redirect targets are validated.
+
+        Raises:
+            ValueError: If any non-``None`` redirect target is absent from *attr_check_obj*.
+
+        """
+        # For @dataclass targets, required fields (no default) are not visible via getattr_static
+        # because they have no class-level value — but they DO exist as valid constructor params
+        # and instance attributes.  Check __dataclass_fields__ as a fallback.
+        _owner = _DeprecatedProxy._get_static_attr_owner(attr_check_obj)
+        _dc_field_names: set[str] = set(getattr(_owner, "__dataclass_fields__", {}))
+        _resolved_targets = list(attrs_mapping.items())
+        missing_targets = [
+            f"{k!r} -> {target!r}"
+            for k, target in _resolved_targets
+            if target is not None
+            and not _DeprecatedProxy._has_static_attribute(attr_check_obj, target)
+            and target not in _dc_field_names
+        ]
+        if missing_targets:
+            raise ValueError(
+                f"`attrs_mapping` redirect targets not found on the active class: {missing_targets}."
+                " Each non-None value must be an existing attribute name on the target class when `target` is"
+                " provided, or on the wrapped class otherwise."
+            )
+
+    @staticmethod
+    def _validate_attrs_warn_only_keys(
+        attrs_mapping: dict[str, Optional[str]],
+        obj: Any,  # noqa: ANN401
+        attr_check_obj: Any,  # noqa: ANN401
+    ) -> None:
+        """Validate that every warn-only key (``None``-value entry) exists on at least one class.
+
+        A ``None`` redirect means "warn but still serve the attribute value" — the attribute can
+        live on the target (same-name warning: kept in new API) or only on the source
+        (being-removed attribute that falls back to the source value in ``__getattr__``). Raise
+        only when absent from both classes; a key on neither would always raise
+        :class:`AttributeError` on access.
+
+        Args:
+            attrs_mapping: The redirect map from deprecated attribute names to canonical names
+                (or ``None`` for warn-only).
+            obj: The wrapped source object — used as a fallback for warn-only key existence.
+            attr_check_obj: The class against which warn-only keys are first checked before
+                falling back to *obj*.
+
+        Raises:
+            ValueError: If any warn-only key is absent from both *attr_check_obj* and *obj*.
+
+        """
+        missing_keys = [
+            k
+            for k, v in attrs_mapping.items()
+            if v is None
+            and not _DeprecatedProxy._has_static_attribute(attr_check_obj, k)
+            and not _DeprecatedProxy._has_static_attribute(obj, k)
+        ]
+        if missing_keys:
+            raise ValueError(
+                f"`attrs_mapping` warn-only keys not found on either class: {missing_keys}."
+                " Each key with a `None` value must be an existing attribute name on the target class"
+                " when `target` is provided, or on the wrapped class."
+            )
+
+    def __init__(
+        self,
+        obj: Any,  # noqa: ANN401
+        name: str,
+        *,
+        target: Any = None,  # noqa: ANN401
+        args_mapping: Optional[dict[str, Optional[str]]] = None,
+        args_extra: Optional[dict[str, Any]] = None,
+        attrs_mapping: Optional[dict[str, Optional[str]]] = None,
+        deprecated_in: str = "",
+        remove_in: str = "",
+        num_warns: int = 1,
+        stream: Optional[Callable[..., None]] = deprecation_warning,
+        template_mgs: Optional[str] = None,
+        read_only: bool = False,
+        docstring_style: str = "auto",
+        _misconfigured_override: bool = False,
+    ) -> None:
+        """Initialise the proxy with typed runtime/config dataclasses.
+
+        ``__config`` stores private mutable runtime state in :class:`~deprecate._types._ProxyConfig` (obj, stream,
+        num_warns, read_only, args_extra, warned counter).
+
+        ``__deprecated__`` is the public metadata interface consumed by audit tools
+        (:func:`~deprecate.audit.validate_deprecation_wrapper`,
+        :func:`~deprecate.audit.find_deprecation_wrappers`, etc.)
+        as a :class:`~deprecate._types.DeprecationConfig` instance aligned with the ``@deprecated`` schema.
+
+        ``_misconfigured_override`` is a private hook used by :func:`~deprecate.deprecated` when it delegates to
+        :func:`~deprecate.deprecated_class` for class targets: it lets the caller pre-compute misconfig signals
+        (raw ``target=False`` plus NOTIFY+args_mapping / NOTIFY+args_extra detected upstream) before the proxy
+        rewrites them away, so the final frozen :class:`~deprecate._types.DeprecationConfig` records every signal
+        in one place.
+
+        """
+        # Probe ``template_mgs`` against every documented placeholder so typos and malformed conversion specifiers
+        # fail at decoration time instead of on the first proxy access.
+        _validate_template_mgs(template_mgs)
+        # Reject true cycles in ``attrs_mapping`` at decoration time. Non-cyclic chains are allowed at runtime
+        # and surfaced by audit as mapping chains.
+        if attrs_mapping is not None:
+            attr_check_obj = target if target is not None and not isinstance(target, (TargetMode, bool)) else obj
+            self._validate_attrs_mapping(attrs_mapping, obj, attr_check_obj)
+        # Track whether the raw ``target=False`` sentinel was passed so audit can flag it. The override
+        # path lets upstream callers fold their own pre-validated misconfig signals into the same flag.
+        misconfigured = target is False or _misconfigured_override
+        if isinstance(target, bool):
+            target = TargetMode._from_legacy_proxy(target, args_mapping=args_mapping, stacklevel=3)
+        _dc_check = _DeprecatedProxy._get_static_attr_owner(
+            target if target is not None and not isinstance(target, (TargetMode, bool)) else obj
+        )
+        if args_mapping is not None:
+            args_mapping = dict(args_mapping)
+        # Copy ``attrs_mapping`` too (``args_mapping`` is copied just above): the frozen config stores it, so
+        # aliasing the caller's dict would let post-decoration mutation introduce the exact cycle validation rejected.
+        if attrs_mapping is not None:
+            attrs_mapping = dict(attrs_mapping)
+        # Dataclass dual-surface auto-expand: copy attrs_mapping entries that name a dataclass field
+        # into args_mapping so both attribute access and constructor kwarg paths emit a FutureWarning.
+        args_mapping, _auto_expanded = _expand_dc_attrs_to_args(_dc_check, attrs_mapping, args_mapping)
+        # When auto-expand produced a non-empty args_mapping and the user provided no explicit
+        # target, set target = obj so the callable-target + both-mappings path activates both surfaces.
+        if _auto_expanded and target is None:
+            target = obj
+        # Kwargs-compatibility guard: detect args_mapping keys that remap to POSITIONAL_ONLY params.
+        _incompatible = _detect_proxy_positional_only(_dc_check, name, args_mapping)
+        # Constructor POSITIONAL_ONLY split data: the call path forwards remapped values
+        # positionally (same split machinery as the @deprecated dispatcher) instead of the
+        # historical pop-and-setattr fallback, which failed for required params, immutable
+        # instances, and constructor-derived state.
+        _ctor_positional_only, _ctor_positional_only_order = _detect_ctor_positional_only(_dc_check)
+        # Auto-resolve: no explicit target but args_mapping provided → ARGS_REMAP
+        if target is None and args_mapping:
+            target = TargetMode.ARGS_REMAP
+        # Auto-resolve: no explicit target but attrs_mapping provided → ATTRS_REMAP
+        # Mirrors the args_mapping auto-resolve above: presence of the dict is the activation
+        # signal; explicit TargetMode.ATTRS_REMAP is the equivalent self-documenting form.
+        if target is None and attrs_mapping:
+            target = TargetMode.ATTRS_REMAP
+        # Validate misconfig (NOTIFY+args_mapping, ARGS_REMAP+no-args_mapping, NOTIFY+args_extra). The
+        # validator returns True when any signal fired so we extend ``misconfigured`` accordingly —
+        # ``DeprecationConfig.misconfigured`` becomes a single source of truth for all four signals.
+        if isinstance(target, TargetMode):
+            misconfigured |= TargetMode._validate(
+                target, name, args_mapping=args_mapping, args_extra=args_extra, stacklevel=4
+            )
+        # Proxy-specific validation: attrs_mapping combinations not covered by _validate().
+        # stacklevel=4: caller → decorator(cls) → __init__ → _validate_proxy → warn
+        # deprecated_class() itself is already off the stack when decorator(cls) runs.
+        misconfigured |= TargetMode._validate_proxy(
+            target,
+            name,
+            attrs_mapping=attrs_mapping,
+            args_mapping=args_mapping,
+            args_extra=args_extra,
+            stacklevel=4,
+        )
+        # Private mutable runtime state — warn counter, stream, read-only flag, wrapped object, extras to merge
+        # after args_mapping at call time, optional custom warning template.
+        cfg = _ProxyConfig(
+            obj=obj,
+            stream=stream,
+            num_warns=num_warns,
+            read_only=read_only,
+            args_extra=args_extra,
+            template_mgs=template_mgs,
+            attrs_mapping=attrs_mapping,
+        )
+        object.__setattr__(self, "_DeprecatedProxy__config", cfg)
+        # Static deprecation metadata stored as a dunder attribute — readable by audit tools via __deprecated__.
+        dep_meta = DeprecationConfig(
+            deprecated_in=deprecated_in,
+            remove_in=remove_in,
+            name=name,
+            target=target,
+            args_mapping=args_mapping,
+            args_extra=args_extra,
+            misconfigured=misconfigured,
+            docstring_style=normalize_docstring_style(docstring_style),
+            template_mgs=template_mgs,
+            attrs_mapping=attrs_mapping,
+            args_mapping_auto_expanded=tuple(_auto_expanded),
+            args_mapping_positional_only=_incompatible,
+            target_positional_only=_ctor_positional_only,
+            target_positional_only_order=_ctor_positional_only_order,
+        )
+        object.__setattr__(self, "__deprecated__", dep_meta)
+        # Expose the wrapped object's docstring as an instance attribute so that external tools (autodoc,
+        # mkdocstrings/griffe) see the source class's documentation rather than _DeprecatedProxy's own class docstring.
+        _doc = getattr(obj, "__doc__", None)
+        if _doc:
+            object.__setattr__(self, "__doc__", _doc)
+
+    # ------------------------------------------------------------------
+    # Internal helpers — must use object.__getattribute__ / object.__setattr__
+    # to avoid triggering the proxy's own __getattr__ / __setattr__.
+    # ------------------------------------------------------------------
+
+    @property
+    def _cfg(self) -> _ProxyConfig:
+        """Private mutable runtime state (warn counter, stream, read-only flag, wrapped object).
+
+        Private to this class — not part of the public API and not consumed by audit tools.
+
+        """
+        return cast(_ProxyConfig, object.__getattribute__(self, "_DeprecatedProxy__config"))
+
+    @property
+    def _dep(self) -> DeprecationConfig:
+        """Static deprecation metadata (versions, name, target, args_mapping).
+
+        Stored as ``__deprecated__`` (dunder, not name-mangled) — audit tools and external code may read it directly;
+        this property simply provides a typed view of the same object.
+
+        """
+        return cast(DeprecationConfig, object.__getattribute__(self, "__deprecated__"))
+
+    def _build_attr_warning_msg(
+        self,
+        arg_name: str,
+        dep: DeprecationConfig,
+        attrs_mapping: dict[str, Optional[str]],
+        target: Any,  # noqa: ANN401
+        custom_template: Optional[str],
+    ) -> Optional[str]:
+        """Build the warning message for a deprecated ``attrs_mapping`` attribute access.
+
+        Strips the ``"__attr__:"`` prefix from *arg_name* to recover the attribute name visible to
+        callers.  The prefix must be preserved in the *arg_name* passed by the caller so that the
+        per-attribute budget key in ``cfg.warned_args`` stays disjoint from any same-named
+        ``args_mapping`` key — this method intentionally does not reassign *arg_name*.
+
+        Returns:
+            The formatted warning string, or ``None`` when *attr_name* is not registered in
+            ``dep.attrs_mapping`` (caller should silently return without warning).
+
+        """
+        attr_name = arg_name[len("__attr__:") :]
+        if attr_name not in attrs_mapping:
+            return None
+        new_attr = attrs_mapping[attr_name]
+        if new_attr is not None:
+            owner = self._target_display_name(target, dep.name) if not isinstance(target, TargetMode) else dep.name
+            target_path = f"{owner}.{new_attr}"
+            template = custom_template or TEMPLATE_WARNING_CALLABLE
+            return template % {
+                "source_name": attr_name,
+                "source_path": attr_name,
+                "deprecated_in": dep.deprecated_in,
+                "remove_in": dep.remove_in,
+                "target_name": new_attr,
+                "target_path": target_path,
+                "argument_map": "",
+            }
+        template = custom_template or TEMPLATE_WARNING_NO_TARGET
+        return template % {
+            "source_name": attr_name,
+            "source_path": attr_name,
+            "deprecated_in": dep.deprecated_in,
+            "remove_in": dep.remove_in,
+            "target_name": "",
+            "target_path": "",
+            "argument_map": "",
+        }
+
+    def _warn(self, *, arg_name: Optional[str] = None, _extra_frames: int = 0) -> None:
+        """Emit a deprecation warning if the warn budget is not exhausted.
+
+        Args:
+            arg_name: When given, use per-argument warning tracking (``cfg.warned_args``) instead of the global
+                ``cfg.warned`` counter.  The warning is suppressed when the per-argument count has already reached
+                ``cfg.num_warns``.  When provided alongside an ``args_mapping`` entry, the emitted message uses the
+                per-argument template (`old -> new`) rather than the generic callable template — matching the
+                decorator's argument-deprecation form.
+            _extra_frames: Additional Python helper frames between the public accessor and ``_warn``.
+
+        """
+        cfg = self._cfg
+        stream = cfg.stream
+        if not stream:
+            return
+        # Build the message before taking the lock: attrs_mapping miss returns None (no warning),
+        # and message building is pure CPU work with no IO.
+        dep = self._dep
+        msg = _build_proxy_warn_msg(self, arg_name, dep, cfg)
+        if msg is None:
+            return
+        # Take the state lock around quota check + counter increment so concurrent first accesses
+        # cannot all read the counter as 0, all pass the gate, and each emit a warning
+        # (check-then-act race).  Mirrors the decorator-path pattern in ``deprecation.py``:
+        # decide-and-increment under the lock, emit the warning outside to avoid serialising
+        # callers on a potentially slow ``stream`` callable.
+        should_warn = False
+        with cfg.lock:
+            if arg_name is not None:
+                arg_count = cfg.warned_args.get(arg_name, 0)
+                if cfg.num_warns < 0 or arg_count < cfg.num_warns:
+                    should_warn = True
+                    cfg.warned_args[arg_name] = arg_count + 1
+            else:
+                if cfg.num_warns < 0 or cfg.warned < cfg.num_warns:
+                    should_warn = True
+                    cfg.warned += 1
+        if not should_warn:
+            return
+        # Route the warning to the caller's frame rather than ``proxy.py``.
+        # A plain ``try/except TypeError`` would swallow a TypeError raised *inside* a
+        # stacklevel-accepting stream and re-invoke it (double side-effect).
+        # Checking the exception message distinguishes a keyword-rejection error from an
+        # internal one — the stream is called exactly once in all but the keyword-rejection case.
+        try:
+            stream(msg, stacklevel=_DEFAULT_STACKLEVEL_TO_CALLER + _extra_frames)
+        except TypeError as _exc:
+            if "stacklevel" in str(_exc) or "keyword" in str(_exc):
+                stream(msg)
+            else:
+                raise
+
+    def _check_read_only(self, operation: str) -> None:
+        """Raise AttributeError when the proxy is in read-only mode.
+
+        Raises:
+            AttributeError: If ``read_only=True`` was set at construction time.
+
+        """
+        if self._cfg.read_only:
+            name: str = self._dep.name
+            raise AttributeError(
+                f"'{name}' is deprecated and read-only. {operation} is not allowed. Migrate away from this object."
+            )
+
+    @property
+    def wrapped(self) -> Any:  # noqa: ANN401
+        """The deprecated source object this proxy wraps (audit contract accessor)."""
+        return self._cfg.obj
+
+    def _get_active(self) -> Any:  # noqa: ANN401
+        """Return the active object: *target* when set, otherwise *source*."""
+        target = self._dep.target
+        if target is not None and not isinstance(target, TargetMode):
+            return target
+        return self._cfg.obj
+
+    def _apply_args_mapping(self, kwargs: dict[str, Any]) -> dict[str, Any]:
+        """Apply args_mapping to *kwargs*, renaming or dropping keys as configured.
+
+        When both the old key and its mapped new-name key are present in *kwargs*, the explicit new-name value wins over
+        the renamed old-name value.
+
+        """
+        args_mapping = self._dep.args_mapping
+        if not args_mapping or not kwargs:
+            return kwargs
+        args_to_drop = {k for k, v in args_mapping.items() if v is None}
+        # caller → __call__ → _proxy_call_* → _apply_args_mapping → _apply_args_mapping_collisions → warn = stacklevel 5
+        explicit_new = _apply_args_mapping_collisions(
+            args_mapping, kwargs, args_to_drop, self._dep.name, self._cfg.stream, stacklevel=5
+        )
+        result = {(args_mapping.get(k) or k): v for k, v in kwargs.items() if k not in args_to_drop}
+        result.update(explicit_new)
+        return result
+
+    def _merge_args_extra(self, kwargs: dict[str, Any]) -> dict[str, Any]:
+        """Merge :attr:`_ProxyConfig.args_extra` into *kwargs*; extra values win."""
+        args_extra = self._cfg.args_extra
+        if not args_extra:
+            return kwargs
+        merged = dict(kwargs)
+        merged.update(args_extra)
+        return merged
+
+    @staticmethod
+    def _is_potential_mutator(name: str) -> bool:
+        """Heuristic to detect common mutating methods on built-in collections.
+
+        This is intentionally conservative and only covers the most common mutating APIs on built-in container types
+        (lists, dicts, sets).
+
+        """
+        mutating_names = {
+            "append",
+            "extend",
+            "insert",
+            "pop",
+            "remove",
+            "clear",
+            "update",
+            "setdefault",
+            "add",
+            "discard",
+        }
+        return name in mutating_names
+
+    def _guard_read_only_mutator(self, attr: Any, name: str) -> Any:  # noqa: ANN401
+        """Return a guarded callable for standard mutators in read-only mode."""
+        if self._cfg.read_only and callable(attr) and self._is_potential_mutator(name):
+
+            def _guarded_mutator(*args: Any, **kwargs: Any) -> None:  # noqa: ANN401
+                """Raise a read-only error when this mutating method is called."""
+                self._check_read_only(f"Calling mutating method '{name}'")
+
+            return _guarded_mutator
+        return attr
+
+    # ------------------------------------------------------------------
+    # Attribute access
+    # ------------------------------------------------------------------
+
+    def __getattr__(self, name: str) -> Any:  # noqa: ANN401
+        """Forward attribute lookup to the active object, emitting a deprecation warning.
+
+        When ``attrs_mapping`` is configured, only attributes listed in the mapping emit a warning; all other accesses
+        are forwarded silently without a warning.  The redirect target name (value in the mapping) is used for the
+        actual attribute lookup when the value is a non-``None`` string; ``None`` means warn-only with no rename on the
+        active object.
+
+        Without ``attrs_mapping``, the attribute is resolved *first* and the warning fires only on successful access —
+        failed introspection probes (``hasattr`` duck-typing, copy/pickle machinery) raise :class:`AttributeError`
+        without warning or consuming the warn budget.  Dunder reads (``__mro__``, ``__wrapped__``, …) are forwarded
+        silently: they are introspection machinery, not a use of the deprecated API — the same rationale as
+        :meth:`~deprecate.proxy._DeprecatedProxy.__instancecheck__`.
+
+        In read-only mode, common mutating methods on built-in collections (for example, ``append`` or ``update``) are
+        wrapped so that calling them raises :class:`AttributeError` instead of mutating the underlying object.
+
+        """
+        # Half-initialised instance guard (``cls.__new__(cls)`` during copy/pickle reconstruction): the ``_cfg``
+        # property raises AttributeError when ``__config`` is missing, which Python routes back into __getattr__ —
+        # touching ``self._cfg`` here again would mutually recurse (property ↔ __getattr__) into RecursionError.
+        try:
+            cfg = cast(_ProxyConfig, object.__getattribute__(self, "_DeprecatedProxy__config"))
+        except AttributeError:
+            raise AttributeError(name) from None
+        attrs_mapping = cfg.attrs_mapping
+        if attrs_mapping is not None:
+            if name in attrs_mapping:
+                self._warn(arg_name=f"__attr__:{name}")
+                redirect = attrs_mapping[name]
+                active = self._get_active()
+                attr_name = redirect if redirect is not None else name
+                if redirect is None:
+                    try:
+                        attr = getattr(active, attr_name)
+                    except AttributeError:
+                        # Attribute absent from target — fall back to source. Covers the "being-removed" pattern where
+                        # the deprecated attribute still lives on the old class but was dropped from the new target.
+                        attr = getattr(cfg.obj, attr_name)
+                    return self._guard_read_only_mutator(attr, attr_name)
+                attr = getattr(active, attr_name)
+                return self._guard_read_only_mutator(attr, attr_name)
+            # Not a deprecated attr — silent passthrough, no warning.
+            attr = getattr(self._get_active(), name)
+            return self._guard_read_only_mutator(attr, name)
+        # Resolve first so a missing attribute raises without warning or burning the warn budget.
+        attr = getattr(self._get_active(), name)
+        # ARGS_REMAP deprecates constructor argument names only; attribute access is unrelated
+        # to the deprecated call signature and must not emit a spurious global warning.
+        # Dunder reads are silent machinery — see the docstring above.
+        if self._dep.target is not TargetMode.ARGS_REMAP and not _is_dunder(name):
+            self._warn()
+        return self._guard_read_only_mutator(attr, name)
+
+    def __setattr__(self, name: str, value: Any) -> None:  # noqa: ANN401
+        """Forward attribute mutation to the active object, raising in read-only mode.
+
+        When ``attrs_mapping`` is configured and the attribute name is a deprecated alias, emits a warning and
+        redirects the write to the canonical attribute name.
+
+        Raises:
+            AttributeError: If the proxy is in read-only mode.
+
+        """
+        self._check_read_only(f"Setting attribute '{name}'")
+        attrs_mapping = self._cfg.attrs_mapping
+        if attrs_mapping is not None and name in attrs_mapping:
+            self._warn(arg_name=f"__attr__:{name}")
+            redirect = attrs_mapping[name]
+            active = self._get_active()
+            attr_name = redirect if redirect is not None else name
+            if redirect is None:
+                # "Being-removed" pattern: attribute may live only on the source class.
+                # Mirror the __getattr__ fallback: prefer active, fall back to source.
+                owner = active if hasattr(active, attr_name) else self._cfg.obj
+                setattr(owner, attr_name, value)
+                return
+            setattr(active, attr_name, value)
+            return
+        setattr(self._get_active(), name, value)
+
+    def __delattr__(self, name: str) -> None:
+        """Forward attribute deletion to the active object, raising in read-only mode.
+
+        When ``attrs_mapping`` is configured and the attribute name is a deprecated alias, emits a warning and
+        redirects the deletion to the canonical attribute name.
+
+        Raises:
+            AttributeError: If the proxy is in read-only mode.
+
+        """
+        self._check_read_only(f"Deleting attribute '{name}'")
+        attrs_mapping = self._cfg.attrs_mapping
+        if attrs_mapping is not None and name in attrs_mapping:
+            self._warn(arg_name=f"__attr__:{name}")
+            redirect = attrs_mapping[name]
+            active = self._get_active()
+            attr_name = redirect if redirect is not None else name
+            if redirect is None:
+                # "Being-removed" pattern: attribute may live only on the source class.
+                # Mirror the __getattr__ fallback so delete behaviour is symmetric.
+                try:
+                    delattr(active, attr_name)
+                except AttributeError:
+                    delattr(self._cfg.obj, attr_name)
+                return
+            delattr(active, attr_name)
+            return
+        delattr(self._get_active(), name)
+
+    # ------------------------------------------------------------------
+    # Subscript access
+    # ------------------------------------------------------------------
+
+    def __getitem__(self, key: Any) -> Any:  # noqa: ANN401
+        """Forward subscript lookup to the active object, emitting a deprecation warning."""
+        self._warn()
+        return self._get_active()[key]
+
+    def __setitem__(self, key: Any, value: Any) -> None:  # noqa: ANN401
+        """Forward subscript mutation to the active object, raising in read-only mode.
+
+        Raises:
+            AttributeError: If the proxy is in read-only mode.
+
+        """
+        self._check_read_only(f"Setting item '{key}'")
+        self._get_active()[key] = value
+
+    def __delitem__(self, key: Any) -> None:  # noqa: ANN401
+        """Forward subscript deletion to the active object, raising in read-only mode.
+
+        Raises:
+            AttributeError: If the proxy is in read-only mode.
+
+        """
+        self._check_read_only(f"Deleting item '{key}'")
+        del self._get_active()[key]
+
+    # ------------------------------------------------------------------
+    # Container protocol
+    # ------------------------------------------------------------------
+
+    def __len__(self) -> int:
+        """Return length of the active object without emitting a warning."""
+        return len(self._get_active())
+
+    def __iter__(self) -> Iterator[Any]:
+        """Iterate over the active object, emitting a deprecation warning."""
+        self._warn()
+        return iter(self._get_active())
+
+    def __contains__(self, item: Any) -> bool:  # noqa: ANN401
+        """Check membership in the active object without emitting a warning."""
+        return item in self._get_active()
+
+    # ------------------------------------------------------------------
+    # Callable protocol
+    # ------------------------------------------------------------------
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:  # noqa: ANN401
+        """Call the active object, emitting a deprecation warning conditionally based on target mode.
+
+        Branching logic:
+        - :attr:`~deprecate._types.TargetMode.ARGS_REMAP`: warn only when a deprecated kwarg name is present in the
+          call; remap, merge ``args_extra``, and call ``obj``.
+        - Callable target with ``args_mapping``: warn per deprecated kwarg present; if none of the old names were
+          passed still warn at the callable level (class is deprecated); remap, merge ``args_extra``, and forward to
+          target.
+        - Callable target without ``args_mapping``: warn (global budget), merge ``args_extra``, and forward to target.
+        - :attr:`~deprecate._types.TargetMode.ATTRS_REMAP`: governs attribute access only; ``args_extra`` is
+          intentionally not applied on ``__call__`` — :meth:`~deprecate._types.TargetMode._validate_proxy`
+          already warns about this misconfiguration at decoration time.
+        - :attr:`~deprecate._types.TargetMode.NOTIFY`: always warn (global budget) and forward kwargs unchanged;
+          ``args_extra`` is intentionally ignored (misconfig).
+
+        """
+        dep = object.__getattribute__(self, "__deprecated__")
+        cfg = object.__getattribute__(self, "_DeprecatedProxy__config")
+
+        # ATTRS_REMAP stacked over a proxy: delegate the call to the inner proxy without firing the global
+        # callable warning. ATTRS_REMAP governs attribute access only; the call itself is not a deprecated
+        # surface, so forwarding through the inner proxy avoids double-warning when both layers are active.
+        if dep.target is TargetMode.ATTRS_REMAP and isinstance(cfg.obj, _DeprecatedProxy):
+            return cfg.obj(*args, **kwargs)
+        # ATTRS_REMAP (non-stacking path): only the listed attribute aliases are deprecated, so
+        # instantiating/calling the class is not a deprecated surface — forward WITHOUT the global
+        # warning (mirrors the stacked branch above and the ARGS_REMAP skip in __getattr__). Moving
+        # this check above ``self._warn()`` keeps plain construction from branding the whole class
+        # deprecated and burning the global warn budget. args_extra is intentionally not applied —
+        # validated as a misconfiguration at decoration time.
+        if dep.target is TargetMode.ATTRS_REMAP:
+            return self._get_active()(*args, **kwargs)
+        if dep.target is TargetMode.ARGS_REMAP:
+            return _proxy_call_args_remap(self, dep, cfg, args, kwargs)
+        if callable(dep.target) and dep.args_mapping:
+            return _proxy_call_callable_with_mapping(self, dep, dep.target, args, kwargs)
+        # Callable target without args_mapping: warn globally; still merge args_extra so
+        # injected defaults reach the target.
+        self._warn()
+        if callable(dep.target):
+            return dep.target(*args, **self._merge_args_extra(kwargs))
+        # NOTIFY: forward unchanged — args_extra is intentionally ignored (already warned at construction).
+        if dep.target is TargetMode.NOTIFY:
+            return self._get_active()(*args, **kwargs)
+        # No target configured (e.g. deprecated_instance with no target): merge args_extra into the call so
+        # wrappers can inject default kwargs even without a forwarding target.
+        return self._get_active()(*args, **self._merge_args_extra(kwargs))
+
+    # ------------------------------------------------------------------
+    # Comparison and hashing
+    # ------------------------------------------------------------------
+
+    def __eq__(self, other: object) -> bool:
+        """Compare the *active* object for equality — the object the proxy actually serves.
+
+        Data access (attribute/item/call) forwards to the active object (target when set, else source), so identity #
+        operations must too; comparing the source while serving the target would make a # target-forwarding proxy equal
+        to an object it never returns.
+
+        """
+        obj = self._get_active()
+        if isinstance(other, _DeprecatedProxy):
+            other = other._get_active()
+        return bool(obj == other)
+
+    def __ne__(self, other: object) -> bool:
+        """Return the inverse of equality."""
+        return not self.__eq__(other)
+
+    def __hash__(self) -> int:
+        """Return the hash of the active object (consistent with :meth:`__eq__`)."""
+        return hash(self._get_active())
+
+    # ------------------------------------------------------------------
+    # String representations — no warning emitted (used for debugging)
+    # ------------------------------------------------------------------
+
+    def __repr__(self) -> str:
+        """Return repr of the active object (the object the proxy serves)."""
+        return repr(self._get_active())
+
+    def __str__(self) -> str:
+        """Return str of the active object (the object the proxy serves)."""
+        return str(self._get_active())
+
+    def __bool__(self) -> bool:
+        """Return bool of the active object without emitting a warning."""
+        return bool(self._get_active())
+
+    # ------------------------------------------------------------------
+    # Copy / pickle protocol — no warning emitted (structural machinery)
+    #
+    # Semantics: a copy (shallow, deep, or pickle round-trip) is a *proxy again* — the
+    # deprecation travels with the object so a copied deprecated config keeps warning during
+    # the migration window. The wrapped object is copied per the respective protocol; the
+    # frozen DeprecationConfig metadata is preserved; the warn-budget counters are snapshotted.
+    # ------------------------------------------------------------------
+
+    def __copy__(self) -> "_DeprecatedProxy":
+        """Return a new proxy wrapping a shallow copy of the wrapped object.
+
+        Deprecation metadata (frozen, immutable) is shared; the mutable warn-budget counters are snapshotted into an
+        independent config so the copy warns independently from the original.
+
+        """
+        cfg = self._cfg
+        new_cfg = replace(cfg, obj=copy.copy(cfg.obj), warned_args=dict(cfg.warned_args), lock=threading.Lock())
+        return _reconstruct_proxy(new_cfg, self._dep, object.__getattribute__(self, "__dict__").get("__doc__"))
+
+    def __deepcopy__(self, memo: dict[int, Any]) -> "_DeprecatedProxy":
+        """Return a new proxy deep-copying the wrapped object (and any instance target).
+
+        Registers the new proxy in *memo* before descending so self-referential structures that contain the proxy deep-
+        copy without infinite recursion.
+
+        """
+        cls = type(self)
+        new = cls.__new__(cls)
+        memo[id(self)] = new
+        object.__setattr__(new, "_DeprecatedProxy__config", copy.deepcopy(self._cfg, memo))
+        object.__setattr__(new, "__deprecated__", copy.deepcopy(self._dep, memo))
+        doc = object.__getattribute__(self, "__dict__").get("__doc__")
+        if doc is not None:
+            object.__setattr__(new, "__doc__", doc)
+        return new
+
+    def __reduce_ex__(self, protocol: SupportsIndex) -> tuple[Any, ...]:
+        """Support pickling: reconstruct the proxy from its two config dataclasses.
+
+        The default ``object.__reduce_ex__`` probes attributes through ``__getattr__`` and cannot
+        rebuild an instance whose state lives behind ``object.__setattr__``; this override pickles
+        the runtime config and frozen metadata directly and rebuilds via
+        :func:`~deprecate.proxy._reconstruct_proxy` without re-running ``__init__`` validation.
+
+        Note:
+            The ``stream`` callable is pickled by reference; lambdas and closures are not picklable
+            by the standard pickle protocol.  Use a module-level callable (e.g. ``warnings.warn``)
+            or ``None`` when you intend to pickle the proxy.
+
+            For :func:`~deprecate.proxy.deprecated_instance` proxies the wrapped object is serialised
+            directly and pickle works reliably.  For :func:`~deprecate.proxy.deprecated_class` proxies
+            the wrapped class is serialised by reference; if the module-level name was replaced by the
+            proxy (the typical usage), pickle cannot resolve the reference and raises
+            :class:`~pickle.PicklingError`.
+
+        """
+        doc = object.__getattribute__(self, "__dict__").get("__doc__")
+        return (_reconstruct_proxy, (self._cfg, self._dep, doc))
+
+    # ------------------------------------------------------------------
+    # Type protocol — supports isinstance/issubclass against a proxy
+    # ------------------------------------------------------------------
+
+    @property  # type: ignore[misc]
+    def __class__(self) -> type:
+        """Report the active object's class so ``isinstance(proxy, WrappedType)`` holds.
+
+        Instance-side type transparency (the ``wrapt``/``unittest.mock`` technique): ``isinstance``
+        honours ``__class__``, so consumer code type-checking the deprecated object (json encoders,
+        validators, defensive ``isinstance``) behaves identically before and after wrapping.
+        Stacked proxy chains are resolved to the innermost concrete object. ``type(proxy)`` still
+        returns :class:`_DeprecatedProxy` for code that needs the truth, and
+        ``isinstance(proxy, _DeprecatedProxy)`` remains ``True`` via the ``type()`` fast path.
+        No warning is emitted — type checks are structural, matching
+        :meth:`~deprecate.proxy._DeprecatedProxy.__instancecheck__`.
+
+        *Class* proxies (``deprecated_class`` aliases) deliberately keep reporting the proxy
+        class: forwarding the metaclass would make ``isinstance(proxy, type)`` true, and
+        class-dispatching decorators (e.g. PEP 702 ``typing_extensions.deprecated``) would then
+        patch the wrapped class in place instead of wrapping the proxy callable.  Class-side
+        transparency is provided by ``__instancecheck__``/``__subclasscheck__`` instead.
+
+        """
+        active = _DeprecatedProxy._get_static_attr_owner(self)
+        if isinstance(active, type):
+            return type(self)
+        return type(active)
+
+    def __instancecheck__(self, instance: object) -> bool:
+        """Support ``isinstance(x, proxy)`` by delegating to the active class.
+
+        Allows a proxy used as a deprecated class alias to work transparently with ``isinstance`` without emitting a
+        warning — type checks are structural, not a use of the deprecated API.
+
+        When the active object is itself a :class:`_DeprecatedProxy` (stacked proxy chain), the loop walks inward until
+        a concrete type is reached. Defensive cycle guard breaks the loop on the unlikely case of a circular stack so
+        this dunder never blocks.
+
+        Raises ``TypeError`` (mirroring the builtin) when the active object is an instance rather than a type — using an
+        *instance* proxy as the second argument to ``isinstance`` is a misuse. Returns ``False`` only on a circular
+        proxy stack.
+
+        """
+        seen: set[int] = set()
+        active = self._get_active()
+        while isinstance(active, _DeprecatedProxy):
+            if id(active) in seen:
+                return False
+            seen.add(id(active))
+            active = active._get_active()
+        if isinstance(active, type):
+            # Delegate via isinstance to preserve metaclass-defined instance checks.
+            return isinstance(instance, active)
+        # Active object is an instance, not a class: using an *instance* proxy as the second argument to
+        # ``isinstance`` is a misuse.  Raise the same ``TypeError`` the builtin does instead of silently
+        # returning ``False`` (which hid the mistake).
+        raise TypeError("isinstance() arg 2 must be a type, a tuple of types, or a union")
+
+    def __subclasscheck__(self, subclass: type) -> bool:
+        """Support ``issubclass(X, proxy)`` by delegating to the active class.
+
+        Same rationale as :meth:`~deprecate.proxy._DeprecatedProxy.__instancecheck__` — no warning emitted.
+        Stacked proxy chains are walked iteratively until a concrete type is reached; a defensive cycle guard
+        breaks the loop on the unlikely case of a circular stack.
+
+        Raises ``TypeError`` (mirroring the builtin) when the active object is an instance rather than a type.
+        Returns ``False`` only on a circular proxy stack.
+
+        """
+        seen: set[int] = set()
+        active = self._get_active()
+        while isinstance(active, _DeprecatedProxy):
+            if id(active) in seen:
+                return False
+            seen.add(id(active))
+            active = active._get_active()
+        if isinstance(active, type):
+            # Delegate via issubclass so that any metaclass-defined
+            # __subclasscheck__ (e.g., from abc.ABCMeta) is respected.
+            return issubclass(subclass, active)
+        # Active object is an instance, not a class: using an *instance* proxy as the second argument to
+        # ``issubclass`` is a misuse.  Raise the same ``TypeError`` the builtin does instead of silently
+        # returning ``False`` (which hid the mistake).
+        raise TypeError("issubclass() arg 2 must be a class, a tuple of classes, or a union")
+
+    # ------------------------------------------------------------------
+    # Subclassing protocol (PEP 560) — supports ``class Child(DeprecatedAlias)``
+    # ------------------------------------------------------------------
+
+    def __mro_entries__(self, bases: tuple[Any, ...]) -> tuple[Any, ...]:
+        """Resolve the proxy to the active class when it appears in a subclass ``bases`` list.
+
+        ``deprecated_class`` replaces the class binding with a (non-``type``) proxy, so ``class Child(OldName)`` would
+        otherwise pass the proxy to the class machinery and fail with an opaque metaclass arity error. PEP 560's
+        ``__mro_entries__`` hook lets the proxy substitute the concrete active class (unwrapping any stacked-proxy
+        chain) so the subclass transparently derives from the replacement.
+
+        Subclassing *is* a use of the deprecated name, so a warning is emitted here — except for
+        :attr:`~deprecate._types.TargetMode.ATTRS_REMAP` / :attr:`~deprecate._types.TargetMode.ARGS_REMAP`, whose
+        deprecation scope is a specific set of attributes/arguments rather than the class itself (consistent with
+        :meth:`__call__` and :meth:`__getattr__`).
+
+        """
+        if self._dep.target not in (TargetMode.ATTRS_REMAP, TargetMode.ARGS_REMAP):
+            self._warn()
+        return (_DeprecatedProxy._get_static_attr_owner(self),)
+
+    # ------------------------------------------------------------------
+    # Context-manager protocol — entry warns (a use), exit is silent cleanup
+    # ------------------------------------------------------------------
+
+    def __enter__(self) -> Any:  # noqa: ANN401
+        """Enter the active object's context, emitting a deprecation warning."""
+        self._warn()
+        return self._get_active().__enter__()
+
+    def __exit__(self, *exc_info: Any) -> Any:  # noqa: ANN401
+        """Exit the active object's context without emitting a warning (cleanup half of the pair)."""
+        return self._get_active().__exit__(*exc_info)
+
+    async def __aenter__(self) -> Any:  # noqa: ANN401
+        """Async-enter the active object's context, emitting a deprecation warning."""
+        self._warn()
+        return await self._get_active().__aenter__()
+
+    async def __aexit__(self, *exc_info: Any) -> Any:  # noqa: ANN401
+        """Async-exit the active object's context without emitting a warning (cleanup half of the pair)."""
+        return await self._get_active().__aexit__(*exc_info)
+
+    def __aiter__(self) -> Any:  # noqa: ANN401
+        """Return the active object's async iterator, emitting a deprecation warning."""
+        self._warn()
+        return self._get_active().__aiter__()
+
+    def __anext__(self) -> Any:  # noqa: ANN401
+        """Return the active object's next awaitable, emitting a deprecation warning."""
+        self._warn()
+        return self._get_active().__anext__()
+
+    def __await__(self) -> Any:  # noqa: ANN401
+        """Await the active object, emitting a deprecation warning."""
+        self._warn()
+        return self._get_active().__await__()
+
+    # ------------------------------------------------------------------
+    # Numeric/string dunders with non-uniform signatures — hand-written
+    # ------------------------------------------------------------------
+
+    def __round__(self, ndigits: Any = None) -> Any:  # noqa: ANN401
+        """Round the active object, emitting a deprecation warning (numeric read)."""
+        self._warn()
+        active = self._get_active()
+        return round(active) if ndigits is None else round(active, ndigits)
+
+    def __format__(self, format_spec: str) -> str:
+        """Format the active object without emitting a warning (a repr-like probe, mirroring ``__str__``)."""
+        return format(self._get_active(), format_spec)
+
+
+def _proxy_call_with_positional_split(
+    ctor: Callable[..., Any],
+    dep: DeprecationConfig,
+    args: tuple[Any, ...],
+    mapped_kwargs: dict[str, Any],
+) -> Any:  # noqa: ANN401
+    """Invoke *ctor*, forwarding kwargs bound to POSITIONAL_ONLY constructor params positionally.
+
+    Adopts the ``@deprecated`` dispatcher's split approach: remapped values whose target parameter is positional-only
+    are reordered into positional arguments by declaration order, after the ``consumed=len(args)`` slots the caller
+    already filled positionally.  This keeps required positional-only params, immutable (frozen-dataclass-style)
+    instances, and constructor-derived state working — unlike the historical pop-and-``setattr`` fallback.
+
+    """
+    if dep.target_positional_only:
+        pos_args, kw_args = _split_positional_only_kwargs(
+            dep.target_positional_only_order, mapped_kwargs, dep.target_positional_only, consumed=len(args)
+        )
+        return ctor(*args, *pos_args, **kw_args)
+    return ctor(*args, **mapped_kwargs)
+
+
+def _reconstruct_proxy(
+    cfg: _ProxyConfig,
+    dep: DeprecationConfig,
+    doc: Optional[str],
+) -> "_DeprecatedProxy":
+    """Rebuild a :class:`_DeprecatedProxy` from its config dataclasses without re-running ``__init__``.
+
+    Used by ``__copy__`` and as the pickle reconstructor in ``__reduce_ex__``: re-running
+    ``__init__`` would repeat decoration-time validation and misconfiguration warnings, so the
+    state is re-attached directly via ``object.__setattr__`` (bypassing the proxy's forwarding
+    ``__setattr__``).
+
+    Args:
+        cfg: Private mutable runtime state for the new proxy.
+        dep: Frozen deprecation metadata (shared or copied by the caller as appropriate).
+        doc: Instance-level ``__doc__`` mirrored from the wrapped object, or ``None`` when the
+            original proxy carried no instance docstring.
+
+    """
+    proxy = _DeprecatedProxy.__new__(_DeprecatedProxy)
+    object.__setattr__(proxy, "_DeprecatedProxy__config", cfg)
+    object.__setattr__(proxy, "__deprecated__", dep)
+    if doc is not None:
+        object.__setattr__(proxy, "__doc__", doc)
+    return proxy
+
+
+def _proxy_call_args_remap(
+    proxy: _DeprecatedProxy,
+    dep: DeprecationConfig,
+    cfg: _ProxyConfig,
+    args: tuple[Any, ...],
+    kwargs: dict[str, Any],
+) -> Any:  # noqa: ANN401
+    """Handle ``TargetMode.ARGS_REMAP`` branch of ``__call__``: warn per deprecated kwarg, remap, call obj."""
+    mapping = dep.args_mapping or {}
+    for old_key in mapping:
+        if old_key in kwargs:
+            proxy._warn(arg_name=old_key, _extra_frames=1)
+    mapped_kwargs = proxy._apply_args_mapping(kwargs)
+    mapped_kwargs = proxy._merge_args_extra(mapped_kwargs)
+    return _proxy_call_with_positional_split(cfg.obj, dep, args, mapped_kwargs)
+
+
+def _proxy_call_callable_with_mapping(
+    proxy: _DeprecatedProxy,
+    dep: DeprecationConfig,
+    target_fn: Callable[..., Any],
+    args: tuple[Any, ...],
+    kwargs: dict[str, Any],
+) -> Any:  # noqa: ANN401
+    """Handle callable-target + args_mapping branch of ``__call__``: warn per kwarg, remap, forward."""
+    mapping = dep.args_mapping or {}
+    for old_key in mapping:
+        if old_key in kwargs:
+            proxy._warn(arg_name=old_key, _extra_frames=1)
+    if not any(old_key in kwargs for old_key in mapping):
+        proxy._warn(_extra_frames=1)
+    mapped_kwargs = proxy._apply_args_mapping(kwargs)
+    mapped_kwargs = proxy._merge_args_extra(mapped_kwargs)
+    return _proxy_call_with_positional_split(target_fn, dep, args, mapped_kwargs)
+
+
+def _expand_dc_attrs_to_args(
+    dc_check: Any,  # noqa: ANN401
+    attrs_mapping: Optional[dict[str, Optional[str]]],
+    args_mapping: Optional[dict[str, Optional[str]]],
+) -> tuple[Optional[dict[str, Optional[str]]], list[str]]:
+    """Auto-expand ``attrs_mapping`` entries into ``args_mapping`` for dataclass dual-surface deprecation.
+
+    When the target (or wrapped object) is a ``@dataclass``, copies ``attrs_mapping`` entries whose redirect value names
+    a dataclass ``__init__`` parameter into ``args_mapping`` so that both ``instance.old_field`` (attribute access) and
+    ``DC(old_field=5)`` (constructor kwarg) emit a ``FutureWarning`` from a single ``deprecated_class()`` call.
+
+    Returns ``(updated_args_mapping, auto_expanded_keys)``.  Returns the original ``args_mapping`` unchanged (possibly
+    ``None``) when ``attrs_mapping`` is empty/``None`` or ``dc_check`` is not a dataclass.  Keys already present in
+    ``args_mapping`` are never overwritten.
+
+    """
+    if not (attrs_mapping and _is_dataclass_target(dc_check)):
+        return args_mapping, []
+    auto_expanded: list[str] = []
+    _init_param_names: set[str] = set(inspect.signature(dc_check).parameters)
+    for _old_key, _mapping_val in attrs_mapping.items():
+        if _mapping_val in _init_param_names:
+            if args_mapping is None:
+                args_mapping = {}
+            if _old_key not in args_mapping:
+                args_mapping[_old_key] = _mapping_val
+                auto_expanded.append(_old_key)
+    return args_mapping, auto_expanded
+
+
+def _detect_ctor_positional_only(dc_check: Any) -> tuple[frozenset[str], tuple[str, ...]]:  # noqa: ANN401
+    """Inspect the active class constructor for POSITIONAL_ONLY parameters.
+
+    Proxy twin of :func:`~deprecate.deprecation._detect_positional_only`: pre-computes the split
+    data consumed by :func:`_proxy_call_with_positional_split` so remapped kwargs bound to
+    positional-only constructor params can be forwarded positionally at call time.
+
+    Args:
+        dc_check: The resolved active object (target class when configured, wrapped object
+            otherwise).  Non-class objects yield empty results.
+
+    Returns:
+        Tuple of ``(positional_only, param_order)`` — the POSITIONAL_ONLY parameter names of the
+        constructor and the full parameter-name sequence in declaration order (``self`` excluded,
+        matching ``inspect.signature`` on a class).  Both empty when *dc_check* is not a class or
+        its constructor declares no positional-only params.
+
+    """
+    if not isinstance(dc_check, type):
+        return frozenset(), ()
+    try:
+        ctor_sig = inspect.signature(dc_check)
+    except (TypeError, ValueError):
+        return frozenset(), ()
+    positional_only = frozenset(
+        param_name
+        for param_name, param in ctor_sig.parameters.items()
+        if param.kind is inspect.Parameter.POSITIONAL_ONLY
+    )
+    param_order: tuple[str, ...] = tuple(ctor_sig.parameters) if positional_only else ()
+    return positional_only, param_order
+
+
+def _detect_proxy_positional_only(
+    dc_check: Any,  # noqa: ANN401
+    name: str,
+    args_mapping: Optional[dict[str, Optional[str]]],
+) -> tuple[str, ...]:
+    """Detect ``args_mapping`` keys that remap to POSITIONAL_ONLY constructor parameters.
+
+    Emits a ``UserWarning`` at decoration time and returns the incompatible old-key names so they can be recorded in
+    :class:`~deprecate._types.DeprecationConfig` for audit surfacing. Returns an empty tuple when no incompatibilities
+    are found.
+
+    """
+    if not (args_mapping and isinstance(dc_check, type)):
+        return ()
+    incompatible = _get_args_mapping_positional_only_keys(dc_check, args_mapping)
+    if incompatible:
+        warnings.warn(
+            f"`args_mapping` on `{name}` remaps {list(incompatible)!r} to POSITIONAL_ONLY "
+            f"constructor parameter(s) of `{dc_check.__name__}`. "
+            "Calls using those deprecated names will pass the remapped values positionally "
+            "to the constructor — consider removing `/` from the target signature or using "
+            "`attrs_mapping` instead.",
+            UserWarning,
+            stacklevel=5,  # caller → decorator(cls) → __init__ → _detect_proxy_positional_only → warn
+        )
+    return incompatible
+
+
+def _build_proxy_warn_msg(
+    proxy: _DeprecatedProxy,
+    arg_name: Optional[str],
+    dep: DeprecationConfig,
+    cfg: _ProxyConfig,
+) -> Optional[str]:
+    """Build the warning message string for a proxy warning emission.
+
+    Returns ``None`` when the warning should be suppressed (``attrs_mapping`` lookup miss).
+
+    """
+    target: Any = dep.target
+    args_mapping = dep.args_mapping
+    custom_template = cfg.template_mgs
+
+    if arg_name is not None and args_mapping and arg_name in args_mapping:
+        new_arg = args_mapping[arg_name]
+        argument_map = TEMPLATE_ARGUMENT_MAPPING % {"old_arg": arg_name, "new_arg": str(new_arg)}
+        template = custom_template or TEMPLATE_WARNING_ARGUMENTS
+        return template % {
+            "source_name": dep.name,
+            "source_path": dep.name,
+            "deprecated_in": dep.deprecated_in,
+            "remove_in": dep.remove_in,
+            "target_name": str(new_arg) if new_arg is not None else "",
+            "target_path": "",
+            "argument_map": argument_map,
+        }
+    if arg_name is not None and arg_name.startswith("__attr__:") and dep.attrs_mapping is not None:
+        return proxy._build_attr_warning_msg(arg_name, dep, dep.attrs_mapping, target, custom_template)
+    if callable(target):
+        target_name = target.__name__
+        target_path = f"{target.__module__}.{target_name}"
+        template = custom_template or TEMPLATE_WARNING_CALLABLE
+        return template % {
+            "source_name": dep.name,
+            "source_path": dep.name,
+            "deprecated_in": dep.deprecated_in,
+            "remove_in": dep.remove_in,
+            "target_name": target_name,
+            "target_path": target_path,
+            "argument_map": "",
+        }
+    template = custom_template or TEMPLATE_WARNING_NO_TARGET
+    return template % {
+        "source_name": dep.name,
+        "source_path": dep.name,
+        "deprecated_in": dep.deprecated_in,
+        "remove_in": dep.remove_in,
+        "target_name": "",
+        "target_path": "",
+        "argument_map": "",
+    }
+
+
+def deprecated_class(
+    target: Any = None,  # noqa: ANN401
+    *,
+    deprecated_in: str = "",
+    remove_in: str = "",
+    num_warns: int = 1,
+    stream: Optional[Callable[..., None]] = deprecation_warning,
+    template_mgs: Optional[str] = None,
+    args_mapping: Optional[dict[str, Optional[str]]] = None,
+    args_extra: Optional[dict[str, Any]] = None,
+    attrs_mapping: Optional[dict[str, Optional[str]]] = None,
+    update_docstring: bool = False,
+    docstring_style: Literal["auto", "rst", "mkdocs", "markdown"] = "auto",
+    _misconfigured_override: bool = False,
+) -> Callable[[Union[type, "_DeprecatedProxy"]], "_DeprecatedProxy"]:
+    r"""Decorator factory for deprecating class definitions with optional target redirection.
+
+    Apply ``@deprecated_class(...)`` to an Enum or dataclass to wrap the class in a
+    :class:`~deprecate.proxy._DeprecatedProxy`.  All attribute, item, and call access on the resulting object will
+    emit a deprecation warning and, if *target* is provided, will be forwarded to the replacement class.
+
+    Args:
+        target: Optional replacement class to redirect all access to.
+        deprecated_in: Version string when the class was deprecated.
+        remove_in: Version string when the class will be removed.
+        num_warns: Maximum number of warnings to emit per proxy instance. ``1`` warns once; ``-1`` warns on every
+            access.
+        stream: Callable used to emit warnings. Defaults to :data:`~deprecate.deprecation.deprecation_warning`.
+        template_mgs: Optional custom warning message template that overrides the built-in templates.  When ``None``
+            (default), the built-in template for the active scenario is used (callable-target, no-target, or
+            per-argument for ``args_mapping``).  Available ``%``-style placeholders:
+
+            - ``%(source_name)s`` — the deprecated class name (taken from ``cls.__name__``)
+            - ``%(deprecated_in)s`` — value of the ``deprecated_in`` argument
+            - ``%(remove_in)s`` — value of the ``remove_in`` argument
+            - ``%(target_name)s`` — target class name (only when *target* is callable)
+            - ``%(target_path)s`` — fully-qualified target path (only when *target* is callable)
+            - ``%(argument_map)s`` — formatted ``\`old\` -> \`new\``` string (only for per-argument warnings
+              emitted by ``args_mapping``)
+
+            Example: ``"v%(deprecated_in)s: ``%(source_name)s`` -> ``%(target_name)s``"``.
+        args_mapping: Optional dict remapping keyword argument names when the decorated class is called.  Keys are
+            old argument names; values are new names, or ``None`` to drop the argument entirely.  When provided
+            without an explicit callable *target*, the mode auto-resolves to
+            :attr:`~deprecate._types.TargetMode.ARGS_REMAP`: the proxy warns **only when an old argument name is
+            actually used** in the call, matching the per-argument warning behaviour of
+            ``@deprecated(target=TargetMode.ARGS_REMAP, args_mapping=...)``.  Passing ``args_mapping`` together with
+            ``target=TargetMode.NOTIFY`` is a misconfiguration and emits a :class:`UserWarning` at decoration time
+            (will be :class:`TypeError` in v1.0).  Similarly, ``target=TargetMode.ARGS_REMAP`` without
+            ``args_mapping`` emits a :class:`UserWarning` at decoration time.
+        args_extra: Optional dict of extra keyword arguments merged into the forwarded call after ``args_mapping`` has
+            been applied.  ``args_extra`` values win over any caller-supplied value with the same key (i.e.
+            ``args_extra`` > explicit new-name kwarg > remapped old-name value > source defaults).  Ignored when
+            ``target`` is :attr:`~deprecate._types.TargetMode.NOTIFY` (passing both emits a :class:`UserWarning` at
+            decoration time; will be :class:`TypeError` in v1.0).
+        attrs_mapping: Optional dict mapping deprecated attribute names to canonical names (or ``None`` for
+            warn-only).  When set, only the listed attribute names emit a deprecation warning on access; all other
+            attributes are forwarded silently.  The redirect applies to reads (``__getattr__``), writes
+            (``__setattr__``), and deletes (``__delattr__``).  Every non-``None`` value must be an existing attribute
+            on the target class when ``target`` is provided, or on the wrapped source class otherwise.
+            ``None`` values keep the same attribute name but still resolve against the active class, so with
+            ``target=SomeClass`` a warn-only mapping such as ``{"size": None}`` reads, writes, and deletes
+            ``SomeClass.size``.
+            Redirect chains such as ``{"a": "b", "b": "c"}`` are allowed at decoration time and reported by audit as
+            :attr:`~deprecate.audit.ChainType.STACKED`. Cycles such as ``{"a": "b", "b": "a"}`` raise
+            :class:`ValueError` at decoration time.
+
+            Example: ``attrs_mapping={"color": "colour", "txt": "text"}`` warns on ``proxy.color`` access and
+            returns ``proxy.colour``; ``proxy.colour`` is forwarded silently.
+
+            When ``attrs_mapping`` is ``None`` (default), the existing behaviour is preserved: a warning is emitted
+            on every attribute access through the proxy.
+
+            **Callable target interaction**: when ``target=SomeClass`` is also provided, listed attribute aliases
+            resolve against ``SomeClass``.  A ``None`` mapping keeps the original attribute name on ``SomeClass``.
+            Unlisted attributes and calls continue to use the normal target-forwarding behaviour.
+
+            **Validation limitation**: attribute existence is checked using :func:`inspect.getattr_static`,
+            which detects class-level attributes and ``__slots__`` entries but not instance-only attributes
+            set in ``__init__`` via ``self.x = ...``.  For dataclass targets without defaults, the field
+            name appears in ``__dataclass_fields__`` but the attribute itself is instance-only —
+            decoration-time validation will raise :class:`ValueError` even though access would succeed at
+            runtime.  As a workaround, add a class-level default or use a ``None`` (warn-only) entry.
+
+            The mode can also be set explicitly as ``target=TargetMode.ATTRS_REMAP`` — both forms are equivalent;
+            the explicit form is self-documenting and enables validation at decoration time. Passing
+            ``target=TargetMode.ATTRS_REMAP`` without ``attrs_mapping``, or passing an empty ``attrs_mapping={}``,
+            emits a :class:`UserWarning` at decoration time (will be :class:`TypeError` in v1.0). Passing
+            ``attrs_mapping`` together with ``target=TargetMode.NOTIFY`` is also a misconfiguration and emits a
+            :class:`UserWarning` at decoration time.
+        update_docstring: If ``True``, inject a deprecation notice into the class docstring at decoration time (same
+            behaviour as ``@deprecated(update_docstring=True)``).
+        docstring_style: Output style for the injected notice when ``update_docstring=True``.  ``"auto"`` detects the
+            doc engine at decoration time; ``"rst"`` emits a ``.. deprecated::`` directive; ``"mkdocs"`` /
+            ``"markdown"`` emit a ``!!! warning`` admonition.
+
+    Returns:
+        A decorator that wraps the class in a :class:`~deprecate.proxy._DeprecatedProxy`.
+
+    Note:
+        **Subclassing (PEP 560)**: the proxy implements ``__mro_entries__`` so
+        ``class Child(deprecated_alias):`` resolves to ``class Child(target_or_source_class):``
+        in the MRO — ``issubclass(Child, target_class)`` returns ``True`` and standard inheritance
+        semantics are preserved.  One ``FutureWarning`` fires at class-definition time (not per
+        instance).  With :attr:`~deprecate._types.TargetMode.ATTRS_REMAP` aliases (``attrs_mapping``
+        without a callable *target*) and :attr:`~deprecate._types.TargetMode.ARGS_REMAP` aliases
+        (``args_mapping`` without a callable *target*) subclassing stays **silent** — both modes
+        scope deprecation to specific axes (attribute names or argument names), not the class name.
+
+    Examples:
+        >>> from enum import Enum
+        >>> class NewColor(Enum):
+        ...     RED = 1
+        >>> @deprecated_class(target=NewColor, deprecated_in="1.0", remove_in="2.0", stream=None)
+        ... class OldColor(Enum):
+        ...     RED = 1
+        >>> OldColor.RED is NewColor.RED
+        True
+        >>> OldColor(1) is NewColor.RED
+        True
+
+        When only argument names changed, omit *target* and supply ``args_mapping``. The proxy auto-resolves to
+        :attr:`~deprecate._types.TargetMode.ARGS_REMAP` and warns **only when the old argument name is passed**:
+
+        >>> class Config:
+        ...     def __init__(self, timeout: int = 0) -> None:
+        ...         self.timeout = timeout
+        >>> LegacyConfig = deprecated_class(
+        ...     args_mapping={"time_limit": "timeout"},
+        ...     deprecated_in="1.5", remove_in="2.0", stream=None,
+        ... )(Config)
+        >>> LegacyConfig(timeout=30).timeout     # new name — no remap needed
+        30
+        >>> LegacyConfig(time_limit=30).timeout  # old name — remapped to timeout
+        30
+
+        Selective per-attribute deprecation via ``attrs_mapping``: only the listed attribute
+        aliases emit a warning; other attribute accesses pass through silently.
+
+        >>> @deprecated_class(
+        ...     attrs_mapping={"color": "colour"},
+        ...     deprecated_in="1.0",
+        ...     remove_in="2.0",
+        ...     stream=None,
+        ... )
+        ... class Palette:
+        ...     colour = "red"
+        ...     color = colour  # deprecated alias for ``colour``
+        >>> Palette.colour     # canonical name — silent passthrough
+        'red'
+        >>> Palette.color      # deprecated alias — warns (suppressed by ``stream=None``)
+        'red'
+
+    """
+
+    def decorator(cls: Union[type, "_DeprecatedProxy"]) -> "_DeprecatedProxy":
+        # When cls is a _DeprecatedProxy (stacking case), cls.__name__ triggers __getattr__
+        # which emits a spurious warning. Retrieve the name safely via the stored metadata.
+        cls_name = (
+            object.__getattribute__(cls, "__deprecated__").name if isinstance(cls, _DeprecatedProxy) else cls.__name__
+        )
+        if stream is not None and not deprecated_in and not template_mgs:
+            warnings.warn(
+                f"`@deprecated_class` on `{cls_name}` has no `deprecated_in` set."
+                " Deprecation notices and generated documentation will omit the `deprecated_in` version."
+                " Pass `deprecated_in` for a meaningful deprecation notice.",
+                UserWarning,
+                stacklevel=2,
+            )
+        proxy = _DeprecatedProxy(
+            obj=cls,
+            name=cls_name,
+            deprecated_in=deprecated_in,
+            remove_in=remove_in,
+            num_warns=num_warns,
+            stream=stream,
+            template_mgs=template_mgs,
+            read_only=False,
+            target=target,
+            args_mapping=args_mapping,
+            args_extra=args_extra,
+            attrs_mapping=attrs_mapping,
+            docstring_style=docstring_style,
+            _misconfigured_override=_misconfigured_override,
+        )
+        if update_docstring:
+            # Use a SimpleNamespace shim so _update_docstring_with_deprecation can set __doc__ normally; then store
+            # the result on the proxy via object.__setattr__ (bypassing the proxy's forwarding __setattr__).
+            shim = types.SimpleNamespace(__doc__=object.__getattribute__(proxy, "__doc__"), __deprecated__=proxy._dep)
+            _update_docstring_with_deprecation(shim)
+            object.__setattr__(proxy, "__doc__", shim.__doc__)
+        return proxy
+
+    return decorator
+
+
+def deprecated_instance(
+    obj: Any,  # noqa: ANN401
+    *,
+    name: str = "",
+    deprecated_in: str = "",
+    remove_in: str = "",
+    num_warns: int = 1,
+    stream: Optional[Callable[..., None]] = deprecation_warning,
+    template_mgs: Optional[str] = None,
+    read_only: bool = False,
+    args_extra: Optional[dict[str, Any]] = None,
+) -> "_DeprecatedProxy":
+    """Wrap any Python object with deprecation warnings.
+
+    Returns a :class:`~deprecate.proxy._DeprecatedProxy` that transparently forwards all read access to *obj* while
+    emitting a :class:`FutureWarning`.  In *read-only* mode any write attempt through the proxy raises
+    :class:`AttributeError`.
+
+    Args:
+        obj: The object to deprecate (dict, list, custom object, …).
+        name: Display name for *obj* used in the warning message. When omitted, the type name of *obj* is used
+            (e.g. ``"dict"``).
+        deprecated_in: Version string when *obj* was deprecated.
+        remove_in: Version string when *obj* will be removed.
+        num_warns: Maximum number of warnings to emit. ``1`` (default) warns once; ``-1`` warns on every access.
+        stream: Callable used to emit warnings. Defaults to :data:`~deprecate.deprecation.deprecation_warning`
+            (:class:`FutureWarning`).  Pass ``None`` to suppress warnings.
+        template_mgs: Optional custom warning message template that overrides the built-in templates.  When ``None``
+            (default), the built-in template for the active scenario is used.  See
+            :func:`~deprecate.proxy.deprecated_class` for the available ``%``-style placeholders.
+        read_only: If ``True``, raise :class:`AttributeError` on any write attempt through the proxy.
+            Only the following standard collection mutator names are intercepted: ``append``, ``clear``,
+            ``discard``, ``extend``, ``insert``, ``pop``, ``remove``, ``setdefault``, ``update``, ``add``.
+            Custom method names (e.g. ``register()``, ``reload()``, ``set_value()``) are not blocked.
+        args_extra: Optional dict of extra keyword arguments merged into the forwarded call when the proxy is invoked.
+            ``args_extra`` values win over any caller-supplied value with the same key.
+
+    Returns:
+        A :class:`~deprecate.proxy._DeprecatedProxy` wrapping *obj*.
+
+    Note:
+        **Operator warnings**: arithmetic operators (``+``, ``-``, ``*``, ``**``, ``//``, ``%``, ``<<``,
+        ``>>``, ``&``, ``|``, ``^``) and their reflected forms emit a deprecation warning and consume the
+        ``num_warns`` budget.  In-place operators (``+=``, ``-=``, …) additionally enforce ``read_only``.
+        Ordering comparisons (``<``, ``<=``, ``>``, ``>=``) and structural probes (``__eq__``, ``__len__``,
+        ``__bool__``, ``__str__``) are **silent** — they do not consume the warn budget.
+
+    Example:
+        >>> cfg = {"threshold": 0.5, "enabled": True}
+        >>> proxy = deprecated_instance(
+        ...     cfg,
+        ...     name="config_dict",
+        ...     deprecated_in="1.0",
+        ...     remove_in="2.0",
+        ...     stream=None,
+        ... )
+        >>> proxy["threshold"]
+        0.5
+        >>> proxy.get("enabled")
+        True
+
+    """
+    resolved_name = name or type(obj).__name__
+    if stream is not None and not deprecated_in and not template_mgs:
+        warnings.warn(
+            f"`deprecated_instance()` on `{resolved_name}` has no `deprecated_in` set."
+            " Deprecation notices and generated documentation will omit the `deprecated_in` version."
+            " Pass `deprecated_in` for a meaningful deprecation notice.",
+            UserWarning,
+            stacklevel=2,
+        )
+    return _DeprecatedProxy(
+        obj=obj,
+        name=resolved_name,
+        deprecated_in=deprecated_in,
+        remove_in=remove_in,
+        num_warns=num_warns,
+        stream=stream,
+        template_mgs=template_mgs,
+        read_only=read_only,
+        args_extra=args_extra,
+    )
+
+
+# ----------------------------------------------------------------------
+# Operator / protocol dunder forwarding (see the "Protocol forwarding" section of the
+# _DeprecatedProxy docstring for the warn-policy contract).
+#
+# Implicit special-method lookup bypasses ``__getattr__`` — Python resolves dunders on the *type*,
+# not the instance — so every operator, conversion, and protocol dunder must live on the class
+# itself for the proxy to stay transparent. These are generated from a table (rather than ~60
+# hand-written defs) and installed onto ``_DeprecatedProxy`` below.
+# ----------------------------------------------------------------------
+
+
+def _unwrap_operand(value: Any) -> Any:  # noqa: ANN401
+    """Return the active object behind a proxy operand, leaving non-proxy operands untouched."""
+    if isinstance(value, _DeprecatedProxy):
+        return _DeprecatedProxy._get_static_attr_owner(value)
+    return value
+
+
+def _make_binary_forward(op_name: str, *, warn: bool) -> Callable[..., Any]:
+    """Build a binary-operator dunder that forwards to the active object.
+
+    Looks the operator up on the *type* of the active object and returns :data:`NotImplemented` when it is absent, so
+    Python can try the reflected operand and ultimately raise its normal :class:`TypeError` — the proxy never masks an
+    unsupported-operand error. Proxy operands are unwrapped to their active object first.
+
+    """
+
+    def _binary_dunder(self: "_DeprecatedProxy", other: Any, *extra: Any) -> Any:  # noqa: ANN401
+        active = self._get_active()
+        impl = getattr(type(active), op_name, None)
+        if impl is None:
+            return NotImplemented
+        result = impl(active, _unwrap_operand(other), *(_unwrap_operand(e) for e in extra))
+        if result is NotImplemented:
+            return NotImplemented
+        if warn:
+            self._warn()
+        return result
+
+    _binary_dunder.__name__ = op_name
+    _binary_dunder.__qualname__ = f"_DeprecatedProxy.{op_name}"
+    return _binary_dunder
+
+
+def _make_inplace_forward(op_name: str) -> Callable[..., Any]:
+    """Build an in-place operator dunder that enforces ``read_only`` before forwarding.
+
+    In-place operators mutate the active object, so they must honour the ``read_only=True`` contract.  This is a
+    separate factory from :func:`_make_binary_forward` so that the check is not paid by the much more common
+    arithmetic/reflected paths.
+
+    """
+
+    def _inplace_dunder(self: "_DeprecatedProxy", other: Any) -> Any:  # noqa: ANN401
+        self._check_read_only(f"In-place operation '{op_name}'")
+        active = self._get_active()
+        impl = getattr(type(active), op_name, None)
+        if impl is None:
+            return NotImplemented
+        self._warn()
+        return impl(active, _unwrap_operand(other))
+
+    _inplace_dunder.__name__ = op_name
+    _inplace_dunder.__qualname__ = f"_DeprecatedProxy.{op_name}"
+    return _inplace_dunder
+
+
+def _make_unary_forward(op_name: str, func: Callable[[Any], Any]) -> Callable[..., Any]:
+    """Build a unary/conversion dunder that forwards through *func* (a builtin such as ``int`` or ``abs``).
+
+    Delegating through the builtin preserves Python's own fallbacks (e.g. ``int()`` falling back to ``__index__``) and
+    lets the natural :class:`TypeError` surface when the active object does not support the protocol.
+
+    """
+
+    def _unary_dunder(self: "_DeprecatedProxy") -> Any:  # noqa: ANN401
+        self._warn()
+        return func(self._get_active())
+
+    _unary_dunder.__name__ = op_name
+    _unary_dunder.__qualname__ = f"_DeprecatedProxy.{op_name}"
+    return _unary_dunder
+
+
+#: Arithmetic, reflected, and in-place binary operators — all warn (a data-producing use).
+_ARITHMETIC_OPS: tuple[str, ...] = (
+    "__add__", "__sub__", "__mul__", "__matmul__", "__truediv__", "__floordiv__",
+    "__mod__", "__divmod__", "__pow__", "__lshift__", "__rshift__", "__and__", "__xor__", "__or__",
+)  # fmt: skip
+_REFLECTED_OPS: tuple[str, ...] = (
+    "__radd__", "__rsub__", "__rmul__", "__rmatmul__", "__rtruediv__", "__rfloordiv__",
+    "__rmod__", "__rdivmod__", "__rpow__", "__rlshift__", "__rrshift__", "__rand__", "__rxor__", "__ror__",
+)  # fmt: skip
+_INPLACE_OPS: tuple[str, ...] = (
+    "__iadd__", "__isub__", "__imul__", "__imatmul__", "__itruediv__", "__ifloordiv__",
+    "__imod__", "__ipow__", "__ilshift__", "__irshift__", "__iand__", "__ixor__", "__ior__",
+)  # fmt: skip
+#: Ordering comparisons — silent (cheap probes, mirroring ``__eq__``/``__len__``).
+_ORDERING_OPS: tuple[str, ...] = ("__lt__", "__le__", "__gt__", "__ge__")
+#: Unary and conversion protocols forwarded through their builtin — all warn (a data-producing use).
+_UNARY_OPS: dict[str, Callable[[Any], Any]] = {
+    "__neg__": operator.neg,
+    "__pos__": operator.pos,
+    "__abs__": abs,
+    "__invert__": operator.invert,
+    "__int__": int,
+    "__float__": float,
+    "__complex__": complex,
+    "__index__": operator.index,
+    "__trunc__": math.trunc,
+    "__floor__": math.floor,
+    "__ceil__": math.ceil,
+    "__reversed__": reversed,
+    "__fspath__": os.fspath,
+    "__next__": next,
+}
+
+
+def _install_forwarding_dunders(cls: type) -> None:
+    """Attach the generated operator/conversion dunders to *cls* at import time.
+
+    Arithmetic and reflected binary operators are installed via :func:`_make_binary_forward`; in-place operators via
+    :func:`_make_inplace_forward` (which also enforces ``read_only``); ordering comparisons via
+    :func:`_make_binary_forward` (silent); unary and conversion protocols via :func:`_make_unary_forward`. Ordering
+    comparisons are silent (structural probes); every other generated dunder warns (data use).
+
+    """
+    for _op in (*_ARITHMETIC_OPS, *_REFLECTED_OPS):
+        setattr(cls, _op, _make_binary_forward(_op, warn=True))
+    for _op in _INPLACE_OPS:
+        setattr(cls, _op, _make_inplace_forward(_op))
+    for _op in _ORDERING_OPS:
+        setattr(cls, _op, _make_binary_forward(_op, warn=False))
+    for _op, _func in _UNARY_OPS.items():
+        setattr(cls, _op, _make_unary_forward(_op, _func))
+
+
+_install_forwarding_dunders(_DeprecatedProxy)

.venv/lib/python3.12/site-packages/deprecate/utils.py

@@ -0,0 +1,355 @@
+"""Low-level helpers for the deprecation system.
+
+This module provides two kinds of helpers:
+
+**Internal** (used by :mod:`deprecate.deprecation` and :mod:`deprecate.audit`):
+    - :func:`~deprecate.utils.get_func_arguments_types_defaults`: Extract parameter names, annotations, and defaults
+      from a callable's signature. Used when applying ``args_mapping`` and when auditing wrapper configuration.
+
+**Public — decorator companion** (exported via :mod:`deprecate`):
+    - :func:`~deprecate.utils.void`: Accepts any arguments and returns ``None``. Used in deprecated function stubs
+      to satisfy IDEs and mypy about unused parameters.
+
+**Public — testing** (exported via :mod:`deprecate`):
+    - :func:`~deprecate.utils.assert_no_warnings`: Context manager that asserts no warnings are raised during a
+      block — the inverse of ``pytest.warns()``.
+
+Copyright (C) 2020-2026 Jiri Borovec <6035284+Borda@users.noreply.github.com>
+
+"""
+
+import inspect
+import warnings
+from collections.abc import Generator
+from contextlib import contextmanager
+from functools import lru_cache
+from types import TracebackType
+from typing import Any, Callable, Optional, Union
+
+
+def get_func_arguments_types_defaults(func: Callable) -> list[tuple[str, Any, Any]]:
+    """Parse function arguments, types and default values.
+
+    This introspection helper extracts the complete signature information from a function, including parameter names,
+    type annotations, and default values.  Useful for dynamic argument handling and validation in wrapper functions.
+
+    Args:
+        func: A function to be examined.
+
+    Returns:
+        List of tuples, one per argument, each containing:
+            - str: argument name
+            - Any: argument type annotation (or inspect.Parameter.empty if no annotation)
+            - Any: default value (or inspect.Parameter.empty if no default)
+
+    Example:
+        >>> def example_func(x: int, y: str = "hello", z=42) -> None:
+        ...     pass
+        >>> result = get_func_arguments_types_defaults(example_func)
+        >>> for name, type_hint, default in result:
+        ...     print(f"{name}: type={type_hint}, default={default}")
+        x: type=<class 'int'>, default=<class 'inspect._empty'>
+        y: type=<class 'str'>, default=hello
+        z: type=<class 'inspect._empty'>, default=42
+
+    Note:
+        - Parameters without type annotations have annotation = inspect.Parameter.empty
+        - Parameters without defaults have default = inspect.Parameter.empty
+        - Excludes *args and **kwargs (use inspect.getfullargspec for those)
+
+    """
+    func_default_params = _get_signature(func).parameters
+    func_arg_type_val = []
+    for arg in func_default_params:
+        param = func_default_params[arg]
+        # Exclude ``*args`` / ``**kwargs`` (as the docstring promises): their names are not concrete
+        # parameters, and leaking them into caller-argument validation yields a raw ``TypeError`` instead
+        # of the curated "argument not accepted by target" message.
+        if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+            continue
+        func_arg_type_val.append((arg, param.annotation, param.default))
+    return func_arg_type_val
+
+
+@lru_cache(maxsize=256)
+def _get_signature_cached(func: Callable) -> inspect.Signature:
+    """Cache inspect.signature lookups for repeated calls.
+
+    Uses an LRU cache (maxsize=256) since function signatures are stable at runtime. The size balances reuse for common
+    callables without unbounded memory growth.
+
+    """
+    return inspect.signature(func)
+
+
+def _get_signature(func: Callable) -> inspect.Signature:
+    """Get function signature with caching when possible.
+
+    Falls back to uncached lookup for unhashable callables.
+
+    """
+    try:
+        return _get_signature_cached(func)
+    except TypeError:
+        return inspect.signature(func)
+
+
+def _is_dataclass_target(cls: Any) -> bool:  # noqa: ANN401
+    """Return True if *cls* is a dataclass class (not an instance).
+
+    Used by :class:`~deprecate.proxy._DeprecatedProxy` to detect ``@dataclass`` targets that benefit from automatic
+    ``attrs_mapping`` → ``args_mapping`` expansion.
+
+    """
+    import dataclasses
+
+    return isinstance(cls, type) and dataclasses.is_dataclass(cls)
+
+
+def _apply_args_mapping_collisions(
+    args_mapping: dict[str, Optional[str]],
+    kwargs: dict[str, Any],
+    args_skip: Any,  # noqa: ANN401 - accepts list or set
+    name: str,
+    stream: Any,  # noqa: ANN401 - truthy check; callable in deprecation path
+    stacklevel: int,
+) -> dict[str, Any]:
+    """Return snapshot of explicit new-name values for collision pairs and emit UserWarning per collision.
+
+    A collision occurs when a caller supplies both the deprecated old argument name and its mapped new name
+    simultaneously.  The new-name value always wins; this function snapshots it before the remap overwrites
+    it and warns the caller that the old name was ignored.
+
+    Args:
+        args_mapping: Mapping of old argument names to new names (``None`` = drop).
+        kwargs: Current keyword arguments at the call site.
+        args_skip: Names whose mapped value is ``None`` (drop); excluded from collision detection.
+        name: Callable name used in the warning message.
+        stream: Warning stream; falsy value suppresses all warnings.
+        stacklevel: Passed to ``warnings.warn``; caller is responsible for counting frames above this function.
+
+    Returns:
+        Dict of ``{new_k: kwargs[new_k]}`` for each detected collision pair (empty when no collisions).
+
+    """
+    collision_pairs = [
+        (old_k, new_k)
+        for old_k, new_k in args_mapping.items()
+        if new_k is not None and old_k in kwargs and new_k in kwargs and new_k not in args_skip
+    ]
+    explicit_new: dict[str, Any] = {new_k: kwargs[new_k] for _, new_k in collision_pairs}
+    if collision_pairs and stream:
+        for old_k, new_k in collision_pairs:
+            warnings.warn(
+                f"Both `{old_k}` (deprecated) and `{new_k}` were supplied to `{name}()`; `{old_k}` is ignored.",
+                UserWarning,
+                stacklevel=stacklevel,
+            )
+    return explicit_new
+
+
+def _get_args_mapping_positional_only_keys(
+    target_cls: Any,  # noqa: ANN401
+    args_mapping: dict[str, Any],
+) -> tuple[str, ...]:
+    """Return ``args_mapping`` keys whose redirect target is a POSITIONAL_ONLY constructor param.
+
+    When ``deprecated_class(args_mapping={"old": "new"}, ...)`` is applied to a target class whose
+    constructor declares ``new`` as positional-only (``def __init__(self, new, /): ...``), calling
+    the proxy with ``old=value`` would remap to ``new=value`` and then immediately raise
+    ``TypeError`` because ``new`` cannot be passed as a keyword argument.
+
+    This helper detects that mismatch at decoration time so the proxy can emit a ``UserWarning``
+    and store the incompatible keys on :class:`~deprecate._types.DeprecationConfig` for audit
+    surfacing.
+
+    Args:
+        target_cls: The resolved target class to inspect.
+        args_mapping: The ``args_mapping`` dict being validated.
+
+    Returns:
+        Tuple of ``args_mapping`` old-key names whose remapped target name is positional-only in
+        the target's constructor signature.  Empty tuple when no incompatibilities detected.
+
+    """
+    try:
+        sig = inspect.signature(target_cls)
+    except (TypeError, ValueError):
+        return ()
+
+    positional_only: set[str] = {
+        name for name, p in sig.parameters.items() if p.kind is inspect.Parameter.POSITIONAL_ONLY
+    }
+    if not positional_only:
+        return ()
+
+    return tuple(old_key for old_key, mapping_val in args_mapping.items() if mapping_val in positional_only)
+
+
+def _warns_repr(warns: list[warnings.WarningMessage]) -> list[Union[Warning, str]]:
+    """Convert list of warning messages to their string representations.
+
+    Args:
+        warns: List of warning message objects captured during execution.
+
+    Returns:
+        List of warning messages as strings or Warning objects.
+
+    """
+    return [w.message for w in warns]
+
+
+@contextmanager
+def assert_no_warnings(warning_type: Optional[type[Warning]] = None, match: Optional[str] = None) -> Generator:
+    """Context manager asserting that no warnings are raised — the inverse of ``pytest.warns()``.
+
+    Useful for testing that refactored code properly avoids deprecated functionality or that new implementations don't
+    trigger warnings.
+
+    Args:
+        warning_type: The warning type that must NOT be raised (e.g., :class:`FutureWarning`,
+            :class:`DeprecationWarning`). If ``None``, asserts that no warnings of any type are raised.
+        match: If given, only fail if a warning message contains this string. If ``None``, fails on any warning of
+            the specified type.
+
+    Raises:
+        AssertionError: If a warning of the specified type (and optionally matching the message pattern) was raised
+            during the context.
+
+    Example:
+        >>> # Assert new function doesn't trigger FutureWarning
+        >>> import warnings
+        >>> def new_func(x: int) -> int:
+        ...     return x * 2
+        >>> with assert_no_warnings(FutureWarning):
+        ...     result = new_func(42)
+        >>> result
+        84
+
+        >>> # Assert NO warnings at all are raised
+        >>> def clean_function():
+        ...     pass
+        >>> with assert_no_warnings():
+        ...     clean_function()
+
+        >>> # Only fail if warning message matches pattern
+        >>> def some_function():
+        ...     warnings.warn("deprecated feature", FutureWarning)
+        >>> # Passes because warning contains "feature", not "other"
+        >>> with assert_no_warnings(FutureWarning, match="other"):
+        ...     some_function()
+
+    Note:
+        This context manager is particularly useful in pytest for testing that refactored code properly uses new APIs
+        without triggering deprecation warnings.
+
+    """
+    with warnings.catch_warnings(record=True) as called:
+        # Cause all warnings to always be triggered.
+        warnings.simplefilter("always")
+        # Trigger a warning.
+        yield
+        # no warning raised
+        if not called:
+            return
+        if not warning_type:
+            raise AssertionError(f"While catching all warnings, these were found: {_warns_repr(called)}")
+        # filter warnings by type
+        warns = [w for w in called if issubclass(w.category, warning_type)]
+        # Verify some things
+        if not warns:
+            return
+        if not match:
+            raise AssertionError(
+                f"While catching `{warning_type.__name__}` warnings, these were found: {_warns_repr(warns)}"
+            )
+        found = [w for w in warns if match in w.message.__str__()]
+        if found:
+            raise AssertionError(
+                f'While catching `{warning_type.__name__}` warnings with "{match}",'
+                f" these were found: {_warns_repr(found)}"
+            )
+
+
+class no_warning_call:  # noqa: N801 - kept for backward compatibility with prior snake_case API
+    """Deprecated alias for :func:`~deprecate.utils.assert_no_warnings`.
+
+    This context manager is kept for backward compatibility so that existing imports like
+    ``from deprecate.utils import no_warning_call`` continue to work until v1.0.
+
+    Warning fires at instantiation — the ``no_warning_call(...)`` call line receives the
+    deprecation notice, regardless of how the context manager is subsequently used.
+
+    Args:
+        warning_type: The :class:`Warning` subclass to watch for.  Defaults to :class:`Warning`
+            (all warning categories).
+        match: Optional substring that must appear in the warning message.  When ``None`` (default),
+            any warning of the right category triggers an :class:`AssertionError`.
+
+    Examples:
+        >>> import warnings
+        >>> with warnings.catch_warnings():
+        ...     warnings.simplefilter("ignore", DeprecationWarning)
+        ...     with no_warning_call():
+        ...         pass  # no AssertionError means no warnings were emitted
+
+    """
+
+    def __init__(self, warning_type: Optional[type[Warning]] = None, match: Optional[str] = None) -> None:
+        """Emit the alias-deprecation warning and capture args for the no-warning assertion."""
+        warnings.warn(
+            "`deprecate.utils.no_warning_call` is deprecated in `0.6` and will be removed in `1.0`; "
+            "use `deprecate.utils.assert_no_warnings` instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self._warning_type = warning_type
+        self._match = match
+        self._inner: Any = None  # ``assert_no_warnings`` returns a ``_GeneratorContextManager``
+
+    def __enter__(self) -> None:
+        """Enter the underlying ``assert_no_warnings`` context."""
+        self._inner = assert_no_warnings(warning_type=self._warning_type, match=self._match)
+        self._inner.__enter__()
+
+    def __exit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        """Forward exit to the underlying ``assert_no_warnings`` so its AssertionError still surfaces."""
+        assert self._inner is not None  # noqa: S101 — internal invariant: __exit__ only runs after __enter__
+        return self._inner.__exit__(exc_type, exc_val, exc_tb)
+
+
+def void(*args: Any, **kwargs: Any) -> Any:  # noqa: ANN401
+    """Empty function that accepts any arguments and returns None.
+
+    This helper function is used to silence IDE warnings about unused parameters in deprecated functions where the
+    body is never executed (calls are forwarded to a target function). It's purely a convenience for developers.
+
+    Args:
+        *args: Any positional arguments (ignored).
+        **kwargs: Any keyword arguments (ignored).
+
+    Returns:
+        None always.
+
+    Example:
+        >>> from deprecate import deprecated, void
+        >>>
+        >>> def new_func(x: int) -> int:
+        ...     return x * 2
+        >>>
+        >>> @deprecated(target=new_func, deprecated_in="1.0", remove_in="2.0")
+        ... def old_func(x: int) -> int:
+        ...     void(x)  # Silences IDE warning about unused 'x'
+        ...     # This line is never reached - call forwarded to new_func
+
+    Note:
+        This function has no runtime effect - it's purely for developer convenience. You can also use ``pass`` or
+        just a docstring instead of calling ``void()``.
+
+    """
+    _, _ = args, kwargs

.venv/lib/python3.12/site-packages/distutils-precedence.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2638ce9e2500e572a5e0de7faed6661eb569d1b696fcba07b0dd223da5f5d224
+size 151

.venv/lib/python3.12/site-packages/example.py

@@ -0,0 +1,169 @@
+#################################################################################
+# Copyright (c) 2020, NVIDIA Corporation.  All rights reserved.                 #
+#                                                                               #
+# Redistribution and use in source and binary forms, with or without            #
+# modification, are permitted provided that the following conditions are met:   #
+#                                                                               #
+#    * Redistributions of source code must retain the above copyright notice,   #
+#      this list of conditions and the following disclaimer.                    #
+#    * Redistributions in binary form must reproduce the above copyright        #
+#      notice, this list of conditions and the following disclaimer in the      #
+#      documentation and/or other materials provided with the distribution.     #
+#    * Neither the name of the NVIDIA Corporation nor the names of its          #
+#      contributors may be used to endorse or promote products derived from     #
+#      this software without specific prior written permission.                 #
+#                                                                               #
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"   #
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE     #
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE    #
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE     #
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR           #
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF          #
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS      #
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN       #
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)       #
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF        #
+# THE POSSIBILITY OF SUCH DAMAGE.                                               #
+#################################################################################
+
+#
+# Sample script to demonstrate the usage of NVML API python bindings
+#
+
+# To Run:
+# $ python ./example.py
+
+from pynvml import *
+
+#
+# Helper function
+#
+def StrVirt(mode):
+    if mode == NVML_GPU_VIRTUALIZATION_MODE_NONE:
+        return "None";
+    elif mode == NVML_GPU_VIRTUALIZATION_MODE_PASSTHROUGH:
+        return "Pass-Through";
+    elif mode == NVML_GPU_VIRTUALIZATION_MODE_VGPU:
+        return "VGPU";
+    elif mode == NVML_GPU_VIRTUALIZATION_MODE_HOST_VGPU:
+        return "Host VGPU";
+    elif mode == NVML_GPU_VIRTUALIZATION_MODE_HOST_VSGA:
+        return "Host VSGA";
+    else:
+        return "Unknown";
+
+#
+# Converts errors into string messages
+#
+def handleError(err):
+    if (err.value == NVML_ERROR_NOT_SUPPORTED):
+        return "N/A"
+    else:
+        return err.__str__()
+
+#######
+def deviceQuery():
+
+    strResult = ''
+    try:
+        #
+        # Initialize NVML
+        #
+        nvmlInit()
+
+        strResult += '  <driver_version>' + str(nvmlSystemGetDriverVersion()) + '</driver_version>\n'
+
+        deviceCount = nvmlDeviceGetCount()
+        strResult += '  <attached_gpus>' + str(deviceCount) + '</attached_gpus>\n'
+
+        for i in range(0, deviceCount):
+            handle = nvmlDeviceGetHandleByIndex(i)
+
+            pciInfo = nvmlDeviceGetPciInfo(handle)
+
+            strResult += '  <gpu id="%s">\n' % pciInfo.busId
+
+            strResult += '    <product_name>' + nvmlDeviceGetName(handle) + '</product_name>\n'
+
+            brandNames = {NVML_BRAND_UNKNOWN             :  "Unknown",
+                          NVML_BRAND_QUADRO              :  "Quadro",
+                          NVML_BRAND_TESLA               :  "Tesla",
+                          NVML_BRAND_NVS                 :  "NVS",
+                          NVML_BRAND_GRID                :  "Grid",
+                          NVML_BRAND_TITAN               :  "Titan",
+                          NVML_BRAND_GEFORCE             :  "GeForce",
+                          NVML_BRAND_NVIDIA_VAPPS        :  "NVIDIA Virtual Applications",
+                          NVML_BRAND_NVIDIA_VPC          :  "NVIDIA Virtual PC",
+                          NVML_BRAND_NVIDIA_VCS          :  "NVIDIA vGPU for Compute",
+                          NVML_BRAND_NVIDIA_VWS          :  "NVIDIA RTX Virtual Workstation",
+                          NVML_BRAND_NVIDIA_CLOUD_GAMING :  "NVIDIA Cloud Gaming",
+                          NVML_BRAND_QUADRO_RTX          :  "Quadro RTX",
+                          NVML_BRAND_NVIDIA_RTX          :  "NVIDIA RTX",
+                          NVML_BRAND_NVIDIA              :  "NVIDIA",
+                          NVML_BRAND_GEFORCE_RTX         :  "GeForce RTX",
+                          NVML_BRAND_TITAN_RTX           :  "TITAN RTX",
+
+            }
+
+            try:
+                # If nvmlDeviceGetBrand() succeeds it is guaranteed to be in the dictionary
+                brandName = brandNames[nvmlDeviceGetBrand(handle)]
+            except NVMLError as err:
+                brandName = handleError(err)
+
+            strResult += '    <product_brand>' + brandName + '</product_brand>\n'
+
+            try:
+                serial = nvmlDeviceGetSerial(handle)
+            except NVMLError as err:
+                serial = handleError(err)
+
+            strResult += '    <serial>' + serial + '</serial>\n'
+
+            try:
+                uuid = nvmlDeviceGetUUID(handle)
+            except NVMLError as err:
+                uuid = handleError(err)
+
+            strResult += '    <uuid>' + uuid + '</uuid>\n'
+
+            strResult += '    <gpu_virtualization_mode>\n'
+            try:
+                mode = StrVirt(nvmlDeviceGetVirtualizationMode(handle))
+            except NVMLError as err:
+                mode = handleError(err)
+            strResult += '      <virtualization_mode>' + mode + '</virtualization_mode>\n'
+            strResult += '    </gpu_virtualization_mode>\n'
+
+            try:
+                gridLicensableFeatures = nvmlDeviceGetGridLicensableFeatures(handle)
+                if gridLicensableFeatures.isGridLicenseSupported == 1:
+                    strResult += '    <vgpu_software_licensed_product>\n'
+                    for i in range(gridLicensableFeatures.licensableFeaturesCount):
+                        if gridLicensableFeatures.gridLicensableFeatures[i].featureState == 0:
+                            if nvmlDeviceGetVirtualizationMode(handle) == NVML_GPU_VIRTUALIZATION_MODE_PASSTHROUGH:
+                                strResult += '        <licensed_product_name>' + 'NVIDIA Virtual Applications' + '</licensed_product_name>\n'
+                                strResult += '        <license_status>' + 'Licensed' + '</license_status>\n'
+                            else:
+                                strResult += '        <licensed_product_name>' + gridLicensableFeatures.gridLicensableFeatures[i].productName + '</licensed_product_name>\n'
+                                strResult += '        <license_status>' + 'Unlicensed' + '</license_status>\n'
+                        else:
+                            strResult += '        <licensed_product_name>' + gridLicensableFeatures.gridLicensableFeatures[i].productName + '</licensed_product_name>\n'
+                            strResult += '        <license_status>' + 'Licensed' + '</license_status>\n'
+                    strResult += '    </vgpu_software_licensed_product>\n'
+            except NVMLError as err:
+                gridLicensableFeatures = handleError(err)
+
+            strResult += '  </gpu>\n'
+
+    except NVMLError as err:
+        strResult += 'example.py: ' + err.__str__() + '\n'
+
+    nvmlShutdown()
+
+    return strResult
+
+# If this is not exectued when module is imported
+if __name__ == "__main__":
+    print(deviceQuery())
+

.venv/lib/python3.12/site-packages/filelock-3.32.3.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

.venv/lib/python3.12/site-packages/filelock-3.32.3.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.5
+Name: filelock
+Version: 3.32.3
+Summary: A platform independent file lock.
+Project-URL: Documentation, https://py-filelock.readthedocs.io
+Project-URL: Homepage, https://github.com/tox-dev/py-filelock
+Project-URL: Source, https://github.com/tox-dev/py-filelock
+Project-URL: Tracker, https://github.com/tox-dev/py-filelock/issues
+Maintainer-email: Bernát Gábor <gaborjbernat@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: application,cache,directory,log,user
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# filelock
+
+[![PyPI](https://img.shields.io/pypi/v/filelock)](https://pypi.org/project/filelock/)
+[![Supported Python versions](https://img.shields.io/pypi/pyversions/filelock.svg)](https://pypi.org/project/filelock/)
+[![Documentation status](https://readthedocs.org/projects/py-filelock/badge/?version=latest)](https://py-filelock.readthedocs.io/en/latest/?badge=latest)
+[![Downloads](https://static.pepy.tech/badge/filelock/month)](https://pepy.tech/project/filelock)
+[![check](https://github.com/tox-dev/py-filelock/actions/workflows/check.yaml/badge.svg)](https://github.com/tox-dev/py-filelock/actions/workflows/check.yaml)
+
+For more information checkout the [official documentation](https://py-filelock.readthedocs.io/en/latest/index.html).

.venv/lib/python3.12/site-packages/filelock-3.32.3.dist-info/RECORD

@@ -0,0 +1,48 @@
+filelock-3.32.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+filelock-3.32.3.dist-info/METADATA,sha256=LYD0O9kFaJFFwAsxM7yViV1lTO1wqWoYAukjfg1mWZ8,2028
+filelock-3.32.3.dist-info/RECORD,,
+filelock-3.32.3.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+filelock-3.32.3.dist-info/licenses/LICENSE,sha256=YIyJ1QYK6ZIa3M8yNmlbxlSplG4SMj72wCHfoE4pTUg,1088
+filelock/__init__.py,sha256=ZEhX0CozvRxFQwsm8YYc6uiLvuIYe-aoD20ACfjyizg,3469
+filelock/__pycache__/__init__.cpython-312.pyc,,
+filelock/__pycache__/_api.cpython-312.pyc,,
+filelock/__pycache__/_async.cpython-312.pyc,,
+filelock/__pycache__/_async_read_write.cpython-312.pyc,,
+filelock/__pycache__/_descriptor.cpython-312.pyc,,
+filelock/__pycache__/_error.cpython-312.pyc,,
+filelock/__pycache__/_identity.cpython-312.pyc,,
+filelock/__pycache__/_lease.cpython-312.pyc,,
+filelock/__pycache__/_marker.cpython-312.pyc,,
+filelock/__pycache__/_read_write.cpython-312.pyc,,
+filelock/__pycache__/_soft.cpython-312.pyc,,
+filelock/__pycache__/_soft_protocol.cpython-312.pyc,,
+filelock/__pycache__/_strict.cpython-312.pyc,,
+filelock/__pycache__/_unix.cpython-312.pyc,,
+filelock/__pycache__/_util.cpython-312.pyc,,
+filelock/__pycache__/_windows.cpython-312.pyc,,
+filelock/__pycache__/asyncio.cpython-312.pyc,,
+filelock/__pycache__/version.cpython-312.pyc,,
+filelock/_api.py,sha256=VWiuW2oWHrM9Fy3yRlsxre-daXjpmzCbJO43iFuYkJE,82436
+filelock/_async.py,sha256=rO6gt1h6ZvT2gw_0P1Xmf1jZs82kEipZ9xX4_rJUm3k,6111
+filelock/_async_read_write.py,sha256=ZAJJ02CALgZ6uhhWew4DefTtnEU7lslSoG-VjmMpDBs,13325
+filelock/_descriptor.py,sha256=ss1FfyEAyrZ1QB3LDXUtJHk5ZFAfSAaCdaa5Yp1Vzk4,2981
+filelock/_error.py,sha256=SfdLwQeooh81jIM1S4d1010ctZzXZBYBo78bJA1lEZs,2699
+filelock/_identity.py,sha256=dY_ngMJQJHm0fLD5TaGef12oOGeBAl9h0_7Xv1d3GMM,8415
+filelock/_lease.py,sha256=nEi4I02Ry3t8QSLYcctr36XV4jV6eLyaTyHo6zBeSKE,15152
+filelock/_marker.py,sha256=7VJWyyrh8wW8VywSTLLIR7OC__aNUn4zFnel5JdQwWI,6026
+filelock/_read_write.py,sha256=PBlLg_fbkqDcpRyJ5NkZgoWLR9DEUHM-1sQzBnZsOD8,32881
+filelock/_soft.py,sha256=ydpW15r3gGW2kBaHhj8FvnATQw5-kfXnSWyYhbEQNKA,13014
+filelock/_soft_protocol.py,sha256=qEM2x9Nz9zguXwwWjZsCsPEfas5nqHlJ-_oHvAM0Uo4,187
+filelock/_soft_rw/__init__.py,sha256=_ktpGmVObzrvL0K1_EAV3LF7B9JarYxW-mx_eyGPhT0,370
+filelock/_soft_rw/__pycache__/__init__.cpython-312.pyc,,
+filelock/_soft_rw/__pycache__/_async.cpython-312.pyc,,
+filelock/_soft_rw/__pycache__/_sync.cpython-312.pyc,,
+filelock/_soft_rw/_async.py,sha256=oKDt9jgsRSAvx2ls9cA0AN2Lk0WlHc7bdmKTTCNjl9g,11492
+filelock/_soft_rw/_sync.py,sha256=XMC0kMoRBMoCAJqxK9bU_UW5o0KVQ5UmcdYqpp5j8kM,43201
+filelock/_strict.py,sha256=N5037nWAz2AF59LlyPMsOg4IwGL13D6x64hhQEn3vQQ,38823
+filelock/_unix.py,sha256=W95gKLjYivNZYLT3634o7l0pQfvU8SdBW_2C3bo3lLw,8722
+filelock/_util.py,sha256=gY839OXIttp1JOr9-FuhLTYYOoBtExkB2Nn50t8oxYQ,6356
+filelock/_windows.py,sha256=sLAk--cnOK1f-9RTuAAAOSjh4XBcxa0R3jy2w3XgUZs,15988
+filelock/asyncio.py,sha256=iE593J-CgUl3yAAGsnzitId4MtHDs5ne--F8N8oS6ys,34599
+filelock/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+filelock/version.py,sha256=7xrb9cafe38S02w7EZcEpqTbiGOe0tDHHrLpKSH8XgM,522

.venv/lib/python3.12/site-packages/filelock-3.32.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

.venv/lib/python3.12/site-packages/filelock-3.32.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Bernát Gábor and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

.venv/lib/python3.12/site-packages/filelock/__init__.py

@@ -0,0 +1,115 @@
+"""
+A platform independent file lock that supports the with-statement.
+
+.. autodata:: filelock.__version__
+    :no-value:
+
+"""
+
+from __future__ import annotations
+
+import sys
+import warnings
+from typing import TYPE_CHECKING, Final
+
+from ._api import AcquireReturnProxy, BaseFileLock, CloseErrorPolicy, ContextErrorPolicy, LockOptions
+from ._descriptor import lock_descriptor, unlock_descriptor
+from ._error import LeaseSettingsMismatch, SoftFileLockLifetimeWarning, SoftFileLockProtocolError, Timeout
+from ._lease import LeaseCompromise, SoftFileLease
+from ._marker import MarkerSoftFileLock, OwnerRecord
+
+if TYPE_CHECKING:
+    from ._async_read_write import (
+        AsyncAcquireReadWriteReturnProxy,
+        AsyncReadWriteLock,
+    )
+    from ._read_write import ReadWriteLock
+else:
+    try:
+        from ._async_read_write import AsyncAcquireReadWriteReturnProxy, AsyncReadWriteLock
+        from ._read_write import ReadWriteLock
+    except ImportError:  # pragma: lacks sqlite3
+        AsyncAcquireReadWriteReturnProxy = None
+        AsyncReadWriteLock = None
+        ReadWriteLock = None
+
+from ._soft import SoftFileLock
+from ._soft_rw import AsyncAcquireSoftReadWriteReturnProxy, AsyncSoftReadWriteLock, SoftReadWriteLock
+from ._strict import StrictSoftFileClaim, StrictSoftFileClaimState, StrictSoftFileLock
+from ._unix import UnixFileLock, has_fcntl
+from ._windows import WindowsFileLock
+from .asyncio import (
+    AsyncAcquireReturnProxy,
+    AsyncSoftFileLease,
+    AsyncSoftFileLock,
+    AsyncStrictSoftFileLock,
+    AsyncUnixFileLock,
+    AsyncWindowsFileLock,
+    BaseAsyncFileLock,
+)
+from .version import version
+
+#: version of the project as a string
+__version__: Final[str] = version
+
+
+if sys.platform == "win32":  # pragma: win32 cover
+    _FileLock: type[BaseFileLock] = WindowsFileLock
+    _AsyncFileLock: type[BaseAsyncFileLock] = AsyncWindowsFileLock
+else:  # pragma: win32 no cover # ruff:ignore[collapsible-else-if]  # the else carries the win32 no-cover pragma
+    if has_fcntl:
+        _FileLock: type[BaseFileLock] = UnixFileLock
+        _AsyncFileLock: type[BaseAsyncFileLock] = AsyncUnixFileLock
+    else:
+        _FileLock = SoftFileLock
+        _AsyncFileLock = AsyncSoftFileLock
+        warnings.warn("only soft file lock is available", stacklevel=2)
+
+if TYPE_CHECKING:
+    FileLock = SoftFileLock
+    AsyncFileLock = AsyncSoftFileLock
+else:
+    #: Alias for the lock, which should be used for the current platform.
+    FileLock = _FileLock
+    AsyncFileLock = _AsyncFileLock
+
+
+__all__ = [
+    "AcquireReturnProxy",
+    "AsyncAcquireReadWriteReturnProxy",
+    "AsyncAcquireReturnProxy",
+    "AsyncAcquireSoftReadWriteReturnProxy",
+    "AsyncFileLock",
+    "AsyncReadWriteLock",
+    "AsyncSoftFileLease",
+    "AsyncSoftFileLock",
+    "AsyncSoftReadWriteLock",
+    "AsyncStrictSoftFileLock",
+    "AsyncUnixFileLock",
+    "AsyncWindowsFileLock",
+    "BaseAsyncFileLock",
+    "BaseFileLock",
+    "CloseErrorPolicy",
+    "ContextErrorPolicy",
+    "FileLock",
+    "LeaseCompromise",
+    "LeaseSettingsMismatch",
+    "LockOptions",
+    "MarkerSoftFileLock",
+    "OwnerRecord",
+    "ReadWriteLock",
+    "SoftFileLease",
+    "SoftFileLock",
+    "SoftFileLockLifetimeWarning",
+    "SoftFileLockProtocolError",
+    "SoftReadWriteLock",
+    "StrictSoftFileClaim",
+    "StrictSoftFileClaimState",
+    "StrictSoftFileLock",
+    "Timeout",
+    "UnixFileLock",
+    "WindowsFileLock",
+    "__version__",
+    "lock_descriptor",
+    "unlock_descriptor",
+]

.venv/lib/python3.12/site-packages/filelock/_api.py

@@ -0,0 +1,1826 @@
+from __future__ import annotations
+
+import contextlib
+import inspect
+import logging
+import math
+import os
+import secrets
+import sys
+import time
+import warnings
+from abc import ABCMeta, abstractmethod
+from collections.abc import Callable, Hashable
+from contextlib import contextmanager
+from dataclasses import dataclass
+from itertools import count, starmap
+from threading import Condition, RLock, get_ident, local
+from typing import TYPE_CHECKING, Final, Literal, NoReturn, TypedDict, TypeVar, cast
+from weakref import WeakKeyDictionary, WeakValueDictionary
+
+from ._error import SoftFileLockLifetimeWarning, Timeout
+from ._util import break_lock_file
+
+#: No explicit file permission mode was passed. Lock files then open with 0o666 so umask and default ACLs pick
+#: the final permissions, and fchmod is skipped to preserve POSIX default ACL inheritance.
+_UNSET_FILE_MODE: Final[int] = -1
+
+#: Ceiling on the retry counter used as a power of two, so a long contended wait cannot overflow the backoff multiply.
+_MAX_BACKOFF_EXPONENT: Final[int] = 20
+
+#: How a context manager reconciles a body failure with a release failure on exit (see the property of this name).
+ContextErrorPolicy = Literal["chain", "group"]
+_CONTEXT_ERROR_POLICIES: Final[frozenset[str]] = frozenset({"chain", "group"})
+
+#: What a descriptor-owning backend does with an ``os.close`` failure after relinquishing ownership (see the property).
+CloseErrorPolicy = Literal["default", "raise", "suppress"]
+_CLOSE_ERROR_POLICIES: Final[frozenset[str]] = frozenset({"default", "raise", "suppress"})
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+    from types import TracebackType
+    from typing import Protocol
+
+    from _typeshed import Unused
+
+    from ._read_write import ReadWriteLock
+    from ._soft_rw import SoftReadWriteLock
+
+    class _ForkResettable(Protocol):
+        def _reset_after_fork_in_child(self) -> None: ...
+
+    class _ForkDescriptorOwner(Protocol):
+        def _descriptors_for_fork(self) -> tuple[tuple[int, tuple[int, int] | None], ...]: ...
+
+    # Matched against the class object itself rather than `type[...]` of it. A metaclass supplies this method to the
+    # class while leaving instances without it, so a `type[_ForkResettableClass]` bound rejects `ReadWriteLock`.
+    class _ForkResettableClass(Protocol):
+        def _reset_class_after_fork(self) -> None: ...
+
+    class _RegisterAtFork(Protocol):
+        def __call__(
+            self,
+            *,
+            before: Callable[[], None] | None = None,
+            after_in_parent: Callable[[], None] | None = None,
+            after_in_child: Callable[[], None] | None = None,
+        ) -> None: ...
+
+    if sys.version_info >= (3, 11):  # pragma: no cover (py311+)
+        from typing import Self
+    else:  # pragma: no cover (<py311)
+        from typing_extensions import Self
+
+_LOGGER: Final[logging.Logger] = logging.getLogger("filelock")
+_REGISTER_AT_FORK: Final[_RegisterAtFork | None] = cast("_RegisterAtFork | None", getattr(os, "register_at_fork", None))
+_HAS_REGISTER_AT_FORK: Final[bool] = _REGISTER_AT_FORK is not None
+
+_ExtraValue = TypeVar("_ExtraValue")
+_MarkerValue = TypeVar("_MarkerValue")
+_SubclassValue = TypeVar("_SubclassValue")
+_LockInitValue = float | int | bool | str | None | Callable[[int], None]
+
+
+class LockOptions(TypedDict, total=False):
+    """Every option the metaclass forwards, so a subclass adding its own can still type what it passes through."""
+
+    timeout: float
+    mode: int
+    thread_local: bool
+    blocking: bool
+    is_singleton: bool
+    poll_interval: float
+    lifetime: float | None
+    context_error_policy: ContextErrorPolicy
+    close_error_policy: CloseErrorPolicy
+    fallback_to_soft: bool
+    preserve_lock_file: bool
+    on_acquired: Callable[[int], None] | None
+
+
+def _exception_group_cls() -> type[BaseException]:
+    # BaseExceptionGroup is a builtin on 3.11+; on 3.10 it needs the exceptiongroup backport. filelock keeps zero
+    # runtime dependencies, so the backport is imported lazily rather than required, and only group mode needs it.
+    if sys.version_info >= (3, 11):  # pragma: no cover (py311+)
+        return BaseExceptionGroup  # ruff:ignore[undefined-name]  # builtin on 3.11+
+    # Alias the import so BaseExceptionGroup above stays the builtin rather than an unbound local of this function.
+    from exceptiongroup import (  # ruff:ignore[import-outside-top-level]  # pragma: no cover (<py311)
+        BaseExceptionGroup as _Backport,
+    )
+
+    return _Backport  # pragma: no cover (<py311)
+
+
+def _raise_grouped_errors(
+    message: str,
+    first_error: BaseException,
+    second_error: BaseException,
+    *additional_errors: BaseException,
+    marker: tuple[str, _MarkerValue] | None = None,
+) -> NoReturn:
+    errors = (first_error, second_error, *additional_errors)
+    _detach_grouped_contexts(errors)
+    group = _exception_group_cls()(message, errors)
+    if marker is not None:
+        setattr(group, marker[0], marker[1])
+    raise group from None
+
+
+def _detach_grouped_contexts(errors: tuple[BaseException, ...]) -> None:
+    seen: set[int] = set()
+    pending = list(errors)
+    while pending:
+        error = pending.pop()
+        if id(error) in seen:
+            continue
+        seen.add(id(error))
+        if (context := error.__context__) is not None and (
+            context is error
+            or _same_exception_tree(error, context)
+            or any(context is root or _contains_exception(root, context) for root in errors)
+        ):
+            error.__context__ = None
+        elif context is not None:
+            pending.append(context)
+        if error.__cause__ is not None:
+            pending.append(error.__cause__)
+        if isinstance(error, _exception_group_cls()):
+            pending.extend(cast("_ExceptionGroupProtocol", error).exceptions)
+
+
+def _same_exception_tree(first: BaseException, second: BaseException) -> bool:
+    pending = [(first, second)]
+    seen: set[tuple[int, int]] = set()
+    while pending:
+        first_error, second_error = pending.pop()
+        if first_error is second_error:
+            continue
+        if (pair := (id(first_error), id(second_error))) in seen:
+            continue
+        seen.add(pair)
+        if (
+            type(first_error) is not type(second_error)
+            or not isinstance(first_error, _exception_group_cls())
+            or not isinstance(second_error, _exception_group_cls())
+        ):
+            return False
+        first_group = cast("_ExceptionGroupProtocol", first_error)
+        second_group = cast("_ExceptionGroupProtocol", second_error)
+        if first_group.message != second_group.message or len(first_group.exceptions) != len(second_group.exceptions):
+            return False
+        pending.extend(zip(first_group.exceptions, second_group.exceptions, strict=True))
+    return True
+
+
+def _contains_exception(error: BaseException, target: BaseException | None) -> bool:
+    if target is None or not isinstance(error, _exception_group_cls()):
+        return False
+    pending = list(cast("_ExceptionGroupProtocol", error).exceptions)
+    seen: set[int] = set()
+    while pending:
+        child = pending.pop()
+        if child is target:
+            return True
+        if id(child) in seen:
+            continue
+        seen.add(id(child))
+        if isinstance(child, _exception_group_cls()):
+            pending.extend(cast("_ExceptionGroupProtocol", child).exceptions)
+    return False
+
+
+def _append_exception_context(error: BaseException, context: BaseException) -> None:
+    if _exception_graph_contains(error, context) or _exception_graph_contains(context, error):
+        return
+    if error.__context__ is None:
+        error.__context__ = context
+        return
+    tail = error
+    seen: set[int] = set()
+    while id(tail) not in seen:
+        seen.add(id(tail))
+        if (next_error := tail.__cause__ if tail.__cause__ is not None else tail.__context__) is None:
+            tail.__context__ = context
+            return
+        tail = next_error
+
+
+def _exception_graph_contains(error: BaseException, target: BaseException) -> bool:
+    pending = [error]
+    seen: set[int] = set()
+    while pending:
+        current = pending.pop()
+        if current is target:
+            return True
+        if id(current) in seen:  # pragma: no cover - arbitrary caller exceptions can contain cycles
+            continue
+        seen.add(id(current))
+        if current.__cause__ is not None:
+            pending.append(current.__cause__)
+        if current.__context__ is not None:
+            pending.append(current.__context__)
+        if isinstance(current, _exception_group_cls()):
+            pending.extend(cast("_ExceptionGroupProtocol", current).exceptions)
+    return False
+
+
+def _grouped_errors(
+    error: BaseException, message: str, marker: tuple[str, _MarkerValue]
+) -> tuple[BaseException, ...] | None:
+    if not isinstance(error, _exception_group_cls()):
+        return None
+    group = cast("_ExceptionGroupProtocol", error)
+    return group.exceptions if group.message == message and getattr(group, marker[0], None) is marker[1] else None
+
+
+if TYPE_CHECKING:
+
+    class _ExceptionGroupProtocol(Protocol):
+        @property
+        def message(self) -> str: ...
+
+        @property
+        def exceptions(self) -> tuple[BaseException, ...]: ...
+
+
+def _raise_chained_errors(first_error: BaseException, second_error: BaseException | None = None) -> NoReturn:
+    if second_error is None:
+        first_context = first_error.__context__
+        try:
+            raise first_error  # ruff:ignore[raise-within-try]  # the handler restores caller-supplied context before propagation
+        except BaseException:
+            first_error.__context__ = first_context
+            raise
+    if (second_context := second_error.__context__) is not None and second_context is not first_error:
+        _detach_exception_context(second_context, first_error)
+        _append_exception_context(first_error, second_context)
+    first_context = first_error.__context__
+    try:
+        raise first_error  # ruff:ignore[raise-within-try]  # the second raise needs this error as implicit context
+    except BaseException:  # ruff:ignore[blind-except]  # first_error may be a control-flow exception
+        first_error.__context__ = first_context
+        try:
+            raise second_error  # ruff:ignore[raise-within-try]  # the handler makes the chain interpreter-independent
+        except BaseException:
+            second_error.__context__ = first_error
+            first_error.__context__ = first_context
+            raise
+
+
+def _detach_exception_context(error: BaseException, target: BaseException) -> None:
+    pending = [error]
+    seen: set[int] = set()
+    while pending:
+        current = pending.pop()
+        if id(current) in seen:
+            continue
+        seen.add(id(current))
+        if current.__context__ is target:
+            current.__context__ = None
+        elif current.__context__ is not None:
+            pending.append(current.__context__)
+        if current.__cause__ is not None:
+            pending.append(current.__cause__)
+        if isinstance(current, _exception_group_cls()):
+            pending.extend(cast("_ExceptionGroupProtocol", current).exceptions)
+
+
+def _raise_body_and_release(body_error: BaseException, release_error: BaseException) -> NoReturn:
+    # Group mode: surface the body failure and the release failure as sibling leaves instead of letting one hide in the
+    # other's __context__. BaseExceptionGroup returns a plain ExceptionGroup when both leaves subclass Exception, so
+    # ``except*`` and ``except Exception`` still catch them; a BaseException leaf (KeyboardInterrupt, CancelledError)
+    # keeps the group outside ordinary handlers. ``from None`` stops the group itself gaining a redundant __context__.
+    _raise_grouped_errors("lock body and release both failed", body_error, release_error)
+
+
+def _raise_cleanup_errors(
+    message: str,
+    primary_error: BaseException,
+    *cleanup_errors: BaseException | None,
+) -> NoReturn:
+    _raise_grouped_errors(
+        message,
+        primary_error,
+        *(error for error in cleanup_errors if error is not None),
+    )
+
+
+# On Windows os.path.realpath calls CreateFileW with share_mode=0, which blocks concurrent DeleteFileW and causes
+# livelocks under threaded contention with SoftFileLock. os.path.abspath is purely string-based and avoids this.
+_resolve_dir: Final[Callable[[str], str]] = os.path.abspath if sys.platform == "win32" else os.path.realpath
+
+
+def _canonical(path: str | os.PathLike[str]) -> str:
+    """
+    Return one stable key for *path*, collapsing equivalent spellings without following a final symlink.
+
+    Relative, absolute, and ``./`` spellings of one lock file must map to a single singleton instance, deadlock-registry
+    entry, and removal key. Resolving the whole path with ``realpath`` would follow a final symlink and alias a lock
+    target the backend deliberately rejects, so the registry identity would differ from the backend's. Resolving only
+    the parent directory and re-appending the literal final component collapses the equivalent spellings while keeping a
+    final symlink a distinct key. On Windows the parent is resolved with ``abspath`` so junctions and reparse points are
+    not followed either.
+    """
+    parent, name = os.path.split(os.fspath(path))
+    return os.path.join(_resolve_dir(parent or os.curdir), name)  # ruff:ignore[os-path-join]  # string join matches abspath/realpath
+
+
+class _ThreadLocalRegistry(local):
+    def __init__(self) -> None:
+        super().__init__()
+        self.held: dict[Hashable, int] = {}
+
+
+_registry: Final[_ThreadLocalRegistry] = _ThreadLocalRegistry()
+
+
+_T = TypeVar("_T", bound="BaseFileLock")
+
+
+class FileLockMeta(ABCMeta):
+    _instances: WeakValueDictionary[str, BaseFileLock]
+    _instances_lock: RLock
+    _instances_under_construction: set[str]
+
+    def __call__(  # ruff:ignore[too-many-arguments]  # forwards the public constructor's documented parameters
+        cls: type[_T],
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,
+        mode: int = _UNSET_FILE_MODE,
+        thread_local: bool = True,  # ruff:ignore[boolean-type-hint-positional-argument, boolean-default-value-positional-argument]  # public API: positional bool kept for backwards compatibility
+        *,
+        blocking: bool = True,
+        is_singleton: bool = False,
+        poll_interval: float = 0.05,
+        lifetime: float | None = None,
+        context_error_policy: ContextErrorPolicy = "chain",
+        close_error_policy: CloseErrorPolicy = "default",
+        fallback_to_soft: bool = True,
+        preserve_lock_file: bool = False,
+        on_acquired: Callable[[int], None] | None = None,
+        **kwargs: _ExtraValue,
+    ) -> _T:
+        _ensure_current_process()
+        lifetime = _resolve_lifetime(lifetime, cls, stacklevel=cls._constructor_lifetime_warning_stacklevel)
+        # Validate before building the instance: a raise inside __init__ would leave a half-constructed object whose
+        # __del__ then trips over the missing context.
+        context_error_policy = _resolve_context_error_policy(context_error_policy)
+        close_error_policy = _resolve_close_error_policy(close_error_policy)
+        preserve_lock_file = _resolve_preserve_lock_file(
+            preserve=preserve_lock_file, supported=cls._preserve_lock_file_supported, cls_name=cls.__name__
+        )
+        on_acquired = _resolve_on_acquired(on_acquired, supported=cls._on_acquired_supported, cls_name=cls.__name__)
+        params: dict[str, _LockInitValue | _ExtraValue] = {
+            "timeout": timeout,
+            "mode": mode,
+            "thread_local": thread_local,
+            "blocking": blocking,
+            "is_singleton": is_singleton,
+            "poll_interval": poll_interval,
+            "lifetime": lifetime,
+            "context_error_policy": context_error_policy,
+            "close_error_policy": close_error_policy,
+            "fallback_to_soft": fallback_to_soft,
+            "preserve_lock_file": preserve_lock_file,
+            "on_acquired": on_acquired,
+            **kwargs,
+        }
+        if not is_singleton:
+            return cls._create_instance(lock_file, params)
+
+        # Look up, build and store under one lock. Without it two threads racing the first construction for a
+        # path both miss the cache and each build their own instance, so callers relying on is_singleton for
+        # reentrant locking across instances end up with two "singletons" and acquire()'s deadlock check then
+        # rejects a legitimate reentrant acquire; the unguarded writes to the WeakValueDictionary are a data
+        # race besides. ReadWriteLock and SoftReadWriteLock already guard their singleton caches this way.
+        # Key the cache on the canonical form so equivalent spellings of one path share a singleton, and it matches the
+        # deadlock-registry key acquire() uses.
+        singleton_key = _canonical(lock_file)
+        with cls._instances_lock:
+            if (instance := cls._instances.get(singleton_key)) is None:
+                if singleton_key in cls._instances_under_construction:  # pragma: needs fork
+                    msg = f"Singleton lock construction is already active for {lock_file!s}"
+                    raise RuntimeError(msg)
+                construction_registry = cls._instances_under_construction
+                construction_pid = os.getpid()
+                construction_registry.add(singleton_key)
+                try:
+                    instance = cls._create_instance(lock_file, params)
+                finally:
+                    construction_registry.discard(singleton_key)
+                if os.getpid() != construction_pid:  # pragma: needs fork
+                    msg = "Lock construction cannot continue after fork; construct a new lock in the child"
+                    raise RuntimeError(msg)
+                cls._instances[singleton_key] = instance
+                return instance
+
+        params_to_check = {
+            "thread_local": (thread_local, instance.is_thread_local()),
+            "timeout": (timeout, instance.timeout),
+            "mode": (mode, instance._context.mode),  # ruff:ignore[private-member-access]  # compares against the managed instance's own context
+            "blocking": (blocking, instance.blocking),
+            "poll_interval": (poll_interval, instance.poll_interval),
+            "lifetime": (lifetime, instance.lifetime),
+            "context_error_policy": (context_error_policy, instance.context_error_policy),
+            "close_error_policy": (close_error_policy, instance.close_error_policy),
+            "fallback_to_soft": (fallback_to_soft, instance.fallback_to_soft),
+            "preserve_lock_file": (preserve_lock_file, instance.preserve_lock_file),
+        }
+        non_matching_params = {
+            name: (passed_param, set_param)
+            for name, (passed_param, set_param) in params_to_check.items()
+            if passed_param != set_param
+        }
+        # Callables compare by identity, not equality: two equal callables can close over different state, so a
+        # singleton must reject a different hook object even if it compares equal. Keep it out of the scalar dict above.
+        hook_mismatch = on_acquired is not instance.on_acquired
+        if not non_matching_params and not hook_mismatch:
+            return instance  # ty: ignore[invalid-return-type]  # https://github.com/astral-sh/ty/issues/3231
+
+        msg = "Singleton lock instances cannot be initialized with differing arguments"
+        msg += "\nNon-matching arguments: "
+        for param_name, (passed_param, set_param) in non_matching_params.items():
+            msg += f"\n\t{param_name} (existing lock has {set_param} but {passed_param} was passed)"
+        if hook_mismatch:
+            msg += f"\n\ton_acquired (existing lock has {instance.on_acquired} but {on_acquired} was passed)"
+        raise ValueError(msg)
+
+    def _create_instance(
+        cls: type[_T], lock_file: str | os.PathLike[str], params: dict[str, _LockInitValue | _ExtraValue]
+    ) -> _T:
+        model = _init_parameter_model(cls)
+        if model.accepts_kwargs:
+            return super().__call__(lock_file, **params)
+
+        unsupported = sorted(
+            name
+            for name, value in params.items()
+            if name not in model.accepted_params
+            and ((parameter := model.default_params.get(name)) is None or value != parameter.default)
+        )
+        if unsupported:
+            msg = f"{cls.__name__} does not support non-default lock options: {', '.join(unsupported)}"
+            raise TypeError(msg)
+        # virtualenv narrows a BaseFileLock descendant's signature; omit base defaults it does not accept (#340).
+        return super().__call__(
+            lock_file,
+            **{name: value for name, value in params.items() if name in model.accepted_params},
+        )
+
+
+_INIT_PARAMETER_MODELS: Final[WeakKeyDictionary[type[BaseFileLock], _InitParameterModel]] = WeakKeyDictionary()
+
+
+def _init_parameter_model(cls: type[BaseFileLock]) -> _InitParameterModel:
+    # A strong cache would keep dynamically created subclasses alive for the process lifetime.
+    with _fork_transition(), _FORK_STATE.parameter_models_lock:
+        if (model := _INIT_PARAMETER_MODELS.get(cls)) is None:
+            parameters = inspect.signature(cls.__init__).parameters.values()
+            model = _InitParameterModel(
+                accepted_params=frozenset(
+                    parameter.name
+                    for parameter in parameters
+                    if parameter.kind in {inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY}
+                ),
+                accepts_kwargs=any(parameter.kind is inspect.Parameter.VAR_KEYWORD for parameter in parameters),
+                default_params={
+                    name: parameter
+                    for name, parameter in inspect.signature(type(cls).__call__).parameters.items()
+                    if parameter.default is not inspect.Parameter.empty
+                },
+            )
+            _INIT_PARAMETER_MODELS[cls] = model
+        return model
+
+
+@dataclass(frozen=True)
+class _InitParameterModel:
+    accepted_params: frozenset[str]
+    accepts_kwargs: bool
+    default_params: dict[str, inspect.Parameter]
+
+
+def _resolve_lifetime(lifetime: float | None, cls: type[BaseFileLock], *, stacklevel: int) -> float | None:
+    """
+    Validate ``lifetime`` and drop a value the backend cannot honor.
+
+    ``lifetime`` is a deliberate age-based lease: a lock file older than ``lifetime`` is broken even while its holder is
+    still alive. Existence locks (:class:`SoftFileLock`) implement that behavior by unlinking a reclaimable pathname,
+    which can overlap a live holder. A native OS lock lives on the inode, so unlinking the pathname by age cannot revoke
+    the kernel lock; a contender would lock a fresh inode and overlap the live holder (#590). Ignore the request with a
+    warning rather than accept a setting that breaks mutual exclusion.
+    """
+    if lifetime is not None:
+        if isinstance(lifetime, bool) or not isinstance(lifetime, (int, float)):
+            msg = f"lifetime must be a finite non-negative number or None, not {type(lifetime).__name__}"
+            raise TypeError(msg)
+        if lifetime < 0 or (isinstance(lifetime, float) and not math.isfinite(lifetime)):
+            msg = f"lifetime must be finite and non-negative, not {lifetime!r}"
+            raise ValueError(msg)
+    if lifetime is not None and not cls._lifetime_supported:
+        warnings.warn(
+            f"lifetime is ignored for {cls.__name__}: {cls._lifetime_unsupported_reason}; "
+            f"only SoftFileLock supports lifetime-based expiry",
+            stacklevel=stacklevel,
+        )
+        return None
+    if lifetime is not None and cls._lifetime_replacements is not None:
+        strict_lock, lease = cls._lifetime_replacements
+        warnings.warn(
+            f"{cls.__name__}(lifetime=...) uses age-based expiry and can overlap a live holder; "
+            f"use {lease} for expiry or {strict_lock} for fail-closed locking",
+            SoftFileLockLifetimeWarning,
+            stacklevel=stacklevel,
+        )
+    return lifetime
+
+
+def _resolve_context_error_policy(policy: str) -> ContextErrorPolicy:
+    if policy not in _CONTEXT_ERROR_POLICIES:
+        msg = f"context_error_policy must be 'chain' or 'group', got {policy!r}"
+        raise ValueError(msg)
+    if policy == "group":  # fail fast at construction rather than only when a dual failure happens to occur
+        try:
+            _exception_group_cls()
+        except ImportError as exc:  # pragma: no cover  # only on 3.10 without the exceptiongroup backport
+            msg = "context_error_policy='group' requires Python 3.11+ or the 'exceptiongroup' backport installed"
+            raise ValueError(msg) from exc
+    return cast("ContextErrorPolicy", policy)
+
+
+def _resolve_close_error_policy(policy: str) -> CloseErrorPolicy:
+    if policy not in _CLOSE_ERROR_POLICIES:
+        msg = f"close_error_policy must be 'default', 'raise', or 'suppress', got {policy!r}"
+        raise ValueError(msg)
+    return cast("CloseErrorPolicy", policy)
+
+
+def _resolve_preserve_lock_file(*, preserve: bool, supported: bool, cls_name: str) -> bool:
+    # An existence lock unlinks its marker to release, so preserving the pathname would defeat unlocking. Reject the
+    # request rather than silently ignore it, since a caller asking for a stable identity must know it cannot be kept.
+    if preserve and not supported:
+        msg = f"preserve_lock_file=True is not supported by {cls_name}: unlinking its marker is how it releases"
+        raise ValueError(msg)
+    return preserve
+
+
+def _resolve_on_acquired(
+    on_acquired: Callable[[int], None] | None, *, supported: bool, cls_name: str
+) -> Callable[[int], None] | None:
+    if on_acquired is None:
+        return None
+    # An existence lock stores protocol state in its marker, so a caller writing through the descriptor would corrupt
+    # stale detection and ownership metadata; only native locks lend out the descriptor.
+    if not supported:
+        msg = f"on_acquired is not supported by {cls_name}: only native locks expose the lock descriptor"
+        raise ValueError(msg)
+    # A hook that fails and then also fails to release surfaces both errors as a BaseExceptionGroup. Require that class
+    # at construction rather than at the rare moment both fail, matching how context_error_policy='group' validates.
+    try:
+        _exception_group_cls()
+    except ImportError as exc:  # pragma: no cover  # only on 3.10 without the exceptiongroup backport
+        msg = "on_acquired requires Python 3.11+ or the 'exceptiongroup' backport for its rollback error path"
+        raise ValueError(msg) from exc
+    return on_acquired
+
+
+class BaseFileLock(contextlib.ContextDecorator, metaclass=FileLockMeta):  # ruff:ignore[too-many-public-methods]  # public config properties
+    """
+    Abstract base class for a file lock object.
+
+    Provides the common reentrant API and state management. Subclasses implement the locking mechanism
+    (:class:`UnixFileLock <filelock.UnixFileLock>`, :class:`WindowsFileLock <filelock.WindowsFileLock>`,
+    :class:`SoftFileLock <filelock.SoftFileLock>`).
+
+    """
+
+    _instances: WeakValueDictionary[str, BaseFileLock]
+    _instances_lock: RLock
+    _instances_under_construction: set[str]
+
+    #: How the cross-instance deadlock message names the conflicting holder; the async subclass says "task".
+    _deadlock_holder_desc: str = "FileLock instance in this thread"
+
+    #: Whether an age-based :attr:`lifetime` lease may break this lock. Only existence locks set it (they reclaim by
+    #: unlinking a pathname); native OS locks leave it ``False`` since a kernel lock cannot be revoked by file age.
+    _lifetime_supported: bool = False
+
+    #: Strict-lock and lease replacements for a backend with legacy age-based expiry.
+    _lifetime_replacements: tuple[str, str] | None = None
+
+    #: Why a backend that refuses ``lifetime`` cannot honor it, named in the warning that drops the value.
+    _lifetime_unsupported_reason: str = "a native OS lock cannot be broken safely by file age"
+
+    #: Async construction adds one metaclass frame before lifetime validation.
+    _constructor_lifetime_warning_stacklevel: int = 3
+
+    #: Whether :attr:`preserve_lock_file` may be ``True``. Native locks keep the pathname on release, so they support
+    #: it; existence locks unlink their marker to release and reject it.
+    _preserve_lock_file_supported: bool = True
+
+    #: Whether an :attr:`on_acquired` hook may be set. Native locks lend the descriptor out; existence locks keep
+    #: protocol state in the marker and reject it.
+    _on_acquired_supported: bool = True
+
+    #: Whether a shared instance serializes its physical acquire and release behind one gate. A backend that publishes
+    #: several files per owner needs it; a single-file backend is atomic and leaves it off to skip the gate entirely.
+    _serialize_transitions: bool = False
+
+    #: Ceiling in seconds on the jittered backoff between contended acquisition retries. ``0`` keeps the fixed
+    #: poll cadence; a multi-file backend sets it so contending processes desynchronize instead of livelocking.
+    _poll_backoff_cap: float = 0.0
+
+    def __init_subclass__(cls, **kwargs: _SubclassValue) -> None:
+        """Give each lock subclass its own singleton registry and lock."""
+        super().__init_subclass__(**kwargs)
+        cls._instances = WeakValueDictionary()
+        cls._instances_lock = RLock()
+        cls._instances_under_construction = set()
+        _register_fork_class(cls)
+
+    @classmethod
+    def _reset_class_after_fork(cls) -> None:  # pragma: forked child
+        cls._instances = WeakValueDictionary()
+        cls._instances_lock = RLock()
+        cls._instances_under_construction = set()
+
+    def __init__(  # ruff:ignore[too-many-arguments]  # public constructor: one parameter per documented lock option
+        self,
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,
+        mode: int = _UNSET_FILE_MODE,
+        thread_local: bool = True,  # ruff:ignore[boolean-type-hint-positional-argument, boolean-default-value-positional-argument]  # public API: positional bool kept for backwards compatibility
+        *,
+        blocking: bool = True,
+        is_singleton: bool = False,
+        poll_interval: float = 0.05,
+        lifetime: float | None = None,
+        context_error_policy: ContextErrorPolicy = "chain",
+        close_error_policy: CloseErrorPolicy = "default",
+        fallback_to_soft: bool = True,
+        preserve_lock_file: bool = False,
+        on_acquired: Callable[[int], None] | None = None,
+    ) -> None:
+        """
+        Create a new lock object.
+
+        :param lock_file: path to the file
+        :param timeout: default timeout when acquiring the lock, in seconds. It will be used as fallback value in the
+            acquire method, if no timeout value (``None``) is given. If you want to disable the timeout, set it to a
+            negative value. A timeout of 0 means that there is exactly one attempt to acquire the file lock.
+        :param mode: file permissions for the lockfile. When not specified, the OS controls permissions via umask and
+            default ACLs, preserving POSIX default ACL inheritance in shared directories.
+        :param thread_local: Whether this object's internal context should be thread local or not. If this is set to
+            ``False`` then the lock will be reentrant across threads. When ``True`` (the default), **all fields of the
+            lock's internal context are per-thread**, including the configuration values ``poll_interval``, ``timeout``,
+            ``blocking``, ``mode``, and ``lifetime``. Setting one of these properties from one thread does not change
+            the value seen by another thread; threads that did not perform the write continue to see the value supplied
+            at construction time. If you need configuration values to be visible across threads, construct the lock
+            with ``thread_local=False``.
+        :param blocking: whether the lock should be blocking or not
+        :param is_singleton: If this is set to ``True`` then only one instance of this class will be created per lock
+            file. This is useful if you want to use the lock object for reentrant locking without needing to pass the
+            same object around.
+        :param poll_interval: default interval for polling the lock file, in seconds. It will be used as fallback value
+            in the acquire method, if no poll_interval value (``None``) is given.
+        :param lifetime: for :class:`SoftFileLock`, the age in seconds after which a waiting process may delete the
+            marker, even while its holder remains alive. This legacy expiry mode does not provide strict mutual
+            exclusion. ``None`` (the default) disables age-based expiry. Native OS locks (:class:`FileLock`) cannot be
+            revoked by file age and ignore a non-``None`` ``lifetime`` with a warning.
+        :param context_error_policy: how a context manager reconciles a failure in its body with a failure while
+            releasing on exit. ``"chain"`` (the default) keeps Python's behavior: the release error propagates with the
+            body error in its ``__context__``. ``"group"`` raises a :class:`BaseExceptionGroup` holding the body error
+            first and the release error second, so neither hides the other.
+        :param close_error_policy: what to do with an ``os.close`` failure after relinquishing descriptor ownership.
+            ``"default"`` keeps each backend's historical behavior (Unix native locks drop a FUSE/Docker ``EIO``;
+            Windows native locks and :class:`SoftFileLock` propagate); ``"raise"`` always propagates the ``OSError``;
+            ``"suppress"`` always ignores it. Held state is released either way. It does not affect unlock failures or
+            lock-file deletion.
+        :param fallback_to_soft: for :class:`UnixFileLock`, whether to switch to :class:`SoftFileLock` when the
+            filesystem's ``flock`` returns ``ENOSYS``. ``True`` (the default) keeps the historical fallback;
+            ``False`` fails closed, letting the ``ENOSYS`` propagate so a caller that needs kernel-enforced
+            locking is never silently downgraded. It has no effect on Windows or :class:`SoftFileLock`.
+        :param preserve_lock_file: for native locks (:class:`FileLock`), whether filelock promises not to unlink the
+            lock pathname on release. ``False`` (the default) keeps each backend's cleanup: Windows removes the lock
+            file, Unix already leaves it. ``True`` keeps a stable file identity for ACLs, auditing, and holder metadata:
+            Windows skips its post-release unlink and Unix refuses to enter the ``ENOSYS`` soft fallback (which releases
+            by unlinking). :class:`SoftFileLock` rejects ``True``. The promise covers filelock's own release path only;
+            it cannot stop another process or the filesystem from removing the pathname.
+        :param on_acquired: for native locks (:class:`FileLock`), a callable invoked with the borrowed lock descriptor
+            once per physical acquisition, after filelock holds the native lock and finished backend initialization but
+            before :meth:`~BaseFileLock.acquire` returns. Recursive acquisitions do not call it again. The callback may
+            read, write, seek, truncate, or set metadata through ``os`` on the descriptor, but must not close, unlock,
+            or take ownership of it, and filelock does not fsync its writes. If it raises, filelock releases the lock
+            and re-raises. :class:`SoftFileLock` rejects the hook.
+
+        """
+        self._creator_pid = os.getpid()
+        self._transition_lock = RLock()
+        self._is_thread_local = thread_local
+        self._is_singleton = is_singleton
+        self._context_error_policy = context_error_policy  # already validated by the metaclass
+        self._close_error_policy = close_error_policy  # already validated by the metaclass
+        self._fallback_to_soft = fallback_to_soft
+        self._preserve_lock_file = preserve_lock_file  # already validated by the metaclass
+        self._on_acquired = on_acquired  # already validated by the metaclass
+
+        self._context: FileLockContext = (ThreadLocalFileContext if thread_local else FileLockContext)(
+            lock_file=os.fspath(lock_file),
+            timeout=timeout,
+            mode=mode,
+            blocking=blocking,
+            poll_interval=poll_interval,
+            lifetime=lifetime,
+        )
+        _register_fork_object(self)
+
+    def is_thread_local(self) -> bool:
+        """:returns: a flag indicating if this lock is thread local or not"""
+        return self._is_thread_local
+
+    @property
+    def is_singleton(self) -> bool:
+        """
+        A flag indicating if this lock is singleton or not.
+
+        .. versionadded:: 3.13.0
+
+        """
+        return self._is_singleton
+
+    @property
+    def context_error_policy(self) -> ContextErrorPolicy:
+        """
+        How a context manager reconciles a body failure with a release failure on exit.
+
+        .. versionadded:: 3.30.0
+
+        """
+        return self._context_error_policy
+
+    @property
+    def close_error_policy(self) -> CloseErrorPolicy:
+        """
+        What a lock does with an ``os.close`` failure after relinquishing descriptor ownership.
+
+        .. versionadded:: 3.30.0
+
+        """
+        return self._close_error_policy
+
+    def _close_released_fd(self, fd: int, *, default_suppresses: bool) -> None:
+        # CPython never retries close() after EINTR because the descriptor number may already be reused, so neither does
+        # this. close_error_policy decides the error's fate after the backend relinquishes descriptor ownership.
+        try:
+            os.close(fd)
+        except OSError:
+            if self._close_error_policy == "suppress" or (self._close_error_policy == "default" and default_suppresses):
+                return
+            raise
+
+    @property
+    def fallback_to_soft(self) -> bool:
+        """
+        Whether a :class:`FileLock` falls back to :class:`SoftFileLock` when the filesystem lacks ``flock``.
+
+        Only :class:`UnixFileLock` acts on it: when ``False`` an ``ENOSYS`` from ``flock`` propagates instead of
+        switching to existence-lock semantics.
+
+        .. versionadded:: 3.30.0
+
+        """
+        return self._fallback_to_soft
+
+    @property
+    def preserve_lock_file(self) -> bool:
+        """
+        Whether filelock promises not to unlink the lock pathname on release.
+
+        When ``True``, Windows skips its post-release unlink and Unix refuses the ``ENOSYS`` soft fallback.
+        :class:`SoftFileLock` rejects ``True`` because unlinking its marker is how it releases.
+
+        .. versionadded:: 3.30.0
+
+        """
+        return self._preserve_lock_file
+
+    @property
+    def on_acquired(self) -> Callable[[int], None] | None:
+        """
+        The callback run with the borrowed lock descriptor once per physical acquisition, or ``None``.
+
+        Native locks only. It runs after the native lock is held and backend initialization finished, before
+        :meth:`~BaseFileLock.acquire` returns; a raise rolls back the acquisition. :class:`SoftFileLock` rejects it.
+
+        .. versionadded:: 3.30.0
+
+        """
+        return self._on_acquired
+
+    @property
+    def lock_file(self) -> str:
+        """Path to the lock file."""
+        return self._context.lock_file
+
+    @property
+    def timeout(self) -> float:
+        """
+        The default timeout value, in seconds.
+
+        .. versionadded:: 2.0.0
+
+        """
+        return self._context.timeout
+
+    @timeout.setter
+    def timeout(self, value: float | str) -> None:
+        """
+        Change the default timeout value.
+
+        :param value: the new value, in seconds
+
+        """
+        self._context.timeout = float(value)
+
+    @property
+    def blocking(self) -> bool:
+        """
+        Whether the locking is blocking or not.
+
+        .. versionadded:: 3.14.0
+
+        """
+        return self._context.blocking
+
+    @blocking.setter
+    def blocking(self, value: bool) -> None:
+        """
+        Change the default blocking value.
+
+        :param value: the new value as bool
+
+        """
+        self._context.blocking = value
+
+    @property
+    def poll_interval(self) -> float:
+        """
+        The default polling interval, in seconds.
+
+        .. versionadded:: 3.24.0
+
+        """
+        return self._context.poll_interval
+
+    @poll_interval.setter
+    def poll_interval(self, value: float) -> None:
+        """
+        Change the default polling interval.
+
+        :param value: the new value, in seconds
+
+        """
+        self._context.poll_interval = value
+
+    @property
+    def lifetime(self) -> float | None:
+        """
+        The soft marker age in seconds that permits expiry, or ``None`` to disable age-based expiry.
+
+        A non-``None`` value permits a waiter to enter while the previous holder remains active, so it does not provide
+        strict mutual exclusion. Native locks ignore the value with a warning.
+
+        .. versionadded:: 3.24.0
+
+        """
+        return self._context.lifetime
+
+    @lifetime.setter
+    def lifetime(self, value: float | None) -> None:
+        """
+        Change the legacy age-based expiry threshold.
+
+        :param value: the new value in seconds, or ``None`` to disable expiration
+
+        :raises ValueError: if *value* is negative or not finite
+        :raises TypeError: if *value* is not ``None`` and not a real number
+
+        """
+        self._context.lifetime = _resolve_lifetime(value, type(self), stacklevel=3)
+
+    @property
+    def mode(self) -> int:
+        """The file permissions for the lockfile."""
+        return 0o644 if self._context.mode == _UNSET_FILE_MODE else self._context.mode
+
+    @property
+    def has_explicit_mode(self) -> bool:
+        """Whether the file permissions were explicitly set."""
+        return self._context.mode != _UNSET_FILE_MODE
+
+    def _open_mode(self) -> int:
+        """Mode for ``os.open``: 0o666 when unset so umask and ACLs decide, otherwise the explicit mode."""
+        return 0o666 if self._context.mode == _UNSET_FILE_MODE else self._context.mode
+
+    @property
+    def is_locked(self) -> bool:
+        """
+        A boolean indicating if the lock file is holding the lock currently.
+
+        .. versionchanged:: 2.0.0
+
+            This was previously a method and is now a property.
+
+        """
+        _ensure_current_process()
+        return self._context.lock_file_fd is not None
+
+    @property
+    def lock_counter(self) -> int:
+        """The number of times this lock has been acquired (but not yet released)."""
+        _ensure_current_process()
+        return self._context.lock_counter
+
+    def __enter__(self) -> Self:
+        """
+        Acquire the lock.
+
+        :returns: the lock object
+
+        """
+        self.acquire()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        """Release the lock, reconciling a release failure with any body failure per :attr:`context_error_policy`."""
+        self._release_in_context(exc_value)
+
+    def _release_in_context(self, body_error: BaseException | None) -> None:
+        # Release from a context-manager exit. "chain" lets a release failure propagate with the body error already in
+        # its __context__ (Python's default); "group" raises both as sibling leaves so neither one hides the other.
+        try:
+            self.release()
+        except BaseException as release_error:
+            if body_error is None or self._context_error_policy == "chain":
+                raise
+            _raise_body_and_release(body_error, release_error)
+
+    def __del__(self) -> None:
+        """Force-release so a dropped reference never leaks a held lock."""
+        if vars(self).get("_creator_pid") != os.getpid():
+            return  # pragma: forked child
+        # A finalizer must not raise. A release error during garbage collection would otherwise surface as an
+        # unraisable-exception warning, attributed to whichever code triggered collection. The dropped lock still gets
+        # best-effort cleanup; an explicit release() reports the same error to a caller who can act on it.
+        with contextlib.suppress(Exception):
+            self.release(force=True)
+
+    def acquire(
+        self,
+        timeout: float | None = None,
+        poll_interval: float | None = None,
+        *,
+        poll_intervall: float | None = None,
+        blocking: bool | None = None,
+        cancel_check: Callable[[], bool] | None = None,
+    ) -> AcquireReturnProxy:
+        """
+        Try to acquire the file lock.
+
+        :param timeout: maximum wait time for acquiring the lock, ``None`` means use the default :attr:`~timeout` is and
+            if ``timeout < 0``, there is no timeout and this method will block until the lock could be acquired
+        :param poll_interval: interval of trying to acquire the lock file, ``None`` means use the default
+            :attr:`~poll_interval`
+        :param poll_intervall: deprecated, kept for backwards compatibility, use ``poll_interval`` instead
+        :param blocking: defaults to True. If False, function will return immediately if it cannot obtain a lock on the
+            first attempt. Otherwise, this method will block until the timeout expires or the lock is acquired.
+        :param cancel_check: a callable returning ``True`` when the acquisition should be canceled. Checked on each poll
+            iteration. When triggered, raises :class:`~Timeout` just like an expired timeout.
+
+        :returns: a context object that will unlock the file when the context is exited
+
+        :raises Timeout: if fails to acquire lock within the timeout period
+
+        .. code-block:: python
+
+            # You can use this method in the context manager (recommended)
+            with lock.acquire():
+                pass
+
+            # Or use an equivalent try-finally construct:
+            lock.acquire()
+            try:
+                pass
+            finally:
+                lock.release()
+
+        .. versionchanged:: 2.0.0
+
+            This method returns now a *proxy* object instead of *self*, so that it can be used in a with statement
+            without side effects.
+
+        """
+        self._raise_if_inherited()
+        if timeout is None:
+            timeout = self._context.timeout
+
+        if blocking is None:
+            blocking = self._context.blocking
+
+        if poll_intervall is not None:
+            msg = "use poll_interval instead of poll_intervall"
+            warnings.warn(msg, DeprecationWarning, stacklevel=2)
+            poll_interval = poll_intervall
+
+        poll_interval = poll_interval if poll_interval is not None else self._context.poll_interval
+
+        start_time = time.perf_counter()
+        # Wait for admission before touching any state: a caller refused entry must leave the counter, the registry and
+        # the descriptor exactly as it found them.
+        with self._transition_admission(
+            blocking=blocking,
+            cancel_check=cancel_check,
+            timeout=timeout,
+            poll_interval=poll_interval,
+            start_time=start_time,
+        ):
+            # Bump the counter up front; _undo_acquire rolls it back if acquisition fails.
+            self._context.lock_counter += 1
+
+            canonical = _canonical(self.lock_file)
+            self._raise_if_would_deadlock(canonical, timeout=timeout, blocking=blocking)
+
+            try:
+                self._poll_until_acquired(
+                    blocking=blocking,
+                    cancel_check=cancel_check,
+                    timeout=timeout,
+                    poll_interval=poll_interval,
+                    start_time=start_time,
+                )
+            except BaseException:
+                self._reconcile_failed_acquire(canonical)
+                raise
+            self._commit_acquire(canonical)
+            return AcquireReturnProxy(lock=self)
+
+    @contextlib.contextmanager
+    def _transition_admission(
+        self,
+        *,
+        blocking: bool,
+        cancel_check: Callable[[], bool] | None,
+        timeout: float,
+        poll_interval: float,
+        start_time: float,
+    ) -> Generator[None]:
+        # One thread at a time drives the physical transition of a shared instance. A protocol that publishes several
+        # files per owner leaves a half-built claim visible otherwise, and a second thread would read it as a holder.
+        # Only such a backend opts in; a single-file backend and a thread-local context each need no gate.
+        if not self._serialize_transitions or self._is_thread_local:
+            yield
+            return
+        while not self._transition_lock.acquire(blocking=False):  # pragma: needs hard-link
+            if not blocking or (cancel_check is not None and cancel_check()):
+                raise Timeout(self.lock_file)
+            if timeout >= 0 and time.perf_counter() - start_time >= timeout:
+                raise Timeout(self.lock_file)
+            time.sleep(poll_interval)
+        try:  # pragma: needs hard-link
+            yield
+        finally:  # pragma: needs hard-link
+            self._transition_lock.release()
+
+    def release(self, force: bool = False) -> None:  # ruff:ignore[boolean-type-hint-positional-argument, boolean-default-value-positional-argument]  # public API: positional bool kept for backwards compatibility
+        """
+        Release the file lock. The lock is only completely released when the lock counter reaches 0. The lock file
+        itself may be deleted automatically, the behavior is platform-specific.
+
+        :param force: If true, the lock counter is ignored and the lock is released in every case.
+
+        """
+        # A shared instance releases under the same gate its acquisition ran through, so a thread entering the lock
+        # never observes a partially torn-down owner.
+        serialize = self._serialize_transitions and not self._is_thread_local
+        with self._transition_lock if serialize else contextlib.nullcontext():
+            if self._creator_pid != os.getpid() or not self.is_locked:
+                return
+            if not force and self._context.lock_counter > 1:
+                self._context.lock_counter -= 1
+                return
+
+            lock_id, lock_filename = id(self), self.lock_file
+            _LOGGER.debug("Attempting to release lock %s on %s", lock_id, lock_filename)
+            try:
+                self._release_with_fork_tracking()
+            except BaseException:
+                # A failure after the OS unlock (during close or unlink) still released the lock: the backend cleared
+                # its descriptor, so commit the counter and registry to released even as the cleanup error propagates.
+                # A failure that left the lock held keeps the counter so a later release can retry the OS unlock.
+                if not self.is_locked:
+                    self._commit_release()
+                raise
+            self._commit_release()
+            _LOGGER.debug("Lock %s released on %s", lock_id, lock_filename)
+
+    def _raise_if_inherited(self) -> None:
+        if self._creator_pid != os.getpid():  # pragma: forked child
+            msg = f"{type(self).__name__} on {self.lock_file} was inherited across fork; construct a new instance"
+            raise RuntimeError(msg)
+
+    def _mark_descriptor_owned(self, fd: int, identity: tuple[int, int] | None = None) -> None:
+        self._context.pending_lock_file_fd = None
+        self._context.pending_lock_file_fd_identity = None
+        self._context.lock_file_fd = fd
+        self._context.lock_file_fd_identity = identity
+
+    def _mark_descriptor_pending(self, fd: int, identity: tuple[int, int] | None = None) -> None:
+        self._context.pending_lock_file_fd = fd
+        self._context.pending_lock_file_fd_identity = identity
+
+    def _mark_descriptor_released(self) -> None:
+        self._context.pending_lock_file_fd = None
+        self._context.pending_lock_file_fd_identity = None
+        self._context.lock_file_fd = None
+        self._context.lock_file_fd_identity = None
+
+    def _reset_after_fork_in_child(self) -> None:  # pragma: forked child
+        # fork copies the lock in whatever state the parent's threads left it, so give the child an unheld one.
+        self._transition_lock = RLock()
+        self._context.owner_claim_paths = ()
+        self._context.claim_root = None
+        self._context.lock_file_fd = None
+        self._context.lock_file_fd_token = None
+        self._context.lock_file_fd_identity = None
+        self._context.pending_lock_file_fd = None
+        self._context.pending_lock_file_fd_identity = None
+        self._context.lock_counter = 0
+        self._context.lock_file_key = None
+
+    def _descriptors_for_fork(self) -> tuple[tuple[int, tuple[int, int] | None], ...]:  # pragma: needs fork
+        descriptors: list[tuple[int, tuple[int, int] | None]] = []
+        if self._context.lock_file_fd is not None and self._context.lock_file_fd_token is None:
+            descriptors.append((self._context.lock_file_fd, self._context.lock_file_fd_identity))
+        if self._context.pending_lock_file_fd is not None:
+            descriptors.append((self._context.pending_lock_file_fd, self._context.pending_lock_file_fd_identity))
+        return tuple(descriptors)
+
+    def _raise_if_would_deadlock(self, canonical: str, *, timeout: float, blocking: bool) -> None:
+        """
+        Fail fast when a *different* live instance already holds this path in the current deadlock scope.
+
+        Only the first, indefinitely-blocking acquire can self-deadlock this way: waiting in the OS primitive would
+        block on a lock this flow already owns. A finite timeout or ``blocking=False`` keeps the normal Timeout path.
+        """
+        would_block = self._context.lock_counter == 1 and not self.is_locked and timeout < 0 and blocking
+        if would_block and _registry.held.get(self._registry_key(canonical)) not in {None, id(self)}:
+            self._context.lock_counter -= 1
+            msg = (
+                f"Deadlock: lock '{self.lock_file}' is already held by a different {self._deadlock_holder_desc}. "
+                f"Use is_singleton=True to enable reentrant locking across instances."
+            )
+            raise RuntimeError(msg)
+
+    def _registry_key(self, canonical: str) -> Hashable:
+        return canonical if (scope := self._deadlock_scope()) is None else (scope, canonical)
+
+    @staticmethod
+    def _deadlock_scope() -> Hashable | None:
+        """
+        Execution unit whose own hold would deadlock a new acquire.
+
+        ``None`` scopes holders to the thread, which the thread-local registry already separates. Async locks
+        override it with the running task, since one event loop thread runs many tasks and only a reacquire from
+        the *same* task can self-deadlock.
+        """
+        return None
+
+    def _poll_until_acquired(
+        self,
+        *,
+        blocking: bool,
+        cancel_check: Callable[[], bool] | None,
+        timeout: float,
+        poll_interval: float,
+        start_time: float,
+    ) -> None:
+        lock_id = id(self)
+        lock_filename = self.lock_file
+        attempt = 0
+        while True:
+            self._raise_if_inherited()
+            if not self.is_locked:
+                self._try_break_expired_lock()
+                _LOGGER.debug("Attempting to acquire lock %s on %s", lock_id, lock_filename)
+                self._acquire_with_fork_tracking()
+                self._raise_if_inherited()
+            if self.is_locked:
+                _LOGGER.debug("Lock %s acquired on %s", lock_id, lock_filename)
+                return
+            if self._check_give_up(
+                blocking=blocking,
+                cancel_check=cancel_check,
+                timeout=timeout,
+                start_time=start_time,
+            ):
+                raise Timeout(lock_filename)
+            attempt += 1
+            delay = self._poll_delay(poll_interval, attempt)
+            msg = "Lock %s not acquired on %s, waiting %s seconds ..."
+            _LOGGER.debug(msg, lock_id, lock_filename, delay)
+            time.sleep(delay)
+
+    def _poll_delay(self, poll_interval: float, attempt: int) -> float:
+        # A single-file lock retries on a fixed cadence. A backend that publishes several files per acquisition sets a
+        # cap, and then contending processes back off across a jittered, exponentially widening window instead of
+        # colliding on every poll; poll_interval stays the floor so a lone waiter is still responsive.
+        if not self._poll_backoff_cap:
+            return poll_interval
+        # Cap the exponent before doubling: under heavy contention attempt reaches the thousands, and 2**attempt would
+        # overflow the float multiply long before the window itself stops growing past the cap.
+        window = min(
+            self._poll_backoff_cap, poll_interval * 2 ** min(attempt, _MAX_BACKOFF_EXPONENT)
+        )  # pragma: needs hard-link
+        return max(poll_interval, secrets.randbelow(int(window * 1_000_000) + 1) / 1_000_000)  # pragma: needs hard-link
+
+    def _reconcile_failed_acquire(self, canonical: str) -> None:
+        # An acquire that raised while still holding the native lock (a hook that failed and whose rollback could not
+        # release) must keep the registry entry so a later release can retry the OS unlock; otherwise roll the counter
+        # back. is_locked was already reconciled by whichever release ran.
+        if self.is_locked:
+            self._commit_acquire(canonical)
+        else:
+            self._undo_acquire()
+
+    def _invoke_on_acquired(self) -> None:
+        # The wrapper runs in the backend executor for async locks, preserving the callback's documented thread.
+        if self._on_acquired is None or self._context.lock_counter != 1:
+            return
+        try:
+            self._on_acquired(cast("int", self._context.lock_file_fd))
+        except BaseException as callback_error:  # arbitrary caller code; roll back on any failure
+            callback_context = callback_error.__context__
+            try:
+                self._release_with_fork_tracking()
+            except BaseException as release_error:  # ruff:ignore[blind-except]  # both errors surface via the group below
+                _raise_body_and_release(callback_error, release_error)
+            callback_error.__context__ = callback_context
+            raise
+
+    def _acquire_with_fork_tracking(self) -> None:
+        with _fork_transition(self):
+            try:
+                self._acquire()
+            except BaseException as acquisition_error:
+                self._rollback_failed_acquire(acquisition_error)
+                raise
+            try:
+                self._register_context_descriptor()
+            except BaseException as registration_error:  # pragma: needs fork
+                self._rollback_failed_registration(registration_error)
+                raise
+        if self.is_locked:
+            self._invoke_on_acquired()
+
+    def _rollback_failed_acquire(self, acquisition_error: BaseException) -> None:
+        if not self.is_locked:
+            return
+        registration_error: BaseException | None = None
+        tracking_error: BaseException | None = None
+        try:
+            self._register_context_descriptor()
+        except BaseException as error:  # ruff:ignore[blind-except]  # preserve registration and acquisition failures
+            registration_error = error
+            try:
+                # Rollback may fail too; retain the fd so a child can close it without another identity probe.
+                self._register_unverified_context_descriptor()
+            except BaseException as error:  # ruff:ignore[blind-except]  # pragma: no cover - allocation/control-flow during fallback
+                tracking_error = error
+        try:
+            self._release_with_fork_tracking()
+        except BaseException as rollback_error:  # ruff:ignore[blind-except]  # preserve rollback and acquisition failures
+            _raise_cleanup_errors(
+                "lock acquisition cleanup failed",
+                acquisition_error,
+                registration_error,
+                tracking_error,
+                rollback_error,
+            )
+        if registration_error is not None:  # pragma: needs fork
+            _raise_cleanup_errors(
+                "lock acquisition cleanup failed", acquisition_error, registration_error, tracking_error
+            )
+
+    def _rollback_failed_registration(self, registration_error: BaseException) -> None:  # pragma: needs fork
+        tracking_error: BaseException | None = None
+        try:
+            # Rollback may fail too; retain the fd so a child can close it without another identity probe.
+            self._register_unverified_context_descriptor()
+        except BaseException as error:  # ruff:ignore[blind-except]  # pragma: no cover - allocation/control-flow during fallback
+            tracking_error = error
+        try:
+            self._release_with_fork_tracking()
+        except BaseException as rollback_error:  # ruff:ignore[blind-except]  # preserve rollback and registration failures
+            _raise_cleanup_errors(
+                "descriptor registration cleanup failed", registration_error, tracking_error, rollback_error
+            )
+        if tracking_error is not None:  # pragma: no cover - requires failed in-memory fallback
+            _raise_cleanup_errors("descriptor registration cleanup failed", registration_error, tracking_error)
+
+    def _release_with_fork_tracking(self) -> None:
+        with _fork_transition(self):
+            try:
+                self._release()
+            finally:
+                self._unregister_released_descriptor()
+
+    def _register_context_descriptor(self) -> None:
+        if self._context.lock_file_fd is not None and self._context.lock_file_fd_token is None:
+            self._context.lock_file_fd_token = _register_owned_descriptor(
+                self._context.lock_file_fd,
+                self._context.lock_file_fd_identity,
+            )
+
+    def _register_unverified_context_descriptor(self) -> None:
+        # The rollback only reaches here still holding a descriptor it never managed to register.
+        if self._context.lock_file_fd is not None and self._context.lock_file_fd_token is None:  # pragma: no branch
+            self._context.lock_file_fd_token = _register_unverified_owned_descriptor(self._context.lock_file_fd)
+
+    def _unregister_released_descriptor(self) -> None:
+        if self._context.lock_file_fd is None:
+            if (token := self._context.lock_file_fd_token) is not None:  # pragma: needs fork
+                _unregister_owned_descriptor(token)
+            self._context.lock_file_fd_token = None
+            self._context.lock_file_fd_identity = None
+
+    def _undo_acquire(self) -> None:
+        """Roll back the counter after a failed acquire, dropping the registry entry once nothing holds the path."""
+        self._context.lock_counter = max(0, self._context.lock_counter - 1)
+        if self._context.lock_counter == 0:
+            self._drop_registry_entry()
+
+    def _commit_acquire(self, canonical: str) -> None:
+        """Record this instance as the holder once the first acquire succeeds, so peers can detect the deadlock."""
+        if self._context.lock_counter == 1:
+            key = self._registry_key(canonical)
+            # The holder scope is resolved once at commit so a later release from another flow drops the right entry.
+            self._context.lock_file_key = key
+            _registry.held[key] = id(self)
+
+    def _drop_registry_entry(self) -> None:
+        """Forget the key owned by this hold without resolving a mutable path again."""
+        key = self._context.lock_file_key
+        self._context.lock_file_key = None
+        if key is not None:
+            _registry.held.pop(key, None)
+
+    def _commit_release(self) -> None:
+        """Record the lock as fully released: reset the recursion counter and drop the deadlock-registry entry."""
+        self._context.lock_counter = 0
+        self._drop_registry_entry()
+
+    def _try_break_expired_lock(self) -> None:
+        """Remove the lock file if its modification time exceeds the configured :attr:`lifetime`."""
+        if (lifetime := self._context.lifetime) is None:
+            return
+        with contextlib.suppress(OSError):
+            # lstat, not stat: an attacker with write access to the lock directory can replace a held
+            # lock file with a symlink pointing at an old file, making stat() report the target's stale
+            # mtime so a waiter breaks a live lock and two processes hold it at once. lstat reads the
+            # symlink's own mtime, matching the O_NOFOLLOW reads elsewhere.
+            st = os.lstat(self.lock_file)
+            if time.time() - st.st_mtime < lifetime:
+                return
+            break_lock_file(self.lock_file, st.st_mtime, st.st_ino)
+
+    def _check_give_up(
+        self,
+        *,
+        blocking: bool,
+        cancel_check: Callable[[], bool] | None,
+        timeout: float,
+        start_time: float,
+    ) -> bool:
+        lock_id, lock_filename = id(self), self.lock_file
+        if blocking is False:
+            _LOGGER.debug("Failed to immediately acquire lock %s on %s", lock_id, lock_filename)
+            return True
+        if cancel_check is not None and cancel_check():
+            _LOGGER.debug("Cancellation requested for lock %s on %s", lock_id, lock_filename)
+            return True
+        if 0 <= timeout < time.perf_counter() - start_time:
+            _LOGGER.debug("Timeout on acquiring lock %s on %s", lock_id, lock_filename)
+            return True
+        return False
+
+    @abstractmethod
+    def _acquire(self) -> None:
+        """If the file lock could be acquired, self._context.lock_file_fd holds the file descriptor of the lock file."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _release(self) -> None:
+        """Releases the lock and sets self._context.lock_file_fd to None."""
+        raise NotImplementedError
+
+
+# acquire() returns this wrapper instead of self so entering the with-statement does not call __enter__ a second
+# time; returning self would re-acquire the lock in BaseFileLock.__enter__ without a matching release (issue #37).
+class AcquireReturnProxy:
+    """A context-aware object that will release the lock file when exiting."""
+
+    def __init__(self, lock: BaseFileLock | ReadWriteLock | SoftReadWriteLock) -> None:
+        self.lock: BaseFileLock | ReadWriteLock | SoftReadWriteLock = lock
+
+    def __enter__(self) -> BaseFileLock | ReadWriteLock | SoftReadWriteLock:
+        return self.lock
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        if isinstance(self.lock, BaseFileLock):
+            self.lock._release_in_context(exc_value)  # ruff:ignore[private-member-access]  # forwards __exit__ to the owned lock's context release
+        else:  # a reader/writer lock does not carry a context_error_policy
+            self.lock.release()
+
+
+@dataclass
+class FileLockContext:
+    """Holds the context for a ``BaseFileLock`` object."""
+
+    # A separate class so ThreadLocalFileContext can make the whole context thread-local.
+
+    lock_file: str
+    timeout: float
+    mode: int
+    blocking: bool
+    poll_interval: float
+
+    #: The lock lifetime in seconds; ``None`` means the lock never expires.
+    lifetime: float | None = None
+
+    #: File descriptor from os.open for the lock file; not None while the lock is held.
+    lock_file_fd: int | None = None
+
+    #: Registry token for the descriptor owned by this thread's context.
+    lock_file_fd_token: int | None = None
+
+    #: Identity captured by a backend that already inspected the descriptor.
+    lock_file_fd_identity: tuple[int, int] | None = None
+
+    #: Descriptor opened by a backend but not yet committed as the held lock.
+    pending_lock_file_fd: int | None = None
+
+    #: Identity captured for a descriptor whose acquisition has not committed.
+    pending_lock_file_fd_identity: tuple[int, int] | None = None
+
+    #: Depth of nested acquisitions; the lock is released only when it returns to 0.
+    lock_counter: int = 0
+
+    #: Canonical registry key captured when the first physical acquisition commits.
+    lock_file_key: Hashable | None = None
+
+    #: Claim pathnames this owner published, removed by name on release so no holder ever unlinks a peer's claim.
+    owner_claim_paths: tuple[str, ...] = ()
+
+    #: Canonical lock path resolved when an acquisition starts. A waiter polling a relative path must keep publishing
+    #: into the directory it started in, even when another thread changes the working directory mid-wait.
+    claim_root: str | None = None
+
+
+class ThreadLocalFileContext(FileLockContext, local):
+    """A thread local version of the ``FileLockContext`` class."""
+
+
+@dataclass(frozen=True)
+class _OwnedDescriptor:
+    fd: int
+    creator_pid: int
+    device: int | None
+    inode: int | None
+
+
+class _ForkTransitionContext(local):
+    depth: int = 0
+
+
+class _ForkState:
+    def __init__(self) -> None:
+        self.gate = Condition(RLock())
+        self.registry_lock = RLock()
+        self.parameter_models_lock = RLock()
+        self.transition_context = _ForkTransitionContext()
+        self.transitions: dict[int, dict[int, _ForkDescriptorOwner | None]] = {}
+        self.active_transitions = 0
+        self.admission_closed = False
+        self.fork_owner_depths: dict[int, int] = {}
+        self.pinned_objects: dict[int, list[tuple[_ForkResettable, ...]]] = {}
+        self.pinned_classes: dict[int, list[tuple[_ForkResettableClass, ...]]] = {}
+        self.provisional_descriptor_tokens: dict[int, list[tuple[int, ...]]] = {}
+        self.pid = os.getpid()
+
+    def reset_synchronization(self) -> None:  # pragma: forked child
+        self.gate = Condition(RLock())
+        self.registry_lock = RLock()
+        self.parameter_models_lock = RLock()
+        self.transition_context = _ForkTransitionContext()
+        self.transitions = {}
+        self.active_transitions = 0
+        self.admission_closed = False
+        self.fork_owner_depths = {}
+        self.pinned_objects = {}
+        self.pinned_classes = {}
+        self.provisional_descriptor_tokens = {}
+
+
+_FORK_OBJECTS: Final[WeakValueDictionary[int, _ForkResettable]] = WeakValueDictionary()
+_FORK_CLASSES: Final[WeakValueDictionary[int, _ForkResettableClass]] = WeakValueDictionary()
+_OWNED_DESCRIPTORS: Final[dict[int, _OwnedDescriptor]] = {}
+_DESCRIPTOR_TOKENS: Final[count[int]] = count()
+_TRANSITION_TOKENS: Final[count[int]] = count()
+_FORK_STATE: Final = _ForkState()
+_FORK_AUDIT_EVENTS: Final[frozenset[str]] = frozenset({"os.fork", "os.forkpty"})
+
+
+def _register_fork_hooks() -> None:
+    if _REGISTER_AT_FORK is None:
+        return  # pragma: lacks fork
+    sys.addaudithook(_audit_fork_safety)  # pragma: needs fork
+    _REGISTER_AT_FORK(  # pragma: needs fork
+        before=_pin_fork_objects,
+        after_in_parent=_resume_parent_after_fork,
+        after_in_child=_reset_child_after_fork,
+    )
+
+
+@contextmanager
+def _fork_transition(descriptor_owner: _ForkDescriptorOwner | None = None) -> Generator[None]:
+    if not _HAS_REGISTER_AT_FORK:
+        yield  # pragma: lacks fork
+        return  # pragma: lacks fork
+    _ensure_current_process()  # pragma: needs fork
+    creator_pid = os.getpid()  # pragma: needs fork
+    token = _enter_fork_transition(descriptor_owner)  # pragma: needs fork
+    try:  # pragma: needs fork
+        yield
+    finally:
+        if os.getpid() == creator_pid:  # pragma: needs fork
+            _leave_fork_transition(token)
+
+
+def _register_fork_object(instance: _ForkResettable) -> None:
+    if not _HAS_REGISTER_AT_FORK:
+        return  # pragma: lacks fork
+    with _fork_transition(), _FORK_STATE.registry_lock:  # pragma: needs fork
+        _FORK_OBJECTS[id(instance)] = instance
+        _refresh_owner_pins()
+
+
+def _register_fork_class(cls: _ForkResettableClass) -> None:
+    if not _HAS_REGISTER_AT_FORK:
+        return  # pragma: lacks fork
+    with _fork_transition(), _FORK_STATE.registry_lock:  # pragma: needs fork
+        _FORK_CLASSES[id(cls)] = cls
+        _refresh_owner_pins()
+
+
+def _register_owned_descriptor(fd: int, identity: tuple[int, int] | None = None) -> int | None:
+    if not _HAS_REGISTER_AT_FORK:
+        return None  # pragma: lacks fork
+    with _fork_transition():  # pragma: needs fork
+        if identity is None:
+            stat_result = os.fstat(fd)
+            identity = stat_result.st_dev, stat_result.st_ino
+        return _record_owned_descriptor(fd, identity)
+
+
+def _register_unverified_owned_descriptor(fd: int) -> int | None:
+    if not _HAS_REGISTER_AT_FORK:
+        return None  # pragma: lacks fork
+    with _fork_transition():  # pragma: needs fork
+        return _record_owned_descriptor(fd, None)
+
+
+def _record_owned_descriptor(fd: int, identity: tuple[int, int] | None) -> int:  # pragma: needs fork
+    with _FORK_STATE.registry_lock:
+        token = next(_DESCRIPTOR_TOKENS)
+        _OWNED_DESCRIPTORS[token] = _OwnedDescriptor(
+            fd=fd,
+            creator_pid=os.getpid(),
+            device=None if identity is None else identity[0],
+            inode=None if identity is None else identity[1],
+        )
+    return token
+
+
+def _unregister_owned_descriptor(token: int) -> None:  # pragma: needs fork
+    with _fork_transition(), _FORK_STATE.registry_lock:
+        _OWNED_DESCRIPTORS.pop(token, None)
+
+
+def _pin_fork_objects() -> None:  # pragma: needs fork
+    _ensure_current_process()
+    thread_id = get_ident()
+    with _FORK_STATE.gate:
+        _FORK_STATE.fork_owner_depths[thread_id] = _FORK_STATE.fork_owner_depths.get(thread_id, 0) + 1
+        _FORK_STATE.admission_closed = True
+        while _FORK_STATE.active_transitions > len(_FORK_STATE.transitions.get(thread_id, ())):
+            _FORK_STATE.gate.wait()
+        transition_owners = tuple(_FORK_STATE.transitions.get(thread_id, {}).values())
+    _verify_unverified_descriptors()
+    owners = {id(owner): owner for owner in transition_owners if owner is not None}
+    provisional_descriptor_tokens = tuple(
+        starmap(
+            _snapshot_descriptor_for_fork,
+            (descriptor for owner in owners.values() for descriptor in owner._descriptors_for_fork()),  # ruff:ignore[private-member-access]  # snapshots each owner's own fork descriptors
+        )
+    )
+    with _FORK_STATE.registry_lock:
+        _FORK_STATE.provisional_descriptor_tokens.setdefault(thread_id, []).append(provisional_descriptor_tokens)
+        _FORK_STATE.pinned_objects.setdefault(thread_id, []).append(tuple(_FORK_OBJECTS.values()))
+        _FORK_STATE.pinned_classes.setdefault(thread_id, []).append(tuple(_FORK_CLASSES.values()))
+
+
+def _resume_parent_after_fork() -> None:  # pragma: needs fork
+    thread_id = get_ident()
+    with _FORK_STATE.registry_lock:
+        for token in _FORK_STATE.provisional_descriptor_tokens[thread_id].pop():
+            _OWNED_DESCRIPTORS.pop(token, None)
+        _FORK_STATE.pinned_objects[thread_id].pop()
+        _FORK_STATE.pinned_classes[thread_id].pop()
+        if not _FORK_STATE.provisional_descriptor_tokens[thread_id]:  # pragma: needs fork
+            del _FORK_STATE.provisional_descriptor_tokens[thread_id]
+            del _FORK_STATE.pinned_objects[thread_id]
+            del _FORK_STATE.pinned_classes[thread_id]
+    with _FORK_STATE.gate:
+        if _FORK_STATE.fork_owner_depths[thread_id] == 1:
+            del _FORK_STATE.fork_owner_depths[thread_id]
+        else:  # pragma: no cover - earlier at-fork callbacks may deadlock first
+            _FORK_STATE.fork_owner_depths[thread_id] -= 1
+        _FORK_STATE.admission_closed = bool(_FORK_STATE.fork_owner_depths)
+        _FORK_STATE.gate.notify_all()
+
+
+def _ensure_current_process() -> None:
+    _reset_child_after_fork()
+
+
+def _reset_child_after_fork() -> None:  # pragma: forked child
+    if (pid := os.getpid()) == _FORK_STATE.pid:
+        return
+    thread_id = get_ident()
+    pinned_objects = _FORK_STATE.pinned_objects.get(thread_id, [()])[-1]
+    pinned_classes = _FORK_STATE.pinned_classes.get(thread_id, [()])[-1]
+    descriptors: list[_OwnedDescriptor] = []
+    for token, descriptor in tuple(_OWNED_DESCRIPTORS.items()):
+        if descriptor.creator_pid != pid:
+            descriptors.append(_OWNED_DESCRIPTORS.pop(token))
+    _FORK_STATE.reset_synchronization()
+    _FORK_STATE.pid = pid
+    _INIT_PARAMETER_MODELS.clear()
+    _detach_child_state(descriptors, pinned_objects, pinned_classes)
+
+
+def _enter_fork_transition(descriptor_owner: _ForkDescriptorOwner | None) -> int:  # pragma: needs fork
+    thread_id = get_ident()
+    with _FORK_STATE.gate:
+        while (
+            _FORK_STATE.admission_closed
+            and thread_id not in _FORK_STATE.fork_owner_depths
+            and thread_id not in _FORK_STATE.transitions
+        ):
+            _FORK_STATE.gate.wait()  # pragma: no cover - exercised in isolated interpreter
+        token = next(_TRANSITION_TOKENS)
+        _FORK_STATE.transitions.setdefault(thread_id, {})[token] = descriptor_owner
+        _FORK_STATE.active_transitions += 1
+    _FORK_STATE.transition_context.depth += 1
+    return token
+
+
+def _leave_fork_transition(token: int) -> None:  # pragma: needs fork
+    _FORK_STATE.transition_context.depth -= 1
+    with _FORK_STATE.gate:
+        thread_id = get_ident()
+        del _FORK_STATE.transitions[thread_id][token]
+        if not _FORK_STATE.transitions[thread_id]:
+            del _FORK_STATE.transitions[thread_id]
+        _FORK_STATE.active_transitions -= 1
+        _FORK_STATE.gate.notify_all()
+
+
+def _verify_unverified_descriptors() -> None:  # pragma: needs fork
+    with _FORK_STATE.registry_lock:
+        for token, descriptor in tuple(_OWNED_DESCRIPTORS.items()):
+            if descriptor.creator_pid != os.getpid() or descriptor.device is not None:
+                continue
+            try:
+                stat_result = os.fstat(descriptor.fd)
+            except OSError:
+                continue
+            _OWNED_DESCRIPTORS[token] = _OwnedDescriptor(
+                fd=descriptor.fd,
+                creator_pid=descriptor.creator_pid,
+                device=stat_result.st_dev,
+                inode=stat_result.st_ino,
+            )
+
+
+def _snapshot_descriptor_for_fork(fd: int, identity: tuple[int, int] | None) -> int:  # pragma: needs fork
+    if identity is None:  # pragma: needs fork
+        try:
+            stat_result = os.fstat(fd)
+        except OSError:
+            pass
+        else:
+            identity = stat_result.st_dev, stat_result.st_ino
+    return _record_owned_descriptor(fd, identity)
+
+
+def _detach_child_state(  # pragma: forked child
+    descriptors: list[_OwnedDescriptor],
+    pinned_objects: tuple[_ForkResettable, ...],
+    pinned_classes: tuple[_ForkResettableClass, ...],
+) -> None:
+    for descriptor in descriptors:
+        if descriptor.device is None:
+            continue
+        try:
+            stat_result = os.fstat(descriptor.fd)
+        except OSError:
+            continue
+        if (stat_result.st_dev, stat_result.st_ino) != (descriptor.device, descriptor.inode):
+            continue
+        with contextlib.suppress(OSError):
+            os.close(descriptor.fd)
+    for instance in pinned_objects:
+        instance._reset_after_fork_in_child()  # ruff:ignore[private-member-access]  # resets each pinned instance in the fork child
+    for cls in pinned_classes:
+        cls._reset_class_after_fork()
+    _registry.held.clear()
+
+
+def _refresh_owner_pins() -> None:  # pragma: needs fork
+    with _FORK_STATE.gate:
+        fork_owner_thread_ids = tuple(_FORK_STATE.fork_owner_depths)
+    if get_ident() not in fork_owner_thread_ids:  # pragma: no cover - at-fork callbacks disable tracing
+        return
+    objects = tuple(_FORK_OBJECTS.values())
+    classes = tuple(_FORK_CLASSES.values())
+    for thread_id in fork_owner_thread_ids:
+        if object_snapshots := _FORK_STATE.pinned_objects.get(thread_id):  # pragma: needs fork
+            object_snapshots[:] = [objects] * len(object_snapshots)
+            _FORK_STATE.pinned_classes[thread_id][:] = [classes] * len(object_snapshots)
+
+
+# The defaults capture the module globals: the hook outlives them at interpreter shutdown, where CPython wipes the
+# module dict to None before the final audit events fire.
+def _audit_fork_safety(  # pragma: no cover - CPython disables tracing while Python audit hooks run
+    event: str,
+    _args: Unused,
+    *,
+    _fork_events: frozenset[str] = _FORK_AUDIT_EVENTS,
+    _state: _ForkState = _FORK_STATE,
+) -> None:
+    if event in _fork_events:
+        if _state.transition_context.depth or _state.fork_owner_depths:
+            msg = f"{event} is unsafe while filelock is changing descriptor ownership"
+            raise RuntimeError(msg)
+    elif event == "_posixsubprocess.fork_exec" and _state.transition_context.depth:
+        msg = "fork_exec is unsafe while filelock is changing descriptor ownership"
+        raise RuntimeError(msg)
+
+
+_register_fork_hooks()
+
+
+__all__ = [
+    "_UNSET_FILE_MODE",
+    "AcquireReturnProxy",
+    "BaseFileLock",
+    "CloseErrorPolicy",
+    "ContextErrorPolicy",
+    "FileLockContext",
+    "FileLockMeta",
+    "LockOptions",
+    "_append_exception_context",
+    "_canonical",
+    "_ensure_current_process",
+    "_fork_transition",
+    "_grouped_errors",
+    "_raise_body_and_release",
+    "_raise_chained_errors",
+    "_raise_cleanup_errors",
+    "_raise_grouped_errors",
+    "_register_fork_class",
+    "_register_fork_object",
+    "_register_owned_descriptor",
+    "_unregister_owned_descriptor",
+]

.venv/lib/python3.12/site-packages/filelock/_async.py

@@ -0,0 +1,173 @@
+"""Separate caller cancellation from backend task and executor-future results."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import time
+from concurrent.futures import Future as ConcurrentFuture
+from dataclasses import dataclass
+from threading import Lock
+from typing import TYPE_CHECKING, Final, Generic, NoReturn, TypeVar, cast
+
+from ._api import _append_exception_context, _raise_chained_errors
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Awaitable, Callable
+
+_T = TypeVar("_T")
+
+
+class _AsyncTransitionUnavailableError(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class _BackendOutcome(Generic[_T]):
+    value: _T | None = None
+    error: BaseException | None = None
+
+
+class _AsyncTransitionGate:
+    def __init__(self) -> None:
+        self._tail_lock: Final[Lock] = Lock()
+        self._tail: ConcurrentFuture[None] | None = None
+
+    @contextlib.asynccontextmanager
+    async def hold(self) -> AsyncIterator[None]:
+        ticket: ConcurrentFuture[None] = ConcurrentFuture()
+        with self._tail_lock:
+            predecessor = self._tail
+            self._tail = ticket
+        if predecessor is not None:
+            try:
+                await _wait_until_done(asyncio.wrap_future(predecessor))
+            except asyncio.CancelledError:
+                predecessor.add_done_callback(lambda _predecessor: self._leave(ticket))
+                raise
+        try:
+            yield
+        finally:
+            self._leave(ticket)
+
+    @contextlib.asynccontextmanager
+    async def hold_for_acquire(
+        self,
+        *,
+        blocking: bool,
+        cancel_check: Callable[[], bool] | None,
+        deadline: float | None,
+        poll_interval: float,
+    ) -> AsyncIterator[None]:
+        ticket: ConcurrentFuture[None] = ConcurrentFuture()
+        with self._tail_lock:
+            predecessor = self._tail
+            self._tail = ticket
+        if predecessor is not None and not predecessor.done():
+            try:
+                await self._wait_for_predecessor(
+                    predecessor,
+                    blocking=blocking,
+                    cancel_check=cancel_check,
+                    deadline=deadline,
+                    poll_interval=poll_interval,
+                )
+            except BaseException:
+                predecessor.add_done_callback(lambda _predecessor: self._leave(ticket))
+                raise
+        try:
+            yield
+        finally:
+            self._leave(ticket)
+
+    @staticmethod
+    async def _wait_for_predecessor(
+        predecessor: ConcurrentFuture[None],
+        *,
+        blocking: bool,
+        cancel_check: Callable[[], bool] | None,
+        deadline: float | None,
+        poll_interval: float,
+    ) -> None:
+        if not blocking:
+            raise _AsyncTransitionUnavailableError
+        waiter = asyncio.wrap_future(predecessor)
+        while not predecessor.done():
+            if cancel_check is not None and cancel_check():
+                raise _AsyncTransitionUnavailableError
+            if deadline is not None:
+                if (remaining := deadline - time.perf_counter()) <= 0:
+                    raise _AsyncTransitionUnavailableError
+                wait_interval = min(poll_interval, remaining) if cancel_check is not None else remaining
+            else:
+                wait_interval = poll_interval if cancel_check is not None else None
+            await asyncio.wait((waiter,), timeout=wait_interval)
+
+    def _leave(self, ticket: ConcurrentFuture[None]) -> None:
+        with self._tail_lock:
+            if self._tail is ticket:
+                self._tail = None
+        ticket.set_result(None)
+
+
+async def _drain_future(future: asyncio.Future[_BackendOutcome[_T]]) -> _T:
+    while not future.done():
+        with contextlib.suppress(asyncio.CancelledError):
+            await _wait_until_done(future)
+    return _future_result(future)
+
+
+async def _wait_until_done(future: asyncio.Future[_T]) -> None:
+    if not future.done():
+        await asyncio.wait((future,))
+
+
+def _future_result(future: asyncio.Future[_BackendOutcome[_T]]) -> _T:
+    outcome = future.result()
+    if (error := outcome.error) is None:
+        return cast("_T", outcome.value)
+    context = error.__context__
+    try:
+        raise error  # ruff:ignore[raise-within-try]  # the handler restores context changed across the async boundary
+    except BaseException:
+        error.__context__ = context
+        raise
+
+
+def _capture_call(func: Callable[[], _T]) -> _BackendOutcome[_T]:
+    try:
+        return _BackendOutcome(value=func())
+    except BaseException as error:  # ruff:ignore[blind-except]  # backend control-flow exceptions are operation results
+        return _BackendOutcome(error=error)
+
+
+def _raise_cancelled_error(cancellation: asyncio.CancelledError, error: BaseException) -> NoReturn:
+    # A reconciliation step failed while unwinding a cancellation, so keep both exception chains. Splice the error's
+    # existing context onto the cancellation, then make the cancellation the error's context, so both the failure and
+    # the cancellation that triggered it survive. Shared by the async wrappers so cancellations report the same way.
+    if (context := error.__context__) is not None and context is not cancellation:
+        if (cancellation_context := cancellation.__context__) is not None:
+            _append_exception_context(context, cancellation_context)
+        cancellation.__context__ = context
+    error.__context__ = cancellation
+    _raise_chained_errors(error)
+
+
+async def _capture_awaitable(awaitable: Awaitable[_T]) -> _BackendOutcome[_T]:
+    try:
+        return _BackendOutcome(value=await awaitable)
+    except BaseException as error:  # ruff:ignore[blind-except]  # backend cancellation must remain distinct from caller cancellation
+        return _BackendOutcome(error=error)
+
+
+__all__ = [
+    "_AsyncTransitionGate",
+    "_AsyncTransitionUnavailableError",
+    "_BackendOutcome",
+    "_capture_awaitable",
+    "_capture_call",
+    "_drain_future",
+    "_future_result",
+    "_raise_cancelled_error",
+    "_wait_until_done",
+]

.venv/lib/python3.12/site-packages/filelock/_async_read_write.py

@@ -0,0 +1,338 @@
+"""Async wrapper around :class:`ReadWriteLock` for use with ``asyncio``."""
+
+from __future__ import annotations
+
+import asyncio
+import functools
+import os
+import sqlite3
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING, ParamSpec, TypeVar
+
+from ._api import (
+    _append_exception_context,
+    _ensure_current_process,
+    _fork_transition,
+    _register_fork_object,
+)
+from ._async import (
+    _BackendOutcome,
+    _capture_call,
+    _drain_future,
+    _future_result,
+    _raise_cancelled_error,
+    _wait_until_done,
+)
+from ._read_write import ReadWriteLock
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator, Callable
+    from concurrent import futures
+    from types import TracebackType
+
+    from ._api import AcquireReturnProxy
+
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+
+
+class AsyncReadWriteLock:
+    """
+    Async wrapper around :class:`ReadWriteLock` for use in ``asyncio`` applications.
+
+    This wrapper dispatches every blocking SQLite operation to a thread pool via ``loop.run_in_executor()`` because
+    Python's :mod:`sqlite3` module has no async API. It delegates reentrancy, upgrade/downgrade rules, and singleton
+    behavior to the underlying :class:`ReadWriteLock`.
+
+    :param lock_file: path to the SQLite database file used as the lock
+    :param timeout: maximum wait time in seconds; ``-1`` means block indefinitely
+    :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable
+    :param is_singleton: if ``True``, reuse existing :class:`ReadWriteLock` instances for the same resolved path
+    :param loop: event loop for ``run_in_executor``; ``None`` uses the running loop
+    :param executor: executor for ``run_in_executor``. When ``None`` this lock creates and owns a dedicated
+        single-thread executor so every operation runs on the same thread (SQLite affinity requires this) and shuts it
+        down in :meth:`close`. This lock uses a caller-supplied executor as-is and never shuts it down, so after passing
+        no executor call :meth:`close` to release the owned one.
+
+    .. versionadded:: 3.21.0
+
+    """
+
+    def __init__(  # ruff:ignore[too-many-arguments]  # public constructor: one parameter per documented lock option
+        self,
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,
+        *,
+        blocking: bool = True,
+        is_singleton: bool = True,
+        loop: asyncio.AbstractEventLoop | None = None,
+        executor: futures.Executor | None = None,
+    ) -> None:
+        creator_pid = os.getpid()
+        self._creator_pid = creator_pid
+        self._fork_invalidated = False
+        self._closed = False
+        _register_fork_object(self)
+        with _fork_transition():
+            self._lock = ReadWriteLock(lock_file, timeout, blocking=blocking, is_singleton=is_singleton)
+            self._loop = loop
+            self._owns_executor = executor is None
+            self._executor = executor or ThreadPoolExecutor(max_workers=1)
+            if os.getpid() != creator_pid:  # pragma: forked child
+                msg = "AsyncReadWriteLock construction cannot continue after fork"
+                raise RuntimeError(msg)
+
+    @property
+    def lock_file(self) -> str:
+        """The path to the lock file."""
+        return self._lock.lock_file
+
+    @property
+    def timeout(self) -> float:
+        """The default timeout."""
+        return self._lock.timeout
+
+    @property
+    def blocking(self) -> bool:
+        """Whether blocking is enabled by default."""
+        return self._lock.blocking
+
+    @property
+    def loop(self) -> asyncio.AbstractEventLoop | None:
+        """The event loop (or ``None`` for the running loop)."""
+        return self._loop
+
+    @property
+    def executor(self) -> futures.Executor:
+        """The executor used for ``run_in_executor`` (a dedicated single-thread one if none was supplied)."""
+        return self._executor
+
+    @asynccontextmanager
+    async def read_lock(self, timeout: float | None = None, *, blocking: bool | None = None) -> AsyncGenerator[None]:
+        """
+        Async context manager that acquires and releases a shared read lock.
+
+        Falls back to instance defaults for *timeout* and *blocking* when ``None``.
+
+        :param timeout: maximum wait time in seconds, or ``None`` to use the instance default
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default
+
+        """
+        if timeout is None:
+            timeout = self._lock.timeout
+        if blocking is None:
+            blocking = self._lock.blocking
+        await self.acquire_read(timeout, blocking=blocking)
+        body_error: BaseException | None = None
+        try:
+            yield
+        except BaseException as error:
+            body_error = error
+            raise
+        finally:
+            await self._release_in_context(body_error)
+
+    @asynccontextmanager
+    async def write_lock(self, timeout: float | None = None, *, blocking: bool | None = None) -> AsyncGenerator[None]:
+        """
+        Async context manager that acquires and releases an exclusive write lock.
+
+        Falls back to instance defaults for *timeout* and *blocking* when ``None``.
+
+        :param timeout: maximum wait time in seconds, or ``None`` to use the instance default
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default
+
+        """
+        if timeout is None:
+            timeout = self._lock.timeout
+        if blocking is None:
+            blocking = self._lock.blocking
+        await self.acquire_write(timeout, blocking=blocking)
+        body_error: BaseException | None = None
+        try:
+            yield
+        except BaseException as error:
+            body_error = error
+            raise
+        finally:
+            await self._release_in_context(body_error)
+
+    async def _release_in_context(self, body_error: BaseException | None) -> None:
+        try:
+            await self.release()
+        except BaseException as release_error:
+            if body_error is not None:
+                _append_exception_context(release_error, body_error)
+            raise
+
+    async def acquire_read(self, timeout: float = -1, *, blocking: bool = True) -> AsyncAcquireReadWriteReturnProxy:
+        """
+        Acquire a shared read lock.
+
+        See :meth:`ReadWriteLock.acquire_read` for full semantics.
+
+        :param timeout: maximum wait time in seconds; ``-1`` means block indefinitely
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable
+
+        :returns: a proxy that can be used as an async context manager to release the lock
+
+        :raises RuntimeError: if a write lock is already held on this instance
+        :raises Timeout: if the lock cannot be acquired within *timeout* seconds
+
+        """
+        self._raise_if_unusable()
+        await self._run_acquire(functools.partial(self._lock.acquire_read, timeout, blocking=blocking))
+        return AsyncAcquireReadWriteReturnProxy(lock=self)
+
+    async def acquire_write(self, timeout: float = -1, *, blocking: bool = True) -> AsyncAcquireReadWriteReturnProxy:
+        """
+        Acquire an exclusive write lock.
+
+        See :meth:`ReadWriteLock.acquire_write` for full semantics.
+
+        :param timeout: maximum wait time in seconds; ``-1`` means block indefinitely
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable
+
+        :returns: a proxy that can be used as an async context manager to release the lock
+
+        :raises RuntimeError: if a read lock is already held, or a write lock is held by a different thread
+        :raises Timeout: if the lock cannot be acquired within *timeout* seconds
+
+        """
+        self._raise_if_unusable()
+        await self._run_acquire(functools.partial(self._lock.acquire_write, timeout, blocking=blocking))
+        return AsyncAcquireReadWriteReturnProxy(lock=self)
+
+    async def release(self, *, force: bool = False) -> None:
+        """
+        Release one level of the current lock.
+
+        See :meth:`ReadWriteLock.release` for full semantics.
+
+        :param force: if ``True``, release the lock completely regardless of the current lock level
+
+        :raises RuntimeError: if no lock is currently held and *force* is ``False``
+
+        """
+        _ensure_current_process()
+        if self._inherited:  # pragma: needs fork
+            return
+        await self._run(self._lock.release, force=force)
+
+    async def close(self) -> None:
+        """
+        Release the lock (if held) and close the underlying SQLite connection.
+
+        After calling this method, the lock instance is no longer usable.
+
+        """
+        _ensure_current_process()
+        if self._inherited:  # pragma: needs fork
+            return
+        if self._closed:
+            return
+        close_future = self._submit(self._lock.close)
+        try:
+            await _wait_until_done(close_future)
+        except asyncio.CancelledError as cancellation:
+            try:
+                await _drain_future(close_future)
+            except BaseException as error:  # ruff:ignore[blind-except]  # reported with the cancellation below
+                _raise_cancelled_error(cancellation, error)
+            self._closed = True
+            self._shutdown_owned_executor()
+            raise
+        _future_result(close_future)
+        self._closed = True
+        # Wait for the worker to exit rather than letting it drain in the background: a caller that forks right
+        # after closing deserves a single-threaded process, and os.fork warns about any surviving thread.
+        if self._owns_executor:
+            await asyncio.to_thread(functools.partial(self._executor.shutdown, wait=True))
+
+    async def _run_acquire(self, acquire: Callable[[], AcquireReturnProxy]) -> None:
+        acquire_future = self._submit(acquire)
+        try:
+            await _wait_until_done(acquire_future)
+        except asyncio.CancelledError as cancellation:
+            try:
+                await _drain_future(acquire_future)
+            except BaseException as error:  # ruff:ignore[blind-except]  # reported with the cancellation below
+                _raise_cancelled_error(cancellation, error)
+            try:
+                await _drain_future(self._submit(self._lock.release))
+            except BaseException as error:  # ruff:ignore[blind-except]  # reported with the cancellation below
+                _raise_cancelled_error(cancellation, error)
+            raise
+        _future_result(acquire_future)
+
+    async def _run(self, func: Callable[_P, _R], *args: _P.args, **kwargs: _P.kwargs) -> _R:
+        future = self._submit(func, *args, **kwargs)
+        try:
+            await _wait_until_done(future)
+        except asyncio.CancelledError as cancellation:
+            try:
+                await _drain_future(future)
+            except BaseException as error:  # ruff:ignore[blind-except]  # reported with the cancellation below
+                _raise_cancelled_error(cancellation, error)
+            raise
+        return _future_result(future)
+
+    def _submit(
+        self, func: Callable[_P, _R], *args: _P.args, **kwargs: _P.kwargs
+    ) -> asyncio.Future[_BackendOutcome[_R]]:
+        return (self._loop or asyncio.get_running_loop()).run_in_executor(
+            self._executor,
+            _capture_call,
+            functools.partial(func, *args, **kwargs),
+        )
+
+    def _shutdown_owned_executor(self) -> None:
+        if self._owns_executor:
+            self._executor.shutdown(wait=False)
+
+    @property
+    def _inherited(self) -> bool:
+        return self._fork_invalidated or os.getpid() != self._creator_pid
+
+    def _raise_if_unusable(self) -> None:
+        _ensure_current_process()
+        if self._inherited:  # pragma: needs fork
+            msg = f"AsyncReadWriteLock on {self.lock_file} was invalidated by fork(); construct a new instance"
+            raise RuntimeError(msg)
+        if self._closed:
+            msg = "Cannot operate on a closed database."
+            raise sqlite3.ProgrammingError(msg)
+
+    def _reset_after_fork_in_child(self) -> None:  # pragma: forked child
+        self._fork_invalidated = True
+
+    def __del__(self) -> None:
+        # Safety net when close() was never called: shut down the executor we own so its worker thread does not
+        # outlive the lock. shutdown(wait=False) never blocks.
+        if os.getpid() == getattr(self, "_creator_pid", None) and getattr(self, "_owns_executor", False):
+            self._executor.shutdown(wait=False)
+
+
+class AsyncAcquireReadWriteReturnProxy:
+    """Context-aware object that releases the async read/write lock on exit."""
+
+    def __init__(self, lock: AsyncReadWriteLock) -> None:
+        self.lock = lock
+
+    async def __aenter__(self) -> AsyncReadWriteLock:
+        return self.lock
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        await self.lock.release()
+
+
+__all__ = [
+    "AsyncAcquireReadWriteReturnProxy",
+    "AsyncReadWriteLock",
+]