pitone: modo più pulito per avvolgere ogni metodo nella classe genitore in un "con"

Question

ho una classe genitore che ha un sacco di metodi di classe:

class Parent(): 

    @classmethod 
    def methodA(cls): 
     pass 

    @classmethod 
    def methodB(cls): 
     pass 

Nel mio sottoclasse, Vorrei avvolgere un sottoinsieme dei metodi all'interno di un "con". Dovrebbe ottenere questo effetto:

class Child(Parent): 

    @classmethod 
    def methodA(cls): 
     with db.transaction: 
      super(Child, cls).methodA() 

Ho un sacco di metodi che seguono questo modello e preferiscono non ripetermi. C'è un modo più pulito per fare questo?

Answer 1

Sembra che dovresti spostare il file con db.transaction nella base. Fare un metodo in base, restituendo il db.transaction

@staticmethod 
def gettransaction(): return db.transaction 

poi sovraccaricarlo nei figli come/se necessario.

Nella base si poi fare

def methodB(cls): 
    with cls.gettransaction(): 
     bla ... 

Ecco un esempio di lavoro completo di una transazione fittizia

class transact: 
    def __enter__(a): 
     print "enter" 
    def __exit__(a,b,c,d): 
     print "exit" 

class transact2: 
    def __enter__(a): 
     print "enter2" 
    def __exit__(a,b,c,d): 
     print "exit2" 

class Parent(): 
    @staticmethod 
    def gettrans(): 
     return transact() 
    def methodA(cl): 
     with cl.gettrans(): 
      print "A" 

class Child(Parent): 
    pass 
    @staticmethod 
    def gettrans(): 
     return transact2() 

p=Parent() 
p.methodA() 
c=Child() 
c.methodA() 

questo si traduce in

enter 
A 
exit 
enter2 
A 
exit2