File: //lib/python3/dist-packages/twisted/python/__pycache__/deprecate.cpython-312.pyc
�
�bl � � � d Z g d�ZddlZddlZddlmZ ddlmZ ddlm Z ddl
m Z m Z m
Z
mZmZmZ ddlmamZ dd lmZmZ d
Zd � Zd e_ d
e_ d
e_ d� Z d+d�Z d,d�Z d,d�Z d� Z d+d�Z!d+d�Z"d� Z#d� Z$ G d� d� Z% G d� d� Z& G d� d � Z'd � Z(d � Z)d � Z*d � Z+d!� Z,d"� Z- ed#e d$e f �%� Z. d+d&ed'e/d(ee/ d)e e.ge.f fd*�Z0y)-aa
Deprecation framework for Twisted.
To mark a method, function, or class as being deprecated do this::
from incremental import Version
from twisted.python.deprecate import deprecated
@deprecated(Version("Twisted", 8, 0, 0))
def badAPI(self, first, second):
'''
Docstring for badAPI.
'''
...
@deprecated(Version("Twisted", 16, 0, 0))
class BadClass:
'''
Docstring for BadClass.
'''
The newly-decorated badAPI will issue a warning when called, and BadClass will
issue a warning when instantiated. Both will also have a deprecation notice
appended to their docstring.
To deprecate properties you can use::
from incremental import Version
from twisted.python.deprecate import deprecatedProperty
class OtherwiseUndeprecatedClass:
@deprecatedProperty(Version('Twisted', 16, 0, 0))
def badProperty(self):
'''
Docstring for badProperty.
'''
@badProperty.setter
def badProperty(self, value):
'''
Setter sill also raise the deprecation warning.
'''
To mark module-level attributes as being deprecated you can use::
badAttribute = "someValue"
...
deprecatedModuleAttribute(
Version("Twisted", 8, 0, 0),
"Use goodAttribute instead.",
"your.full.module.name",
"badAttribute")
The deprecated attributes will issue a warning whenever they are accessed. If
the attributes being deprecated are in the same module as the
L{deprecatedModuleAttribute} call is being made from, the C{__name__} global
can be used as the C{moduleName} parameter.
To mark an optional, keyword parameter of a function or method as deprecated
without deprecating the function itself, you can use::
@deprecatedKeywordParameter(Version("Twisted", 19, 2, 0), 'baz')
def someFunction(foo, bar=0, baz=None):
...
See also L{incremental.Version}.
@type DEPRECATION_WARNING_FORMAT: C{str}
@var DEPRECATION_WARNING_FORMAT: The default deprecation warning string format
to use when one is not provided by the user.
)�
deprecated�deprecatedProperty�getDeprecationWarningString�getWarningMethod�setWarningMethod�deprecatedModuleAttribute�deprecatedKeywordParameter� N)�findlinestarts��wraps)�
ModuleType)�Any�Callable�Dict�Optional�TypeVar�cast)�warn�
warn_explicit)�Version�getVersionStringz&%(fqpn)s was deprecated in %(version)sc �0 � | j }t j | � st j
| � r| j }|� d|� �S t j | � r| j � d| j � �S |S # t $ r | j }Y ��w xY w)z�
Return the fully qualified name of a module, class, method or function.
Classes and functions need to be module level ones to be correctly
qualified.
@rtype: C{str}.
�.)� __qualname__�AttributeError�__name__�inspect�isclass�
isfunction�
__module__�ismethod)�obj�name�
moduleNames �:/usr/lib/python3/dist-packages/twisted/python/deprecate.py�_fullyQualifiedNamer& o s� � � �� � �� ���s��w� 1� 1�#� 6��^�^�
� � �Q�t�f�%�%� � � �#� ��.�.�!��3�#3�#3�"4�5�5� �K�� � ��|�|�� �s � A= �=B�Bztwisted.python.reflect�fullyQualifiedNamec �: � t | � r t | � } d| � d�S )a
Surround a replacement for a deprecated API with some polite text exhorting
the user to consider it as an alternative.
@type replacement: C{str} or callable
@return: a string like "please use twisted.python.modules.getModule
instead".
z please use z instead)�callabler& �� replacements r% �_getReplacementStringr, � s% � � � � �)�+�6� �
��
�X� .�.� c �L � dt | � � �}|r|� dt |� � �}|dz S )a�
Generate an addition to a deprecated object's docstring that explains its
deprecation.
@param version: the version it was deprecated.
@type version: L{incremental.Version}
@param replacement: The replacement, if specified.
@type replacement: C{str} or callable
@return: a string like "Deprecated in Twisted 27.2.0; please use
twisted.timestream.tachyon.flux instead."
zDeprecated in �; r )r r, )�versionr+ �docs r% �_getDeprecationDocstringr2 � s; � �
�+�G�4�5�
6�C����R�-�k�:�;�<�� ��9�r- c �r � |�t }|| t |� d�z }|rdj |t |� � }|S )ag
Return a string indicating that the Python name was deprecated in the given
version.
@param fqpn: Fully qualified Python name of the thing being deprecated
@type fqpn: C{str}
@param version: Version that C{fqpn} was deprecated in.
@type version: L{incremental.Version}
@param format: A user-provided format to interpolate warning values into, or
L{DEPRECATION_WARNING_FORMAT
<twisted.python.deprecate.DEPRECATION_WARNING_FORMAT>} if L{None} is
given.
@type format: C{str}
@param replacement: what should be used in place of C{fqpn}. Either pass in
a string, which will be inserted into the warning message, or a
callable, which will be expanded to its full import path.
@type replacement: C{str} or callable
@return: A textual description of the deprecation
@rtype: C{str}
)�fqpnr0 z{}; {})�DEPRECATION_WARNING_FORMATr �formatr, )r4 r0 r6 r+ �
warningStrings r% � _getDeprecationWarningStringr8 � sG � �2 �~�+���d�7G��7P� Q�Q�M�� ��� �0��=�
�
� �r- c �0 � t t | � |||� S )ak
Return a string indicating that the callable was deprecated in the given
version.
@type callableThing: C{callable}
@param callableThing: Callable object to be deprecated
@type version: L{incremental.Version}
@param version: Version that C{callableThing} was deprecated in.
@type format: C{str}
@param format: A user-provided format to interpolate warning values into,
or L{DEPRECATION_WARNING_FORMAT
<twisted.python.deprecate.DEPRECATION_WARNING_FORMAT>} if L{None} is
given
@param replacement: what should be used in place of the callable. Either
pass in a string, which will be inserted into the warning message,
or a callable, which will be expanded to its full import path.
@type replacement: C{str} or callable
@return: A string describing the deprecation.
@rtype: C{str}
)r8 r& )�
callableThingr0 r6 r+ s r% r r � s � �2 (��M�*�G�V�[� � r- c �V � | j r| j j � }ng }t |� dk( r|j |� nJt |� dk( r|j d|dg� n'|j � }|j d||z |g� dj
|� | _ y)av
Append the given text to the docstring of C{thingWithDoc}.
If C{thingWithDoc} has no docstring, then the text just replaces the
docstring. If it has a single-line docstring then it appends a blank line
and the message text. If it has a multi-line docstring, then in appends a
blank line a the message text, and also does the indentation correctly.
r � � �
N)�__doc__�
splitlines�len�append�extend�pop�join)� thingWithDoc� textToAppend�docstringLines�spacess r% �_appendToDocstringrJ � s� � � ���%�-�-�8�8�:����
�>��a� �� � �l�+� �^� �� !�� � �r�<�� 4�5� �#�#�%��� � �r�6�L�#8�&� A�B� �9�9�^�4�L�r- c � � �� �� fd�}|S )a�
Return a decorator that marks callables as deprecated. To deprecate a
property, see L{deprecatedProperty}.
@type version: L{incremental.Version}
@param version: The version in which the callable will be marked as
having been deprecated. The decorated function will be annotated
with this version, having it set as its C{deprecatedVersion}
attribute.
@param replacement: what should be used in place of the callable. Either
pass in a string, which will be inserted into the warning message,
or a callable, which will be expanded to its full import path.
@type replacement: C{str} or callable
c � �� �� t � �d�� �t � � � �fd�� }t |t ��� � �|_ |S )zA
Decorator that marks C{function} as deprecated.
Nc �8 �� t �t d�� �| i |��S �N� ��
stacklevel�r �DeprecationWarning��args�kwargs�functionr7 s ��r% �deprecatedFunctionzDdeprecated.<locals>.deprecationDecorator.<locals>.deprecatedFunction � �� � � � 2�q� A��T�,�V�,� ,r- )r r rJ r2 �deprecatedVersion)rW rX r7 r+ r0 s ` @��r% �deprecationDecoratorz(deprecated.<locals>.deprecationDecorator sX �� � 4� �g�t�[�
�
�
�x� � -�
� -� � � 8��+� N�
� 07��,�!�!r- � )r0 r+ r[ s `` r% r r s �� �""�& � r- c �8 � ��� G d� dt � ���� fd�}|S )a
Return a decorator that marks a property as deprecated. To deprecate a
regular callable or class, see L{deprecated}.
@type version: L{incremental.Version}
@param version: The version in which the callable will be marked as
having been deprecated. The decorated function will be annotated
with this version, having it set as its C{deprecatedVersion}
attribute.
@param replacement: what should be used in place of the callable.
Either pass in a string, which will be inserted into the warning
message, or a callable, which will be expanded to its full import
path.
@type replacement: C{str} or callable
@return: A new property with deprecated setter and getter.
@rtype: C{property}
@since: 16.1.0
c � � e Zd ZdZd� Zd� Zy)�/deprecatedProperty.<locals>._DeprecatedPropertyzQ
Extension of the build-in property to allow deprecated setters.
c �2 � �� t �� �� fd�� }|S )Nc �L �� t �j t d�� �| i |��S rN )r r7 rS )rU rV rW �selfs ��r% rX z^deprecatedProperty.<locals>._DeprecatedProperty._deprecatedWrapper.<locals>.deprecatedFunctionJ s, �� ���&�&�&� ��
��0��0�0r- r )rb rW rX s `` r% �_deprecatedWrapperzBdeprecatedProperty.<locals>._DeprecatedProperty._deprecatedWrapperI s! �� �
�8�_�
1� �
1� &� %r- c �L � t j | | j |� � S �N)�property�setterrc )rb rW s r% rg z6deprecatedProperty.<locals>._DeprecatedProperty.setterU s � ��?�?�4��)@�)@��)J�K� Kr- N)r r r r? rc rg r\ r- r% �_DeprecatedPropertyr_ D s � � �
&� Lr- rh c � �� �� t � �d �� �t � � � �fd�� }t |t ��� � �|_ �|� }�|_ |S )Nc �8 �� t �t d�� �| i |��S rN rR rT s ��r% rX zLdeprecatedProperty.<locals>.deprecationDecorator.<locals>.deprecatedFunction] rY r- )r r rJ r2 rZ r7 )rW rX �resultr7 rh r+ r0 s ` @���r% r[ z0deprecatedProperty.<locals>.deprecationDecoratorX sh �� �3� �g�t�[�
�
�
�x� � -�
� -� � � 8��+� N�
� 07��,�$�%7�8�� ,�� ��
r- )rf )r0 r+ r[ rh s `` @r% r r - s �� �.L�h� L�(�& � r- c � � t S )zR
Return the warning method currently used to record deprecation warnings.
�r r\ r- r% r r n s � � �Kr- c � � | a y)z�
Set the warning method to use to record deprecation warnings.
The callable should take message, category and stacklevel. The return
value is ignored.
Nrm )� newMethods r% r r u s � � �Dr- c �" � e Zd ZdZd� Zd� Zd� Zy)�_InternalStatez�
An L{_InternalState} is a helper object for a L{_ModuleProxy}, so that it
can easily access its own attributes, bypassing its logic for delegating to
another object that it's proxying for.
@ivar proxy: a L{_ModuleProxy}
c �2 � t j | d|� y �N�proxy)�object� __setattr__)rb rt s r% �__init__z_InternalState.__init__� s � ����4��%�0r- c �V � t j t j | d� |� S rs )ru �__getattribute__)rb r# s r% ry z _InternalState.__getattribute__� s" � ��&�&�v�'>�'>�t�W�'M�t�T�Tr- c �X � t j t j | d� ||� S rs )ru rv ry )rb r# �values r% rv z_InternalState.__setattr__� s% � ��!�!�&�"9�"9�$��"H�$�PU�V�Vr- N)r r r r? rw ry rv r\ r- r% rq rq � s � ��1�U�Wr- rq c �. � e Zd ZdZd� Zdefd�Zd� Zd� Zy)� _ModuleProxya�
Python module wrapper to hook module-level attribute access.
Access to deprecated attributes first checks
L{_ModuleProxy._deprecatedAttributes}, if the attribute does not appear
there then access falls through to L{_ModuleProxy._module}, the wrapped
module object.
@ivar _module: Module on which to hook attribute access.
@type _module: C{module}
@ivar _deprecatedAttributes: Mapping of attribute names to objects that
retrieve the module attribute's original value.
@type _deprecatedAttributes: C{dict} mapping C{str} to
L{_DeprecatedAttribute}
@ivar _lastWasPath: Heuristic guess as to whether warnings about this
package should be ignored for the next call. If the last attribute
access of this module was a C{getattr} of C{__path__}, we will assume
that it was the import system doing it and we won't emit a warning for
the next access, even if it is to a deprecated attribute. The CPython
import system always tries to access C{__path__}, then the attribute
itself, then the attribute itself again, in both successful and failed
cases.
@type _lastWasPath: C{bool}
c �D � t | � }||_ i |_ d|_ y )NF)rq �_module�_deprecatedAttributes� _lastWasPath)rb �module�states r% rw z_ModuleProxy.__init__� s# � � �t�$�� ��
�&(��#� "��r- �returnc �d � t | � }dt | � j � d|j �d�S )z�
Get a string containing the type of the module proxy and a
representation of the wrapped module object.
�<z module=�>)rq �typer r )rb r� s r% �__repr__z_ModuleProxy.__repr__� s3 � �
�t�$���4��:�&�&�'�x��
�
�/@��B�Br- c �V � t | � }d|_ t |j ||� y)z@
Set an attribute on the wrapped module object.
FN)rq r� �setattrr )rb r# r{ r� s r% rv z_ModuleProxy.__setattr__� s& � � �t�$�� "�����
�
�t�U�+r- c �� � t | � }|j rd}n|j j |� }|�|j � }nt |j
|� }|dk( r d|_ |S d|_ |S )aG
Get an attribute from the module object, possibly emitting a warning.
If the specified name has been deprecated, then a warning is issued.
(Unless certain obscure conditions are met; see
L{_ModuleProxy._lastWasPath} for more information about what might quash
such a warning.)
N�__path__TF)rq r� r� �get�getattrr )rb r# r� �deprecatedAttributer{ s r% ry z _ModuleProxy.__getattribute__� s� � � �t�$�� � � �"&� �"'�"=�"=�"A�"A�$�"G� � � *� (�+�+�-�E� �E�M�M�4�0�E� �:� �!%�E� � � � "'�E� �� r- N) r r r r? rw �strr� rv ry r\ r- r% r} r} � s$ � ��6#� C�#� C�,�r- r} c � � e Zd ZdZd� Zd� Zy)�_DeprecatedAttributeaE
Wrapper for deprecated attributes.
This is intended to be used by L{_ModuleProxy}. Calling
L{_DeprecatedAttribute.get} will issue a warning and retrieve the
underlying attribute's value.
@type module: C{module}
@ivar module: The original module instance containing this attribute
@type fqpn: C{str}
@ivar fqpn: Fully qualified Python name for the deprecated attribute
@type version: L{incremental.Version}
@ivar version: Version that the attribute was deprecated in
@type message: C{str}
@ivar message: Deprecation message
c �j � || _ || _ |j dz |z | _ || _ || _ y)z7
Initialise a deprecated name wrapper.
r N)r� r r4 r0 �message)rb r� r# r0 r� s r% rw z _DeprecatedAttribute.__init__� s5 � � �� � ��
��O�O�c�)�D�0�� � �� � �� r- c �� � t | j | j � }t | j | j
t dz | j z � }t |t d�� |S )zU
Get the underlying attribute value and issue a deprecation warning.
z: � rP )
r� r� r r8 r4 r0 r5 r� r rS )rb rk r� s r% r� z_DeprecatedAttribute.get sT � � ����d�m�m�4��.� �I�I�t�|�|�%?�$�%F�� � �%U�
��
�W�(�Q�7��
r- N)r r r r? rw r� r\ r- r% r� r� � s � ��( �
r- r� c � � t j | d� }t ||||� }t j | d� }|||< y)a�
Mark a module-level attribute as being deprecated.
@type proxy: L{_ModuleProxy}
@param proxy: The module proxy instance proxying the deprecated attributes
@type name: C{str}
@param name: Attribute name
@type version: L{incremental.Version}
@param version: Version that the attribute was deprecated in
@type message: C{str}
@param message: Deprecation message
r r� N)ru ry r� )rt r# r0 r� r �attrr� s r% �_deprecateAttributer� sG � � �%�%�e�Y�7�G� ���w�� @�D� #� 3� 3�E�;R� S��"&��$� r- c � � t j | }t |t � s,t t
t |� � }|t j |< t
||| |� y)aE
Declare a module-level attribute as being deprecated.
@type version: L{incremental.Version}
@param version: Version that the attribute was deprecated in
@type message: C{str}
@param message: Deprecation message
@type moduleName: C{str}
@param moduleName: Fully-qualified Python name of the module containing
the deprecated attribute; if called from the same module as the
attributes are being deprecated in, using the C{__name__} global can
be helpful
@type name: C{str}
@param name: Attribute name to deprecate
N)�sys�modules�
isinstancer} r r
r� )r0 r� r$ r# r� s r% r r * sI � �& �[�[��
$�F� �f�l� +��j�,�v�"6�7��"(�� � �J� ����g�w�7r- c � � t j | j }t |t t j |� t d� t | j � D � � |j | j j di � d�� y)a�
Issue a warning string, identifying C{offender} as the responsible code.
This function is used to deprecate some behavior of a function. It differs
from L{warnings.warn} in that it is not limited to deprecating the behavior
of a function currently on the call stack.
@param offender: The function that is being deprecated.
@param warningString: The string that should be emitted by this warning.
@type warningString: C{str}
@since: 11.0
c 3 �& K � | ] \ }}|�� � y �wre r\ )�.0�_�
lineNumbers r% � <genexpr>z$warnAboutFunction.<locals>.<genexpr>[ s � �� �U�3T�-�!�Z�:�3T�s ��__warningregistry__N)�category�filename�linenor� �registry�module_globals)
r� r� r r rS r �
getabsfile�maxr
�__code__r � __globals__�
setdefault)�offenderr7 �offenderModules r% �warnAboutFunctionr� E sp � �" �[�[��!4�!4�5�N���#��#�#�N�3��U�>�(�BS�BS�3T�U�U� �&�&��%�%�0�0�1F��K��r- c � � i }t | j � t |� z
}| j �i x}|| j < |dk r<| j � t d� �|t | j � d || j < t | j |� D ]
\ }}|||< � |j
� D ]D \ }}|| j v r||v r t d� �|||< �)| j �||< �;t d� � |S )a�
Take an I{inspect.ArgSpec}, a tuple of positional arguments, and a dict of
keyword arguments, and return a mapping of arguments that were actually
passed to their passed values.
@param argspec: The argument specification for the function to inspect.
@type argspec: I{inspect.ArgSpec}
@param positional: The positional arguments that were passed.
@type positional: L{tuple}
@param keyword: The keyword arguments that were passed.
@type keyword: L{dict}
@return: A dictionary mapping argument names (those declared in C{argspec})
to values that were passed explicitly by the user.
@rtype: L{dict} mapping L{str} to L{object}
Nr �Too many arguments.�Already passed.�
no such param)rA rU �keywords�varargs� TypeError�zip�items)�argspec�
positional�keywordrk �unpassedrV r# r{ s r% �_passedArgSpecr� b s � �& !#�F��7�<�<� �3�z�?�2�H����#�,.�.����(�(�)��!�|� �?�?� "�� 1�2� 2�&0��W�\�\�1B�1D�&E�F�7�?�?� #��7�<�<��4� ��e� ��t� � 5� �}�}�� ��e� �7�<�<� ��v�~� � 1�2�2� �F�4�L�
�
�
�
)� �F�4�L��O�,� ,� '� �Mr- c � � i }d}d}t | j j � � D �]b \ }\ }}|j t j
j k( r||d ||< t || � dz }�K|j t j
j k( ri x}||< �z|j t j
j t j
j fv r |t |� k s��|| ||< |dz
}��|j t j
j k( rL||vs��|j t j
j k( rt d|� �� �|j ||< ��Jt d|� d|j � �� � t |� |kD r t d� �|j � D ]H \ }} || j j � v r||v r t d� �| ||< �7|�| ||< �?t d � � |S )
a�
Take an L{inspect.Signature}, a tuple of positional arguments, and a dict of
keyword arguments, and return a mapping of arguments that were actually
passed to their passed values.
@param signature: The signature of the function to inspect.
@type signature: L{inspect.Signature}
@param positional: The positional arguments that were passed.
@type positional: L{tuple}
@param keyword: The keyword arguments that were passed.
@type keyword: L{dict}
@return: A dictionary mapping argument names (those declared in
C{signature}) to values that were passed explicitly by the user.
@rtype: L{dict} mapping L{str} to L{object}
Nr r< zmissing keyword arg �'z ' parameter is invalid kind: r� r� r� )� enumerate�
parametersr� �kindr � Parameter�VAR_POSITIONALrA � VAR_KEYWORD�POSITIONAL_OR_KEYWORD�POSITIONAL_ONLY� KEYWORD_ONLY�default�emptyr� �keys)
� signaturer� r� rk rV �
numPositional�nr# �paramr{ s
r% �_passedSignaturer� � s� � �& �F�
�F��M� '� �(<�(<�(B�(B�(D� E���M�T�5� �:�:��*�*�9�9� 9�%�a�b�>�F�4�L� ��t� � -�� 1�M�
�Z�Z�7�,�,�8�8�
8�$&� &�F�V�D�\�
�Z�Z� � � � 3� 3� � � � -� -�
�
� �3�z�?�"� )�!�}��t� � ��"�
�
�Z�Z�7�,�,�9�9�
9��7�"��=�=�G�$5�$5�$;�$;�;�#�&:�4�&�$A�B�B�#(�=�=�F�4�L��a��v�%B�5�:�:�,� O�P� P�- F�0 �:�� �&��-�.�.� �}�}�� ��e� �9�'�'�,�,�.� .��v�~� � 1�2�2� �F�4�L�
�
� �F�4�L��O�,� ,� '� �Mr- c � � � � fd�}|S )a�
Decorator which causes its decoratee to raise a L{TypeError} if two of the
given arguments are passed at the same time.
@param argumentPairs: pairs of argument identifiers, each pair indicating
an argument that may not be passed in conjunction with another.
@type argumentPairs: sequence of 2-sequences of L{str}
@return: A decorator, used like so::
@_mutuallyExclusiveArguments([["tweedledum", "tweedledee"]])
def function(tweedledum=1, tweedledee=2):
"Don't pass tweedledum and tweedledee at the same time."
@rtype: 1-argument callable taking a callable and returning a callable.
c �p �� ��� t j � � �t �t � � ���� fd�� }|S )Nc � �� ��| |� }�D ], \ }}||v s� ||v s�t d|�d|�dt �� �d�� � �| i |��S )N�The z and z arguments to z are mutually exclusive.)r� r& ) rU rV � arguments�this�that�_passed�
argumentPairs�spec�wrappees ����r% �wrappedz=_mutuallyExclusiveArguments.<locals>.wrapper.<locals>.wrapped� s` �� � ��d�F�3�I� +�
��d��9�$���):�#� ��':�7�'C�E�� � ,� �D�+�F�+� +r- )r r� r� r )r� r� r� r� r� s ` @@�r% �wrapperz,_mutuallyExclusiveArguments.<locals>.wrapper� s5 �� �� � ��)��"�� �w� � ,�
� ,� �r- r\ )r� r� s ` r% �_mutuallyExclusiveArgumentsr� � s �� �$�" �Nr- �_Tc.)�boundr0 r# r+ r� c �4 � ��� dt dt f��� fd� }|S )aw
Return a decorator that marks a keyword parameter of a callable
as deprecated. A warning will be emitted if a caller supplies
a value for the parameter, whether the caller uses a keyword or
positional syntax.
@type version: L{incremental.Version}
@param version: The version in which the parameter will be marked as
having been deprecated.
@type name: L{str}
@param name: The name of the deprecated parameter.
@type replacement: L{str}
@param replacement: Optional text indicating what should be used in
place of the deprecated parameter.
@since: Twisted 21.2.0
r� r� c �� �� ��� t d��dt � � � �� ��� �dj �t � � � }�r|dz t �� z }|dz
}t j � � j }�|v rM|� j t
j j k( r#t |� j �� ����� fd�}n��� fd�}t t t � � |� � }t! ||� |S ) Nr� z parameter to r* z'The {!r} parameter was deprecated in {}r/ r c �\ �� t | � �kD s�|v rt �t d�� �| i |��S rN )rA r rS )rU rV r# �parameterIndexr7 r� s ����r% �checkDeprecatedParameterzMdeprecatedKeywordParameter.<locals>.wrapper.<locals>.checkDeprecatedParameter s2 �� ��t�9�~�-��� �� �(:�q�I� ��/��/�/r- c �@ �� �|v rt �t d�� �| i |��S rN rR )rU rV r# r7 r� s ���r% r� zMdeprecatedKeywordParameter.<locals>.wrapper.<locals>.checkDeprecatedParameter% s' �� ��6�>�� �(:�q�I� ��/��/�/r- )r8 r& r6 r r, r r� r� r� r� r� �list�indexr r� r rJ )
r� r1 �paramsr� � decoratedr� r7 r# r+ r0 s
` @@���r% r� z+deprecatedKeywordParameter.<locals>.wrapper s� �� �4��4�(�.�)<�W�)E�(F� G� �#�
�
� 8�>�>� � �W� %�
�� ���*� 4�[� A�A�C� �s�
���"�"�7�+�6�6�� �F�N��t� �!�!�W�%6�%6�%L�%L�L� !�&�\� /� /�� 5�N�
0�
0�
0�
��n�e�G�n�-E� F�G� ��9�c�*��r- )r� )r0 r# r+ r� s ``` r% r r � s �� �.$�� $�� $�L �Nr- re )NN)1r? �__all__r r� �disr
� functoolsr �typesr
�typingr r r r r r �warningsr r � incrementalr r r5 r& r r r r, r2 r8 r rJ r r r r rq r} r� r� r r� r� r� r� r� r� r r\ r- r% �<module>r� s ��
K�\ �� �
� � � � ?� ?� (� 1� E� ��, ":� � � 3� � �#7� � � /� �( �F�<5�0$ �N> �B��W� W�&M� M�`,� ,�^'�08�6�:'�T9�x#�L �e�8�C��H�-�.�� ?C�=�
�=� �=�.6�s�m�=�
�s�e�S�j��=r-