Merge branch 'master' of ssh://git.labs.libre-entreprise.org/gitroot/tiramisu
[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, 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
44         self.context = context
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         if self._p_.key_is_path:
51             return self._get_opt_path(opt)
52         else:
53             return opt
54
55     def _getdefault(self, opt):
56         meta = self.context.cfgimpl_get_meta()
57         if meta is not None:
58             value = meta.cfgimpl_get_values()[opt]
59         else:
60             value = opt.impl_getdefault()
61         if opt.impl_is_multi():
62             return copy(value)
63         else:
64             return value
65
66     def _getvalue(self, opt, validate=True):
67         "return value or default value if not set"
68         key = self._getkey(opt)
69         if not self._p_.hasvalue(key):
70             # if no value
71             value = self._getdefault(opt)
72             if opt.impl_is_multi():
73                 value = Multi(value, self.context, opt, validate)
74         else:
75             #if value
76             value = self._p_.getvalue(key)
77             if opt.impl_is_multi() and not isinstance(value, Multi):
78                 # load value so don't need to validate if is not a Multi
79                 value = Multi(value, self.context, opt, validate=False)
80         return value
81
82     def get_modified_values(self):
83         return self._p_.get_modified_values()
84
85     def __contains__(self, opt):
86         return self._p_.hasvalue('value', self._getkey(opt))
87
88     def __delitem__(self, opt):
89         """overrides the builtins `del()` instructions 
90         
91         if you use this you are responsible for all bad things happening
92         """
93         self.reset(opt)
94
95     def reset(self, opt):
96         key = self._getkey(opt)
97         if self._p_.hasvalue(key):
98             setting = self.context.cfgimpl_get_settings()
99             opt.impl_validate(opt.impl_getdefault(), self.context,
100                               'validator' in setting)
101             self.context.cfgimpl_reset_cache()
102             if (opt.impl_is_multi() and
103                     opt.impl_get_multitype() == multitypes.master):
104                 for slave in opt.impl_get_master_slaves():
105                     self.reset(slave)
106             self._p_.resetvalue(key)
107
108     def _isempty(self, opt, value):
109         "convenience method to know if an option is empty"
110         empty = opt._empty
111         if (not opt.impl_is_multi() and (value is None or value == empty)) or \
112            (opt.impl_is_multi() and (value == [] or
113                                      None in value or empty in value)):
114             return True
115         return False
116
117     def _getcallback_value(self, opt, index=None):
118         callback, callback_params = opt._callback
119         if callback_params is None:
120             callback_params = {}
121         return carry_out_calculation(opt._name, config=self.context,
122                                      callback=callback,
123                                      callback_params=callback_params,
124                                      index=index)
125
126     def __getitem__(self, opt):
127         return self.getitem(opt)
128
129     def getitem(self, opt, validate=True, force_permissive=False,
130                 force_properties=None, validate_properties=True):
131         ntime = None
132         key = self._getkey(opt)
133         if self._p_.hascache('value', self._getkey(opt)):
134             ntime = time()
135             is_cached, value = self._p_.getcache('value', key, ntime)
136             if is_cached:
137                 if opt.impl_is_multi() and not isinstance(value, Multi):
138                     #load value so don't need to validate if is not a Multi
139                     value = Multi(value, self.context, opt, validate=False)
140                 return value
141         val = self._getitem(opt, validate, force_permissive, force_properties,
142                             validate_properties)
143         if 'expire' in self.context.cfgimpl_get_settings() and validate and \
144                 validate_properties and force_permissive is False and \
145                 force_properties is None:
146             if ntime is None:
147                 ntime = time()
148             self._p_.setcache('value', key, val, ntime + expires_time)
149
150         return val
151
152     def _getitem(self, opt, validate, force_permissive, force_properties,
153                  validate_properties):
154         # options with callbacks
155         setting = self.context.cfgimpl_get_settings()
156         is_frozen = 'frozen' in setting[opt]
157         # if value is callback and is not set
158         # or frozen with force_default_on_freeze
159         if opt.impl_has_callback() and (
160                 self.is_default_owner(opt) or
161                 (is_frozen and 'force_default_on_freeze' in setting[opt])):
162             no_value_slave = False
163             if (opt.impl_is_multi() and
164                     opt.impl_get_multitype() == multitypes.slave):
165                 masterp = self._get_opt_path(opt.impl_get_master_slaves())
166                 mastervalue = getattr(self.context, masterp)
167                 lenmaster = len(mastervalue)
168                 if lenmaster == 0:
169                     value = []
170                     no_value_slave = True
171
172             if not no_value_slave:
173                 value = self._getcallback_value(opt)
174                 if (opt.impl_is_multi() and
175                         opt.impl_get_multitype() == multitypes.slave):
176                     if not isinstance(value, list):
177                         value = [value for i in range(lenmaster)]
178             if opt.impl_is_multi():
179                 value = Multi(value, self.context, opt, validate)
180             # suppress value if already set
181             self.reset(opt)
182         # frozen and force default
183         elif is_frozen and 'force_default_on_freeze' in setting[opt]:
184             value = self._getdefault(opt)
185             if opt.impl_is_multi():
186                 value = Multi(value, self.context, opt, validate)
187         else:
188             value = self._getvalue(opt, validate)
189         if validate:
190             opt.impl_validate(value, self.context, 'validator' in setting)
191         if self.is_default_owner(opt) and \
192                 'force_store_value' in setting[opt]:
193             self.setitem(opt, value, is_write=False)
194         if validate_properties:
195             setting.validate_properties(opt, False, False, value=value,
196                                         force_permissive=force_permissive,
197                                         force_properties=force_properties)
198         return value
199
200     def __setitem__(self, opt, value):
201         self.setitem(opt, value)
202
203     def setitem(self, opt, value, force_permissive=False, is_write=True):
204         # is_write is, for example, used with "force_store_value"
205         # user didn't change value, so not write
206         # valid opt
207         opt.impl_validate(value, self.context,
208                           'validator' in self.context.cfgimpl_get_settings())
209         if opt.impl_is_multi() and not isinstance(value, Multi):
210             value = Multi(value, self.context, opt)
211         self._setvalue(opt, value, force_permissive=force_permissive,
212                        is_write=is_write)
213
214     def _setvalue(self, opt, value, force_permissive=False,
215                   force_properties=None,
216                   is_write=True, validate_properties=True):
217         self.context.cfgimpl_reset_cache()
218         if validate_properties:
219             setting = self.context.cfgimpl_get_settings()
220             setting.validate_properties(opt, False, is_write,
221                                         value=value,
222                                         force_permissive=force_permissive,
223                                         force_properties=force_properties)
224         owner = self.context.cfgimpl_get_settings().getowner()
225         self._p_.setvalue(self._getkey(opt), value, owner)
226
227     def getowner(self, opt):
228         """
229         retrieves the option's owner
230         
231         :param opt: the `option.Option` object 
232         :returns: a `setting.owners.Owner` object
233         """
234         if isinstance(opt, SymLinkOption):
235             opt = opt._opt
236         owner = self._p_.getowner(self._getkey(opt), owners.default)
237         meta = self.context.cfgimpl_get_meta()
238         if owner is owners.default and meta is not None:
239             owner = meta.cfgimpl_get_values().getowner(opt)
240         return owner
241
242     def setowner(self, opt, owner):
243         """
244         sets a owner to an option
245         
246         :param opt: the `option.Option` object 
247         :param owner: a valid owner, that is a `setting.owners.Owner` object
248         """
249         if not isinstance(owner, owners.Owner):
250             raise TypeError(_("invalid generic owner {0}").format(str(owner)))
251         if self.getowner(opt) == owners.default:
252             raise ConfigError(_('no value for {0} cannot change owner to {1}'
253                                 '').format(opt._name, owner))
254         self._p_.setowner(self._getkey(opt), owner)
255
256     def is_default_owner(self, opt):
257         """
258         :param config: *must* be only the **parent** config
259                        (not the toplevel config)
260         :return: boolean
261         """
262         return self.getowner(opt) == owners.default
263
264     def reset_cache(self, only_expired):
265         """
266         clears the cache if necessary
267         """
268         if only_expired:
269             self._p_.reset_expired_cache('value', time())
270         else:
271             self._p_.reset_all_cache('value')
272
273     def _get_opt_path(self, opt):
274         """
275         retrieve the option's path in the config 
276         
277         :param opt: the `option.Option` object 
278         :returns: a string with points like "gc.dummy.my_option"
279         """
280         return self.context.cfgimpl_get_description().impl_get_path_by_opt(opt)
281
282 # ____________________________________________________________
283 # multi types
284
285
286 class Multi(list):
287     """multi options values container
288     that support item notation for the values of multi options"""
289     __slots__ = ('opt', 'context')
290
291     def __init__(self, value, context, opt, validate=True):
292         """
293         :param value: the Multi wraps a list value
294         :param context: the home config that has the values
295         :param opt: the option object that have this Multi value
296         """
297         self.opt = opt
298         self.context = context
299         if not isinstance(value, list):
300             value = [value]
301         if validate and self.opt.impl_get_multitype() == multitypes.slave:
302             value = self._valid_slave(value)
303         elif self.opt.impl_get_multitype() == multitypes.master:
304             self._valid_master(value)
305         super(Multi, self).__init__(value)
306
307     def _valid_slave(self, value):
308         #if slave, had values until master's one
309         masterp = self.context.cfgimpl_get_description().impl_get_path_by_opt(
310             self.opt.impl_get_master_slaves())
311         mastervalue = getattr(self.context, masterp)
312         masterlen = len(mastervalue)
313         valuelen = len(value)
314         if valuelen > masterlen or (valuelen < masterlen and
315                                     not self.context.cfgimpl_get_values(
316                                     ).is_default_owner(self.opt)):
317             raise SlaveError(_("invalid len for the slave: {0}"
318                                " which has {1} as master").format(
319                                    self.opt._name, masterp))
320         elif valuelen < masterlen:
321             for num in range(0, masterlen - valuelen):
322                 value.append(self.opt.impl_getdefault_multi())
323         #else: same len so do nothing
324         return value
325
326     def _valid_master(self, value):
327         masterlen = len(value)
328         values = self.context.cfgimpl_get_values()
329         for slave in self.opt._master_slaves:
330             if not values.is_default_owner(slave):
331                 value_slave = values._getvalue(slave)
332                 if len(value_slave) > masterlen:
333                     raise SlaveError(_("invalid len for the master: {0}"
334                                        " which has {1} as slave with"
335                                        " greater len").format(
336                                            self.opt._name, slave._name))
337                 elif len(value_slave) < masterlen:
338                     for num in range(0, masterlen - len(value_slave)):
339                         value_slave.append(slave.impl_getdefault_multi(),
340                                            force=True)
341
342     def __setitem__(self, key, value):
343         self._validate(value)
344         #assume not checking mandatory property
345         super(Multi, self).__setitem__(key, value)
346         self.context.cfgimpl_get_values()._setvalue(self.opt, self)
347
348     def append(self, value, force=False):
349         """the list value can be updated (appened)
350         only if the option is a master
351         """
352         if not force:
353             if self.opt.impl_get_multitype() == multitypes.slave:
354                 raise SlaveError(_("cannot append a value on a multi option {0}"
355                                    " which is a slave").format(self.opt._name))
356             elif self.opt.impl_get_multitype() == multitypes.master:
357                 values = self.context.cfgimpl_get_values()
358                 if value is None and self.opt.impl_has_callback():
359                     value = values._getcallback_value(self.opt)
360                     #Force None il return a list
361                     if isinstance(value, list):
362                         value = None
363         self._validate(value)
364         super(Multi, self).append(value)
365         self.context.cfgimpl_get_values()._setvalue(self.opt, self, validate_properties=not force)
366         if not force and self.opt.impl_get_multitype() == multitypes.master:
367             for slave in self.opt.impl_get_master_slaves():
368                 if not values.is_default_owner(slave):
369                     if slave.impl_has_callback():
370                         index = self.__len__() - 1
371                         dvalue = values._getcallback_value(slave, index=index)
372                     else:
373                         dvalue = slave.impl_getdefault_multi()
374                     old_value = values.getitem(slave, validate_properties=False)
375                     if len(old_value) < self.__len__():
376                         values.getitem(slave, validate_properties=False).append(
377                             dvalue, force=True)
378                     else:
379                         values.getitem(slave, validate_properties=False)[index] = dvalue
380
381     def sort(self, cmp=None, key=None, reverse=False):
382         if self.opt.impl_get_multitype() in [multitypes.slave,
383                                              multitypes.master]:
384             raise SlaveError(_("cannot sort multi option {0} if master or slave"
385                                "").format(self.opt._name))
386         super(Multi, self).sort(cmp=cmp, key=key, reverse=reverse)
387         self.context.cfgimpl_get_values()._setvalue(self.opt, self)
388
389     def reverse(self):
390         if self.opt.impl_get_multitype() in [multitypes.slave,
391                                              multitypes.master]:
392             raise SlaveError(_("cannot reverse multi option {0} if master or "
393                                "slave").format(self.opt._name))
394         super(Multi, self).reverse()
395         self.context.cfgimpl_get_values()._setvalue(self.opt, self)
396
397     def insert(self, index, obj):
398         if self.opt.impl_get_multitype() in [multitypes.slave,
399                                              multitypes.master]:
400             raise SlaveError(_("cannot insert multi option {0} if master or "
401                                "slave").format(self.opt._name))
402         super(Multi, self).insert(index, obj)
403         self.context.cfgimpl_get_values()._setvalue(self.opt, self)
404
405     def extend(self, iterable):
406         if self.opt.impl_get_multitype() in [multitypes.slave,
407                                              multitypes.master]:
408             raise SlaveError(_("cannot extend multi option {0} if master or "
409                                "slave").format(self.opt._name))
410         super(Multi, self).extend(iterable)
411         self.context.cfgimpl_get_values()._setvalue(self.opt, self)
412
413     def _validate(self, value):
414         if value is not None:
415             try:
416                 self.opt._validate(value)
417             except ValueError, err:
418                 raise ValueError(_("invalid value {0} "
419                                    "for option {1}: {2}"
420                                    "").format(str(value),
421                                               self.opt._name, err))
422
423     def pop(self, key, force=False):
424         """the list value can be updated (poped)
425         only if the option is a master
426
427         :param key: index of the element to pop
428         :return: the requested element
429         """
430         if not force:
431             if self.opt.impl_get_multitype() == multitypes.slave:
432                 raise SlaveError(_("cannot pop a value on a multi option {0}"
433                                    " which is a slave").format(self.opt._name))
434             elif self.opt.impl_get_multitype() == multitypes.master:
435                 for slave in self.opt.impl_get_master_slaves():
436                     values = self.context.cfgimpl_get_values()
437                     if not values.is_default_owner(slave):
438                         #get multi without valid properties
439                         values.getitem(slave,
440                                        validate_properties=False
441                                        ).pop(key, force=True)
442         #set value without valid properties
443         ret = super(Multi, self).pop(key)
444         self.context.cfgimpl_get_values()._setvalue(self.opt, self, validate_properties=not force)
445         return ret