Python decorators in classes

Question

Can one write something like   class Test object       def  decorator self  foo           foo         self  decorator     def bar self           pass   This fails  self in  self is unknown  I also tried    Test  decorator self    which also fails  Test unknown  I would like to temporarily change some instance variables  in the decorator and then run the decorated method  before changing them back

User · Answer

I use this type of decorator in some debugging situations, it allows overriding class properties by decorating, without having to find the calling function.

class myclass(object):
    def __init__(self):
        self.property = "HELLO"

    @adecorator(property="GOODBYE")
    def method(self):
        print self.property

Here is the decorator code

class adecorator (object):
    def __init__ (self, *args, **kwargs):
        # store arguments passed to the decorator
        self.args = args
        self.kwargs = kwargs

    def __call__(self, func):
        def newf(*args, **kwargs):

            #the 'self' for a method function is passed as args[0]
            slf = args[0]

            # replace and store the attributes
            saved = {}
            for k,v in self.kwargs.items():
                if hasattr(slf, k):
                    saved[k] = getattr(slf,k)
                    setattr(slf, k, v)

            # call the method
            ret = func(*args, **kwargs)

            #put things back
            for k,v in saved.items():
                setattr(slf, k, v)

            return ret
        newf.__doc__ = func.__doc__
        return newf

Note: because I've used a class decorator you'll need to use @adecorator() with the brackets on to decorate functions, even if you don't pass any arguments to the decorator class constructor.

User · Answer

Here s an expansion on Michael Speer s answer to take it a few steps further   An instance method decorator which takes arguments and acts on a function with arguments and a return value   class Test object        Prints if x    y  Throws an error otherwise       def   init   self  x           self x   x      def  outer decorator y           def  decorator foo               def magic self   args    kwargs                    print  start magic                   if self x    y                      return foo self   args    kwargs                  else                      raise ValueError  x         y       format self x  y                   print  end magic               return magic          return  decorator        outer decorator y 3      def bar self   args    kwargs            print  normal call           print  args      format args           print  kwargs      format kwargs            return 27   And then  In  2        test   Test 3      test bar          13           Test           q 9          lollipop  1 2 3                  start magic     normal call     args   13   Test       kwargs    q   9   lollipop    1  2  3   Out 2       27 In  3        test   Test 4      test bar          13           Test           q 9          lollipop  1 2 3                  start magic     ---------------------------------------------------------------------------     ValueError                                Traceback  most recent call last       lt ipython-input-3-576146b3d37e gt  in  lt module gt              4      Test             5     q 9      ---- gt  6     lollipop  1 2 3            7         lt ipython-input-1-428f22ac6c9b gt  in magic self   args    kwargs           11                     return foo self   args    kwargs           12                 else      --- gt  13                     raise ValueError  x         y       format self x  y            14                 print  end magic            15             return magic      ValueError  x  4     y  3

User · Answer

You can decorate the decorator   import decorator  class Test object        decorator decorator     def  decorator foo  self           foo self         decorator     def bar self           pass

User · Answer

import functools   class Example       def wrapper func            functools wraps func          def wrap self   args    kwargs               print  inside wrap               return func self   args    kwargs          return wrap       wrapper     def method self           print  METHOD        wrapper   staticmethod wrapper    e   Example   e method

User · Answer

Would something like this do what you need   class Test object       def  decorator foo           def magic  self                 print  start magic              foo  self               print  end magic          return magic        decorator     def bar  self             print  normal call   test   Test    test bar     This avoids the call to self to access the decorator and leaves it hidden in the class namespace as a regular method    gt  gt  gt  import stackoverflow  gt  gt  gt  test   stackoverflow Test    gt  gt  gt  test bar   start magic normal call end magic  gt  gt  gt       edited to answer question in comments   How to use the hidden decorator in another class  class Test object       def  decorator foo           def magic  self                 print  start magic              foo  self               print  end magic          return magic        decorator     def bar  self             print  normal call        decorator   staticmethod   decorator    class TestB  Test         Test  decorator     def bar  self            print  override bar in          super  TestB  self   bar           print  override bar out   print  Normal   test   Test   test bar   print  print  Inherited   b   TestB   b bar   print   Output   Normal  start magic normal call end magic  Inherited  start magic override bar in start magic normal call end magic override bar out end magic

User · Answer

This is one way to access and have used  self from inside a decorator defined inside the same class   class Thing object       def   init   self  name           self name   name      def debug name function           def debug wrapper  args               self   args 0              print  self name       self name             print  running function       format function   name                function  args              print  self name       self name         return debug wrapper       debug name     def set name self  new name           self name   new name   Output  tested on Python 2 7 10     gt  gt  gt  a   Thing  A    gt  gt  gt  a name  A   gt  gt  gt  a set name  B   self name   A running function set name   self name   B  gt  gt  gt  a name  B    The example above is silly  but it works

User · Answer

I found this question while researching a very similar problem  My solution is to split the problem into two parts   First  you need to capture the data that you want to associate with the class methods   In this case  handler for will associate a Unix command with handler for that command s output   class OutputAnalysis object        analyze the output of diagnostic commands      def handler for name            decorator to associate a function with a command          def wrapper func               func handler for   name             return func         return wrapper       associate mount p with  mount -p txt       handler for  mount -p       def mount p self  slurped           pass   Now that we ve associated some data with each class method  we need to gather that data and store it in a class attribute   OutputAnalysis cmd handler      for value in OutputAnalysis   dict   itervalues        try          OutputAnalysis cmd handler value handler for    value     except AttributeError          pass

User · Answer

Declare in inner class  This solution is pretty solid and recommended   class Test object       class Decorators object        staticmethod     def decorator foo           def magic self   args    kwargs                print  start magic               foo self   args    kwargs              print  end magic           return magic       Decorators decorator     def bar  self             print  normal call    test   Test    test bar     The result    gt  gt  gt  test   Test    gt  gt  gt  test bar   start magic normal call end magic  gt  gt  gt

User · Answer

Decorators seem better suited to modify the functionality of an entire object  including function objects  versus the functionality of an object method which in general will depend on instance attributes   For example    def mod bar cls         returns modified class      def decorate fcn             returns decorated function          def new fcn self               print self start str             print fcn self              print self end str          return new fcn      cls bar   decorate cls bar      return cls   mod bar class Test object       def   init   self           self start str    starting dec          self end str    ending dec        def bar self           return  bar    The output is     gt  gt  gt  import Test  gt  gt  gt  a   Test    gt  gt  gt  a bar   starting dec bar ending dec

User · Answer

What you re wanting to do isn t possible  Take  for instance  whether or not the code below looks valid   class Test object        def  decorator self  foo           foo        def bar self           pass     bar   self  decorator bar    It  of course  isn t valid since self isn t defined at that point  The same goes for Test as it won t be defined until the class itself is defined  which its in the process of   I m showing you this code snippet because this is what your decorator snippet transforms into   So  as you can see  accessing the instance in a decorator like that isn t really possible since decorators are applied during the definition of whatever function method they are attached to and not during instantiation   If you need class-level access  try this   class Test object         classmethod     def  decorator cls  foo           foo        def bar self           pass Test bar   Test  decorator Test bar

User · Answer

I have a Implementation of Decorators that Might Help       import functools     import datetime       class Decorator object            def   init   self               pass           def execution time func                 functools wraps func              def wrap self   args    kwargs                        Wrapper Function                      start   datetime datetime now                   Tem   func self   args    kwargs                  end   datetime datetime now                   print  Exection Time     format end-start                   return Tem              return wrap       class Test Decorator            def   init   self               self  MethodName   Test funca   name             Decorator execution time         def funca self               print  Running Function       format self  MethodName               return True       if   name         main             obj   Test           data   obj funca           print data

User · Answer

The simple way to do it  All you need is to put the decorator method outside the class  You can still use it inside  def my decorator func        this is the key line  There s the aditional self parameter     def wrap self   params    kwargs             you can use self here as if you were inside the class         return func       return wrap  class Test object        my decorator     def bar self           pass

[python] Python decorators in classes

Examples related to python

Examples related to class

Examples related to decorator

Examples related to self