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