Décorateur de classe Python et profondeur de récursivité maximale dépassée

Question

J'essaie de définir un décorateur de classe. J'ai un problème avec la méthode __init__ en classe décorée. Si la méthode __init__ invoque super la RuntimeErrorprofondeur de récursivité maximale dépassée est élevée.

Exemple de code:

def decorate(cls): 
    class NewClass(cls): pass 
    return NewClass 

@decorate 
class Foo(object): 
    def __init__(self, *args, **kwargs): 
     super(Foo, self).__init__(*args, **kwargs) 

Qu'est-ce que je fais mal?

Merci, Michał

Modifier 1

Merci à Mike réponse boers je me suis rendu à cette question est correcte que dois-je faire pour que achive super (Foo, auto) pointer à la classe appropriée.

J'ai aussi deux limitations. Je veux appeler la méthode Foo.__init__ et je ne peux pas modifier la définition de classe Foo.

Edit 2

J'ai résolu ce problème. Je modifie le corps de la fonction décorateur. Je ne retourne pas de nouvelle classe. Au lieu d'envelopper des méthodes de classe orginal.

Answer 1

Vous devez remplacer NewClass.__init__ pour empêcher la récursivité, car NewClass.__init__ est Foo.__init__ et il continue à s'appeler.

def decorate(cls): 
    class NewClass(cls): 
     def __init__(self): 
      pass 
    return NewClass 

---

Nouvelle idée:

Que diriez-vous pas sous-classer? Peut-être que le patch de singe est votre ami?

def decorate(cls): 
    old_do_something = cls.do_something 
    def new_do_something(self): 
     print "decorated", 
     old_do_something(self) 

    cls.do_something = new_do_something 
    return cls 

@decorate 
class Foo(object): 
    def __init__(self, *args, **kwargs): 
     super(Foo, self).__init__(*args, **kwargs) 

    def do_something(self): 
     print "Foo" 

f = Foo() 
f.do_something() 

Answer 2

Rappelez-vous qu'un décorateur est tout simplement le sucre syntaxique pour:

>>> Foo = decorate(Foo) 

Donc, dans ce cas, le nom Foo fait référence à la classe NewClass. Dans la méthode Foo.__init__ vous demandez en fait le super __init__ de NewClass, qui est Foo.__init__ (qui est ce qui est en cours d'exécution).

Ainsi, votre Foo.__init__ continue de recevoir son propre __init__ pour appeler, et vous vous retrouvez dans une récursion infinie.