d587de10c0548b23bedf90087c9dd9b13633c71f
[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 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, max_len=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, max_len=max_len)
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         if path is None:
151             path = self._get_opt_path(opt)
152         ntime = None
153         setting = self.context().cfgimpl_get_settings()
154         if 'cache' in setting and self._p_.hascache(path):
155             if 'expire' in setting:
156                 ntime = int(time())
157             is_cached, value = self._p_.getcache(path, ntime)
158             if is_cached:
159                 if opt.impl_is_multi() and not isinstance(value, Multi):
160                     #load value so don't need to validate if is not a Multi
161                     value = Multi(value, self.context, opt, path, validate=False)
162                 return value
163         val = self._getitem(opt, path, validate, force_permissive,
164                             force_properties, validate_properties)
165         if 'cache' in setting and validate and validate_properties and \
166                 force_permissive is False and force_properties is None:
167             if 'expire' in setting:
168                 if ntime is None:
169                     ntime = int(time())
170                 ntime = ntime + expires_time
171             self._p_.setcache(path, val, ntime)
172
173         return val
174
175     def _getitem(self, opt, path, validate, force_permissive, force_properties,
176                  validate_properties):
177         # options with callbacks
178         setting = self.context().cfgimpl_get_settings()
179         is_frozen = 'frozen' in setting[opt]
180         # For calculating properties, we need value (ie for mandatory value).
181         # If value is calculating with a PropertiesOptionError's option
182         # _getcallback_value raise a ConfigError.
183         # We can not raise ConfigError if this option should raise
184         # PropertiesOptionError too. So we get config_error and raise
185         # ConfigError if properties did not raise.
186         config_error = None
187         force_permissives = None
188         # if value is callback and is not set
189         # or frozen with force_default_on_freeze
190         if opt.impl_has_callback() and (
191                 self._is_default_owner(path) or
192                 (is_frozen and 'force_default_on_freeze' in setting[opt])):
193             lenmaster = None
194             no_value_slave = False
195             if (opt.impl_is_multi() and
196                     opt.impl_get_multitype() == multitypes.slave):
197                 masterp = self._get_opt_path(opt.impl_get_master_slaves())
198                 mastervalue = getattr(self.context(), masterp)
199                 lenmaster = len(mastervalue)
200                 if lenmaster == 0:
201                     value = []
202                     no_value_slave = True
203
204             if not no_value_slave:
205                 try:
206                     value = self._getcallback_value(opt, max_len=lenmaster)
207                 except ConfigError as err:
208                     # cannot assign config_err directly in python 3.3
209                     config_error = err
210                     value = None
211                     # should not raise PropertiesOptionError if option is
212                     # mandatory
213                     force_permissives = set(['mandatory'])
214                 else:
215                     if (opt.impl_is_multi() and
216                             opt.impl_get_multitype() == multitypes.slave):
217                         if not isinstance(value, list):
218                             value = [value for i in range(lenmaster)]
219             if config_error is None:
220                 if opt.impl_is_multi():
221                     value = Multi(value, self.context, opt, path, validate)
222                 # suppress value if already set
223                 self.reset(opt, path)
224         # frozen and force default
225         elif is_frozen and 'force_default_on_freeze' in setting[opt]:
226             value = self._getdefault(opt)
227             if opt.impl_is_multi():
228                 value = Multi(value, self.context, opt, path, validate)
229         else:
230             value = self._getvalue(opt, path, validate)
231         if config_error is None and validate:
232             opt.impl_validate(value, self.context(), 'validator' in setting)
233         if config_error is None and self._is_default_owner(path) and \
234                 'force_store_value' in setting[opt]:
235             self.setitem(opt, value, path, is_write=False)
236         if validate_properties:
237             setting.validate_properties(opt, False, False, value=value, path=path,
238                                         force_permissive=force_permissive,
239                                         force_properties=force_properties,
240                                         force_permissives=force_permissives)
241         if config_error is not None:
242             raise ConfigError(config_error)
243         return value
244
245     def __setitem__(self, opt, value):
246         raise ValueError('you should only set value with config')
247
248     def setitem(self, opt, value, path, force_permissive=False,
249                 is_write=True):
250         # is_write is, for example, used with "force_store_value"
251         # user didn't change value, so not write
252         # valid opt
253         opt.impl_validate(value, self.context(),
254                           'validator' in self.context().cfgimpl_get_settings())
255         if opt.impl_is_multi() and not isinstance(value, Multi):
256             value = Multi(value, self.context, opt, path, setitem=True)
257         self._setvalue(opt, path, value, force_permissive=force_permissive,
258                        is_write=is_write)
259
260     def _setvalue(self, opt, path, value, force_permissive=False,
261                   force_properties=None,
262                   is_write=True, validate_properties=True):
263         self.context().cfgimpl_reset_cache()
264         if validate_properties:
265             setting = self.context().cfgimpl_get_settings()
266             setting.validate_properties(opt, False, is_write,
267                                         value=value, path=path,
268                                         force_permissive=force_permissive,
269                                         force_properties=force_properties)
270         owner = self.context().cfgimpl_get_settings().getowner()
271         self._p_.setvalue(path, value, owner)
272
273     def getowner(self, opt):
274         """
275         retrieves the option's owner
276
277         :param opt: the `option.Option` object
278         :returns: a `setting.owners.Owner` object
279         """
280         if isinstance(opt, SymLinkOption):
281             opt = opt._opt
282         path = self._get_opt_path(opt)
283         return self._getowner(path)
284
285     def _getowner(self, path):
286         owner = self._p_.getowner(path, owners.default)
287         meta = self.context().cfgimpl_get_meta()
288         if owner is owners.default and meta is not None:
289             owner = meta.cfgimpl_get_values()._getowner(path)
290         return owner
291
292     def setowner(self, opt, owner):
293         """
294         sets a owner to an option
295
296         :param opt: the `option.Option` object
297         :param owner: a valid owner, that is a `setting.owners.Owner` object
298         """
299         if not isinstance(owner, owners.Owner):
300             raise TypeError(_("invalid generic owner {0}").format(str(owner)))
301
302         path = self._get_opt_path(opt)
303         self._setowner(path, owner)
304
305     def _setowner(self, path, owner):
306         if self._getowner(path) == owners.default:
307             raise ConfigError(_('no value for {0} cannot change owner to {1}'
308                                 '').format(path, owner))
309         self._p_.setowner(path, owner)
310
311     def is_default_owner(self, opt):
312         """
313         :param config: *must* be only the **parent** config
314                        (not the toplevel config)
315         :return: boolean
316         """
317         path = self._get_opt_path(opt)
318         return self._is_default_owner(path)
319
320     def _is_default_owner(self, path):
321         return self._getowner(path) == owners.default
322
323     def reset_cache(self, only_expired):
324         """
325         clears the cache if necessary
326         """
327         if only_expired:
328             self._p_.reset_expired_cache(int(time()))
329         else:
330             self._p_.reset_all_cache()
331
332     def _get_opt_path(self, opt):
333         """
334         retrieve the option's path in the config
335
336         :param opt: the `option.Option` object
337         :returns: a string with points like "gc.dummy.my_option"
338         """
339         return self.context().cfgimpl_get_description().impl_get_path_by_opt(opt)
340
341     # information
342     def set_information(self, key, value):
343         """updates the information's attribute
344
345         :param key: information's key (ex: "help", "doc"
346         :param value: information's value (ex: "the help string")
347         """
348         self._p_.set_information(key, value)
349
350     def get_information(self, key, default=None):
351         """retrieves one information's item
352
353         :param key: the item string (ex: "help")
354         """
355         try:
356             return self._p_.get_information(key)
357         except ValueError:
358             if default is not None:
359                 return default
360             else:
361                 raise ValueError(_("information's item"
362                                    " not found: {0}").format(key))
363
364     def __getstate__(self):
365         return {'_p_': self._p_}
366
367     def _impl_setstate(self, storage):
368         self._p_._storage = storage
369
370     def __setstate__(self, states):
371         self._p_ = states['_p_']
372
373 # ____________________________________________________________
374 # multi types
375
376
377 class Multi(list):
378     """multi options values container
379     that support item notation for the values of multi options"""
380     __slots__ = ('opt', 'path', 'context')
381
382     def __init__(self, value, context, opt, path, validate=True,
383                  setitem=False):
384         """
385         :param value: the Multi wraps a list value
386         :param context: the home config that has the values
387         :param opt: the option object that have this Multi value
388         :param setitem: only if set a value
389         """
390         self.opt = opt
391         self.path = path
392         if not isinstance(context, weakref.ReferenceType):
393             raise ValueError('context must be a Weakref')
394         self.context = context
395         if not isinstance(value, list):
396             value = [value]
397         if validate and self.opt.impl_get_multitype() == multitypes.slave:
398             value = self._valid_slave(value, setitem)
399         elif validate and self.opt.impl_get_multitype() == multitypes.master:
400             self._valid_master(value)
401         super(Multi, self).__init__(value)
402
403     def _valid_slave(self, value, setitem):
404         #if slave, had values until master's one
405         values = self.context().cfgimpl_get_values()
406         masterp = self.context().cfgimpl_get_description().impl_get_path_by_opt(
407             self.opt.impl_get_master_slaves())
408         mastervalue = getattr(self.context(), masterp)
409         masterlen = len(mastervalue)
410         valuelen = len(value)
411         is_default_owner = not values._is_default_owner(self.path) or setitem
412         if valuelen > masterlen or (valuelen < masterlen and
413                                     is_default_owner):
414             raise SlaveError(_("invalid len for the slave: {0}"
415                                " which has {1} as master").format(
416                                    self.opt._name, masterp))
417         elif valuelen < masterlen:
418             for num in range(0, masterlen - valuelen):
419                 if self.opt.impl_has_callback():
420                     # if callback add a value, but this value will not change
421                     # anymore automaticly (because this value has owner)
422                     index = value.__len__()
423                     value.append(values._getcallback_value(self.opt,
424                                                            index=index))
425                 else:
426                     value.append(self.opt.impl_getdefault_multi())
427         #else: same len so do nothing
428         return value
429
430     def _valid_master(self, value):
431         masterlen = len(value)
432         values = self.context().cfgimpl_get_values()
433         for slave in self.opt._master_slaves:
434             path = values._get_opt_path(slave)
435             if not values._is_default_owner(path):
436                 value_slave = values._getvalue(slave, path)
437                 if len(value_slave) > masterlen:
438                     raise SlaveError(_("invalid len for the master: {0}"
439                                        " which has {1} as slave with"
440                                        " greater len").format(
441                                            self.opt._name, slave._name))
442                 elif len(value_slave) < masterlen:
443                     for num in range(0, masterlen - len(value_slave)):
444                         if slave.impl_has_callback():
445                             # if callback add a value, but this value will not
446                             # change anymore automaticly (because this value
447                             # has owner)
448                             index = value_slave.__len__()
449                             value_slave.append(
450                                 values._getcallback_value(slave, index=index),
451                                 force=True)
452                         else:
453                             value_slave.append(slave.impl_getdefault_multi(),
454                                                force=True)
455
456     def __setitem__(self, key, value):
457         self._validate(value)
458         #assume not checking mandatory property
459         super(Multi, self).__setitem__(key, value)
460         self.context().cfgimpl_get_values()._setvalue(self.opt, self.path, self)
461
462     def append(self, value, force=False):
463         """the list value can be updated (appened)
464         only if the option is a master
465         """
466         if not force:
467             if self.opt.impl_get_multitype() == multitypes.slave:
468                 raise SlaveError(_("cannot append a value on a multi option {0}"
469                                    " which is a slave").format(self.opt._name))
470             elif self.opt.impl_get_multitype() == multitypes.master:
471                 values = self.context().cfgimpl_get_values()
472                 if value is None and self.opt.impl_has_callback():
473                     value = values._getcallback_value(self.opt)
474                     #Force None il return a list
475                     if isinstance(value, list):
476                         value = None
477         self._validate(value)
478         super(Multi, self).append(value)
479         self.context().cfgimpl_get_values()._setvalue(self.opt, self.path, self, validate_properties=not force)
480         if not force and self.opt.impl_get_multitype() == multitypes.master:
481             for slave in self.opt.impl_get_master_slaves():
482                 path = values._get_opt_path(slave)
483                 if not values._is_default_owner(path):
484                     if slave.impl_has_callback():
485                         index = self.__len__() - 1
486                         dvalue = values._getcallback_value(slave, index=index)
487                     else:
488                         dvalue = slave.impl_getdefault_multi()
489                     old_value = values.getitem(slave, path,
490                                                validate_properties=False)
491                     if len(old_value) < self.__len__():
492                         values.getitem(slave, path,
493                                        validate_properties=False).append(
494                                            dvalue, force=True)
495                     else:
496                         values.getitem(slave, path,
497                                        validate_properties=False)[
498                                            index] = dvalue
499
500     def sort(self, cmp=None, key=None, reverse=False):
501         if self.opt.impl_get_multitype() in [multitypes.slave,
502                                              multitypes.master]:
503             raise SlaveError(_("cannot sort multi option {0} if master or slave"
504                                "").format(self.opt._name))
505         if sys.version_info[0] >= 3:
506             if cmp is not None:
507                 raise ValueError(_('cmp is not permitted in python v3 or greater'))
508             super(Multi, self).sort(key=key, reverse=reverse)
509         else:
510             super(Multi, self).sort(cmp=cmp, key=key, reverse=reverse)
511         self.context().cfgimpl_get_values()._setvalue(self.opt, self.path, self)
512
513     def reverse(self):
514         if self.opt.impl_get_multitype() in [multitypes.slave,
515                                              multitypes.master]:
516             raise SlaveError(_("cannot reverse multi option {0} if master or "
517                                "slave").format(self.opt._name))
518         super(Multi, self).reverse()
519         self.context().cfgimpl_get_values()._setvalue(self.opt, self.path, self)
520
521     def insert(self, index, obj):
522         if self.opt.impl_get_multitype() in [multitypes.slave,
523                                              multitypes.master]:
524             raise SlaveError(_("cannot insert multi option {0} if master or "
525                                "slave").format(self.opt._name))
526         super(Multi, self).insert(index, obj)
527         self.context().cfgimpl_get_values()._setvalue(self.opt, self.path, self)
528
529     def extend(self, iterable):
530         if self.opt.impl_get_multitype() in [multitypes.slave,
531                                              multitypes.master]:
532             raise SlaveError(_("cannot extend multi option {0} if master or "
533                                "slave").format(self.opt._name))
534         super(Multi, self).extend(iterable)
535         self.context().cfgimpl_get_values()._setvalue(self.opt, self.path, self)
536
537     def _validate(self, value):
538         if value is not None:
539             try:
540                 self.opt._validate(value)
541             except ValueError as err:
542                 raise ValueError(_("invalid value {0} "
543                                    "for option {1}: {2}"
544                                    "").format(str(value),
545                                               self.opt._name, err))
546
547     def pop(self, index, force=False):
548         """the list value can be updated (poped)
549         only if the option is a master
550
551         :param index: remove item a index
552         :type index: int
553         :param force: force pop item (withoud check master/slave)
554         :type force: boolean
555         :returns: item at index
556         """
557         if not force:
558             if self.opt.impl_get_multitype() == multitypes.slave:
559                 raise SlaveError(_("cannot pop a value on a multi option {0}"
560                                    " which is a slave").format(self.opt._name))
561             elif self.opt.impl_get_multitype() == multitypes.master:
562                 for slave in self.opt.impl_get_master_slaves():
563                     values = self.context().cfgimpl_get_values()
564                     if not values.is_default_owner(slave):
565                         #get multi without valid properties
566                         values.getitem(slave,
567                                        validate_properties=False
568                                        ).pop(index, force=True)
569         #set value without valid properties
570         ret = super(Multi, self).pop(index)
571         self.context().cfgimpl_get_values()._setvalue(self.opt, self.path, self, validate_properties=not force)
572         return ret