ipsilon/util/config.py

   1 # Copyright (C) 2014  Ipsilon project Contributors, for licensee see COPYING
   2
   3 from ipsilon.util.log import Log
   4
   5
   6 class Config(Log):
   7
   8     def __init__(self, name, *args):
   9         self.name = name
  10         self._list = list()
  11         self._dict = dict()
  12         for item in args:
  13             if not isinstance(item, Option):
  14                 raise ValueError('Invalid option type for %s' % repr(item))
  15             self._list.append(item.name)
  16             self._dict[item.name] = item
  17         self.debug('Config(%s) %s' % (self.name, self._dict))
  18
  19     def __repr__(self):
  20         return '%s: %s' % (self.__class__, ', '.join(self._list))
  21
  22     def __str__(self):
  23         return str(self._list)
  24
  25     def __len__(self):
  26         return len(self._list)
  27
  28     def __getitem__(self, key):
  29         return self._dict[key]
  30
  31     def __setitem__(self, key, value):
  32         if not isinstance(value, Option):
  33             raise ValueError('Invalid type for %s' % value)
  34         if key != value.name:
  35             raise NameError('Name mismatch, key=%s but value.name=%s' % (
  36                 key, value.name))
  37         if key not in self._list:
  38             self._list.append(key)
  39         self._dict[key] = value
  40
  41     def __delitem__(self, key):
  42         self._list.remove(key)
  43         del self._dict[key]
  44
  45     def __iter__(self):
  46         i = 0
  47         while i < len(self._list):
  48             yield self._list[i]
  49             i += 1
  50
  51     def __reversed__(self):
  52         i = len(self._list)
  53         while i > 0:
  54             yield self._list[i - 1]
  55             i -= 1
  56
  57     def __contains__(self, item):
  58         return (item in self._dict)
  59
  60     def iteritems(self):
  61         i = 0
  62         while i < len(self._list):
  63             yield (self._list[i], self._dict[self._list[i]])
  64             i += 1
  65
  66     def items(self):
  67         return [(k, self._dict[k]) for k in self._list]
  68
  69
  70 class Option(Log):
  71
  72     def __init__(self, name, description):
  73         self.name = name
  74         self.description = description
  75         self._default_value = None
  76         self._assigned_value = None
  77
  78     def __repr__(self):
  79         return "%s: %s {%s}, value = %s [def: %s]" % (self.__class__,
  80                                                       self.name,
  81                                                       self.description,
  82                                                       self._assigned_value,
  83                                                       self._default_value)
  84
  85     def __str__(self):
  86         return '%s=%s' % (self.name, self.get_value())
  87
  88     def get_value(self, default=True):
  89         if self._assigned_value is not None:
  90             return self._assigned_value
  91         elif default is True:
  92             return self._default_value
  93         else:
  94             return None
  95
  96     def set_value(self, value):
  97         self._assigned_value = value
  98
  99     def export_value(self):
 100         raise NotImplementedError
 101
 102     def import_value(self, value):
 103         raise NotImplementedError
 104
 105     def _str_export_value(self):
 106         if self._assigned_value:
 107             return str(self._assigned_value)
 108         return None
 109
 110     def _str_import_value(self, value):
 111         if type(value) is not str:
 112             raise ValueError('Value must be string')
 113         self._assigned_value = value
 114
 115
 116 class String(Option):
 117
 118     def __init__(self, name, description, default_value=None):
 119         super(String, self).__init__(name, description)
 120         self._default_value = str(default_value)
 121
 122     def set_value(self, value):
 123         self._assigned_value = str(value)
 124
 125     def export_value(self):
 126         return self._str_export_value()
 127
 128     def import_value(self, value):
 129         self._str_import_value(value)
 130
 131
 132 class Template(Option):
 133
 134     def __init__(self, name, description, default_template=None):
 135         super(Template, self).__init__(name, description)
 136         self._default_value = str(default_template)
 137
 138     def set_value(self, value):
 139         self._assigned_value = str(value)
 140
 141     def templatize(self, args):
 142         if not args:
 143             raise ValueError('Templatized called w/o arguments')
 144
 145         return self.get_value() % args
 146
 147     def export_value(self):
 148         return self._str_export_value()
 149
 150     def import_value(self, value):
 151         self._str_import_value(value)
 152
 153
 154 class List(Option):
 155
 156     def __init__(self, name, description, default_list=None):
 157         super(List, self).__init__(name, description)
 158         if default_list:
 159             self._default_value = list(default_list)
 160         else:
 161             self._default_value = []
 162
 163     def set_value(self, value):
 164         self._assigned_value = list(value)
 165
 166     def export_value(self):
 167         if self._assigned_value:
 168             return ','.join(self._assigned_value)
 169         return None
 170
 171     def import_value(self, value):
 172         if type(value) is not str:
 173             raise ValueError('Value (type: %s) must be string' % type(value))
 174         self._assigned_value = [x.strip() for x in value.split(',')]
 175
 176
 177 class Choice(Option):
 178
 179     def __init__(self, name, description, allowed=None, default=None):
 180         super(Choice, self).__init__(name, description)
 181         if allowed:
 182             self._allowed_values = list(allowed)
 183         else:
 184             self._allowed_values = list()
 185         self._default_value = list()
 186         if default is None:
 187             default = []
 188         for name in default:
 189             if name not in self._allowed_values:
 190                 raise ValueError(
 191                     'item [%s] is not in allowed [%s]' % (name, allowed))
 192             self._default_value.append(name)
 193
 194     def __repr__(self):
 195         return "%s: %s {%s}, values = %s d:%s ok:%s" % (self.__class__,
 196                                                         self.name,
 197                                                         self.description,
 198                                                         self._assigned_value,
 199                                                         self._default_value,
 200                                                         self._allowed_values)
 201
 202     def __str__(self):
 203         return '%s=%s' % (self.name, self.get_value())
 204
 205     def set_value(self, value):
 206         if type(value) is not list:
 207             value = [value]
 208         self._assigned_value = list()
 209         for val in value:
 210             if val not in self._allowed_values:
 211                 raise ValueError(
 212                     'Value "%s" not allowed [%s]' % (val,
 213                                                      self._allowed_values))
 214             self._assigned_value.append(val)
 215
 216         if not self._assigned_value:
 217             self._assigned_value = None
 218
 219     def unset_value(self, value):
 220         if type(value) is str:
 221             value = [value]
 222         unset = list()
 223         for val in value:
 224             unset.append((val, False))
 225         self.set_value(unset)
 226
 227     def get_allowed(self):
 228         return self._allowed_values
 229
 230     def export_value(self):
 231         enabled = self.get_value()
 232         return ', '.join(enabled)
 233
 234     def import_value(self, value):
 235         enabled = [x.strip() for x in value.split(',')]
 236         if enabled:
 237             if self._assigned_value is None:
 238                 self._assigned_value = list()
 239         for val in enabled:
 240             if val not in self._allowed_values:
 241                 # We silently ignore invalid options on import for now
 242                 continue
 243             self._assigned_value.append(val)
 244
 245
 246 class Pick(Option):
 247
 248     def __init__(self, name, description, allowed, default_value):
 249         super(Pick, self).__init__(name, description)
 250         self._allowed_values = list(allowed)
 251         if default_value not in self._allowed_values:
 252             raise ValueError('The default value is not in the allowed list')
 253         self._default_value = default_value
 254
 255     def set_value(self, value):
 256         if value not in self._allowed_values:
 257             raise ValueError(
 258                 'Value "%s" not allowed [%s]' % (value, self._allowed_values))
 259         self._assigned_value = value
 260
 261     def get_allowed(self):
 262         return self._allowed_values
 263
 264     def export_value(self):
 265         return self._str_export_value()
 266
 267     def import_value(self, value):
 268         self._str_import_value(value)
 269
 270
 271 class Condition(Pick):
 272
 273     def __init__(self, name, description, default_value=False):
 274         super(Condition, self).__init__(name, description,
 275                                         [True, False], default_value)
 276
 277     def import_value(self, value):
 278         self._assigned_value = value == 'True'