Implementazione del pattern decorator in Python

Question

Voglio implementare lo decorator pattern in Python e mi chiedevo se c'è un modo per scrivere un decoratore che implementa semplicemente la funzione che desidera modificare, senza scrivere il boiler-plate per tutte le funzioni che sono appena inoltrati all'oggetto decorato. In questo modo:

class foo(object): 
    def f1(self): 
     print "original f1" 
    def f2(self): 
     print "original f2" 

class foo_decorator(object): 
    def __init__(self, decoratee): 
     self._decoratee = decoratee 
    def f1(self): 
     print "decorated f1" 
     self._decoratee.f1() 
    def f2(self):    # I would like to leave that part out 
     self._decoratee.f2() 

Mi piacerebbe avere chiamate a foo_decorator.f2 inoltrate decoratee.f2 automaticamente. C'è un modo per scrivere un metodo generico che inoltra tutte le chiamate di funzioni non implementate a decoratee?

Answer 1

si potrebbe usare __getattr__:

class foo(object): 
    def f1(self): 
     print "original f1" 
    def f2(self): 
     print "original f2" 

class foo_decorator(object): 
    def __init__(self, decoratee): 
     self._decoratee = decoratee 
    def f1(self): 
     print "decorated f1" 
     self._decoratee.f1() 
    def __getattr__(self, name): 
     return getattr(self._decoratee, name) 

u = foo() 
v = foo_decorator(u) 
v.f1() 
v.f2() 

Answer 2

non è probabilmente la migliore prassi, ma è possibile aggiungere funzionalità alle istanze, come ho fatto per aiutare la transizione il mio codice da ORM di Django per SQLAlachemy, come segue:

def _save(self): 
    session.add(self) 
    session.commit() 
setattr(Base,'save',_save) 

Answer 3

Il diagramma UML nell'articolo di Wikipedia collegato è errato e lo è anche il tuo codice.

Se segui il "motivo decoratore", la classe decoratore deriva dalla classe decorata di base. (Nel diagramma UML manca una freccia di eredità da WindowDecorator a Window).

con

class foo_decorator(foo): 

non è necessario implementare metodi non decorati.

BTW: In forte lingue digitati c'è una ragione in più, per cui il decoratore deve essere derivato dalla classe decorato: In caso contrario, si wouldnt essere in grado di decoratori catena.

Answer 4

Come addendum alla risposta di Philipp; se è necessario non solo per decorare, ma preservare la tipo di un oggetto, Python consente di sottoclasse un'istanza in fase di esecuzione:

class foo(object): 
    def f1(self): 
     print "original f1" 

    def f2(self): 
     print "original f2" 


class foo_decorator(object): 
    def __new__(cls, decoratee): 
     cls = type('decorated', 
        (foo_decorator, decoratee.__class__), 
        decoratee.__dict__) 
     return object.__new__(cls) 

    def f1(self): 
     print "decorated f1" 
     super(foo_decorator, self).f1() 


u = foo() 
v = foo_decorator(u) 
v.f1() 
v.f2() 
print 'isinstance(v, foo) ==', isinstance(v, foo) 

Questo è un po 'più coinvolto di quanto strettamente necessario per il tuo esempio, in cui si sapere che la classe viene decorata in anticipo

Questo potrebbe bastano:

class foo_decorator(foo): 
    def __init__(self, decoratee): 
     self.__dict__.update(decoratee.__dict__) 

    def f1(self): 
     print "decorated f1" 
     super(foo_decorator, self).f1() 

Answer 5

Per completare @Alec Thomas risposta. Ho modificato la sua risposta per seguire lo schema del decoratore. In questo modo non è necessario conoscere in anticipo la classe che stai decorando.

class Decorator(object): 
    def __new__(cls, decoratee): 
     cls = type('decorated', 
        (cls, decoratee.__class__), 
        decoratee.__dict__) 
     return object.__new__(cls) 

Quindi, è possibile utilizzarlo come:

class SpecificDecorator(Decorator): 
    def f1(self): 
     print "decorated f1" 
     super(foo_decorator, self).f1() 

class Decorated(object): 
    def f1(self): 
     print "original f1" 


d = SpecificDecorator(Decorated()) 
d.f1() 

Answer 6

In uno dei miei progetti, ho anche bisogno di fare una cosa in particolare, vale a dire che anche l'oggetto sottostante dovrebbe realmente eseguire il metodo che è stato reimplementato nel decoratore. In realtà è abbastanza facile da fare se sai dove indirizzarlo.

Il caso di utilizzo è:

• Ho un oggetto X con metodi A e B.
• Creo una classe decoratore Y che sostituisce A.
• Se si crea un'istanza Y (X) e si chiama A, verrà utilizzata la A decorata come previsto.
• Se B chiama A, quindi se istanzia Y (X) e chiama B sul decoratore, la chiamata dall'interno di B quindi passa alla vecchia A dell'oggetto originale che non era desiderabile. Voglio che anche la vecchia B chiami la nuova A.

E 'possibile raggiungere questo comportamento come questo:

import inspect 
import six  # for handling 2-3 compatibility 

class MyBaseDecorator(object): 
    def __init__(self, decorated): 
     self.decorated = decorated 

    def __getattr__(self, attr): 
     value = getattr(self.decorated, attr) 
     if inspect.ismethod(value): 
      function = six.get_method_function(value) 
      value = function.__get__(self, type(self)) 
     return value 

class SomeObject(object): 
    def a(self): 
     pass 

    def b(self): 
     pass 

class MyDecorator(MyBaseDecorator): 
    def a(self): 
     pass 

decorated = MyDecorator(SomeObject()) 

Questo non può funzionare out of the box, come ho digitato tutto il resto a parte il metodo di getattr dalla parte superiore della testa.

Il codice cerca l'attributo richiesto nell'oggetto decorato e se è un metodo (non funziona per le proprietà ora, ma la modifica per supportarle non dovrebbe essere troppo difficile), il codice quindi attira l'effettivo funzione fuori dal metodo e usando l'invocazione dell'interfaccia del descrittore "ricollega" la funzione come metodo, ma sul decoratore. Quindi viene restituito e molto probabilmente eseguito.

L'effetto di questo è che se b chiama sempre a sull'oggetto originale, quindi quando l'oggetto è decorato e c'è una chiamata di metodo proveniente dal decoratore, il decoratore si assicura che tutti i metodi a cui si accede siano vincolati al decoratore invece, quindi cercare le cose usando il decoratore e non l'oggetto originale, quindi i metodi specificati nel decoratore hanno la precedenza.

P.S .: Sì, lo so che assomiglia molto all'eredità, ma questo nel senso della composizione di più oggetti.