How to decorate a class

Question

In Python 2 5  is there a way to create a decorator that decorates a class   Specifically  I want to use a decorator to add a member to a class and change the constructor to take a value for that member   Looking for something like the following  which has a syntax error on  class 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     I guess what I m really after is a way to do something like a C  interface in Python  I need to switch my paradigm I suppose

User · Answer

Apart from the question whether class decorators are the right solution to your problem:

In Python 2.6 and higher, there are class decorators with the @-syntax, so you can write:

@addID
class Foo:
    pass

In older versions, you can do it another way:

class Foo:
    pass

Foo = addID(Foo)

Note however that this works the same as for function decorators, and that the decorator should return the new (or modified original) class, which is not what you're doing in the example. The addID decorator would look like this:

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

You could then use the appropriate syntax for your Python version as described above.

But I agree with others that inheritance is better suited if you want to override __init__.

User · Answer

I d agree inheritance is a better fit for the problem posed   I found this question really handy though on decorating classes  thanks all    Here s another couple of examples  based on other answers  including how inheritance affects things in Python 2 7   and  wraps  which maintains the original function s docstring  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      Often you want to add parameters to your decorator   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     Outputs    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   I ve used a function decorator  as I find them more concise  Here s a class to decorate a class   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   A more robust version that checks for those parentheses  and works if the methods don t exist on the decorated class   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   The assert checks that the decorator has not been used without parentheses  If it has  then the class being decorated is passed to the msg parameter of the decorator  which raises an AssertionError    decorate if only applies the decorator if condition evaluates to True   The getattr  callable test  and  decorate if are used so that the decorator doesn t break if the foo   method doesn t exist on the class being decorated

User · Answer

There s actually a pretty good implementation of a class decorator here   https   github com agiliq Django-parsley blob master parsley decorators py  I actually think this is a pretty interesting implementation  Because it subclasses the class it decorates  it will behave exactly like this class in things like isinstance checks    It has an added benefit  it s not uncommon for the   init   statement in a custom django Form to make modifications or additions to self fields so it s better for changes to self fields to happen after all of   init   has run for the class in question   Very clever   However  in your class you actually want the decoration to alter the constructor  which I don t think is a good use case for a class decorator

User · Answer

No one has explained that you can dynamically define classes  So you can have a decorator that defines  and returns  a subclass   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   Which can be used in Python 2  the comment from Blckknght which explains why you should continue to do this in 2 6   like this   class Foo      pass  FooId   addId Foo    And in Python 3 like this  but be careful to use super   in your classes     addId class Foo      pass   So you can have your cake and eat it - inheritance and decorators

User · Answer

Django has method decorator which is a decorator that turns any decorator into a method decorator  you can see how it s implemented in django utils decorators   https   github com django django blob 50cf183d219face91822c75fa0a15fe2fe3cb32d django utils decorators py L53  https   docs djangoproject com en 3 0 topics class-based-views intro  decorating-the-class

User · Answer

That s not a good practice and there is no mechanism to do that because of that  The right way to accomplish what you want is inheritance   Take a look into the class documentation   A little example   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    This way Boss has everything Employee has  with also his own   init   method and own members

User · Answer

I would second the notion that you may wish to consider a subclass instead of the approach you ve outlined  However  not knowing your specific scenario  YMMV  -   What you re thinking of is a metaclass  The   new   function in a metaclass is passed the full proposed definition of the class  which it can then rewrite before the class is created  You can  at that time  sub out the constructor for a new one   Example   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   Replacing the constructor is perhaps a bit dramatic  but the language does provide support for this kind of deep introspection and dynamic modification

User · Answer

Here is an example which answers the question of returning the parameters of a class  Moreover  it still respects the chain of inheritance  i e  only the parameters of the class itself are returned  The function get params is added as a simple example  but other functionalities can be added thanks to the inspect module    import inspect   class Parent       classmethod     def get params my class           return list inspect signature my class  parameters keys     class OtherParent      def   init   self  a  b  c           pass  class Child Parent  OtherParent       def   init   self  x  y  z           pass  print Child get params     gt  gt   x    y    z

[python] How to decorate a class?

Examples related to python

Examples related to decorator

Examples related to python-2.5