Why property works only for objects?

[Michal Kwiatkowski]

Hi,

Code below shows that property() works only if you use it within a class.

------------------------------------------------
class A(object):
pass

a = A()
a.y = 7

def method_get(self ):
return self.y

a.x = property(method _get)
print a.x # => <property object at 0xb7dc1c84>

A.x = property(method _get)
print a.x # => 7
------------------------------------------------

Is there any method of making descriptors on per-object basis? I would
like to customize x access in different objects of class A. Is this
possible and how?

mk
--
. o . >> http://joker.linuxstuff.pl <<
. . o It's easier to get forgiveness for being wrong
o o o than forgiveness for being right.

[Steven Bethard]

Michal Kwiatkowski wrote:

Code below shows that property() works only if you use it within a class.
Yes, descriptors are only applied at the class level (that is, only
class objects call the __get__ methods).
Is there any method of making descriptors on per-object basis?

I'm still not convinced that you actually want to, but you can write
your own descriptor to dispatch to the instance object (instead of the
type):

class InstancePropert y(object): .... def __init__(self, func_name):
.... self.func_name = func_name
.... def __get__(self, obj, type=None):
.... if obj is None:
.... return self
.... return getattr(obj, self.func_name) (obj)
.... class C(object): .... x = InstancePropert y('_x')
.... c = C()
c.x Traceback (most recent call last):
File "<interacti ve input>", line 1, in ?
File "<interacti ve input>", line 7, in __get__
AttributeError: 'C' object has no attribute '_x' def getx(self): .... return 42
.... c._x = getx
c.x

42
STeVe

[Michal Kwiatkowski]

Steven Bethard napisa³(a):

Is there any method of making descriptors on per-object basis?

I'm still not convinced that you actually want to, but you can write
your own descriptor to dispatch to the instance object (instead of the
type):

Ok, this works for attributes I know a name of at class definition. What
about other situations? I could possibly want to have different sets of
attributes for instances of a class. Is it still possible to do? I don't
also like current solution, as it wraps things around, creating another
attribute ('_x') in the process. Aren't there any cleaner solutions?

The problem is I have an instance of a given class (say BaseClass) and I
want it to implement some attribute accesses as method calls. I'm not a
creator of this object, so changing definition of BaseClass or
subclassing it is not an option. Code below doesn't work, but shows my
intention:

# obj is instance of BaseClass
def get_x(self):
# ...
def set_x(self, value):
# ...
obj.x = property(get_x, set_x)

Changing __setattr__/__getattr__ of an object also doesn't work for the
same reason: dictionary lookup is made only in class attributes,
ommiting object attributes. It's confusing, because writting obj.x and
obj.__getattrib ute__('x') gives a different results. There also seems
not to be any clear way to define methods for objects. Something like:

class C(object):
pass

def method(self):
return self.x

c = c.x
c.method = method
c.method() # => AttributeError

So another question arise. Is it possible to make function a method (so
it will receive calling object as first argument)?

mk
--
. o . >> http://joker.linuxstuff.pl <<
. . o It's easier to get forgiveness for being wrong
o o o than forgiveness for being right.

[Alex Martelli]

Michal Kwiatkowski <ru**@no.spam > wrote:
...

The problem is I have an instance of a given class (say BaseClass) and I
want it to implement some attribute accesses as method calls. I'm not a
creator of this object, so changing definition of BaseClass or
subclassing it is not an option.
Wrong! Of _course_ it's an option -- why do you think it matters at all
whether you're the creator of this object?!
Code below doesn't work, but shows my
intention:

# obj is instance of BaseClass
def get_x(self):
# ...
def set_x(self, value):
# ...
obj.x = property(get_x, set_x)

def insert_property (obj, name, getter, setter):
class sub(obj.__class __): pass
setattr(sub, name, property(getter , setter))
obj.__class__ = sub

See? Of COURSE you can subclass -- not hard at all, really.
Alex

[Alex Martelli]

Michal Kwiatkowski <ru**@no.spam > wrote:

So another question arise. Is it possible to make function a method (so
it will receive calling object as first argument)?

Sure, impor types then call types.MethodTyp e:

f = types.MethodTyp e(f, obj, someclass)

(f.__get__ is also fine for Python-coded functions) -- make sure that
someclass is obj's class or some ancestor of it, of course.
Alex

[Michal Kwiatkowski]

Alex Martelli napisa³(a):

Wrong! Of _course_ it's an option -- why do you think it matters at all
whether you're the creator of this object?!

Statically typed languages background. Sorry. ;)

Code below doesn't work, but shows my
intention:

# obj is instance of BaseClass
def get_x(self):
# ...
def set_x(self, value):
# ...
obj.x = property(get_x, set_x)

def insert_property (obj, name, getter, setter):
class sub(obj.__class __): pass
setattr(sub, name, property(getter , setter))
obj.__class__ = sub

See? Of COURSE you can subclass -- not hard at all, really.

Let me understand it clearly. If I change __class__ of an object,
existing attributes (so methods as well) of an object are still
accessible the same way and don't change its values. Only resolution of
attributes/methods not found in object is changed, as it uses new
version of __class__ to lookup names. Is this right?

mk
--
. o . >> http://joker.linuxstuff.pl <<
. . o It's easier to get forgiveness for being wrong
o o o than forgiveness for being right.

[Michal Kwiatkowski]

Alex Martelli napisa³(a):

So another question arise. Is it possible to make function a method (so
it will receive calling object as first argument)?

Sure, impor types then call types.MethodTyp e:

f = types.MethodTyp e(f, obj, someclass)

(f.__get__ is also fine for Python-coded functions) -- make sure that
someclass is obj's class or some ancestor of it, of course.

I wasn't aware of types module. Thanks for your reply.

mk
--
. o . >> http://joker.linuxstuff.pl <<
. . o It's easier to get forgiveness for being wrong
o o o than forgiveness for being right.

[Bruno Desthuilliers]

Michal Kwiatkowski a écrit :

Steven Bethard napisa³(a):

Is there any method of making descriptors on per-object basis?
I'm still not convinced that you actually want to, but you can write
your own descriptor to dispatch to the instance object (instead of the
type):

Ok, this works for attributes I know a name of at class definition. What
about other situations? I could possibly want to have different sets of
attributes for instances of a class.

Then you want a different class for each different set of attributes.
Is it still possible to do? I don't
also like current solution, as it wraps things around, creating another
attribute ('_x') in the process. Aren't there any cleaner solutions?

The problem is I have an instance of a given class (say BaseClass) and I
want it to implement some attribute accesses as method calls. I'm not a
creator of this object, so changing definition of BaseClass or
subclassing it is not an option.
What you want is delegation. Which is pretty easy with Python, look at
__getattr__ and __setattr__.
Code below doesn't work, but shows my
intention:

# obj is instance of BaseClass
def get_x(self):
# ...
def set_x(self, value):
# ...
obj.x = property(get_x, set_x)
class ObjWrapper(obje ct):
def __init__(self, obj):
self.obj = obj

# special case x
def _get_x(self):
return self.obj.x

def _set_x(self, value):
self.obj.x = value

x = property(fget=_ get_x, fset=_set_x)

# default lookup, directly delegate to obj
def __getattr__(sel f, name):
return getattr(self.ob j, name)

def __setattr__(sel f, name, value):
# this one is a bit more tricky
# and I don't remember it right now,
# but it's in the fine manual anyway

obj = ObjWrapper(obj)
obj.x # calls ObjWrapper._get _x()

Changing __setattr__/__getattr__ of an object also doesn't work for the
same reason: dictionary lookup is made only in class attributes,
ommiting object attributes. It's confusing, because writting obj.x and
obj.__getattrib ute__('x') gives a different results. There also seems
not to be any clear way to define methods for objects. Something like:

class C(object):
pass

def method(self):
return self.x

c = c.x
c.method = method
c.method() # => AttributeError
import types
c.method = types.MethodTyp e(method, c, c.__class__)
So another question arise. Is it possible to make function a method (so
it will receive calling object as first argument)?

Yeps, just wrap it in a Method object (cf above)

[Bruno Desthuilliers]

Michal Kwiatkowski a écrit :

Alex Martelli napisa³(a):

Wrong! Of _course_ it's an option -- why do you think it matters at all
whether you're the creator of this object?!

(snip)

def insert_property (obj, name, getter, setter):
class sub(obj.__class __): pass
setattr(sub, name, property(getter , setter))
obj.__class__ = sub

See? Of COURSE you can subclass -- not hard at all, really.

Let me understand it clearly. If I change __class__ of an object,
existing attributes (so methods as well)
of an object are still
accessible the same way and don't change its values. Only resolution of
attributes/methods not found in object is changed, as it uses new
version of __class__ to lookup names. Is this right?

Attributes, yes. Not methods. Methods are looked up in the class. But in
the example above (brillant, as usual), Alex dynamically creates a
subclass of obj.__class__, so inheritence takes care of methods lookup.

mk

[Michal Kwiatkowski]

Bruno Desthuilliers napisa³(a):

Let me understand it clearly. If I change __class__ of an object,
existing attributes (so methods as well) of an object are still
accessible the same way and don't change its values. Only resolution of
attributes/methods not found in object is changed, as it uses new
version of __class__ to lookup names. Is this right?

Attributes, yes. Not methods. Methods are looked up in the class.

My experience shows exactly the opposite. Any attribute/method you try
to access is first looked up in object dictionary, then inside class
definition.

import types

class C(object):
def f(self):
print "old method f()"

obj = C()

def f(self):
print "new method f()"

obj.f = types.MethodTyp e(f, C)

obj.f() # => "new method f()"

Since that works, intuitively for me would be to assign object's
descriptors like that:

obj.x = property(types. MethodType(lamb da self: 42, C))

But I just get a property object. So, it seems descriptors have little
bit of magic, as they don't work identically for classes and objects.

The same goes for special methods and attributes (written as __*__). So
I cannot change __getattr__/__setattr__/__metaclass__ or any other
attribute that starts with __ for a single object. It's not so bad
except for situations were class of an object defines its own
__getattribute_ _ method, which takes control of an object from us. To
get/set any attribute of an object we must use object type methods:

class C(object):
def __getattribute_ _(self, name):
return 42

obj = C()

obj.a = 5

print obj.a # => 42
print object.__getatt ribute__(obj, 'a') # => 5

I gets even more strange when you try to modify, say __len__ or
__repr__. Docstring for object.__repr__ says:
"x.__repr__ () <==> repr(x)" which doesn't seem to be always true:

class C(object):
def __repr__(self):
return "class repr"

obj = C()
obj.__repr__ = types.MethodTyp e(lambda self: "instance repr", C)

print repr(obj) # => class repr
print obj.__repr__() # => instance repr

Maybe the manual should say "x.__class__.__ repr__() <==> repr(x)" instead?

I'm trying to understand attributes lookups made by Python, having
properties and special methods in mind. So far I've come up with kind of
reasoning I've coded below. I would appreciate any comments and
suggestions.

def lookup_name(obj , name):
get = lambda obj, name: object.__getatt ribute__(obj, name)
has = lambda obj, name: name in get(obj, '__dict__')

# assume C is a new style class
C = get(obj, '__class__')

# 1) use class' __getattribute_ _ method
try:
if has(C, '__getattribute __'):
return get(C, '__getattribute __')(obj, name)
except AttributeError: pass

# 2) lookup in object's dictionary
try:
if has(obj, name):
return get(obj, name)
except AttributeError: pass

# 3) lookup in classes
for c in obj.__class__.m ro():
try:
if has(c, name):
desc = get(c, name)
# 3a) handle descriptors
try:
return get(desc, '__get__')(obj)
except: pass
# 3b) no descriptors -> use value
return desc
except AttributeError: pass

raise AttributeError, "Not found!"

mk
--
. o . >> http://joker.linuxstuff.pl <<
. . o It's easier to get forgiveness for being wrong
o o o than forgiveness for being right.