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