Método de clase Python Wrap

Question

Estoy tratando de crear un objeto con un método de ejecución que estará envuelto por un método _wrap_run. Me gustaría poder llamar al método y a su envoltorio simplemente escribiendo instance.run() y me gustaría poder subclasificar el objeto para poder anular el método run() y hacer que siga ejecutando el contenedor .

Más simplemente, quiero que la gente sea capaz de subclase A y anular run(), pero todavía tienen las llamadas al método run() ejecutar la función de contenedor.

Tengo algunas dificultades con la mecánica de esto. ¿Alguien tiene alguna sugerencia con respecto a este enfoque? Gracias por leer.

class A: 

    def run(self): 
     print "Run A" 
     return True 

    def _wrap_run(self): 
     print "PRE" 
     return_value = self.run() 
     print "POST" 
     return return_value 

    run = property(_wrap_run) 


a = A() 
a.run() 
""" 
Should Print: 
PRE 
Run A 
POST 
""" 


class B(A): 

    def run(self): 
     print "Run B" 
     return True 

b = B() 
b.run() 
""" 
Should Print: 
PRE 
Run B 
POST 
""" 

Answer 1

Usa una metaclase.

class MetaClass(type): 
    @staticmethod 
    def wrap(run): 
     """Return a wrapped instance method""" 
     def outer(self): 
      print "PRE", 
      return_value = run(self) 
      print "POST" 
      return return_value 
     return outer 
    def __new__(cls, name, bases, attrs): 
     """If the class has a 'run' method, wrap it""" 
     if 'run' in attrs: 
      attrs['run'] = cls.wrap(attrs['run']) 
     return super(MetaClass, cls).__new__(cls, name, bases, attrs) 

class MyClass(object): 
    """Use MetaClass to make this class""" 
    __metaclass__ = MetaClass 
    def run(self): print 'RUN', 

myinstance = MyClass() 

# Prints PRE RUN POST 
myinstance.run() 

Ahora bien, si otras personas subclasifican MyClass, que seguirá recibiendo sus métodos run() envueltos.

Answer 2

La manera más fácil: hacer run la envoltura, y un método privado sea el overrideable.

class A(object): 
    def run(self): 
     print "PRE" 
     return_value = self._inner_run() 
     print "POST" 
     return return_value 

    def _inner_run(self): 
     print "Run A" 
     return True 

class B(A): 
    def _inner_run(self): 
     print "Run B" 
     return True 

Answer 3

lo que tienes ahí es básicamente un decorator, ¿por qué no seguir adelante y poner en práctica _wrap_run como decorador y aplicarlo cuando la subclasificación de la función?

Answer 4

Lo que otras personas hacen

class A: 
    def do_run(self): 
     """Must be overridden.""" 
     raise NotImplementedError 
    def run(self, *args, **kw): 
     """Must not be overridden. 
     You were warned. 
     """ 
     print "PRE" 
     return_value = self.do_run(*args, **kw) 
     print "POST" 
     return return_value 

class B(A): 
    def do_run(self): 
     print "Run B" 
     return True 

Eso es por lo general suficiente.

Si desea preocuparse de que alguien "rompa" esto, deténgase ahora. No pierdas el tiempo preocupándote.

Es Python. Todos somos adultos aquí. Todos los sociópatas maliciosos romperán todo tu código copiándolo, cambiándolo y luego rompiéndolo. No importa lo que hagas, simplemente copiarán tu código y lo modificarán para romper las partes inteligentes.

Todos los demás leerán su comentario y se atendrán a sus reglas. Si quieren usar su módulo/paquete/marco, cooperarán.