tiramisu/value.py

   1 # -*- coding: utf-8 -*-
   2 "takes care of the option's values and multi values"
   3 # Copyright (C) 2013 Team tiramisu (see AUTHORS for all contributors)
   4 #
   5 # This program is free software; you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation; either version 2 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program; if not, write to the Free Software
  17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 #
  19 # ____________________________________________________________
  20 from time import time
  21 from copy import copy
  22 from tiramisu.error import ConfigError, SlaveError
  23 from tiramisu.setting import owners, multitypes, expires_time, storage_type
  24 from tiramisu.autolib import carry_out_calculation
  25 from tiramisu.i18n import _
  26 from tiramisu.option import SymLinkOption
  27
  28
  29 class Values(object):
  30     """The `Config`'s root is indeed  in charge of the `Option()`'s values,
  31     but the values are physicaly located here, in `Values`, wich is also
  32     responsible of a caching utility.
  33     """
  34     __slots__ = ('context', '_p_')
  35
  36     def __init__(self, context, storage):
  37         """
  38         Initializes the values's dict.
  39
  40         :param context: the context is the home config's values
  41
  42         """
  43         self.context = context
  44         # the storage type is dictionary or sqlite3
  45         import_lib = 'tiramisu.storage.{0}.value'.format(storage_type)
  46         self._p_ = __import__(import_lib, globals(), locals(), ['Values'],
  47                               -1).Values(storage)
  48
  49     def _getkey(self, opt):
  50         """depends on the storage utility.
  51         typically, the option's path in the parent `Config` or `SubConfig`
  52         """
  53         if self._p_.key_is_path:
  54             return self._get_opt_path(opt)
  55         else:
  56             return opt
  57
  58     def _getdefault(self, opt):
  59         """
  60         actually retrieves the default value
  61
  62         :param opt: the `option.Option()` object
  63         """
  64         meta = self.context.cfgimpl_get_meta()
  65         if meta is not None:
  66             value = meta.cfgimpl_get_values()[opt]
  67         else:
  68             value = opt.impl_getdefault()
  69         if opt.impl_is_multi():
  70             return copy(value)
  71         else:
  72             return value
  73
  74     def _getvalue(self, opt, validate=True):
  75         """actually retrieves the value
  76
  77         :param opt: the `option.Option()` object
  78         :returns: the option's value (or the default value if not set)
  79         """
  80         key = self._getkey(opt)
  81         if not self._p_.hasvalue(key):
  82             # if there is no value
  83             value = self._getdefault(opt)
  84             if opt.impl_is_multi():
  85                 value = Multi(value, self.context, opt, validate)
  86         else:
  87             # if there is a value
  88             value = self._p_.getvalue(key)
  89             if opt.impl_is_multi() and not isinstance(value, Multi):
  90                 # load value so don't need to validate if is not a Multi
  91                 value = Multi(value, self.context, opt, validate=False)
  92         return value
  93
  94     def get_modified_values(self):
  95         return self._p_.get_modified_values()
  96
  97     def __contains__(self, opt):
  98         """
  99         implements the 'in' keyword syntax in order provide a pythonic way
 100         to kow if an option have a value
 101
 102         :param opt: the `option.Option()` object
 103         """
 104         return self._p_.hasvalue('value', self._getkey(opt))
 105
 106     def __delitem__(self, opt):
 107         """overrides the builtins `del()` instructions"""
 108         self.reset(opt)
 109
 110     def reset(self, opt):
 111         key = self._getkey(opt)
 112         if self._p_.hasvalue(key):
 113             setting = self.context.cfgimpl_get_settings()
 114             opt.impl_validate(opt.impl_getdefault(), self.context,
 115                               'validator' in setting)
 116             self.context.cfgimpl_reset_cache()
 117             if (opt.impl_is_multi() and
 118                     opt.impl_get_multitype() == multitypes.master):
 119                 for slave in opt.impl_get_master_slaves():
 120                     self.reset(slave)
 121             self._p_.resetvalue(key)
 122
 123     def _isempty(self, opt, value):
 124         "convenience method to know if an option is empty"
 125         empty = opt._empty
 126         if (not opt.impl_is_multi() and (value is None or value == empty)) or \
 127            (opt.impl_is_multi() and (value == [] or
 128                                      None in value or empty in value)):
 129             return True
 130         return False
 131
 132     def _getcallback_value(self, opt, index=None):
 133         """
 134         retrieves a value for the options that have a callback
 135
 136         :param opt: the `option.Option()` object
 137         :param index: if an option is multi, only calculates the nth value
 138         :type index: int
 139         :returns: a calculated value
 140         """
 141         callback, callback_params = opt._callback
 142         if callback_params is None:
 143             callback_params = {}
 144         return carry_out_calculation(opt._name, config=self.context,
 145                                      callback=callback,
 146                                      callback_params=callback_params,
 147                                      index=index)
 148
 149     def __getitem__(self, opt):
 150         "enables us to use the pythonic dictionnary-like access to values"
 151         return self.getitem(opt)
 152
 153     def getitem(self, opt, validate=True, force_permissive=False,
 154                 force_properties=None, validate_properties=True):
 155         ntime = None
 156         key = self._getkey(opt)
 157         if self._p_.hascache('value', self._getkey(opt)):
 158             ntime = time()
 159             is_cached, value = self._p_.getcache('value', key, ntime)
 160             if is_cached:
 161                 if opt.impl_is_multi() and not isinstance(value, Multi):
 162                     #load value so don't need to validate if is not a Multi
 163                     value = Multi(value, self.context, opt, validate=False)
 164                 return value
 165         val = self._getitem(opt, validate, force_permissive, force_properties,
 166                             validate_properties)
 167         if 'expire' in self.context.cfgimpl_get_settings() and validate and \
 168                 validate_properties and force_permissive is False and \
 169                 force_properties is None:
 170             if ntime is None:
 171                 ntime = time()
 172             self._p_.setcache('value', key, val, ntime + expires_time)
 173
 174         return val
 175
 176     def _getitem(self, opt, validate, force_permissive, force_properties,
 177                  validate_properties):
 178         # options with callbacks
 179         setting = self.context.cfgimpl_get_settings()
 180         is_frozen = 'frozen' in setting[opt]
 181         # if value is callback and is not set
 182         # or frozen with force_default_on_freeze
 183         if opt.impl_has_callback() and (
 184                 self.is_default_owner(opt) or
 185                 (is_frozen and 'force_default_on_freeze' in setting[opt])):
 186             no_value_slave = False
 187             if (opt.impl_is_multi() and
 188                     opt.impl_get_multitype() == multitypes.slave):
 189                 masterp = self._get_opt_path(opt.impl_get_master_slaves())
 190                 mastervalue = getattr(self.context, masterp)
 191                 lenmaster = len(mastervalue)
 192                 if lenmaster == 0:
 193                     value = []
 194                     no_value_slave = True
 195
 196             if not no_value_slave:
 197                 value = self._getcallback_value(opt)
 198                 if (opt.impl_is_multi() and
 199                         opt.impl_get_multitype() == multitypes.slave):
 200                     if not isinstance(value, list):
 201                         value = [value for i in range(lenmaster)]
 202             if opt.impl_is_multi():
 203                 value = Multi(value, self.context, opt, validate)
 204             # suppress value if already set
 205             self.reset(opt)
 206         # frozen and force default
 207         elif is_frozen and 'force_default_on_freeze' in setting[opt]:
 208             value = self._getdefault(opt)
 209             if opt.impl_is_multi():
 210                 value = Multi(value, self.context, opt, validate)
 211         else:
 212             value = self._getvalue(opt, validate)
 213         if validate:
 214             opt.impl_validate(value, self.context, 'validator' in setting)
 215         if self.is_default_owner(opt) and \
 216                 'force_store_value' in setting[opt]:
 217             self.setitem(opt, value, is_write=False)
 218         if validate_properties:
 219             setting.validate_properties(opt, False, False, value=value,
 220                                         force_permissive=force_permissive,
 221                                         force_properties=force_properties)
 222         return value
 223
 224     def __setitem__(self, opt, value):
 225         self.setitem(opt, value)
 226
 227     def setitem(self, opt, value, force_permissive=False, is_write=True):
 228         # is_write is, for example, used with "force_store_value"
 229         # user didn't change value, so not write
 230         # valid opt
 231         opt.impl_validate(value, self.context,
 232                           'validator' in self.context.cfgimpl_get_settings())
 233         if opt.impl_is_multi() and not isinstance(value, Multi):
 234             value = Multi(value, self.context, opt)
 235         self._setvalue(opt, value, force_permissive=force_permissive,
 236                        is_write=is_write)
 237
 238     def _setvalue(self, opt, value, force_permissive=False,
 239                   force_properties=None,
 240                   is_write=True, validate_properties=True):
 241         self.context.cfgimpl_reset_cache()
 242         if validate_properties:
 243             setting = self.context.cfgimpl_get_settings()
 244             setting.validate_properties(opt, False, is_write,
 245                                         value=value,
 246                                         force_permissive=force_permissive,
 247                                         force_properties=force_properties)
 248         owner = self.context.cfgimpl_get_settings().getowner()
 249         self._p_.setvalue(self._getkey(opt), value, owner)
 250
 251     def getowner(self, opt):
 252         """
 253         retrieves the option's owner
 254
 255         :param opt: the `option.Option` object
 256         :returns: a `setting.owners.Owner` object
 257         """
 258         if isinstance(opt, SymLinkOption):
 259             opt = opt._opt
 260         owner = self._p_.getowner(self._getkey(opt), owners.default)
 261         meta = self.context.cfgimpl_get_meta()
 262         if owner is owners.default and meta is not None:
 263             owner = meta.cfgimpl_get_values().getowner(opt)
 264         return owner
 265
 266     def setowner(self, opt, owner):
 267         """
 268         sets a owner to an option
 269
 270         :param opt: the `option.Option` object
 271         :param owner: a valid owner, that is a `setting.owners.Owner` object
 272         """
 273         if not isinstance(owner, owners.Owner):
 274             raise TypeError(_("invalid generic owner {0}").format(str(owner)))
 275         if self.getowner(opt) == owners.default:
 276             raise ConfigError(_('no value for {0} cannot change owner to {1}'
 277                                 '').format(opt._name, owner))
 278         self._p_.setowner(self._getkey(opt), owner)
 279
 280     def is_default_owner(self, opt):
 281         """
 282         :param config: *must* be only the **parent** config
 283                        (not the toplevel config)
 284         :return: boolean
 285         """
 286         return self.getowner(opt) == owners.default
 287
 288     def reset_cache(self, only_expired):
 289         """
 290         clears the cache if necessary
 291         """
 292         if only_expired:
 293             self._p_.reset_expired_cache('value', time())
 294         else:
 295             self._p_.reset_all_cache('value')
 296
 297     def _get_opt_path(self, opt):
 298         """
 299         retrieve the option's path in the config
 300
 301         :param opt: the `option.Option` object
 302         :returns: a string with points like "gc.dummy.my_option"
 303         """
 304         return self.context.cfgimpl_get_description().impl_get_path_by_opt(opt)
 305
 306 # ____________________________________________________________
 307 # multi types
 308
 309
 310 class Multi(list):
 311     """multi options values container
 312     that support item notation for the values of multi options"""
 313     __slots__ = ('opt', 'context')
 314
 315     def __init__(self, value, context, opt, validate=True):
 316         """
 317         :param value: the Multi wraps a list value
 318         :param context: the home config that has the values
 319         :param opt: the option object that have this Multi value
 320         """
 321         self.opt = opt
 322         self.context = context
 323         if not isinstance(value, list):
 324             value = [value]
 325         if validate and self.opt.impl_get_multitype() == multitypes.slave:
 326             value = self._valid_slave(value)
 327         elif self.opt.impl_get_multitype() == multitypes.master:
 328             self._valid_master(value)
 329         super(Multi, self).__init__(value)
 330
 331     def _valid_slave(self, value):
 332         #if slave, had values until master's one
 333         masterp = self.context.cfgimpl_get_description().impl_get_path_by_opt(
 334             self.opt.impl_get_master_slaves())
 335         mastervalue = getattr(self.context, masterp)
 336         masterlen = len(mastervalue)
 337         valuelen = len(value)
 338         if valuelen > masterlen or (valuelen < masterlen and
 339                                     not self.context.cfgimpl_get_values(
 340                                     ).is_default_owner(self.opt)):
 341             raise SlaveError(_("invalid len for the slave: {0}"
 342                                " which has {1} as master").format(
 343                                    self.opt._name, masterp))
 344         elif valuelen < masterlen:
 345             for num in range(0, masterlen - valuelen):
 346                 value.append(self.opt.impl_getdefault_multi())
 347         #else: same len so do nothing
 348         return value
 349
 350     def _valid_master(self, value):
 351         masterlen = len(value)
 352         values = self.context.cfgimpl_get_values()
 353         for slave in self.opt._master_slaves:
 354             if not values.is_default_owner(slave):
 355                 value_slave = values._getvalue(slave)
 356                 if len(value_slave) > masterlen:
 357                     raise SlaveError(_("invalid len for the master: {0}"
 358                                        " which has {1} as slave with"
 359                                        " greater len").format(
 360                                            self.opt._name, slave._name))
 361                 elif len(value_slave) < masterlen:
 362                     for num in range(0, masterlen - len(value_slave)):
 363                         value_slave.append(slave.impl_getdefault_multi(),
 364                                            force=True)
 365
 366     def __setitem__(self, key, value):
 367         self._validate(value)
 368         #assume not checking mandatory property
 369         super(Multi, self).__setitem__(key, value)
 370         self.context.cfgimpl_get_values()._setvalue(self.opt, self)
 371
 372     def append(self, value, force=False):
 373         """the list value can be updated (appened)
 374         only if the option is a master
 375         """
 376         if not force:
 377             if self.opt.impl_get_multitype() == multitypes.slave:
 378                 raise SlaveError(_("cannot append a value on a multi option {0}"
 379                                    " which is a slave").format(self.opt._name))
 380             elif self.opt.impl_get_multitype() == multitypes.master:
 381                 values = self.context.cfgimpl_get_values()
 382                 if value is None and self.opt.impl_has_callback():
 383                     value = values._getcallback_value(self.opt)
 384                     #Force None il return a list
 385                     if isinstance(value, list):
 386                         value = None
 387         self._validate(value)
 388         super(Multi, self).append(value)
 389         self.context.cfgimpl_get_values()._setvalue(self.opt, self, validate_properties=not force)
 390         if not force and self.opt.impl_get_multitype() == multitypes.master:
 391             for slave in self.opt.impl_get_master_slaves():
 392                 if not values.is_default_owner(slave):
 393                     if slave.impl_has_callback():
 394                         index = self.__len__() - 1
 395                         dvalue = values._getcallback_value(slave, index=index)
 396                     else:
 397                         dvalue = slave.impl_getdefault_multi()
 398                     old_value = values.getitem(slave, validate_properties=False)
 399                     if len(old_value) < self.__len__():
 400                         values.getitem(slave, validate_properties=False).append(
 401                             dvalue, force=True)
 402                     else:
 403                         values.getitem(slave, validate_properties=False)[index] = dvalue
 404
 405     def sort(self, cmp=None, key=None, reverse=False):
 406         if self.opt.impl_get_multitype() in [multitypes.slave,
 407                                              multitypes.master]:
 408             raise SlaveError(_("cannot sort multi option {0} if master or slave"
 409                                "").format(self.opt._name))
 410         super(Multi, self).sort(cmp=cmp, key=key, reverse=reverse)
 411         self.context.cfgimpl_get_values()._setvalue(self.opt, self)
 412
 413     def reverse(self):
 414         if self.opt.impl_get_multitype() in [multitypes.slave,
 415                                              multitypes.master]:
 416             raise SlaveError(_("cannot reverse multi option {0} if master or "
 417                                "slave").format(self.opt._name))
 418         super(Multi, self).reverse()
 419         self.context.cfgimpl_get_values()._setvalue(self.opt, self)
 420
 421     def insert(self, index, obj):
 422         if self.opt.impl_get_multitype() in [multitypes.slave,
 423                                              multitypes.master]:
 424             raise SlaveError(_("cannot insert multi option {0} if master or "
 425                                "slave").format(self.opt._name))
 426         super(Multi, self).insert(index, obj)
 427         self.context.cfgimpl_get_values()._setvalue(self.opt, self)
 428
 429     def extend(self, iterable):
 430         if self.opt.impl_get_multitype() in [multitypes.slave,
 431                                              multitypes.master]:
 432             raise SlaveError(_("cannot extend multi option {0} if master or "
 433                                "slave").format(self.opt._name))
 434         super(Multi, self).extend(iterable)
 435         self.context.cfgimpl_get_values()._setvalue(self.opt, self)
 436
 437     def _validate(self, value):
 438         if value is not None:
 439             try:
 440                 self.opt._validate(value)
 441             except ValueError, err:
 442                 raise ValueError(_("invalid value {0} "
 443                                    "for option {1}: {2}"
 444                                    "").format(str(value),
 445                                               self.opt._name, err))
 446
 447     def pop(self, key, force=False):
 448         """the list value can be updated (poped)
 449         only if the option is a master
 450
 451         :param key: index of the element to pop
 452         :return: the requested element
 453         """
 454         if not force:
 455             if self.opt.impl_get_multitype() == multitypes.slave:
 456                 raise SlaveError(_("cannot pop a value on a multi option {0}"
 457                                    " which is a slave").format(self.opt._name))
 458             elif self.opt.impl_get_multitype() == multitypes.master:
 459                 for slave in self.opt.impl_get_master_slaves():
 460                     values = self.context.cfgimpl_get_values()
 461                     if not values.is_default_owner(slave):
 462                         #get multi without valid properties
 463                         values.getitem(slave,
 464                                        validate_properties=False
 465                                        ).pop(key, force=True)
 466         #set value without valid properties
 467         ret = super(Multi, self).pop(key)
 468         self.context.cfgimpl_get_values()._setvalue(self.opt, self, validate_properties=not force)
 469         return ret