split cache/value/setting in plugin
[tiramisu.git] / 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
24 from tiramisu.autolib import carry_out_calculation
25 from tiramisu.i18n import _
26 from tiramisu.option import SymLinkOption
27
28 #FIXME
29 from tiramisu.plugins.dictionary.value import PluginValues
30
31
32 class Values(PluginValues):
33     """The `Config`'s root is indeed  in charge of the `Option()`'s values,
34     but the values are physicaly located here, in `Values`, wich is also
35     responsible of a caching utility.
36     """
37     __slots__ = ('context',)
38
39     def __init__(self, context):
40         """
41         Initializes the values's dict.
42
43         :param context: the context is the home config's values
44
45         """
46
47         self.context = context
48         super(Values, self).__init__()
49
50     def _getdefault(self, opt):
51         meta = self.context.cfgimpl_get_meta()
52         if meta is not None:
53             value = meta.cfgimpl_get_values()[opt]
54         else:
55             value = opt.impl_getdefault()
56         if opt.impl_is_multi():
57             return copy(value)
58         else:
59             return value
60
61     def _getvalue(self, opt, validate=True):
62         "return value or default value if not set"
63         if not self._p_hasvalue(opt):
64             #if no value
65             value = self._getdefault(opt)
66             if opt.impl_is_multi():
67                 value = Multi(value, self.context, opt, validate)
68         else:
69             #if value
70             value = self._p_getvalue(opt)
71             if opt.impl_is_multi() and not isinstance(value, Multi):
72                 #load value so don't need to validate if is not a Multi
73                 value = Multi(value, self.context, opt, validate=False)
74         return value
75
76     def get_modified_values(self):
77         return self._p_get_modified_values()
78
79     def __contains__(self, opt):
80         return self._p_hascache('value', opt)
81
82     def __delitem__(self, opt):
83         self.reset(opt)
84
85     def reset(self, opt):
86         if self._p_hasvalue(opt):
87             setting = self.context.cfgimpl_get_settings()
88             opt.impl_validate(opt.impl_getdefault(), self.context,
89                               'validator' in setting)
90             self.context.cfgimpl_reset_cache()
91             if opt.impl_is_multi() and opt.impl_get_multitype() == multitypes.master:
92                 for slave in opt.impl_get_master_slaves():
93                     self.reset(slave)
94             self._p_resetvalue(opt)
95
96     def _isempty(self, opt, value):
97         "convenience method to know if an option is empty"
98         empty = opt._empty
99         if (not opt.impl_is_multi() and (value is None or value == empty)) or \
100            (opt.impl_is_multi() and (value == [] or
101                                      None in value or empty in value)):
102             return True
103         return False
104
105     def _getcallback_value(self, opt, index=None):
106         callback, callback_params = opt._callback
107         if callback_params is None:
108             callback_params = {}
109         return carry_out_calculation(opt._name, config=self.context,
110                                      callback=callback,
111                                      callback_params=callback_params,
112                                      index=index)
113
114     def __getitem__(self, opt):
115         return self.getitem(opt)
116
117     def getitem(self, opt, validate=True, force_permissive=False,
118                 force_properties=None, validate_properties=True):
119         ntime = None
120         if self._p_hascache('value', opt):
121             ntime = time()
122             is_cached, value = self._p_getcache('value', opt, ntime)
123             if is_cached:
124                 return value
125         val = self._getitem(opt, validate, force_permissive, force_properties,
126                             validate_properties)
127         if 'expire' in self.context.cfgimpl_get_settings() and validate and \
128                 validate_properties and force_permissive is False and \
129                 force_properties is None:
130             if ntime is None:
131                 ntime = time()
132             self._p_setcache('value', opt, val, ntime + expires_time)
133
134         return val
135
136     def _getitem(self, opt, validate, force_permissive, force_properties,
137                  validate_properties):
138         # options with callbacks
139         setting = self.context.cfgimpl_get_settings()
140         is_frozen = 'frozen' in setting[opt]
141         #if value is callback and is not set or frozen with force_default_on_freeze
142         if opt.impl_has_callback() and (self.is_default_owner(opt) or
143                                         (is_frozen and
144                                          'force_default_on_freeze' in setting[opt])):
145             no_value_slave = False
146             if opt.impl_is_multi() and opt.impl_get_multitype() == multitypes.slave:
147                 masterp = self.context.cfgimpl_get_description().impl_get_path_by_opt(
148                     opt.impl_get_master_slaves())
149                 mastervalue = getattr(self.context, masterp)
150                 lenmaster = len(mastervalue)
151                 if lenmaster == 0:
152                     value = []
153                     no_value_slave = True
154
155             if not no_value_slave:
156                 value = self._getcallback_value(opt)
157                 if opt.impl_is_multi() and opt.impl_get_multitype() == multitypes.slave:
158                     if not isinstance(value, list):
159                         value = [value for i in range(lenmaster)]
160             if opt.impl_is_multi():
161                 value = Multi(value, self.context, opt, validate)
162             #suppress value if already set
163             self.reset(opt)
164         # frozen and force default
165         elif is_frozen and 'force_default_on_freeze' in setting[opt]:
166             value = self._getdefault(opt)
167             if opt.impl_is_multi():
168                 value = Multi(value, self.context, opt, validate)
169         else:
170             value = self._getvalue(opt, validate)
171         if validate:
172             opt.impl_validate(value, self.context, 'validator' in setting)
173         if self.is_default_owner(opt) and \
174                 'force_store_value' in setting[opt]:
175             self.setitem(opt, value, is_write=False)
176         if validate_properties:
177             setting.validate_properties(opt, False, False, value=value,
178                                         force_permissive=force_permissive,
179                                         force_properties=force_properties)
180         return value
181
182     def __setitem__(self, opt, value):
183         self.setitem(opt, value)
184
185     def setitem(self, opt, value, force_permissive=False, is_write=True):
186         #is_write is, for example, used with "force_store_value"
187         #user didn't change value, so not write
188         #valid opt
189         opt.impl_validate(value, self.context,
190                           'validator' in self.context.cfgimpl_get_settings())
191         if opt.impl_is_multi() and not isinstance(value, Multi):
192             value = Multi(value, self.context, opt)
193         self._setvalue(opt, value, force_permissive=force_permissive,
194                        is_write=is_write)
195
196     def _setvalue(self, opt, value, force_permissive=False, force_properties=None,
197                   is_write=True, validate_properties=True):
198         self.context.cfgimpl_reset_cache()
199         if validate_properties:
200             setting = self.context.cfgimpl_get_settings()
201             setting.validate_properties(opt, False, is_write,
202                                         value=value,
203                                         force_permissive=force_permissive,
204                                         force_properties=force_properties)
205         self._p_setvalue(opt, value)
206
207     def getowner(self, opt):
208         if isinstance(opt, SymLinkOption):
209             opt = opt._opt
210         owner = self._p_getowner(opt, owners.default)
211         meta = self.context.cfgimpl_get_meta()
212         if owner is owners.default and meta is not None:
213             owner = meta.cfgimpl_get_values().getowner(opt)
214         return owner
215
216     def setowner(self, opt, owner):
217         if not isinstance(owner, owners.Owner):
218             raise TypeError(_("invalid generic owner {0}").format(str(owner)))
219         if self.getowner(opt) == owners.default:
220             raise ConfigError(_('no value for {0} cannot change owner to {1}'
221                                 '').format(opt._name, owner))
222         self._p_setowner(opt, owner)
223
224     def is_default_owner(self, opt):
225         """
226         :param config: *must* be only the **parent** config
227                        (not the toplevel config)
228         :return: boolean
229         """
230         return self.getowner(opt) == owners.default
231
232     def reset_cache(self, only_expired):
233         if only_expired:
234             self._p_reset_expired_cache('value', time())
235         else:
236             self._p_reset_all_cache('value')
237
238     def _get_opt_path(self, opt):
239         return self.context.cfgimpl_get_description().impl_get_path_by_opt(opt)
240
241     def _get_owner_from_str(self, owner):
242         return getattr(owners, owner)
243
244 # ____________________________________________________________
245 # multi types
246
247
248 class Multi(list):
249     """multi options values container
250     that support item notation for the values of multi options"""
251     __slots__ = ('opt', 'context')
252
253     def __init__(self, value, context, opt, validate=True):
254         """
255         :param value: the Multi wraps a list value
256         :param context: the home config that has the values
257         :param opt: the option object that have this Multi value
258         """
259         self.opt = opt
260         self.context = context
261         if not isinstance(value, list):
262             value = [value]
263         if validate and self.opt.impl_get_multitype() == multitypes.slave:
264             value = self._valid_slave(value)
265         elif self.opt.impl_get_multitype() == multitypes.master:
266             self._valid_master(value)
267         super(Multi, self).__init__(value)
268
269     def _valid_slave(self, value):
270         #if slave, had values until master's one
271         masterp = self.context.cfgimpl_get_description().impl_get_path_by_opt(
272             self.opt.impl_get_master_slaves())
273         mastervalue = getattr(self.context, masterp)
274         masterlen = len(mastervalue)
275         if len(value) > masterlen or (len(value) < masterlen and
276                                       not self.context.cfgimpl_get_values().is_default_owner(self.opt)):
277             raise SlaveError(_("invalid len for the slave: {0}"
278                                " which has {1} as master").format(
279                                    self.opt._name, masterp))
280         elif len(value) < masterlen:
281             for num in range(0, masterlen - len(value)):
282                 value.append(self.opt.impl_getdefault_multi())
283         #else: same len so do nothing
284         return value
285
286     def _valid_master(self, value):
287         masterlen = len(value)
288         values = self.context.cfgimpl_get_values()
289         for slave in self.opt._master_slaves:
290             if not values.is_default_owner(slave):
291                 value_slave = values._getvalue(slave)
292                 if len(value_slave) > masterlen:
293                     raise SlaveError(_("invalid len for the master: {0}"
294                                        " which has {1} as slave with"
295                                        " greater len").format(
296                                            self.opt._name, slave._name))
297                 elif len(value_slave) < masterlen:
298                     for num in range(0, masterlen - len(value_slave)):
299                         value_slave.append(slave.impl_getdefault_multi(), force=True)
300
301     def __setitem__(self, key, value):
302         self._validate(value)
303         #assume not checking mandatory property
304         super(Multi, self).__setitem__(key, value)
305         self.context.cfgimpl_get_values()._setvalue(self.opt, self)
306
307     def append(self, value, force=False):
308         """the list value can be updated (appened)
309         only if the option is a master
310         """
311         if not force:
312             if self.opt.impl_get_multitype() == multitypes.slave:
313                 raise SlaveError(_("cannot append a value on a multi option {0}"
314                                    " which is a slave").format(self.opt._name))
315             elif self.opt.impl_get_multitype() == multitypes.master:
316                 values = self.context.cfgimpl_get_values()
317                 if value is None and self.opt.impl_has_callback():
318                     value = values._getcallback_value(self.opt)
319                     #Force None il return a list
320                     if isinstance(value, list):
321                         value = None
322         self._validate(value)
323         super(Multi, self).append(value)
324         if not force and self.opt.impl_get_multitype() == multitypes.master:
325             for slave in self.opt.impl_get_master_slaves():
326                 if not values.is_default_owner(slave):
327                     if slave.impl_has_callback():
328                         index = self.__len__() - 1
329                         dvalue = values._getcallback_value(slave, index=index)
330                     else:
331                         dvalue = slave.impl_getdefault_multi()
332                     #get multi without valid properties
333                     values.getitem(slave, validate_properties=False).append(
334                         dvalue, force=True)
335         self.context.cfgimpl_get_values()._setvalue(self.opt, self, validate_properties=not force)
336
337     def sort(self, cmp=None, key=None, reverse=False):
338         if self.opt.impl_get_multitype() in [multitypes.slave,
339                                              multitypes.master]:
340             raise SlaveError(_("cannot sort multi option {0} if master or slave"
341                                "").format(self.opt._name))
342         super(Multi, self).sort(cmp=cmp, key=key, reverse=reverse)
343         self.context.cfgimpl_get_values()._setvalue(self.opt, self)
344
345     def reverse(self):
346         if self.opt.impl_get_multitype() in [multitypes.slave,
347                                              multitypes.master]:
348             raise SlaveError(_("cannot reverse multi option {0} if master or "
349                                "slave").format(self.opt._name))
350         super(Multi, self).reverse()
351         self.context.cfgimpl_get_values()._setvalue(self.opt, self)
352
353     def insert(self, index, obj):
354         if self.opt.impl_get_multitype() in [multitypes.slave,
355                                              multitypes.master]:
356             raise SlaveError(_("cannot insert multi option {0} if master or "
357                                "slave").format(self.opt._name))
358         super(Multi, self).insert(index, obj)
359         self.context.cfgimpl_get_values()._setvalue(self.opt, self)
360
361     def extend(self, iterable):
362         if self.opt.impl_get_multitype() in [multitypes.slave,
363                                              multitypes.master]:
364             raise SlaveError(_("cannot extend multi option {0} if master or "
365                                "slave").format(self.opt._name))
366         super(Multi, self).extend(iterable)
367         self.context.cfgimpl_get_values()._setvalue(self.opt, self)
368
369     def _validate(self, value):
370         if value is not None:
371             try:
372                 self.opt._validate(value)
373             except ValueError, err:
374                 raise ValueError(_("invalid value {0} "
375                                    "for option {1}: {2}").format(str(value),
376                                                                  self.opt._name, err))
377
378     def pop(self, key, force=False):
379         """the list value can be updated (poped)
380         only if the option is a master
381
382         :param key: index of the element to pop
383         :return: the requested element
384         """
385         if not force:
386             if self.opt.impl_get_multitype() == multitypes.slave:
387                 raise SlaveError(_("cannot pop a value on a multi option {0}"
388                                    " which is a slave").format(self.opt._name))
389             elif self.opt.impl_get_multitype() == multitypes.master:
390                 for slave in self.opt.impl_get_master_slaves():
391                     values = self.context.cfgimpl_get_values()
392                     if not values.is_default_owner(slave):
393                         #get multi without valid properties
394                         values.getitem(slave, validate_properties=False).pop(key, force=True)
395         #set value without valid properties
396         ret = super(Multi, self).pop(key)
397         self.context.cfgimpl_get_values()._setvalue(self.opt, self, validate_properties=not force)
398         return ret