Decoradores de clase en Python: casos de uso prácticos

Estoy buscando casos de uso prácticos y no sintéticos de decoradores de clase Python. Hasta ahora, el único caso que tenía sentido para mí es registrar una clase en un sistema editor-suscriptor, por ejemplo, complementos o eventos, algo como:

@register
class MyPlugin(Plugin):
    pass

o

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

Cualquier otro caso sensato en el que haya estado pensando podría haberse construido sobre la herencia, las metaclases o los métodos de decoración. ¿Podrías compartir ejemplos buenos (o malos) del uso de decoradores de clase?

¡Gracias!

Al escribir pruebas unitarias que tengan el @unittest.skipIfy @unittest.skipUnlessse pueden usar en métodos individuales o en una unittest.TestCasedefinición de clase completa . Esto hace que escribir pruebas para problemas específicos de la plataforma sea mucho más fácil.

Ejemplo 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):
...

Los decoradores de clase se crearon explícitamente para hacer que algunas cosas que ya se podían expresar mediante metaclases fueran más agradables, desde el PEP :

El caso de uso motivador fue hacer que ciertas construcciones se expresen más fácilmente y que dependan menos de los detalles de implementación del intérprete de CPython. Si bien es posible expresar una funcionalidad similar a un decorador de clase utilizando metaclases, los resultados son generalmente desagradables y la implementación altamente frágil. Además, las metaclases se heredan, mientras que los decoradores de clases no lo son, lo que hace que las metaclases no sean adecuadas para algunos usos específicos de clase de los decoradores de clases. El hecho de que los proyectos de Python a gran escala como Zope estuvieran pasando por estas contorsiones salvajes para lograr algo así como los decoradores de clase se ganó el BDFL.

De esta pregunta de desbordamiento de pila:

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

Buscar casos de uso que se puedan hacer con decoradores en clases es inútil; todo lo que se puede hacer con decoradores en clases se puede hacer con metaclases. Incluso su ejemplo de registro. Para probarlo, aquí hay una metaclase que aplica un 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