src/nepi/core/attributes.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 class Attribute(object):
   5     ### Attribute types
   6     STRING  = "STRING"
   7     BOOL    = "BOOL"
   8     ENUM    = "ENUM"
   9     DOUBLE  = "DOUBLE"
  10     INTEGER = "INTEGER"
  11
  12     types = [
  13         STRING,
  14         BOOL,
  15         ENUM,
  16         DOUBLE,
  17         INTEGER
  18     ]
  19
  20     type_parsers = {
  21         STRING : str,
  22         BOOL : lambda x : str(x).lower() in ("1","on","yes","true"),
  23         ENUM : str,
  24         DOUBLE : float,
  25         INTEGER : int,
  26     }
  27
  28     ### Attribute Flags
  29     NoFlags     = 0x00
  30     # Attribute is only modifiable during experiment design
  31     DesignOnly  = 0x01
  32     # Attribute is read only and can't be modified by the user
  33     # Note: ReadOnly implies DesignOnly
  34     ReadOnly    = 0x03
  35     # Attribute is invisible to the user but can be modified
  36     Invisible   = 0x04
  37     # Attribute has no default value in the testbed instance.
  38     # So it needs to be set explicitely
  39     HasNoDefaultValue = 0x08
  40
  41     def __init__(self, name, help, type, value = None, range = None,
  42         allowed = None, flags = NoFlags, validation_function = None,
  43         category = None):
  44         if not type in Attribute.types:
  45             raise AttributeError("invalid type %s " % type)
  46         self._name = name
  47         self._type = type
  48         self._help = help
  49         self._value = value
  50         self._flags = flags
  51         # range: max and min possible values
  52         self._range = range
  53         # list of possible values
  54         self._allowed = allowed
  55         self._validation_function = validation_function
  56         self._modified = False
  57         self._category = category
  58
  59     @property
  60     def name(self):
  61         return self._name
  62
  63     @property
  64     def type(self):
  65         return self._type
  66
  67     @property
  68     def help(self):
  69         return self._help
  70
  71     @property
  72     def flags(self):
  73         return self._flags
  74
  75     @property
  76     def invisible(self):
  77         return (self._flags & Attribute.Invisible) == Attribute.Invisible
  78
  79     @property
  80     def read_only(self):
  81         return (self._flags & Attribute.ReadOnly) == Attribute.ReadOnly
  82
  83     @property
  84     def has_no_default_value(self):
  85         return (self._flags & Attribute.HasNoDefaultValue) == \
  86                 Attribute.HasNoDefaultValue
  87
  88     @property
  89     def design_only(self):
  90         return (self._flags & Attribute.DesignOnly) == Attribute.DesignOnly
  91
  92     @property
  93     def modified(self):
  94         return self._modified
  95
  96     @property
  97     def category(self):
  98         return self._category
  99
 100     @property
 101     def range(self):
 102         return self._range
 103
 104     @property
 105     def allowed(self):
 106         return self._allowed
 107
 108     @property
 109     def validation_function(self):
 110         return self._validation_function
 111
 112     def get_value(self):
 113         return self._value
 114
 115     def set_value(self, value):
 116         if self.is_valid_value(value):
 117             self._value = value
 118             self._modified = True
 119         else:
 120             raise ValueError("Invalid value %s for attribute %s" %
 121                     (str(value), self.name))
 122
 123     value = property(get_value, set_value)
 124
 125     def is_valid_value(self, value):
 126         return self._is_in_range(value) and \
 127             self._is_in_allowed_values(value) and \
 128                 self._is_valid(value)
 129
 130     def _is_in_range(self, value):
 131         return not self.range or \
 132                 (value >= self.range[0] and value <= self.range[1])
 133
 134     def _is_in_allowed_values(self, value):
 135         return not self._allowed or value in self._allowed
 136
 137     def _is_valid(self, value):
 138         return not self._validation_function or \
 139                 self._validation_function(self, value)
 140
 141 class AttributesMap(object):
 142     """AttributesMap is the base class for every object whose attributes
 143     are going to be manipulated by the end-user in a script or GUI.
 144     """
 145     def __init__(self):
 146         super(AttributesMap, self).__init__()
 147         self._attributes = dict()
 148
 149     @property
 150     def attributes(self):
 151         return self._attributes.values()
 152
 153     @property
 154     def attributes_list(self):
 155         return self._attributes.keys()
 156
 157     def set_attribute_value(self, name, value):
 158         self._attributes[name].value = value
 159
 160     def get_attribute_value(self, name):
 161         return self._attributes[name].value
 162
 163     def get_attribute_help(self, name):
 164         return self._attributes[name].help
 165
 166     def get_attribute_type(self, name):
 167         return self._attributes[name].type
 168
 169     def get_attribute_range(self, name):
 170         if not self._attributes[name].range:
 171             return (None, None)
 172         return self._attributes[name].range
 173
 174     def get_attribute_allowed(self, name):
 175         return self._attributes[name].allowed
 176
 177     def get_attribute_category(self, name):
 178         return self._attributes[name].category
 179
 180     def is_attribute_read_only(self, name):
 181         return self._attributes[name].read_only
 182
 183     def is_attribute_invisible(self, name):
 184         return self._attributes[name].invisible
 185
 186     def is_attribute_design_only(self, name):
 187         return self._attributes[name].design_only
 188
 189     def has_attribute_no_default_value(self, name):
 190         return self._attributes[name].has_no_default_value
 191
 192     def is_attribute_modified(self, name):
 193         return self._attributes[name].modified
 194
 195     def is_attribute_value_valid(self, name, value):
 196         return self._attributes[name].is_valid_value(value)
 197
 198     def add_attribute(self, name, help, type, value = None, range = None,
 199         allowed = None, flags = Attribute.NoFlags, validation_function = None,
 200         category = None):
 201         if name in self._attributes:
 202             raise AttributeError("Attribute %s already exists" % name)
 203         attribute = Attribute(name, help, type, value, range, allowed, flags,
 204                 validation_function, category)
 205         self._attributes[name] = attribute
 206
 207     def del_attribute(self, name):
 208         del self._attributes[name]
 209
 210     def has_attribute(self, name):
 211         return name in self._attributes
 212
 213     def destroy(self):
 214         self._attributes = dict()
 215