# -*- coding: utf-8 -*- "takes care of the option's values and multi values" # Copyright (C) 2013 Team tiramisu (see AUTHORS for all contributors) # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # ____________________________________________________________ from time import time from copy import copy from tiramisu.error import ConfigError, SlaveError from tiramisu.setting import owners, multitypes, expires_time from tiramisu.autolib import carry_out_calculation from tiramisu.i18n import _ from tiramisu.option import SymLinkOption class Values(object): """The `Config`'s root is indeed in charge of the `Option()`'s values, but the values are physicaly located here, in `Values`, wich is also responsible of a caching utility. """ __slots__ = ('context', '_p_') def __init__(self, context, config_id, plugin_name): """ Initializes the values's dict. :param context: the context is the home config's values """ self.context = context import_lib = 'tiramisu.plugins.{0}.value'.format(plugin_name) self._p_ = __import__(import_lib, globals(), locals(), ['Values'], -1).Values(config_id) def _getkey(self, opt): if self._p_.key_is_path: return self._get_opt_path(opt) else: return opt def _getdefault(self, opt): meta = self.context.cfgimpl_get_meta() if meta is not None: value = meta.cfgimpl_get_values()[opt] else: value = opt.impl_getdefault() if opt.impl_is_multi(): return copy(value) else: return value def _getvalue(self, opt, validate=True): "return value or default value if not set" key = self._getkey(opt) if not self._p_.hasvalue(key): #if no value value = self._getdefault(opt) if opt.impl_is_multi(): value = Multi(value, self.context, opt, validate) else: #if value value = self._p_.getvalue(key) if opt.impl_is_multi() and not isinstance(value, Multi): #load value so don't need to validate if is not a Multi value = Multi(value, self.context, opt, validate=False) return value def get_modified_values(self): return self._p_.get_modified_values() def __contains__(self, opt): return self._p_.hasvalue('value', self._getkey(opt)) def __delitem__(self, opt): self.reset(opt) def reset(self, opt): key = self._getkey(opt) if self._p_.hasvalue(key): setting = self.context.cfgimpl_get_settings() opt.impl_validate(opt.impl_getdefault(), self.context, 'validator' in setting) self.context.cfgimpl_reset_cache() if (opt.impl_is_multi() and opt.impl_get_multitype() == multitypes.master): for slave in opt.impl_get_master_slaves(): self.reset(slave) self._p_.resetvalue(key) def _isempty(self, opt, value): "convenience method to know if an option is empty" empty = opt._empty if (not opt.impl_is_multi() and (value is None or value == empty)) or \ (opt.impl_is_multi() and (value == [] or None in value or empty in value)): return True return False def _getcallback_value(self, opt, index=None): callback, callback_params = opt._callback if callback_params is None: callback_params = {} return carry_out_calculation(opt._name, config=self.context, callback=callback, callback_params=callback_params, index=index) def __getitem__(self, opt): return self.getitem(opt) def getitem(self, opt, validate=True, force_permissive=False, force_properties=None, validate_properties=True): ntime = None key = self._getkey(opt) if self._p_.hascache('value', self._getkey(opt)): ntime = time() is_cached, value = self._p_.getcache('value', key, ntime) if is_cached: if opt.impl_is_multi() and not isinstance(value, Multi): #load value so don't need to validate if is not a Multi value = Multi(value, self.context, opt, validate=False) return value val = self._getitem(opt, validate, force_permissive, force_properties, validate_properties) if 'expire' in self.context.cfgimpl_get_settings() and validate and \ validate_properties and force_permissive is False and \ force_properties is None: if ntime is None: ntime = time() self._p_.setcache('value', key, val, ntime + expires_time) return val def _getitem(self, opt, validate, force_permissive, force_properties, validate_properties): # options with callbacks setting = self.context.cfgimpl_get_settings() is_frozen = 'frozen' in setting[opt] # if value is callback and is not set # or frozen with force_default_on_freeze if opt.impl_has_callback() and ( self.is_default_owner(opt) or (is_frozen and 'force_default_on_freeze' in setting[opt])): no_value_slave = False if (opt.impl_is_multi() and opt.impl_get_multitype() == multitypes.slave): masterp = self._get_opt_path(opt.impl_get_master_slaves()) mastervalue = getattr(self.context, masterp) lenmaster = len(mastervalue) if lenmaster == 0: value = [] no_value_slave = True if not no_value_slave: value = self._getcallback_value(opt) if (opt.impl_is_multi() and opt.impl_get_multitype() == multitypes.slave): if not isinstance(value, list): value = [value for i in range(lenmaster)] if opt.impl_is_multi(): value = Multi(value, self.context, opt, validate) #suppress value if already set self.reset(opt) # frozen and force default elif is_frozen and 'force_default_on_freeze' in setting[opt]: value = self._getdefault(opt) if opt.impl_is_multi(): value = Multi(value, self.context, opt, validate) else: value = self._getvalue(opt, validate) if validate: opt.impl_validate(value, self.context, 'validator' in setting) if self.is_default_owner(opt) and \ 'force_store_value' in setting[opt]: self.setitem(opt, value, is_write=False) if validate_properties: setting.validate_properties(opt, False, False, value=value, force_permissive=force_permissive, force_properties=force_properties) return value def __setitem__(self, opt, value): self.setitem(opt, value) def setitem(self, opt, value, force_permissive=False, is_write=True): #is_write is, for example, used with "force_store_value" #user didn't change value, so not write #valid opt opt.impl_validate(value, self.context, 'validator' in self.context.cfgimpl_get_settings()) if opt.impl_is_multi() and not isinstance(value, Multi): value = Multi(value, self.context, opt) self._setvalue(opt, value, force_permissive=force_permissive, is_write=is_write) def _setvalue(self, opt, value, force_permissive=False, force_properties=None, is_write=True, validate_properties=True): self.context.cfgimpl_reset_cache() if validate_properties: setting = self.context.cfgimpl_get_settings() setting.validate_properties(opt, False, is_write, value=value, force_permissive=force_permissive, force_properties=force_properties) owner = self.context.cfgimpl_get_settings().getowner() self._p_.setvalue(self._getkey(opt), value, owner) def getowner(self, opt): if isinstance(opt, SymLinkOption): opt = opt._opt owner = self._p_.getowner(self._getkey(opt), owners.default) meta = self.context.cfgimpl_get_meta() if owner is owners.default and meta is not None: owner = meta.cfgimpl_get_values().getowner(opt) return owner def setowner(self, opt, owner): if not isinstance(owner, owners.Owner): raise TypeError(_("invalid generic owner {0}").format(str(owner))) if self.getowner(opt) == owners.default: raise ConfigError(_('no value for {0} cannot change owner to {1}' '').format(opt._name, owner)) self._p_.setowner(self._getkey(opt), owner) def is_default_owner(self, opt): """ :param config: *must* be only the **parent** config (not the toplevel config) :return: boolean """ return self.getowner(opt) == owners.default def reset_cache(self, only_expired): if only_expired: self._p_.reset_expired_cache('value', time()) else: self._p_.reset_all_cache('value') def _get_opt_path(self, opt): return self.context.cfgimpl_get_description().impl_get_path_by_opt(opt) # ____________________________________________________________ # multi types class Multi(list): """multi options values container that support item notation for the values of multi options""" __slots__ = ('opt', 'context') def __init__(self, value, context, opt, validate=True): """ :param value: the Multi wraps a list value :param context: the home config that has the values :param opt: the option object that have this Multi value """ self.opt = opt self.context = context if not isinstance(value, list): value = [value] if validate and self.opt.impl_get_multitype() == multitypes.slave: value = self._valid_slave(value) elif self.opt.impl_get_multitype() == multitypes.master: self._valid_master(value) super(Multi, self).__init__(value) def _valid_slave(self, value): #if slave, had values until master's one masterp = self.context.cfgimpl_get_description().impl_get_path_by_opt( self.opt.impl_get_master_slaves()) mastervalue = getattr(self.context, masterp) masterlen = len(mastervalue) valuelen = len(value) if valuelen > masterlen or (valuelen < masterlen and not self.context.cfgimpl_get_values( ).is_default_owner(self.opt)): raise SlaveError(_("invalid len for the slave: {0}" " which has {1} as master").format( self.opt._name, masterp)) elif valuelen < masterlen: for num in range(0, masterlen - valuelen): value.append(self.opt.impl_getdefault_multi()) #else: same len so do nothing return value def _valid_master(self, value): masterlen = len(value) values = self.context.cfgimpl_get_values() for slave in self.opt._master_slaves: if not values.is_default_owner(slave): value_slave = values._getvalue(slave) if len(value_slave) > masterlen: raise SlaveError(_("invalid len for the master: {0}" " which has {1} as slave with" " greater len").format( self.opt._name, slave._name)) elif len(value_slave) < masterlen: for num in range(0, masterlen - len(value_slave)): value_slave.append(slave.impl_getdefault_multi(), force=True) def __setitem__(self, key, value): self._validate(value) #assume not checking mandatory property super(Multi, self).__setitem__(key, value) self.context.cfgimpl_get_values()._setvalue(self.opt, self) def append(self, value, force=False): """the list value can be updated (appened) only if the option is a master """ if not force: if self.opt.impl_get_multitype() == multitypes.slave: raise SlaveError(_("cannot append a value on a multi option {0}" " which is a slave").format(self.opt._name)) elif self.opt.impl_get_multitype() == multitypes.master: values = self.context.cfgimpl_get_values() if value is None and self.opt.impl_has_callback(): value = values._getcallback_value(self.opt) #Force None il return a list if isinstance(value, list): value = None self._validate(value) super(Multi, self).append(value) self.context.cfgimpl_get_values()._setvalue(self.opt, self, validate_properties=not force) if not force and self.opt.impl_get_multitype() == multitypes.master: for slave in self.opt.impl_get_master_slaves(): if not values.is_default_owner(slave): if slave.impl_has_callback(): index = self.__len__() - 1 dvalue = values._getcallback_value(slave, index=index) else: dvalue = slave.impl_getdefault_multi() old_value = values.getitem(slave, validate_properties=False) if len(old_value) < self.__len__(): values.getitem(slave, validate_properties=False).append( dvalue, force=True) else: values.getitem(slave, validate_properties=False)[index] = dvalue def sort(self, cmp=None, key=None, reverse=False): if self.opt.impl_get_multitype() in [multitypes.slave, multitypes.master]: raise SlaveError(_("cannot sort multi option {0} if master or slave" "").format(self.opt._name)) super(Multi, self).sort(cmp=cmp, key=key, reverse=reverse) self.context.cfgimpl_get_values()._setvalue(self.opt, self) def reverse(self): if self.opt.impl_get_multitype() in [multitypes.slave, multitypes.master]: raise SlaveError(_("cannot reverse multi option {0} if master or " "slave").format(self.opt._name)) super(Multi, self).reverse() self.context.cfgimpl_get_values()._setvalue(self.opt, self) def insert(self, index, obj): if self.opt.impl_get_multitype() in [multitypes.slave, multitypes.master]: raise SlaveError(_("cannot insert multi option {0} if master or " "slave").format(self.opt._name)) super(Multi, self).insert(index, obj) self.context.cfgimpl_get_values()._setvalue(self.opt, self) def extend(self, iterable): if self.opt.impl_get_multitype() in [multitypes.slave, multitypes.master]: raise SlaveError(_("cannot extend multi option {0} if master or " "slave").format(self.opt._name)) super(Multi, self).extend(iterable) self.context.cfgimpl_get_values()._setvalue(self.opt, self) def _validate(self, value): if value is not None: try: self.opt._validate(value) except ValueError, err: raise ValueError(_("invalid value {0} " "for option {1}: {2}" "").format(str(value), self.opt._name, err)) def pop(self, key, force=False): """the list value can be updated (poped) only if the option is a master :param key: index of the element to pop :return: the requested element """ if not force: if self.opt.impl_get_multitype() == multitypes.slave: raise SlaveError(_("cannot pop a value on a multi option {0}" " which is a slave").format(self.opt._name)) elif self.opt.impl_get_multitype() == multitypes.master: for slave in self.opt.impl_get_master_slaves(): values = self.context.cfgimpl_get_values() if not values.is_default_owner(slave): #get multi without valid properties values.getitem(slave, validate_properties=False ).pop(key, force=True) #set value without valid properties ret = super(Multi, self).pop(key) self.context.cfgimpl_get_values()._setvalue(self.opt, self, validate_properties=not force) return ret