Decorating class member functions

[Andy Terrel]

Okay does anyone know how to decorate class member functions?

The following code gives me an error:

Traceback (most recent call last):
File "decorators2.py ", line 33, in <module>
s.update()
File "decorators2.py ", line 13, in __call__
retval = self.fn.__call_ _(*args,**kws)
TypeError: update() takes exactly 1 argument (0 given)

------------------
#! /usr/bin/env python

class Bugger (object):
def __init__ (self, module, fn):
self.module = module
self.fn = fn

def __call__ (self,*args, **kws):
ret_val = self.fn(*args,* *kws)
return ret_val

def instrument (module_name):
ret_val = lambda x: Bugger(module_n ame, x)
return ret_val

class Stupid:
def __init__(self):
self.val = 1

@instrument("xp d.spam")
def update(self):
self.val += 1
s = Stupid()
s.update()

[Andy Terrel]

Oh I should mention the decorator needs to have some notion of state
(such as with the above class)

[Virgil Dupras]

On May 3, 9:21 pm, Andy Terrel <andy.ter...@gm ail.comwrote:

Okay does anyone know how to decorate class member functions?

The following code gives me an error:

Traceback (most recent call last):
File "decorators2.py ", line 33, in <module>
s.update()
File "decorators2.py ", line 13, in __call__
retval = self.fn.__call_ _(*args,**kws)
TypeError: update() takes exactly 1 argument (0 given)

------------------

#! /usr/bin/env python

class Bugger (object):
def __init__ (self, module, fn):
self.module = module
self.fn = fn

def __call__ (self,*args, **kws):
ret_val = self.fn(*args,* *kws)
return ret_val

def instrument (module_name):
ret_val = lambda x: Bugger(module_n ame, x)
return ret_val

class Stupid:
def __init__(self):
self.val = 1

@instrument("xp d.spam")
def update(self):
self.val += 1

s = Stupid()
s.update()

A decorator is a function that takes one single parameter: a function.
"instrument " must return a decorator.

[Virgil Dupras]

On May 3, 9:33 pm, Virgil Dupras <hardcoded.soft [e-mail] rote:

On May 3, 9:21 pm, Andy Terrel <andy.ter...@gm ail.comwrote:

Okay does anyone know how to decorate class member functions?

The following code gives me an error:

Traceback (most recent call last):
File "decorators2.py ", line 33, in <module>
s.update()
File "decorators2.py ", line 13, in __call__
retval = self.fn.__call_ _(*args,**kws)
TypeError: update() takes exactly 1 argument (0 given)

------------------

#! /usr/bin/env python

class Bugger (object):
def __init__ (self, module, fn):
self.module = module
self.fn = fn

def __call__ (self,*args, **kws):
ret_val = self.fn(*args,* *kws)
return ret_val

def instrument (module_name):
ret_val = lambda x: Bugger(module_n ame, x)
return ret_val

class Stupid:
def __init__(self):
self.val = 1

@instrument("xp d.spam")
def update(self):
self.val += 1

s = Stupid()
s.update()

A decorator is a function that takes one single parameter: a function.
"instrument " must return a decorator.

Oh wait, I just embarrassed myself. Nevermind my last post.

[Virgil Dupras]

On May 3, 9:21 pm, Andy Terrel <andy.ter...@gm ail.comwrote:

Okay does anyone know how to decorate class member functions?

The following code gives me an error:

Traceback (most recent call last):
File "decorators2.py ", line 33, in <module>
s.update()
File "decorators2.py ", line 13, in __call__
retval = self.fn.__call_ _(*args,**kws)
TypeError: update() takes exactly 1 argument (0 given)

------------------

#! /usr/bin/env python

class Bugger (object):
def __init__ (self, module, fn):
self.module = module
self.fn = fn

def __call__ (self,*args, **kws):
ret_val = self.fn(*args,* *kws)
return ret_val

def instrument (module_name):
ret_val = lambda x: Bugger(module_n ame, x)
return ret_val

class Stupid:
def __init__(self):
self.val = 1

@instrument("xp d.spam")
def update(self):
self.val += 1

s = Stupid()
s.update()

Second attempt. After some fuss around, I think it's just not possible
to have a class instance as a decorator. the self gets lost in
translation.

#! /usr/bin/env python
class Caller(object):
def __init__ (self, fn):
self.fn = fn

def __call__(self, *args, **kwargs):
print 'Caller calling!', repr(args)
return self.fn(*args, **kwargs)

def mydecorator(f):
return Caller(f)

class Stupid:
def __init__(self):
self.val = 1

@mydecorator
def update(self):
self.val += 1

s = Stupid()
s.update()

Caller calling! ()
Traceback (most recent call last):
File "/Users/hsoft/Desktop/foo.py", line 22, in ?
s.update()
File "/Users/hsoft/Desktop/foo.py", line 8, in __call__
return self.fn(*args, **kwargs)
TypeError: update() takes exactly 1 argument (0 given)

But why do you want to use a class? If you want to have a decorator
with argument, you only need to have something like:

def instrument(modu le):
def decorator(f):
def wrapper(*args, **kwargs):
print module
return f(*args, **kwargs)
return wrapper
return decorator

[Andy Terrel]

I just need to keep the state around. I make a call to some function
that is pretty expensive so I want to save it as a member during the
__init__ of the decorator.

Yeah I'm afraid it can't be done either, that's why I asked the group.

[Jorge Godoy]

Andy Terrel <an*********@gm ail.comwrites:

I just need to keep the state around. I make a call to some function
that is pretty expensive so I want to save it as a member during the
__init__ of the decorator.

Yeah I'm afraid it can't be done either, that's why I asked the group.

Have you looked at memoize decorators? They seem to do what you want.
There are examples at the Python website (some link in there, I'm
sorry...).

This will give you lots of resources, including full recipes and
comments from the Python cookbook:
http://www.google.com.br/search?q=py...orator+memoize
--
Jorge Godoy <jg****@gmail.c om>

[Andy Terrel]

not quite as elegant but here is a workaround... Thanks Virgil for
taking some time to think about it.

---

class Bugger (object):
def __init__ (self, module):
print "Entering __init__"
self.module = module
self.verb = 0

def instrument (module_name):
def wrapper(f):
def _wrap(*args,**k ws):
ret_val = f(*args,**kws)
return ret_val
return _wrap
b = Bugger(module_n ame)
if b.verb == 0:
ret_val = wrapper
else:
ret_val = lambda x:x
return ret_val

class Stupid:
def __init__(self):
self.val = 1

@instrument("sp am")
def update(self):
self.val += 1
s = Stupid()
s.update()
s.update()
s.update()
s.update()
print s.val

[Steven D'Aprano]

On Thu, 03 May 2007 19:28:52 -0700, Andy Terrel wrote:

I just need to keep the state around. I make a call to some function
that is pretty expensive so I want to save it as a member during the
__init__ of the decorator.

Yeah I'm afraid it can't be done either, that's why I asked the group.

You can do it if you give up on using the decorator syntax.

(Now that I've said that, some clever bunny will show me how to do it.)

def make_decorator( n):
def addspam(fn):
def new(*args):
print "spam " * n
return fn(*args)
return new
return addspam
class Parrot(object):
def __init__(self, count=3):
from new import instancemethod as im
self.describe = im(make_decorat or(count)(self. __class__.descr ibe), self)
def describe(self):
return "It has beautiful plummage."

>>bird = Parrot()
bird.describe ()

spam spam spam
'It has beautiful plummage.'

>>>

bird = Parrot(5)
bird.describe ()

spam spam spam spam spam
'It has beautiful plummage.'

--
Steven D'Aprano

[Peter Otten]

Andy Terrel wrote:

Okay does anyone know how to decorate class member functions?

The following code gives me an error:

Traceback (most recent call last):
File "decorators2.py ", line 33, in <module>
s.update()
File "decorators2.py ", line 13, in __call__
retval = self.fn.__call_ _(*args,**kws)
TypeError: update() takes exactly 1 argument (0 given)

------------------
#! /usr/bin/env python

class Bugger (object):
def __init__ (self, module, fn):
self.module = module
self.fn = fn

def __call__ (self,*args, **kws):
ret_val = self.fn(*args,* *kws)
return ret_val

def instrument (module_name):
ret_val = lambda x: Bugger(module_n ame, x)
return ret_val

class Stupid:
def __init__(self):
self.val = 1

@instrument("xp d.spam")
def update(self):
self.val += 1
s = Stupid()
s.update()

The problem is not that you are decorating a method but that you are trying
to use a callable class instance as a method. For that to work the class
has to implement the descriptor protocol, see

http://users.rcn.com/python/download/Descriptor.htm

class Bugger (object):
def __init__ (self, module, fn, instance=None):
self.module = module
self.fn = fn
self.instance = instance

def __call__ (self, *args, **kws):
print "calling %s.%s()" % (self.module, self.fn.__name_ _)
if self.instance is not None:
args = (self.instance, ) + args
ret_val = self.fn(*args, **kws)
return ret_val

def __get__(self, instance, class_):
if instance is None:
return self
return Bugger(self.mod ule, self.fn, instance)

def instrument (module_name):
ret_val = lambda x: Bugger(module_n ame, x)
return ret_val

class Stupid(object):
@instrument("xp d.spam")
def update(self):
print "update()"

s = Stupid()
s.update()
Stupid.update(s )

Peter