allen.fowler a écrit :
(snip)
In this case, and I am trying to create a number of ORM-like objects.
(Though, there is no database involved.)
So, instances of these classes are acting as records that are shuttled
around in the system, and the object's properties are acting as
values. The parameters are (mostly) orthogonal, but do need defaults,
and some must be required.
You could specify the names, defaults and validations required at an
upper level then automate the whole thing, ie (thinking out loud):
class Field(object):
def __init__(self, name,required=False,
default=None,target=None,validate=None):
self._name = name
self._required = required
self._default = default
self._target = target or name
self._validate = validate or lambda x: x
def validate(self, value):
""" _validate is supposed to raise a ValueError if not ok.
it can also do any required conversion, formatting etc
"""
return self._validate(value)
def set(self, instance, **kw):
value = kw.get(self._name, None)
if value is None
if self.required:
raise ValueError("argument %s is required" % self._name)
else:
value = self._default
value = self.validate(value)
setattr(instance, self._target, value)
class Record(object):
def __init__(self, **kw):
if not hasattr(self, "_fields"):
raise AttributeError("Record subclasses must define _fields")
for field in self._fields:
field.set(self, **kw)
class Foo(Record):
_fields = (
Field("bar", True, validate=lambda v : v > 1),
Field("baaz", default=42)
)
NB : totally untested code, so it will of course contains at least one
major and obvious bug / typo / whatever !-)
You could go further using an even more declarative API based on a fancy
custom metaclass and descriptors (for Fields) etc etc - and that even
might be the RightThing(tm) to do if you have more than moderatly
complex needs, but for simple cases the above should work fine without
going over the top with black magic.
HTH
--
http://mail.python.org/mailman/listinfo/python-list
