Décorateurs de classe en Python: cas d'utilisation pratiques

Je recherche des cas d'utilisation pratiques et non synthétiques de décorateurs de classe Python. Jusqu'à présent, le seul cas qui avait du sens pour moi est l'enregistrement d'une classe dans un système éditeur-abonné, par exemple des plugins ou des événements, quelque chose comme:

@register
class MyPlugin(Plugin):
    pass

ou

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

Tout autre cas sain auquel j'ai pensé aurait pu être construit en plus de l'héritage, des métaclasses ou des méthodes de décoration. Pourriez-vous s'il vous plaît partager de bons (ou mauvais!) Exemples d'utilisation de décorateurs de classe?

Je vous remercie!

Lors de l'écriture de tests unitaires ayant le @unittest.skipIfet @unittest.skipUnlesspeut être utilisé sur des méthodes individuelles ou sur une unittest.TestCasedéfinition de classe entière . Cela facilite grandement l'écriture de tests pour des problèmes spécifiques à la plate-forme.

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

Les décorateurs de classe ont été explicitement créés pour rendre plus agréables certaines choses qui étaient déjà exprimables via des métaclasses, du PEP :

Le cas d'utilisation motivant était de rendre certaines constructions plus facilement exprimées et moins dépendantes des détails d'implémentation de l'interpréteur CPython. Bien qu'il soit possible d'exprimer une fonctionnalité de type décorateur de classe à l'aide de métaclasses, les résultats sont généralement désagréables et la mise en œuvre très fragile. En outre, les métaclasses sont héritées, contrairement aux décorateurs de classe, ce qui rend les métaclasses inadaptées à certaines utilisations spécifiques à une classe des décorateurs de classe. Le fait que des projets Python à grande échelle comme Zope traversent ces contorsions sauvages pour réaliser quelque chose comme des décorateurs de classe a conquis le BDFL.

De cette question de débordement de pile:

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

La recherche de cas d'utilisation pouvant être réalisés avec des décorateurs dans les classes est futile - tout ce qui peut être fait avec des décorateurs dans les classes peut être fait avec des métaclasses. Même votre exemple d'inscription. Pour le prouver, voici une métaclasse qui applique un décorateur:

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