def __configure__(self, model_class, name):
super(IRelation, self).__configure__(model_class, name)
ref = self._reference
if isinstance(ref, basestring) and ':' not in ref:
self._reference = ref = '%s:%s' % (model_class._meta.package, ref)
try:
ref = pool.get_model(ref)
except:
pool.model_pending.setdefault(ref, []).append(self)
else:
self.prepare(model_class)
def __configure__(self, model_class, name):
super(IRelation, self).__configure__(model_class, name)
ref = self._reference
if isinstance(ref, basestring) and ':' not in ref:
self._reference = ref = '%s:%s' % (model_class._meta.package, ref)
try:
ref = pool.get_model(ref)
except:
pool.model_pending.setdefault(ref, []).append(self)
else:
self.prepare(model_class)
def __new__(cls, name, bases, attrs):
super_new = super(ModelType, cls).__new__
parents = [b for b in bases if isinstance(b, ModelType)]
if not parents:
# This is not a subclass of Model so do nothing
return super_new(cls, name, bases, attrs)
if len(parents) > 1:
raise TypeError(_('Multiple inheritance is not supported.'))
check_reserved_names(attrs)
# always use the last defined base class in the inheritance chain
# to maintain linear hierarchy.
meta = getattr(parents[0], '_meta', None) or Options()
try:
parent = pool.get_model(meta.name) if meta.name else None
except KeyError:
parent = None
if meta.package is None:
try:
meta.package = pool.get_package(attrs['__module__']).package.name
except:
meta.package = ''
if parent:
bases = list(bases)
for i, base in enumerate(bases):
if isinstance(base, ModelType):
bases[i] = parent
bases = tuple(bases)
cls = super_new(cls, name, bases, {
'_meta': meta,
'__module__': attrs.pop('__module__')})
# update meta information
unique = attrs.pop('__unique__', [])
if meta.name is None:
meta_name = name.lower()
if meta.package:
meta_name = '%s:%s' % (meta.package, meta_name)
meta.name = meta_name
meta.table = meta_name.replace(':', '_')
# create primary key field if it is root model
if not parent:
cls.add_field(AutoKey())
# overwrite model class in the pool
pool.register_model(cls)
cls._values = None
# sort fields and set attributes to class
attributes = attrs.items()
attributes.sort(lambda a, b: cmp(
getattr(a[1], '_serial', 0), getattr(b[1], '_serial', 0)))
for name, attr in attributes:
if isinstance(attr, Field):
cls.add_field(attr, name)
if attr.is_unique:
unique.append([attr])
else:
setattr(cls, name, attr)
# prepare validators
for name, attr in attributes:
if name.startswith('validate_') and isinstance(attr, types.FunctionType):
field = getattr(cls, name[9:], None)
if isinstance(field, Field):
field._validator = getattr(cls, name) # use bound method
# prepare unique constraints
for item in unique:
item = list(item) if isinstance(item, (list, tuple)) else [item]
for i, field in enumerate(item):
if isinstance(field, basestring):
try:
item[i] = field = getattr(cls, field)
except:
raise AttributeError(
_('No such field %(name)s.', field))
assert isinstance(field, Field), 'expected a field'
meta.unique.append(item)
return cls
def __new__(cls, **kw):
if cls is Model:
raise TypeError(_("You can't create instance of Model class"))
klass = pool.get_model(cls)
return super(Model, cls).__new__(klass)
def reference(self):
"""Returns the reference class.
"""
return pool.get_model(self._reference)
def reference(self):
"""Returns the reference class.
"""
return pool.get_model(self._reference)
def __new__(cls, name, bases, attrs):
super_new = super(ModelType, cls).__new__
parents = [b for b in bases if isinstance(b, ModelType)]
if not parents:
# This is not a subclass of Model so do nothing
return super_new(cls, name, bases, attrs)
if len(parents) > 1:
raise TypeError(_('Multiple inheritance is not supported.'))
check_reserved_names(attrs)
# always use the last defined base class in the inheritance chain
# to maintain linear hierarchy.
meta = getattr(parents[0], '_meta', None) or Options()
try:
parent = pool.get_model(meta.name) if meta.name else None
except KeyError:
parent = None
if meta.package is None:
try:
meta.package = pool.get_package(attrs['__module__']).package.name
except:
meta.package = ''
if parent:
bases = list(bases)
for i, base in enumerate(bases):
if isinstance(base, ModelType):
bases[i] = parent
bases = tuple(bases)
cls = super_new(cls, name, bases, {
'_meta': meta,
'__module__': attrs.pop('__module__')})
# update meta information
unique = attrs.pop('__unique__', [])
if meta.name is None:
meta_name = name.lower()
if meta.package:
meta_name = '%s:%s' % (meta.package, meta_name)
meta.name = meta_name
meta.table = meta_name.replace(':', '_')
# create primary key field if it is root model
if not parent:
cls.add_field(AutoKey())
# overwrite model class in the pool
pool.register_model(cls)
cls._values = None
# sort fields and set attributes to class
attributes = attrs.items()
attributes.sort(lambda a, b: cmp(
getattr(a[1], '_serial', 0), getattr(b[1], '_serial', 0)))
for name, attr in attributes:
if isinstance(attr, Field):
cls.add_field(attr, name)
if attr.is_unique:
unique.append([attr])
else:
setattr(cls, name, attr)
# prepare validators
for name, attr in attributes:
if name.startswith('validate_') and isinstance(attr, types.FunctionType):
field = getattr(cls, name[9:], None)
if isinstance(field, Field):
field._validator = getattr(cls, name) # use bound method
# prepare unique constraints
for item in unique:
item = list(item) if isinstance(item, (list, tuple)) else [item]
for i, field in enumerate(item):
if isinstance(field, basestring):
try:
item[i] = field = getattr(cls, field)
except:
raise AttributeError(
_('No such field %(name)s.', field))
assert isinstance(field, Field), 'expected a field'
meta.unique.append(item)
return cls
def __new__(cls, **kw):
if cls is Model:
raise TypeError(_("You can't create instance of Model class"))
klass = pool.get_model(cls)
return super(Model, cls).__new__(klass)