def assign_labels(cls, class_name, class_dict):
# Assign labels for the class/extent.
if '_label' not in class_dict and not hasattr(cls, '_label'):
cls._label = label_from_name(class_name)
if '_plural' not in class_dict and not hasattr(cls, '_plural'):
cls._plural = plural_from_name(class_name)
# Assign labels for query, transaction, and view methods.
for key in class_dict:
if key[:2] in ('q_', 't_', 'v_'):
m_name = key
func = getattr(cls, m_name)
# Drop the prefix.
method_name = m_name[2:]
# Assign a label if none exists.
new_label = None
if getattr(func, '_label', None) is None:
# Make a label after dropping prefix.
new_label = label_from_name(method_name)
if isextentmethod(func):
# Extentmethod.
if new_label is not None:
func._label = new_label
else:
# Instancemethod.
if new_label is not None:
class_dict[m_name]._label = new_label
def __init__(self, name, view):
NamespaceExtension.__init__(self, name, view)
d = self._d
entity = view._entity
# Start with the actions defined on the entity.
for q_name in entity._q_instancemethod_names:
func = getattr(entity, q_name)
name = q_name[2:]
d[name] = func
# The add or override with actions defined on the view.
cls = view.__class__
q_names = []
for attr in dir(cls):
if attr.startswith('q_'):
q_name = attr
func = getattr(cls, q_name)
q_names.append(q_name)
for q_name in q_names:
name = q_name[2:]
func = getattr(view, q_name)
# Assign a label if none exists.
new_label = None
if getattr(func, '_label', None) is None:
new_label = label_from_name(name)
if new_label is not None:
cls.__dict__[q_name]._label = new_label
d[name] = func
def field(self, name, instance=None, value=None):
class NoSlotsField(self.FieldClass):
# No __slots__ defined in order to give
# flexibility to other users of this field, like
# transactions and queries.
pass
NoSlotsField.__name__ = self.FieldClass.__name__
NewClass = NoSlotsField
NewClass._name = name
if not NewClass.label:
# Assign a label to the field based on the name.
NewClass.label = label_from_name(name)
f = NewClass(instance, value)
return f
def __setattr__(self, name, value):
field_map = self._i._field_map
if name in field_map:
raise AttributeError('%r already exists.' % name)
if isinstance(value, FieldDefinition):
value = value.field(name=name, instance=self._i)
elif isinstance(value, base.Field):
value._instance = self._i
if not value.label:
# Assign a label to the field based on the name.
value.label = label_from_name(name)
else:
msg = '%r is not a Field or FieldDefinition instance.' % value
raise ValueError(msg)
field_map[name] = value
def __init__(cls, class_name, bases, class_dict):
type.__init__(cls, class_name, bases, class_dict)
# Assign a label for the class.
if '_label' not in class_dict:
cls._label = label_from_name(class_name)
# Only if this global schema definition variable exists.
if (schevo.namespace.SCHEMADEF is not None
and hasattr(cls, '_field_spec')
):
# Create an initial field spec odict, which will get
# updated by the EntityMeta class.
cls._field_spec = field_spec_from_class(cls, class_dict)
# Add this class to the namespace.
ns = getattr(
schevo.namespace.SCHEMADEF, namespace_name)
try:
ns._set(class_name, cls)
except KeyError:
# Skip private classes.
pass
def field_spec_from_class(cls, class_dict, slots=False):
field_spec = FieldSpecMap()
if cls._field_spec:
# Make new subclasses of any inherited fields.
for name, BaseFieldClass in cls._field_spec.iteritems():
field_spec[name] = new_field_class(BaseFieldClass, slots)
specs = []
for name, field_def in class_dict.items():
if isinstance(field_def, FieldDefinition):
field_def.name = name
BaseFieldClass = field_def.FieldClass
NewClass = new_field_class(BaseFieldClass, slots)
NewClass._name = name
if not NewClass.label:
NewClass.label = label_from_name(name)
specs.append((field_def.counter, name, NewClass))
if isinstance(getattr(cls, name, None), FieldDefinition):
delattr(cls, name)
specs.sort()
specs = [s[1:] for s in specs]
field_spec.update(FieldSpecMap(specs))
return field_spec
