Decoradores de classe em Python: casos de uso prático

Estou procurando casos de uso práticos e não sintéticos de decoradores de classe Python. Até agora, o único caso que fez sentido para mim é o registro de uma classe em um sistema de editor-assinante, por exemplo, plugins ou eventos, algo como:

@register
class MyPlugin(Plugin):
    pass

ou

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

Quaisquer outros casos sensatos em que estive pensando poderiam ter sido construídos sobre herança, metaclasses ou métodos de decoração. Você poderia compartilhar exemplos bons (ou ruins!) Do uso de decoradores de classe?

Obrigado!

Ao escrever testes de unidade com @unittest.skipIfe @unittest.skipUnlesspode ser usado em métodos individuais ou em uma unittest.TestCasedefinição de classe inteira . Isso facilita muito a criação de testes para problemas específicos da plataforma.

Exemplo de 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):
...

Decoradores de classe foram criados explicitamente para tornar mais agradáveis ​​algumas coisas que já eram expressáveis ​​através de metaclasses, do PEP :

O caso de uso motivador foi tornar certas construções mais facilmente expressas e menos dependentes dos detalhes de implementação do interpretador CPython. Embora seja possível expressar a funcionalidade de decorador de classe usando metaclasses, os resultados geralmente são desagradáveis ​​e a implementação altamente frágil. Além disso, as metaclasses são herdadas, enquanto os decoradores de classe não são, tornando as metaclasses inadequadas para alguns usos específicos de classe de decoradores de classe. O fato de que projetos Python em larga escala como o Zope estavam passando por essas contorções malucas para conseguir algo como decoradores de classe conquistaram o BDFL.

A partir dessa pergunta de estouro de pilha:

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

É inútil procurar casos de uso que possam ser feitos com decoradores em classes - qualquer coisa que possa ser feita com decoradores em classes pode ser feita com metaclasses. Até o seu exemplo de registro. Para provar isso, aqui está uma metaclasse que aplica um decorador:

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