�
Ϫ�f�m � �� � d Z ddlmZ g d�ZddlZddlZddlmZ ddlm Z ddl
m Z ddl m
Z
mZmZmZmZmZ dd lmamZ dd
lmZmZ dd l mZ ed � Z ed
� ZdZ d� Z de _ de _ de _ d� Z!d+d�Z"d,d�Z#d,d�Z$d� Z% d+ 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$� Z0d%� Z1d&� Z2 ed'ed(e
f �)� Z3 d+ d.d*�Z4y)/ah
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", 22, 10, 0))
def badAPI(self, first, second):
'''
Docstring for badAPI.
'''
...
@deprecated(Version("Twisted", 22, 10, 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", 22, 10, 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", 22, 10, 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", 22, 10, 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.
� )� annotations)�
deprecated�deprecatedProperty�getDeprecationWarningString�getWarningMethod�setWarningMethod�deprecatedModuleAttribute�deprecatedKeywordParameterN)�findlinestarts��wraps)�
ModuleType)�Any�Callable�Dict�Optional�TypeVar�cast)�warn�
warn_explicit)�Version�getVersionString)� ParamSpec�_P�_Rz&%(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* s 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) �_getReplacementStringr0 � 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 r0 )�versionr/ �docs r) �_getDeprecationDocstringr6 � s; � �
�+�G�4�5�
6�C����R�-�k�:�;�<�� ��9�r1 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}
)�fqpnr4 z{}; {})�DEPRECATION_WARNING_FORMATr �formatr0 )r8 r4 r: r/ �
warningStrings r) � _getDeprecationWarningStringr< � sG � �2 �~�+���d�7G��7P� Q�Q�M�� ��� �0��=�
�
� �r1 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}
)r< r* )�
callableThingr4 r: r/ s r) r r � s � �2 (��M�*�G�V�[� � r1 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) �_appendToDocstringrN � s� � � ���%�-�-�8�8�:����
�>��a� �� � �l�+� �^� �� !�� � �r�<�� 4�5� �#�#�%��� � �r�6�L�#8�&� A�B� �9�9�^�4�L�r1 c � � �� d�� 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 � � d� �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�functionr; s ��r) �deprecatedFunctionzDdeprecated.<locals>.deprecationDecorator.<locals>.deprecatedFunction% � �� � � � 2�q� A��T�,�V�,� ,r1 )rY z_P.argsrZ z _P.kwargs�returnr )r r
rN r6 �deprecatedVersion)r[ r\ r; r/ r4 s ` @��r) �deprecationDecoratorz(deprecated.<locals>.deprecationDecorator sX �� � 4� �g�t�[�
�
�
�x� � -�
� -� � � 8��+� N�
� 07��,�!�!r1 )r[ �Callable[_P, _R]r^ ra � )r4 r/ r` s `` r) r r
s �� �&"�& � r1 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 rR )r r; rW )rY rZ r[ �selfs ��r) r\ z^deprecatedProperty.<locals>._DeprecatedProperty._deprecatedWrapper.<locals>.deprecatedFunctionP s, �� ���&�&�&� ��
��0��0�0r1 r )rh r[ r\ s `` r) �_deprecatedWrapperzBdeprecatedProperty.<locals>._DeprecatedProperty._deprecatedWrapperO s! �� �
�8�_�
1� �
1� &� %r1 c �L � t j | | j |� � S �N)�property�setterri )rh r[ s r) rm z6deprecatedProperty.<locals>._DeprecatedProperty.setter[ s � ��?�?�4��)@�)@��)J�K� Kr1 N)r r$ r rC ri rm rb r1 r) �_DeprecatedPropertyre J s � � �
&� Lr1 rn c � �� �� t � �d �� �t � � � �fd�� }t |t ��� � �|_ �|� }�|_ |S )Nc �8 �� t �t d�� �| i |��S rR rV rX s ��r) r\ zLdeprecatedProperty.<locals>.deprecationDecorator.<locals>.deprecatedFunctionc r] r1 )r r
rN r6 r_ r; )r[ r\ �resultr; rn r/ r4 s ` @���r) r` z0deprecatedProperty.<locals>.deprecationDecorator^ sh �� �3� �g�t�[�
�
�
�x� � -�
� -� � � 8��+� N�
� 07��,�$�%7�8�� ,�� ��
r1 )rl )r4 r/ r` rn s `` @r) r r 3 s �� �.L�h� L�(�& � r1 c � � t S )zR
Return the warning method currently used to record deprecation warnings.
�r rb r1 r) r r t s � � �Kr1 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.
Nrs )� newMethods r) r r { s � � �Dr1 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__)rh rz s r) �__init__z_InternalState.__init__� s � ����4��%�0r1 c �V � t j t j | d� |� S ry )r{ �__getattribute__)rh r' s r) r z _InternalState.__getattribute__� s" � ��&�&�v�'>�'>�t�W�'M�t�T�Tr1 c �X � t j t j | d� ||� S ry )r{ r| r )rh r' �values r) r| z_InternalState.__setattr__� s% � ��!�!�&�"9�"9�$��"H�$�PU�V�Vr1 N)r r$ r rC r} r r| rb r1 r) rw rw � s � ��1�U�Wr1 rw c �* � e Zd ZdZd� Zdd�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)rw �_module�_deprecatedAttributes� _lastWasPath)rh �module�states r) r} z_ModuleProxy.__init__� s# � � �t�$�� ��
�&(��#� "��r1 c �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=�>)rw �typer r� )rh r� s r) �__repr__z_ModuleProxy.__repr__� s3 � �
�t�$���4��:�&�&�'�x��
�
�/@��B�Br1 c �V � t | � }d|_ t |j ||� y)z@
Set an attribute on the wrapped module object.
FN)rw r� �setattrr� )rh r' r� r� s r) r| z_ModuleProxy.__setattr__� s& � � �t�$�� "�����
�
�t�U�+r1 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)rw r� r� �get�getattrr� )rh r' r� �deprecatedAttributer� s r) r z _ModuleProxy.__getattribute__� s� � � �t�$�� � � �"&� �"'�"=�"=�"A�"A�$�"G� � � *� (�+�+�-�E� �E�M�M�4�0�E� �:� �!%�E� � � � "'�E� �� r1 N)r^ �str)r r$ r rC r} r� r| r rb r1 r) r� r� � s � ��6#� C�,�r1 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 r8 r4 �message)rh r� r' r4 r� s r) r} z _DeprecatedAttribute.__init__� s5 � � �� � ��
��O�O�c�)�D�0�� � �� � �� r1 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: � rT )
r� r� r r< r8 r4 r9 r� r rW )rh rq r� s r) r� z_DeprecatedAttribute.get sT � � ����d�m�m�4��.� �I�I�t�|�|�%?�$�%F�� � �%U�
��
�W�(�Q�7��
r1 N)r r$ r rC r} r� rb r1 r) r� r� � s � ��( �
r1 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)r{ r r� )rz r' r4 r� r� �attrr� s r) �_deprecateAttributer� sG � � �%�%�e�Y�7�G� ���w�� @�D� #� 3� 3�E�;R� S��"&��$� r1 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� )r4 r� r( r' r� s r) r r 0 sI � �& �[�[��
$�F� �f�l� +��j�,�v�"6�7��"(�� � �J� ����g�w�7r1 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 �wrk rb )�.0�_�
lineNumbers r) � <genexpr>z$warnAboutFunction.<locals>.<genexpr>d s" � �� �
� ��:��%�
�
�s ��__warningregistry__N)�category�filename�linenor� �registry�module_globals)
r� r� r$ r rW r! �
getabsfile�maxr �__code__r � __globals__�
setdefault)�offenderr; �offenderModules r) �warnAboutFunctionr� K sy � �( �[�[��!4�!4�5�N���#��#�#�N�3��
�!/��0A�0A�!B�
�
�
�&�&��%�%�0�0�1F��K�� r1 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)rE rY �keywords�varargs� TypeError�zip�items)�argspec�
positional�keywordrq �unpassedrZ r' r� s r) �_passedArgSpecr� o s � �& !#�F��7�<�<� �3�z�?�2�H����#�,.�.����(�(�)��!�|� �?�?� "�� 1�2� 2�&0��W�\�\�1B�1D�&E�F�7�?�?� #��7�<�<��4� � ��e� ��t� � � �}�}�� -� ��e� �7�<�<� ��v�~� � 1�2�2� �F�4�L�
�
�
�
)� �F�4�L��O�,� ,�-� �Mr1 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_POSITIONALrE � VAR_KEYWORD�POSITIONAL_OR_KEYWORD�POSITIONAL_ONLY� KEYWORD_ONLY�default�emptyr� �keys)
� signaturer� r� rq rZ �
numPositional�nr' �paramr� s
r) �_passedSignaturer� � s� � �& �F�
�F��M� %�i�&:�&:�&@�&@�&B� C� Q���=�D�%� �:�:��*�*�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�-Q�0 �:�� �&��-�.�.� �}�}�� -� ��e� �9�'�'�,�,�.� .��v�~� � 1�2�2� �F�4�L�
�
� �F�4�L��O�,� ,�-� �Mr1 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* ) rY rZ � arguments�this�that�_passed�
argumentPairs�spec�wrappees ����r) �wrappedz=_mutuallyExclusiveArguments.<locals>.wrapper.<locals>.wrapped� se �� � ��d�F�3�I� +�
�
��d��9�$���):�#� ��':�7�'C�E�� �
� �D�+�F�+� +r1 )r! r� r� r
)r� r� r� r� r� s ` @@�r) �wrapperz,_mutuallyExclusiveArguments.<locals>.wrapper� s5 �� �� � ��)��"�� �w� � ,�
� ,� �r1 rb )r� r� s ` r) �_mutuallyExclusiveArgumentsr� � s �� �$�" �Nr1 �_Tc.)�boundc � � ��� d��� 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
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 {}r3 r c �\ �� t | � �kD s�|v rt �t d�� �| i |��S rR )rE r rW )rY rZ r' �parameterIndexr; r� s ����r) �checkDeprecatedParameterzMdeprecatedKeywordParameter.<locals>.wrapper.<locals>.checkDeprecatedParameter+ s2 �� ��t�9�~�-��� �� �(:�q�I� ��/��/�/r1 c �@ �� �|v rt �t d�� �| i |��S rR rV )rY rZ r' r; r� s ���r) r� zMdeprecatedKeywordParameter.<locals>.wrapper.<locals>.checkDeprecatedParameter2 s' �� ��6�>�� �(:�q�I� ��/��/�/r1 )r< r* r: r r0 r! r� r� r� r� r� �list�indexr r� r
rN )
r� r5 �paramsr� � decoratedr� r; r' r/ r4 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�*��r1 )r� r� r^ r� rb )r4 r' r/ r� s ``` r) r
r
� s �� �.$�L �Nr1 rk )NN)r4 r r/ z"str | Callable[..., object] | Noner^ z.Callable[[Callable[_P, _R]], Callable[_P, _R]])r4 r r' r� r/ z
Optional[str]r^ zCallable[[_Tc], _Tc])5rC �
__future__r �__all__r! r� �disr � functoolsr
�typesr �typingr r r r r r �warningsr r � incrementalr r r r r r9 r* r$ r r r0 r6 r< r rN r r r r rw r� r� r� r r� r� r� r� r� r
rb r1 r) �<module>r� sI ��
K�X #� �� �
� � � � ?� ?� (� 1� ��t�_�� �T�]�� E� ��, ":� � � 3� � �#7� � � /� �( �F�<5�2 IM�& �
�& �#E�& �3�& �R> �B��W� W�&M� M�`,� ,�^'�08�6!�H'�T9�x#�L �e�8�C��H�-�.�� ?C�=�
�=� �=�.;�=��=r1 |