Klassendekorateure in Python: praktische Anwendungsfälle

Ich suche nach praktischen und nicht synthetischen Anwendungsfällen von Python-Klassendekorateuren. Bisher war der einzige Fall, der für mich sinnvoll war, die Registrierung einer Klasse in einem Publisher-Subscriber-System, z. B. Plugins oder Events, wie z.

@register
class MyPlugin(Plugin):
    pass

oder

@recieves_notifications
class Console:
    def print(self, text):
        ...

Alle anderen vernünftigen Fälle, an die ich gedacht habe, könnten auf Vererbung, Metaklassen oder Dekorationsmethoden aufbauen. Könnten Sie bitte gute (oder schlechte!) Beispiele für die Verwendung von Klassendekorateuren nennen?

Vielen Dank!

Beim Schreiben von Komponententests mit dem @unittest.skipIfund @unittest.skipUnlesskönnen entweder einzelne Methoden oder eine gesamte unittest.TestCaseKlassendefinition verwendet werden. Dies erleichtert das Schreiben von Tests für plattformspezifische Probleme erheblich.

Beispiel aus asyncio/test_selectors

# Some platforms don't define the select.kqueue object for these tests.
# On those platforms, this entire grouping of tests will be skipped.

@unittest.skipUnless(hasattr(selectors, 'KqueueSelector'),
                 "Test needs selectors.KqueueSelector)")
class KqueueSelectorTestCase(BaseSelectorTestCase, ScalableSelectorMixIn):
...

Klassendekorateure wurden explizit erstellt, um einige Dinge, die bereits über Metaklassen ausgedrückt werden konnten, aus dem PEP angenehmer zu machen :

Der motivierende Anwendungsfall bestand darin, bestimmte Konstrukte leichter auszudrücken und weniger von Implementierungsdetails des CPython-Interpreters abhängig zu machen. Während es möglich ist, Klassendekorator-ähnliche Funktionen mithilfe von Metaklassen auszudrücken, sind die Ergebnisse im Allgemeinen unangenehm und die Implementierung sehr fragil. Darüber hinaus werden Metaklassen vererbt, während dies bei Klassendekoratoren nicht der Fall ist, sodass Metaklassen für einige klassenspezifische Verwendungen von Klassendekoratoren ungeeignet sind. Die Tatsache, dass große Python-Projekte wie Zope diese wilden Verrenkungen durchliefen, um so etwas wie Klassendekorateure zu erreichen, überzeugte die BDFL.

Aus dieser Stapelüberlauffrage:

def singleton(class_):
  instances = {}
  def getinstance(*args, **kwargs):
    if class_ not in instances:
        instances[class_] = class_(*args, **kwargs)
    return instances[class_]
  return getinstance

@singleton
class MyClass(BaseClass):
  pass

Die Suche nach Anwendungsfällen, die mit Dekorateuren in Klassen durchgeführt werden können, ist zwecklos - alles , was mit Dekorateuren in Klassen durchgeführt werden kann, kann mit Metaklassen durchgeführt werden. Sogar Ihr Beispiel für die Registrierung. Um dies zu beweisen, ist hier eine Metaklasse, die einen Dekorateur anwendet:

Python 2:

def register(target):
    print 'Registring', target
    return target


class ApplyDecorator(type):
    def __new__(mcs, name, bases, attrs):
        decorator = attrs.pop('_decorator')
        cls = type(name, bases, attrs)
        return decorator(cls)

    def __init__(cls, name, bases, attrs, decorator=None):
        super().__init__(name, bases, attrs)


class Foo:
    __metaclass__ = ApplyDecorator
    _decorator = register

Python 3:

def register(target):
    print('Registring', target)
    return target


class ApplyDecorator(type):
    def __new__(mcs, name, bases, attrs, decorator):
        cls = type(name, bases, attrs)
        return decorator(cls)

    def __init__(cls, name, bases, attrs):
        super().__init__(name, bases, attrs)


class Foo(metaclass=ApplyDecorator, decorator=register):
    pass