a
J5d& @ s d Z ddlZddlZddlZddlZddlZzddlZdZdZW n, e yl dZe
dkrddZndZY n0 e de dfZ G dd d ej
Zd
d ZdS ) z
Classic deprecation warning
===========================
Classic ``@deprecated`` decorator to deprecate old python classes, functions or methods.
.. _The Warnings Filter: https://docs.python.org/3/library/warnings.html#the-warnings-filter
N PyPy c s: e Zd ZdZdddef fdd Zdd Zdd Z ZS )
ClassicAdaptera8
Classic adapter -- *for advanced usage only*
This adapter is used to get the deprecation message according to the wrapped object type:
class, function, standard method, static method, or class method.
This is the base class of the :class:`~deprecated.sphinx.SphinxAdapter` class
which is used to update the wrapped object docstring.
You can also inherit this class to change the deprecation message.
In the following example, we change the message into "The ... is deprecated.":
.. code-block:: python
import inspect
from deprecated.classic import ClassicAdapter
from deprecated.classic import deprecated
class MyClassicAdapter(ClassicAdapter):
def get_deprecated_msg(self, wrapped, instance):
if instance is None:
if inspect.isclass(wrapped):
fmt = "The class {name} is deprecated."
else:
fmt = "The function {name} is deprecated."
else:
if inspect.isclass(instance):
fmt = "The class method {name} is deprecated."
else:
fmt = "The method {name} is deprecated."
if self.reason:
fmt += " ({reason})"
if self.version:
fmt += " -- Deprecated since version {version}."
return fmt.format(name=wrapped.__name__,
reason=self.reason or "",
version=self.version or "")
Then, you can use your ``MyClassicAdapter`` class like this in your source code:
.. code-block:: python
@deprecated(reason="use another function", adapter_cls=MyClassicAdapter)
def some_old_function(x, y):
return x + y
r Nc s2 |pd| _ |pd| _|| _|| _tt| dS )aQ
Construct a wrapper adapter.
:type reason: str
:param reason:
Reason message which documents the deprecation in your library (can be omitted).
:type version: str
:param version:
Version of your project which deprecates this feature.
If you follow the `Semantic Versioning `_,
the version number has the format "MAJOR.MINOR.PATCH".
:type action: str
:param action:
A warning filter used to activate or not the deprecation warning.
Can be one of "error", "ignore", "always", "default", "module", or "once".
If ``None`` or empty, the the global filtering mechanism is used.
See: `The Warnings Filter`_ in the Python documentation.
:type category: type
:param category:
The warning category to use for the deprecation warning.
By default, the category class is :class:`~DeprecationWarning`,
you can inherit this class to define your own deprecation warning category.
r N)reasonversionactioncategorysuperr __init__)selfr r r
r __class__ N/var/www/html/django/DPS/env/lib/python3.9/site-packages/deprecated/classic.pyr
V s
zClassicAdapter.__init__c C sl |du r t |rd}q2d}nt |r.d}nd}| jr@|d7 }| jrN|d7 }|j|j| jp^d| jpfdd S )
z
Get the deprecation warning message for the user.
:param wrapped: Wrapped class or function.
:param instance: The object to which the wrapped function was bound when it was called.
:return: The warning message.
Nz Call to deprecated class {name}.z5Call to deprecated function (or staticmethod) {name}.z'Call to deprecated class method {name}.z!Call to deprecated method {name}.z ({reason})z' -- Deprecated since version {version}.r )namer r )inspectisclassr r format__name__)r wrappedinstancefmtr r r get_deprecated_msgw s
z!ClassicAdapter.get_deprecated_msgc s. t r*j fdd}t|_S )a
Decorate your class or function.
:param wrapped: Wrapped class or function.
:return: the decorated class or function.
.. versionchanged:: 1.2.4
Don't pass arguments to :meth:`object.__new__` (other than *cls*).
.. versionchanged:: 1.2.8
The warning filter is not set if the *action* parameter is ``None`` or empty.
c s d }jr^t 2 tjj tj|jtd W d qp1 sR0 Y ntj|jtd tj u r | S | g|R i |S N)r
stacklevel)
r r
warningscatch_warnings simplefilterr warn_class_stacklevelobject__new__)clsargskwargsmsgZold_new1r r r r wrapped_cls s
2
z,ClassicAdapter.__call__..wrapped_cls)r r r$ staticmethod)r r r* r r) r __call__ s
zClassicAdapter.__call__) r
__module__ __qualname____doc__DeprecationWarningr
r r,
__classcell__r r r r r # s 2!r c s | r*t | d tr*| d |d< | dd } | rNt| d sNttt| d | r|d |dt|dt }|f i || d }t
|r|}|S t
|rt
jd fd d
}||S ttt|tjtfi |S ) a
This is a decorator which can be used to mark functions
as deprecated. It will result in a warning being emitted
when the function is used.
**Classic usage:**
To use this, decorate your deprecated function with **@deprecated** decorator:
.. code-block:: python
from deprecated import deprecated
@deprecated
def some_old_function(x, y):
return x + y
You can also decorate a class or a method:
.. code-block:: python
from deprecated import deprecated
class SomeClass(object):
@deprecated
def some_old_method(self, x, y):
return x + y
@deprecated
class SomeOldClass(object):
pass
You can give a *reason* message to help the developer to choose another function/class,
and a *version* number to specify the starting version number of the deprecation.
.. code-block:: python
from deprecated import deprecated
@deprecated(reason="use another function", version='1.2.0')
def some_old_function(x, y):
return x + y
The *category* keyword argument allow you to specify the deprecation warning class of your choice.
By default, :exc:`DeprecationWarning` is used but you can choose :exc:`FutureWarning`,
:exc:`PendingDeprecationWarning` or a custom subclass.
.. code-block:: python
from deprecated import deprecated
@deprecated(category=PendingDeprecationWarning)
def some_old_function(x, y):
return x + y
The *action* keyword argument allow you to locally change the warning filtering.
*action* can be one of "error", "ignore", "always", "default", "module", or "once".
If ``None``, empty or missing, the the global filtering mechanism is used.
See: `The Warnings Filter`_ in the Python documentation.
.. code-block:: python
from deprecated import deprecated
@deprecated(action="error")
def some_old_function(x, y):
return x + y
r r Nr
r adapter_cls)adapterc st | |} rVt , t tj|td W d qf1 sJ0 Y ntj|td | |i |S r )r r r r r! _routine_stacklevel)Zwrapped_Z instance_args_kwargs_r( r
r4 r r r wrapper_function s
0z$deprecated..wrapper_function)
isinstance string_typescallable TypeErrorreprtypegetr0 popr r r isroutinewrapt decorator functoolspartial
deprecated)r& r' r3 r r9 r r8 r rG s( L
rG )r/ rE r platformr rC Zwrapt._wrappersr5 r" ImportErrorpython_implementationr? r; ZAdapterFactoryr rG r r r r s$