automatic delegation

[Hallvard B Furuseth]

Is it possible to write a metaclass or something so that
with a class definition not much larger than this:

class foo:
def __init__(self, val): self.val = val

operations on a foo instance f will be applied to f.val?
E.g. str(f) -> f.__str__() -> f.val.__str__().

--
Hallvard

[Ville Vainio]

>>>>> "h.b.furuseth" == Hallvard B Furuseth <h.**********@usit.uio.no> writes:

h.b.furuseth> Is it possible to write a metaclass or something so that
h.b.furuseth> with a class definition not much larger than this:

h.b.furuseth> class foo:
h.b.furuseth> def __init__(self, val): self.val = val

h.b.furuseth> operations on a foo instance f will be applied to f.val?
h.b.furuseth> E.g. str(f) -> f.__str__() -> f.val.__str__().

http://aspn.activestate.com/ASPN/Coo...n/Recipe/52295

--
Ville Vainio http://tinyurl.com/2prnb

[Peter Otten]

Hallvard B Furuseth wrote:

Is it possible to write a metaclass or something so that
with a class definition not much larger than this:

class foo:
def __init__(self, val): self.val = val

operations on a foo instance f will be applied to f.val?
E.g. str(f) -> f.__str__() -> f.val.__str__().

I tried in vain to solve your problem while improving my understanding of
metaclasses. I have made an observation that might interest you, though:
str(foo()) and foo.__str__(foo()) are not the same:

class Type(type): .... def __getattribute__(self, name):
.... def tostr(self):
.... return "so what"
.... return tostr
.... class C: .... __metaclass__ = Type
.... print str(C()) <__main__.C object at 0x40296a8c> print C.__str__(C()) so what

Care to explain, anyone?

Peter

[Yermat]

Hallvard B Furuseth wrote:

Is it possible to write a metaclass or something so that
with a class definition not much larger than this:

class foo:
def __init__(self, val): self.val = val

operations on a foo instance f will be applied to f.val?
E.g. str(f) -> f.__str__() -> f.val.__str__().

Here a simple example :

class proxy(object):
def __init__(self, obj):
self.obj = obj

def __getattr__(self, key):
if key in self.__dict__:
return self.__dict__[key]
else:
return getattr(self.obj, key)

You can also look at:
http://www.python.org/cgi-bin/moinmoin/ProxyProgramming

--
Yermat

[Hallvard B Furuseth]

Yermat wrote:

Hallvard B Furuseth wrote:

Is it possible to write a metaclass or something so that
with a class definition not much larger than this:

class foo:
def __init__(self, val): self.val = val

operations on a foo instance f will be applied to f.val?
E.g. str(f) -> f.__str__() -> f.val.__str__().
Here a simple example :

class proxy(object):
def __init__(self, obj):
self.obj = obj

def __getattr__(self, key):
if key in self.__dict__:
return self.__dict__[key]
else:
return getattr(self.obj, key)

I tried __getattr__ before I posted, but it doesn't work:

int(proxy(5)) Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: int() argument must be a string or a number

However, the example in the Cookbook works. Thanks, Ville.
Turns out the above example also works if one one removes 'object'
and makes it and old-style class:
int(proxy(5)) 5 str(proxy(5))

'5'

Seems that with new-style classes, __getattr__ only works for instance
variables, while for old-style classes, it also works for class
variables like __int__ and __str__. But I can't see anything in the
documentation which says so?
You can also look at:
http://www.python.org/cgi-bin/moinmoin/ProxyProgramming

That example doesn't work at all. The initialization of self._subject
in __init__() breaks because of the definition of __setattr__.

--
Hallvard