Malcolm Tredinnick wrote:
> On Sat, 2006-05-13 at 01:33 +0000, George Sakkis wrote:
> > Is there a way to combine python properties with Django fields so that
> > one can essentially use both regular (persistent) and callable fields
> > transparently ? If the previous sentence didn't make any sense, here's
> > a simplest example:
> >
> > from django.db.models import Model, IntegerField
> >
> > class Foo(Model):
> > number = IntegerField()
> > square = property(lambda self: self.number ** 2)
> >
> > x = Foo(number=3)
> > # attribute access works transparently:
> > print x.number, x.square
> > # still you can't do something "for every field" and have square
> > # included
> > for field in Foo._meta.fields:
> > print "%s: %s" % (field.name, getattr(x,field.name)
>
>
> Short answer: no, but easy to simulate.
>
> The behaviour you are seeing is really because the persistent fields are
> "faked" in some sense (by being hidden and managed in _meta), rather
> than because properties are behaving unnaturally. Extracting all
> properties from a class is not amazingly common in Python (unless you
> are writing meta-code that requires introspection), so there is no
> built-in one-stop function. But you could define a function like:
>
> def get_properties(obj):
> for name, value in obj.__class__.__dict__.items():
> if type(value) == type(property()):
> yield name
>
> and then "for p in get_properties(x): ..." loops over the properties. I
> made it return an iterator, you might want a list returned or whatever.
> But that is incidental to the problem.
>
> Regards,
> Malcolm
Nice, but still
1) not all properties should necessarily be considered fields (minor
point), and
2) it isn't transparent; you'd have to say something like
for name in itertools.chain([f.name for f in model._meta.fields],
get_properties(model)):
print name, getattr(obj,name)
After digging a little into Django's guts, I came up with a simple
field that is also a property:
from django.db.models import Field
class PropertyField(Field,property):
def __init__(self, func, **kwds):
Field.__init__(self,**kwds)
# allow but ignore attribute setting
property.__init__(self, fget=func, fset=lambda s,val:None)
def contribute_to_class(self, cls, name):
Field.contribute_to_class(self,cls,name)
# add self in the class; properties don't work per instance
setattr(cls, self.attname, self)
# example
from django.db.models import Model, IntegerField
class Foo(Model):
number = IntegerField()
square = PropertyField(lambda self: self.number**2)
>>> x = models.Foo(number=3)
>>> print x.number, x.square
3 9
>>> print dict((f.attname, getattr(x,f.attname)) for f in
>>> models.Foo._meta.fields)
{'square': 9, 'id': None, 'number': 3}
Of course this needs more work to be really usable (e.g. letting the
backend know that it should not try to store it) but it seems it may be
doable. Is it worth to be considered for future addition ?
George
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"Django users" group.
To post to this group, send email to django-users@googlegroups.com
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at
http://groups.google.com/group/django-users
-~----------~----~----~----~------~----~------~--~---
