Dekoratory klas w Pythonie: praktyczne przypadki użycia

Szukam praktycznych i niesyntetycznych przypadków użycia dekoratorów klasy Python. Jak dotąd jedynym przypadkiem, który miał dla mnie sens, było zarejestrowanie klasy w systemie wydawcy-subskrybenta, np. Wtyczek lub wydarzeń, coś w rodzaju:

@register
class MyPlugin(Plugin):
    pass

lub

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

Wszelkie inne rozsądne przypadki, o których myślałem, mogłyby zostać zbudowane na podstawie dziedziczenia, metaklas lub metod dekoracyjnych. Czy możesz podać jakieś dobre (lub złe!) Przykłady korzystania z dekoratorów klas?

Dziękuję Ci!

Pisząc testy jednostkowe posiadające @unittest.skipIfi @unittest.skipUnlessmogą być użyte na poszczególnych metodach lub na całej unittest.TestCasedefinicji klasy. To znacznie ułatwia pisanie testów problemów specyficznych dla platformy.

Przykład z 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):
...

Dekoratorzy klas zostali wyraźnie stworzeni, aby uczynić niektóre rzeczy, które były już możliwe do wyrażenia poprzez metaklasy, z PEP :

Motywujący przypadek użycia polegał na tym, aby niektóre konstrukcje były łatwiej wyrażane i mniej zależne od szczegółów implementacji interpretera CPython. Chociaż można wyrazić funkcjonalność klasy dekoratora za pomocą metaklas, wyniki są na ogół nieprzyjemne, a implementacja bardzo delikatna. Ponadto metaklasy są dziedziczone, podczas gdy dekoratory klas nie, co czyni metaklasy nieodpowiednimi do niektórych, specyficznych dla jednej klasy zastosowań dekoratorów klas. Fakt, że na dużą skalę projekty Pythona, takie jak Zope, przechodził przez te dzikie wysiłki, aby osiągnąć coś w rodzaju dekoratorów klas, wygrał z BDFL.

Z tego pytania o przepełnienie stosu:

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

Poszukiwanie przypadków użycia z dekoratorami na zajęciach jest daremne - wszystko , co można zrobić z dekoratorami na zajęciach, można wykonać za pomocą metaklas. Nawet twój przykład rejestracji. Aby to udowodnić, oto metaklasa, która stosuje dekoratora:

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