^j(vdZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z m Z mZmZde d eeee e ffd Zed de d ej(fd Zde d ej(fdZdeej.d eeeeffdZeddeeedeed efdZGddZde de d e fdZy)uLow-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> N) Generator)contextmanager) lru_cache) TracebackType)AnyCallableOptionalUnionfuncreturnct|j}g}|D]4}||j}||j}|j |||f6|S)a0Parse 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=, default= y: type=, default=hello z: type=, 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) )_get_signature parameters annotationdefaultappend)r func_default_paramsfunc_arg_type_valargarg_type arg_defaults Z/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/deprecate/utils.py!get_func_arguments_types_defaultsrsg>).99"?&s+66)#.66   #x!=>? )maxsizec,tj|S)zCache 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. )inspect signaturer s r_get_signature_cachedr!Fs   T ""rcb t|S#t$rtj|cYSwxYw)zuGet function signature with caching when possible. Falls back to uncached lookup for unhashable callables. )r! TypeErrorrrr s rrrQs2 '$T** '  &&'s ..warnsc@|Dcgc]}|jc}Scc}w)zConvert 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. )message)r$ws r _warns_reprr(]s % %!AII %% %s warning_typematchc #NKtjd5}tjdd|s dddy|stdt ||Dcgc]}t |j |s|}}|s dddy|s$td|jdt ||Dcgc]!}||jjvs |#}}|r'td|jd|d t | dddycc}wcc}w#1swYyxYww) uContext 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. T)recordalwaysNz/While catching all warnings, these were found: zWhile catching `z` warnings, these were found: z` warnings with "z", these were found: ) warningscatch_warnings simplefilterAssertionErrorr( issubclasscategory__name__r&__str__)r)r*calledr'r$founds rassert_no_warningsr8jsJZ   -h'   #RS^_eSfRg!hi i"Kqj\&JKK  "<#8#8"99WXcdiXjWkl "BqUaii.?.?.A%ABB  "<#8#8"99J5'R&&1%&8%9;  )LC's\D%D D%DD8D<D D% *D4!DD+D D% DD"D%c veZdZdZd deeedeeddfdZd dZ deee d ee d ee dee fd Z y)no_warning_calluDeprecated 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 Nr)r*r cftjdtd||_||_d|_y)zQEmit the alias-deprecation warning and capture args for the no-warning assertion.z`deprecate.utils.no_warning_call` is deprecated in `0.6` and will be removed in `1.0`; use `deprecate.utils.assert_no_warnings` instead.) stacklevelN)r.warnDeprecationWarning _warning_type_match_inner)selfr)r*s r__init__zno_warning_call.__init__s2  @   *  rct|j|j|_|jj y)z4Enter the underlying ``assert_no_warnings`` context.)r)r*N)r8r@rArB __enter__)rCs rrFzno_warning_call.__enter__s-(d6H6HPTP[P[\  rexc_typeexc_valexc_tbcX|jJ|jj|||S)z[Forward exit to the underlying ``assert_no_warnings`` so its AssertionError still surfaces.)rB__exit__)rCrGrHrIs rrKzno_warning_call.__exit__s-{{&&&{{##Hgv>>rNN)r N)r4 __module__ __qualname____doc__r typeWarningstrrDrF BaseExceptionrboolrKrrr:r:sx.  Xd7m%<  HUXM  ei   ?4 ./?-(?' ? $ ?rr:argskwrgsc||c}}y)aEmpty 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). **kwrgs: 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()``. NrU)rVrW_s rvoidrZs: DAqrrL)rOrr.collections.abcr contextlibr functoolsrtypesrtypingrrr r listtuplerRr Signaturer!rWarningMessagerQr(rPr8r:rZrUrrrds(%%11%H%eCcM>R9S%P 3##W->->## ' 'g&7&7 ' &tH334 &eGSL>Q9R &DXd7m%<DHUXMDenDDN1?1?hccr