Dekoratoren in der Python-Standardbibliothek (@speziell veraltet)

Ich muss Routinen als veraltet markieren, aber anscheinend gibt es keinen Standard-Bibliotheksdekorator für veraltete Routinen. Mir sind Rezepte dafür und das Warnmodul bekannt, aber meine Frage ist: Warum gibt es für diese (häufige) Aufgabe keinen Standard-Bibliotheksdekorator?

Zusätzliche Frage: Gibt es in der Standardbibliothek überhaupt Standarddekorateure?

Hier ist ein Auszug, der von den von Leandro zitierten abgeändert wurde:

import warnings
import functools

def deprecated(func):
    """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."""
    @functools.wraps(func)
    def new_func(*args, **kwargs):
        warnings.simplefilter('always', DeprecationWarning)  # turn off filter
        warnings.warn("Call to deprecated function {}.".format(func.__name__),
                      category=DeprecationWarning,
                      stacklevel=2)
        warnings.simplefilter('default', DeprecationWarning)  # reset filter
        return func(*args, **kwargs)
    return new_func

# Examples

@deprecated
def some_old_function(x, y):
    return x + y

class SomeClass:
    @deprecated
    def some_old_method(self, x, y):
        return x + y

Denn in einigen Interpretern kann die erste verfügbare Lösung (ohne Filterbehandlung) zu einer Unterdrückung der Warnung führen.

Hier ist eine andere Lösung:

Dieser Dekorateur (eigentlich eine Dekorateurfabrik) ermöglicht es Ihnen, etwas zu geben Grund Nachricht. Es ist auch nützlicher, dem Entwickler durch die Angabe der Quelle bei der Diagnose des Problems zu helfen Dateinamen Und Zeilennummer.

BEARBEITEN: Dieser Code verwendet die Empfehlung von Zero: Ersetzen warnings.warn_explicit Zeile nach warnings.warn(msg, category=DeprecationWarning, stacklevel=2), wodurch die Funktionsaufrufseite und nicht die Funktionsdefinitionsseite gedruckt wird. Es erleichtert das Debuggen.

BEARBEITEN2: Diese Version ermöglicht es dem Entwickler, eine optionale „Grund“-Nachricht anzugeben.

import functools
import inspect
import warnings

string_types = (type(b''), type(u''))


def deprecated(reason):
    """
    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.
    """

    if isinstance(reason, string_types):

        # The @deprecated is used with a 'reason'.
        #
        # .. code-block:: python
        #
        #    @deprecated("please, use another function")
        #    def old_function(x, y):
        #      pass

        def decorator(func1):

            if inspect.isclass(func1):
                fmt1 = "Call to deprecated class {name} ({reason})."
            else:
                fmt1 = "Call to deprecated function {name} ({reason})."

            @functools.wraps(func1)
            def new_func1(*args, **kwargs):
                warnings.simplefilter('always', DeprecationWarning)
                warnings.warn(
                    fmt1.format(name=func1.__name__, reason=reason),
                    category=DeprecationWarning,
                    stacklevel=2
                )
                warnings.simplefilter('default', DeprecationWarning)
                return func1(*args, **kwargs)

            return new_func1

        return decorator

    elif inspect.isclass(reason) or inspect.isfunction(reason):

        # The @deprecated is used without any 'reason'.
        #
        # .. code-block:: python
        #
        #    @deprecated
        #    def old_function(x, y):
        #      pass

        func2 = reason

        if inspect.isclass(func2):
            fmt2 = "Call to deprecated class {name}."
        else:
            fmt2 = "Call to deprecated function {name}."

        @functools.wraps(func2)
        def new_func2(*args, **kwargs):
            warnings.simplefilter('always', DeprecationWarning)
            warnings.warn(
                fmt2.format(name=func2.__name__),
                category=DeprecationWarning,
                stacklevel=2
            )
            warnings.simplefilter('default', DeprecationWarning)
            return func2(*args, **kwargs)

        return new_func2

    else:
        raise TypeError(repr(type(reason)))

Sie können diesen Dekorateur für verwenden Funktionen, Methoden Und Klassen.

Hier ist ein einfaches Beispiel:

@deprecated("use another function")
def some_old_function(x, y):
    return x + y


class SomeClass(object):
    @deprecated("use another method")
    def some_old_method(self, x, y):
        return x + y


@deprecated("use another class")
class SomeOldClass(object):
    pass


some_old_function(5, 3)
SomeClass().some_old_method(8, 9)
SomeOldClass()

Du wirst kriegen:

deprecated_example.py:59: DeprecationWarning: Call to deprecated function or method some_old_function (use another function).
  some_old_function(5, 3)
deprecated_example.py:60: DeprecationWarning: Call to deprecated function or method some_old_method (use another method).
  SomeClass().some_old_method(8, 9)
deprecated_example.py:61: DeprecationWarning: Call to deprecated class SomeOldClass (use another class).
  SomeOldClass()

EDIT3: Dieser Dekorator ist jetzt Teil der veralteten Bibliothek:

• Python-Paketindex (PyPi)
• GitHub-Website
• Lesen Sie die Dokumente
• Twitter

Neue stabile Version v1.2.13 🎉

Wie Myon vorgeschlagen hat, können Sie das installieren deprecation Paket dafür.

Der deprecation Die Bibliothek bietet eine deprecated Dekorateur und a fail_if_not_removed Dekorateur für Ihre Tests.

Installation

pip install deprecation

Beispielverwendung

import deprecation

@deprecation.deprecated(deprecated_in="1.0", removed_in="2.0",
                        current_version=__version__,
                        details="Use the bar function instead")
def foo():
    """Do some stuff"""
    return 1

Sehen http://deprecation.readthedocs.io/ für die vollständige Dokumentation.

Ich schätze, der Grund liegt darin, dass Python-Code nicht statisch verarbeitet werden kann (wie es bei C++-Compilern der Fall war) und man vor der Verwendung einiger Dinge keine Warnung erhalten kann, bevor man ihn tatsächlich verwendet. Ich halte es nicht für eine gute Idee, Benutzer Ihres Skripts mit einer Reihe von Nachrichten zu spammen: „Warnung: Dieser Entwickler dieses Skripts verwendet eine veraltete API“.

Aktualisieren: Sie können jedoch einen Dekorator erstellen, der die ursprüngliche Funktion in eine andere umwandelt. Die neue Funktion markiert/prüft den Schalter, um anzuzeigen, dass diese Funktion bereits aufgerufen wurde, und zeigt nur dann eine Meldung an, wenn der Schalter in den Ein-Zustand geschaltet wird. Und/oder beim Beenden wird möglicherweise eine Liste aller veralteten Funktionen gedruckt, die im Programm verwendet werden.

Sie können eine Utils-Datei erstellen

import warnings

def deprecated(message):
  def deprecated_decorator(func):
      def deprecated_func(*args, **kwargs):
          warnings.warn("{} is a deprecated function. {}".format(func.__name__, message),
                        category=DeprecationWarning,
                        stacklevel=2)
          warnings.simplefilter('default', DeprecationWarning)
          return func(*args, **kwargs)
      return deprecated_func
  return deprecated_decorator

Und importieren Sie dann den Deprecation-Decorator wie folgt:

from .utils import deprecated

@deprecated("Use method yyy instead")
def some_method():
 pass

Python ist ein dynamisch getippte Sprache. Es ist nicht erforderlich, den Typ statisch als Variable oder Argumenttyp für die Funktion zu deklarieren.

Da es dynamisch ist, wird alles zur Laufzeit verarbeitet. Auch wenn eine Methode veraltet ist, wird sie nur zur Laufzeit oder während der Interpretation bekannt sein.

verwenden Missbilligung Modul zum Verwerfen von Methoden.

Deprecation ist eine Bibliothek, die automatisierte Deprekationen ermöglicht. Es bietet die veraltet() Decorator, um Funktionen zu umschließen und entsprechende Warnungen sowohl in der Dokumentation als auch über Python bereitzustellen Warnungen System, sowie die deprecation.fail_if_not_removed() Dekorator für Testmethoden, um sicherzustellen, dass veralteter Code schließlich entfernt wird.

Installieren:

python3.10 -m pip install deprecation

Kleine Demonstration:

import deprecation

@deprecation.deprecated(details="Use bar instead")
def foo():
    print("Foo")


def bar():
    print("Bar")


foo()

bar()

Ausgang:

test.py: DeprecatedWarning: foo is deprecated. Use bar instead
  foo()

Foo

Bar

UPDATE: Ich denke, es ist besser, wenn wir DeprecationWarning nur beim ersten Mal anzeigen jede Codezeile und wenn wir eine Nachricht senden können:

import inspect
import traceback
import warnings
import functools

import time


def deprecated(message: str=""):
    """
    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 first time and filter is set for show DeprecationWarning.
    """
    def decorator_wrapper(func):
        @functools.wraps(func)
        def function_wrapper(*args, **kwargs):
            current_call_source="|".join(traceback.format_stack(inspect.currentframe()))
            if current_call_source not in function_wrapper.last_call_source:
                warnings.warn("Function {} is now deprecated! {}".format(func.__name__, message),
                              category=DeprecationWarning, stacklevel=2)
                function_wrapper.last_call_source.add(current_call_source)

            return func(*args, **kwargs)

        function_wrapper.last_call_source = set()

        return function_wrapper
    return decorator_wrapper


@deprecated('You must use my_func2!')
def my_func():
    time.sleep(.1)
    print('aaa')
    time.sleep(.1)


def my_func2():
    print('bbb')


warnings.simplefilter('always', DeprecationWarning)  # turn off filter
print('before cycle')
for i in range(5):
    my_func()
print('after cycle')
my_func()
my_func()
my_func()

Ergebnis:

before cycle
C:/Users/adr-0/OneDrive/Projects/Python/test/unit1.py:45: DeprecationWarning: Function my_func is now deprecated! You must use my_func2!
aaa
aaa
aaa
aaa
aaa
after cycle
C:/Users/adr-0/OneDrive/Projects/Python/test/unit1.py:47: DeprecationWarning: Function my_func is now deprecated! You must use my_func2!
aaa
C:/Users/adr-0/OneDrive/Projects/Python/test/unit1.py:48: DeprecationWarning: Function my_func is now deprecated! You must use my_func2!
aaa
C:/Users/adr-0/OneDrive/Projects/Python/test/unit1.py:49: DeprecationWarning: Function my_func is now deprecated! You must use my_func2!
aaa

Process finished with exit code 0

Wir können einfach auf den Warnpfad klicken und zur Zeile in PyCharm gehen.