Python Class Decorator

Question

En Python 2.5, ¿hay alguna manera de crear un decorador que decore una clase? Específicamente, quiero usar un decorador para agregar un miembro a una clase y cambiar el constructor para tomar un valor para ese miembro.

Buscando algo como lo siguiente (que tiene un error de sintaxis en la 'clase Foo:':

def getId(self): return self.__id 

class addID(original_class): 
    def __init__(self, id, *args, **kws): 
     self.__id = id 
     self.getId = getId 
     original_class.__init__(self, *args, **kws) 

@addID 
class Foo: 
    def __init__(self, value1): 
     self.value1 = value1 

if __name__ == '__main__': 
    foo1 = Foo(5,1) 
    print foo1.value1, foo1.getId() 
    foo2 = Foo(15,2) 
    print foo2.value1, foo2.getId() 

Gracias, Rob

Editar: Al releer esta pregunta, supongo que lo Estoy realmente después es una forma de hacer algo así como una interfaz C# en Python. Necesito cambiar mi paradigma, supongo.

Answer 1

Me gustaría secundar la idea de que es posible que desee considerar una subclase en lugar del enfoque que ha descrito. Sin embargo, sin conocer su escenario específico, YMMV :-)

Lo que está pensando es una metaclase. La función __new__ en una metaclase se pasa a la definición propuesta completa de la clase, que luego puede reescribir antes de que se cree la clase. En ese momento, puede subcontratar al constructor para obtener uno nuevo.

Ejemplo:

def substitute_init(self, id, *args, **kwargs): 
    pass 

class FooMeta(type): 

    def __new__(cls, name, bases, attrs): 
     attrs['__init__'] = substitute_init 
     return super(FooMeta, cls).__new__(cls, name, bases, attrs) 

class Foo(object): 

    __metaclass__ = FooMeta 

    def __init__(self, value1): 
     pass 

Sustitución del constructor es tal vez un poco dramático, pero el lenguaje sí provee soporte para este tipo de profunda introspección y la modificación dinámica.

Answer 2

Eso no es una buena práctica y no hay mec Hanism para hacer eso debido a eso. La forma correcta de lograr lo que quieres es la herencia.

Eche un vistazo a class documentation.

Un pequeño ejemplo:

class Employee(object): 

    def __init__(self, age, sex, siblings=0): 
     self.age = age 
     self.sex = sex  
     self.siblings = siblings 

    def born_on(self):  
     today = datetime.date.today() 

     return today - datetime.timedelta(days=self.age*365) 


class Boss(Employee):  
    def __init__(self, age, sex, siblings=0, bonus=0): 
     self.bonus = bonus 
     Employee.__init__(self, age, sex, siblings) 

este jefe manera tiene todo Employee tiene, también con su propio método __init__ y propios miembros.

Answer 3

Aparte de la cuestión de si los decoradores de clase son la solución adecuada a su problema:

en Python 2.6 y superior, hay decoradores de clase con el @ -Sintaxis, para que pueda escribir:

@addID 
class Foo: 
    pass 

en las versiones anteriores, puede hacerlo de otro modo: sin embargo

class Foo: 
    pass 

Foo = addID(Foo) 

Tenga en cuenta que esto funciona lo mismo que para los decoradores de función, y que el decorador debe r edita la clase nueva (o original modificada), que no es lo que estás haciendo en el ejemplo. El decorador Addid se vería así:

def addID(original_class): 
    orig_init = original_class.__init__ 
    # make copy of original __init__, so we can call it without recursion 

    def __init__(self, id, *args, **kws): 
     self.__id = id 
     self.getId = getId 
     orig_init(self, *args, **kws) # call the original __init__ 

    original_class.__init__ = __init__ # set the class' __init__ to the new one 
    return original_class 

A continuación, puede utilizar la sintaxis apropiada para su versión de Python como se describió anteriormente.

Pero estoy de acuerdo con otros en que la herencia es más adecuada si desea anular __init__.

Answer 4

De hecho, hay una muy buena aplicación de un decorador de la clase aquí:

https://github.com/agiliq/Django-parsley/blob/master/parsley/decorators.py

realidad creo que esta es una aplicación bastante interesante. Debido a que subclasifica la clase que decora, se comportará exactamente como esta clase en cosas como cheques isinstance.

Se tiene un beneficio adicional: no es raro que la declaración __init__ en un formulario de Django encargo de realizar modificaciones o adiciones a self.fields por lo que es mejor para los cambios en self.fields sucedan después todos __init__ ha utilizado por la clase de pregunta.

Muy inteligente.

Sin embargo, en su clase realmente desea que la decoración altere el constructor, lo que no creo que sea un buen caso de uso para un decorador de clases.

Answer 5

nadie ha explicado que puede definir dinámicamente las clases. lo que puede tener un decorador que define (y vuelve) una subclase:

def addId(cls): 

    class AddId(cls): 

     def __init__(self, id, *args, **kargs): 
      super(AddId, self).__init__(*args, **kargs) 
      self.__id = id 

     def getId(self): 
      return self.__id 

    return AddId 

que se puede utilizar en Python 2 (el comentario de Blckknght que explica por qué usted debe seguir para hacer esto en 2.6+) así:

class Foo: 
    pass 

FooId = addId(Foo) 

y en Python 3 como esto (pero tenga cuidado de usar super() en sus clases):

@addId 
class Foo: 
    pass 

para que pueda tener su pastel y cómelo - herencia y decoradores!

Answer 6

Estoy de acuerdo en que la herencia es una mejor opción para el problema planteado.

Encontré esta pregunta realmente útil en las clases de decoración, gracias a todos. Aquí hay otro par de ejemplos, sobre la base de otras respuestas, incluyendo cómo afecta la herencia cosas en Python 2.7, (y @wraps, que mantiene cadena de documentación de la función original, etc):

def dec(klass): 
    old_foo = klass.foo 
    @wraps(klass.foo) 
    def decorated_foo(self, *args ,**kwargs): 
     print('@decorator pre %s' % msg) 
     old_foo(self, *args, **kwargs) 
     print('@decorator post %s' % msg) 
    klass.foo = decorated_foo 
    return klass 

@dec # no parentheses 
class Foo... 

frecuencia con que desea añadir parámetros a su decorador:

from functools import wraps 

def dec(msg='default'): 
    def decorator(klass): 
     old_foo = klass.foo 
     @wraps(klass.foo) 
     def decorated_foo(self, *args ,**kwargs): 
      print('@decorator pre %s' % msg) 
      old_foo(self, *args, **kwargs) 
      print('@decorator post %s' % msg) 
     klass.foo = decorated_foo 
     return klass 
    return decorator 

@dec('foo decorator') # you must add parentheses now, even if they're empty 
class Foo(object): 
    def foo(self, *args, **kwargs): 
     print('foo.foo()') 

@dec('subfoo decorator') 
class SubFoo(Foo): 
    def foo(self, *args, **kwargs): 
     print('subfoo.foo() pre') 
     super(SubFoo, self).foo(*args, **kwargs) 
     print('subfoo.foo() post') 

@dec('subsubfoo decorator') 
class SubSubFoo(SubFoo): 
    def foo(self, *args, **kwargs): 
     print('subsubfoo.foo() pre') 
     super(SubSubFoo, self).foo(*args, **kwargs) 
     print('subsubfoo.foo() post') 

SubSubFoo().foo() 

Salidas:

@decorator pre subsubfoo decorator 
subsubfoo.foo() pre 
@decorator pre subfoo decorator 
subfoo.foo() pre 
@decorator pre foo decorator 
foo.foo() 
@decorator post foo decorator 
subfoo.foo() post 
@decorator post subfoo decorator 
subsubfoo.foo() post 
@decorator post subsubfoo decorator 

he utilizado un decorador función, ya que me parece más concisos. Aquí está una clase para decorar una clase:

class Dec(object): 

    def __init__(self, msg): 
     self.msg = msg 

    def __call__(self, klass): 
     old_foo = klass.foo 
     msg = self.msg 
     def decorated_foo(self, *args, **kwargs): 
      print('@decorator pre %s' % msg) 
      old_foo(self, *args, **kwargs) 
      print('@decorator post %s' % msg) 
     klass.foo = decorated_foo 
     return klass 

Una versión más robusta que los controles de los paréntesis, y funciona si no existen los métodos de la clase decorada:

from inspect import isclass 

def decorate_if(condition, decorator): 
    return decorator if condition else lambda x: x 

def dec(msg): 
    # Only use if your decorator's first parameter is never a class 
    assert not isclass(msg) 

    def decorator(klass): 
     old_foo = getattr(klass, 'foo', None) 

     @decorate_if(old_foo, wraps(klass.foo)) 
     def decorated_foo(self, *args ,**kwargs): 
      print('@decorator pre %s' % msg) 
      if callable(old_foo): 
       old_foo(self, *args, **kwargs) 
      print('@decorator post %s' % msg) 

     klass.foo = decorated_foo 
     return klass 

    return decorator 

Los assert cheques que el decorador no se ha usado sin paréntesis.Si lo tiene, la clase que se está decorando se pasa al parámetro msg del decorador, lo que genera un AssertionError.

@decorate_if solo aplica decorator si condition evalúa a True.

El getattr, callable prueba, y @decorate_if se utilizan para que el decorador no se rompe si el método foo() no existe en la clase de ser decorado.