def __fill_basics(obj, intr): label = get(obj.trait.inits.kwd, 'label', obj.trait.name) if not label: label = obj.trait.name intr.update({ 'default': (obj.value or obj.trait.value) if hasattr(obj, 'value') else obj.trait.value, 'description': get(obj.trait.inits.kwd, 'doc'), 'label': label.capitalize(), 'name': obj.trait.name, 'locked': obj.trait.inits.kwd.get('locked', False), 'required': obj.trait.inits.kwd.get('required', True) })
def __get_basics(obj): label = get(obj.trait.inits.kwd, 'label', obj.trait.name) if not label: label = obj.trait.name default = (obj.value or obj.trait.value) if hasattr( obj, 'value') else obj.trait.value description = get(obj.trait.inits.kwd, 'doc') label = label.capitalize() name = obj.trait.name locked = obj.trait.inits.kwd.get('locked', False) required = obj.trait.inits.kwd.get('required', True) return name, label, description, default, required, locked
def __handle_nonmapped_subtypes(ownr, obj, intr): """ Populate options for each subtype. This fills in models etc""" for opt in TYPE_REGISTER.subclasses( ownr, KWARG_AVOID_SUBCLASSES in obj.trait.inits.kwd): if hasattr(obj, 'value') and obj.value is not None and isinstance( obj.value, opt): ## fill option currently selected with attributes from instance opt = obj.value opt_class = opt.__class__ else: opt_class = opt opt.trait.bound = INTERFACE_ATTRIBUTES_ONLY description = multiline_math_directives_to_matjax( opt_class.__doc__) intr['options'].append({ 'name': get(opt, '_ui_name', opt_class.__name__), 'value': str_class_name(opt_class, short_form=True), 'class': str_class_name(opt_class, short_form=False), 'description': description, 'attributes': opt.interface['attributes'] })
def __get__(self, inst, cls): """ Called when an attribute of Type is retrieved on another class/instance. """ if inst is None: return self if self.trait.bound: ### Return simple DB field or cached value return get(inst, '__' + self.trait.name, None) else: return self
def _get_cached_data(self, inst): """ Overwrite method from library mode array to read from storage when needed. """ cached_data = get(inst, '__' + self.trait.name, None) if ((cached_data is None or cached_data.size == 0) and self.trait.file_storage != FILE_STORAGE_NONE and TvbProfile.current.TRAITS_CONFIGURATION.use_storage and inst.trait.use_storage and isinstance(inst, mapped.MappedTypeLight)): ### Data not already loaded, and storage usage cached_data = self._read_from_storage(inst) setattr(inst, '__' + self.trait.name, cached_data) ## Data already loaded, or no storage is used return cached_data
def __handle_nonmapped_subtypes(ownr, obj): """ Populate options for each subtype. This fills in models etc""" options = [] for opt in TYPE_REGISTER.subclasses( ownr, KWARG_AVOID_SUBCLASSES in obj.trait.inits.kwd): if hasattr(obj, 'value') and obj.value is not None and isinstance( obj.value, opt): ## fill option currently selected with attributes from instance opt = obj.value opt_class = opt.__class__ else: opt_class = opt opt.trait.bound = INTERFACE_ATTRIBUTES_ONLY description = multiline_math_directives_to_matjax( opt_class.__doc__) name = get(opt, '_ui_name', opt_class.__name__) value = str_class_name(opt_class, short_form=True) type_ = str_class_name(opt_class, short_form=False) attributes = opt.interface_experimental options.append( itr.TypeNode(name, value, type_, description, attributes)) return options
def __new__(mcs, name, bases, dikt): """ MetaType.__new__ creates a new class, but is typically involved *implicitly* either by declaring the __metaclass__ attribute class Type(object): __metaclass__ = MetaType or by subclassing Type: class Foo(Type): pass but in both cases, this method is called to produce the new class object. To setup a trait attribute, we : - check if it's a type, if so, instantiate - tell the attr it's name on owner class - setup private attr with attr.value - augment owner class doc-string with trait description - add trait to information on class """ # if we're wrapping a class, pop that out wraps = dikt.pop('wraps', set([])) wraps_defaults = dikt.pop('defaults', ()) # make new class newcls = super(MetaType, mcs).__new__(mcs, name, bases, dikt) # add new class to type register TYPE_REGISTER.append(newcls) # prep class doc string doc = get(dikt, '__doc__', 'traited class ' + name) doc += "\n **traits on this class:**\n" # build traits info on newcls' attrs if hasattr(newcls, 'trait'): trait = newcls.trait.copy() else: trait = TraitsInfo(newcls) for key in filter(ispublic, dir(newcls)): attr = getattr(newcls, key) if isinstance(attr, MetaType) or isinstance(attr, Type): if isinstance(attr, MetaType): attr = attr() try: attr = deepcopy(attr) except Exception: attr = copy(attr) attr.trait.name = key setattr(newcls, key, attr) doc += "\n\t``%s`` (%s)\n" % ( key, str(attr.trait.inits.kwd.get('label', ""))) doc += "\t\t| %s\n" % str(attr.trait.inits.kwd.get( 'doc', "")).replace("\n", " ") doc += "\t\t| ``default``: %s \n" % str( attr.trait.inits.kwd.get('default', None)).replace( "\n", " ") specified_range = attr.trait.inits.kwd.get('range', None) if specified_range: doc += "\t\t| ``range``: low = %s ; high = %s \n\t\t\n" % ( str(specified_range.lo), str(specified_range.hi)) trait[key] = attr # add info to new class if wraps: trait.wraps = wraps if wraps_defaults: trait.wraps_defaults = wraps_defaults newcls.trait = trait # bind traits unless told otherwise for attr in newcls.trait.itervalues(): attr.trait.bound = attr.trait.inits.kwd.get('bind', True) newcls.__doc__ = doc return newcls
def __get__(self, inst, ownr): obj = inst if inst else ownr if not obj.trait.bound: return {} label = get(obj.trait.inits.kwd, 'label', obj.trait.name) if not label: label = obj.trait.name intr = {'default': (obj.value or obj.trait.value) if hasattr(obj, 'value') else obj.trait.value, 'description': get(obj.trait.inits.kwd, 'doc'), 'label': self.label(label), 'name': obj.trait.name, 'locked': obj.trait.inits.kwd.get('locked', False), 'required': obj.trait.inits.kwd.get('required', True)} range_value = obj.trait.inits.kwd.get('range', False) if range_value: intr['minValue'] = range_value.lo intr['maxValue'] = range_value.hi intr['stepValue'] = range_value.step noise_configurable = obj.trait.inits.kwd.get('configurable_noise', None) if noise_configurable is not None: intr['configurableNoise'] = noise_configurable if KWARG_FILTERS_UI in obj.trait.inits.kwd: intr[KWARG_FILTERS_UI] = json.dumps([ui_filter.to_dict() for ui_filter in obj.trait.inits.kwd[KWARG_FILTERS_UI]]) if hasattr(obj, 'dtype'): intr['elementType'] = getattr(obj, 'dtype') if get(obj.trait, 'wraps', False): if isinstance(obj.trait.wraps, tuple): intr['type'] = str(obj.trait.wraps[0].__name__) else: intr['type'] = str(obj.trait.wraps.__name__) if intr['type'] == 'dict' and isinstance(intr['default'], dict): intr['attributes'], intr['elementType'] = self.__prepare_dictionary(intr['default']) if len(intr['attributes']) < 1: ## Dictionary without any sub-parameter return {} ##### ARRAY specific processing ######################################## if 'Array' in [str(i.__name__) for i in ownr.mro()]: intr['type'] = 'array' intr['elementType'] = str(inst.dtype) intr['quantifier'] = 'manual' if obj.trait.value is not None and isinstance(obj.trait.value, numpy.ndarray): # Make sure arrays are displayed in a compatible form: [1, 2, 3] intr['default'] = str(obj.trait.value.tolist()) ##### TYPE & subclasses specifics ###################################### elif ('Type' in [str(i.__name__) for i in ownr.mro()] and (obj.__module__ != 'tvb.basic.traits.types_basic' or 'Range' in [str(i.__name__) for i in ownr.mro()]) or 'Enumerate' in [str(i.__name__) for i in ownr.mro()]): # Populate Attributes for current entity attrs = sorted(getattr(obj, 'trait').values(), key=lambda entity: entity.trait.order_number) attrs = [val.interface for val in attrs if val.trait.order_number >= 0] attrs = [attr for attr in attrs if attr is not None and len(attr) > 0] intr['attributes'] = attrs if obj.trait.bound == INTERFACE_ATTRIBUTES_ONLY: # We need to do this, to avoid infinite loop on attributes # of class Type with no subclasses return intr if obj.trait.select_multiple: intr['type'] = 'selectMultiple' else: intr['type'] = 'select' ##### MAPPED_TYPE specifics ############################################ if 'MappedType' in [str(i.__name__) for i in ownr.mro()]: intr['datatype'] = True #### For simple DataTypes, cut options and attributes intr['options'] = [] if not ownr._ui_complex_datatype: intr['attributes'] = [] ownr_class = ownr.__class__ else: ownr_class = ownr._ui_complex_datatype if 'MetaType' in ownr_class.__name__: ownr_class = ownr().__class__ intr['type'] = ownr_class.__module__ + '.' + ownr_class.__name__ else: ##### TYPE (not MAPPED_TYPE) again #################################### intr['attributes'] = [] # Build options list intr['options'] = [] if 'Enumerate' in obj.__class__.__name__: for val in obj.trait.options: intr['options'].append({'name': val, 'value': val}) intr['default'] = obj.trait.value return intr else: for opt in TYPE_REGISTER.subclasses(ownr, KWARG_AVOID_SUBCLASSES in obj.trait.inits.kwd): if hasattr(obj, 'value') and obj.value is not None and isinstance(obj.value, opt): ## fill option currently selected with attributes from instance opt = obj.value opt_class = opt.__class__ else: opt_class = opt opt.trait.bound = INTERFACE_ATTRIBUTES_ONLY intr['options'].append({'name': get(opt, '_ui_name', opt_class.__name__), 'value': str_class_name(opt_class, short_form=True), 'class': str_class_name(opt_class, short_form=False), 'description': opt_class.__doc__, 'attributes': opt.interface['attributes']}) if intr['default'] is not None and intr['default'].__class__: intr['default'] = str(intr['default'].__class__.__name__) if intr['default'] == 'RandomState': intr['default'] = 'RandomStream' else: intr['default'] = None return intr
def _get_cached_data(self, inst): """ Just read from instance since we don't have storage in library mode. """ return get(inst, '__' + self.trait.name, None)
def __new__(mcs, name, bases, dikt): """ MetaType.__new__ creates a new class, but is typically involved *implicitly* either by declaring the __metaclass__ attribute class Type(object): __metaclass__ = MetaType or by subclassing Type: class Foo(Type): pass but in both cases, this method is called to produce the new class object. To setup a trait attribute, we : - check if it's a type, if so, instantiate - tell the attr it's name on owner class - setup private attr with attr.value - augment owner class doc-string with trait description - add trait to information on class """ # if we're wrapping a class, pop that out wraps = dikt.pop('wraps', set([])) wraps_defaults = dikt.pop('defaults', ()) # make new class newcls = super(MetaType, mcs).__new__(mcs, name, bases, dikt) # add new class to type register TYPE_REGISTER.append(newcls) # prep class doc string doc = get(dikt, '__doc__', 'traited class ' + name) doc += "\n **traits on this class:**\n" # build traits info on newcls' attrs if hasattr(newcls, 'trait'): trait = newcls.trait.copy() else: trait = TraitsInfo(newcls) for key in filter(ispublic, dir(newcls)): attr = getattr(newcls, key) if isinstance(attr, MetaType) or isinstance(attr, Type): if isinstance(attr, MetaType): attr = attr() attr = deepcopy(attr) attr.trait.name = key setattr(newcls, key, attr) doc += "\n\t``%s`` (%s)\n" % (key, str(attr.trait.inits.kwd.get('label', ""))) doc += "\t\t| %s\n" % str(attr.trait.inits.kwd.get('doc', "")).replace("\n", " ") doc += "\t\t| ``default``: %s \n" % str(attr.trait.inits.kwd.get('default', None)).replace("\n", " ") specified_range = attr.trait.inits.kwd.get('range', None) if specified_range: doc += "\t\t| ``range``: low = %s ; high = %s \n\t\t\n" % (str(specified_range.lo), str(specified_range.hi)) trait[key] = attr # add info to new class if wraps: trait.wraps = wraps if wraps_defaults: trait.wraps_defaults = wraps_defaults newcls.trait = trait # bind traits unless told otherwise for attr in newcls.trait.itervalues(): attr.trait.bound = attr.trait.inits.kwd.get('bind', True) newcls.__doc__ = doc return newcls