ece79bd074d87e1769e01b8a94683772d5cfb8bc
[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 tiramisu.error import ConfigError, SlaveError
22 from tiramisu.setting import owners, multitypes, expires_time
23 from tiramisu.autolib import carry_out_calculation
24 from tiramisu.i18n import _
25
26
27 class Values(object):
28     __slots__ = ('context', '_values', '_cache')
29
30     def __init__(self, context):
31         """
32         Initializes the values's dict.
33
34         :param context: the context is the home config's values
35         """
36         "Config's root indeed is in charge of the `Option()`'s values"
37         self.context = context
38         self._values = {}
39         self._cache = {}
40         super(Values, self).__init__()
41
42     def _get_value(self, opt):
43         "return value or default value if not set"
44         #if no value
45         if opt not in self._values:
46             value = opt.optimpl_getdefault()
47             if opt.optimpl_is_multi():
48                 value = Multi(value, self.context, opt)
49         else:
50             #if value
51             value = self._values[opt][1]
52         return value
53
54     def __delitem__(self, opt):
55         self._reset(opt)
56
57     def _reset(self, opt):
58         if opt in self._values:
59             self.context.cfgimpl_reset_cache()
60             del(self._values[opt])
61
62     def _is_empty(self, opt, value):
63         "convenience method to know if an option is empty"
64         empty = opt._empty
65         if (not opt.optimpl_is_multi() and (value is None or value == empty)) or \
66            (opt.optimpl_is_multi() and (value == [] or
67                                         None in value or empty in value)):
68             return True
69         return False
70
71     def _getcallback_value(self, opt):
72         callback, callback_params = opt._callback
73         if callback_params is None:
74             callback_params = {}
75         return carry_out_calculation(opt._name, config=self.context,
76                                      callback=callback,
77                                      callback_params=callback_params)
78
79     def __getitem__(self, opt):
80         return self.getitem(opt)
81
82     def getitem(self, opt, validate=True, force_permissive=False,
83                 force_properties=None):
84         if opt in self._cache:
85             exp = time()
86             value, created = self._cache[opt]
87             if exp < created:
88                 return value
89         val = self._getitem(opt, validate, force_permissive, force_properties)
90         self._set_cache(opt, val)
91         return val
92
93     def _getitem(self, opt, validate, force_permissive, force_properties):
94         # options with callbacks
95         setting = self.context.cfgimpl_get_settings()
96         value = self._get_value(opt)
97         is_frozen = 'frozen' in setting[opt]
98         if opt.optimpl_has_callback():
99             #if value is set and :
100             # - not frozen
101             # - frozen and not force_default_on_freeze
102             if not self.is_default_owner(opt) and (
103                     not is_frozen or (is_frozen and
104                                       not 'force_default_on_freeze' in setting[opt])):
105                 pass
106             else:
107                 value = self._getcallback_value(opt)
108                 if opt.optimpl_is_multi():
109                     value = Multi(value, self.context, opt)
110                 #suppress value if already set
111                 self._reset(opt)
112         # frozen and force default
113         elif is_frozen and 'force_default_on_freeze' in setting[opt]:
114             value = opt.optimpl_getdefault()
115             if opt.optimpl_is_multi():
116                 value = Multi(value, self.context, opt)
117         if validate and not opt.optimpl_validate(value, self.context, 'validator' in setting):
118             raise ValueError(_('invalid calculated value returned'
119                              ' for option {0}: {1}').format(opt._name, value))
120         if self.is_default_owner(opt) and \
121                 'force_store_value' in setting[opt]:
122             self.setitem(opt, value)
123         setting.validate_properties(opt, False, False, value=value,
124                                     force_permissive=force_permissive,
125                                     force_properties=force_properties)
126         return value
127
128     def __setitem__(self, opt, value):
129         self.setitem(opt, value)
130
131     def setitem(self, opt, value, force_permissive=False):
132         self._setitem(opt, value, force_permissive)
133
134     def _setitem(self, opt, value, force_permissive=False, force_properties=None):
135         #valid opt
136         if not opt.optimpl_validate(value, self.context,
137                                     'validator' in self.context.cfgimpl_get_settings()):
138             raise ValueError(_('invalid value {}'
139                              ' for option {}').format(value, opt._name))
140         if opt.optimpl_is_multi() and not isinstance(value, Multi):
141             value = Multi(value, self.context, opt)
142         self._setvalue(opt, value, force_permissive=force_permissive,
143                        force_properties=force_properties)
144
145     def _setvalue(self, opt, value, force_permissive=False, force_properties=None):
146         self.context.cfgimpl_reset_cache()
147         setting = self.context.cfgimpl_get_settings()
148         setting.validate_properties(opt, False, True,
149                                     value=value,
150                                     force_permissive=force_permissive,
151                                     force_properties=force_properties)
152         self._values[opt] = (setting.getowner(), value)
153
154     def getowner(self, opt):
155         return self._values.get(opt, (owners.default, None))[0]
156
157     def setowner(self, opt, owner):
158         if opt not in self._values:
159             raise ConfigError(_('no value for {1} cannot change owner to {2}').format(opt))
160         if not isinstance(owner, owners.Owner):
161             raise TypeError(_("invalid generic owner {0}").format(str(owner)))
162         self._values[opt] = (owner, self._values[opt][1])
163
164     def is_default_owner(self, opt):
165         """
166         :param config: *must* be only the **parent** config
167                        (not the toplevel config)
168         :return: boolean
169         """
170         return self.getowner(opt) == owners.default
171
172     def _set_cache(self, opt, val):
173         if 'expire' in self.context.cfgimpl_get_settings():
174             self._cache[opt] = (val, time() + expires_time)
175
176     def reset_cache(self, only_expired):
177         if only_expired:
178             exp = time()
179             keys = self._cache.keys()
180             for key in keys:
181                 val, created = self._cache[key]
182                 if exp > created:
183                     del(self._cache[key])
184         else:
185             self._cache.clear()
186
187     def __contains__(self, opt):
188         return opt in self._values
189
190 # ____________________________________________________________
191 # multi types
192
193
194 class Multi(list):
195     """multi options values container
196     that support item notation for the values of multi options"""
197     __slots__ = ('opt', 'context')
198
199     def __init__(self, value, context, opt):
200         """
201         :param value: the Multi wraps a list value
202         :param context: the home config that has the values
203         :param opt: the option object that have this Multi value
204         """
205         self.opt = opt
206         self.context = context
207         if not isinstance(value, list):
208             value = [value]
209         if self.opt.optimpl_get_multitype() == multitypes.slave:
210             value = self._valid_slave(value)
211         elif self.opt.optimpl_get_multitype() == multitypes.master:
212             self._valid_master(value)
213         super(Multi, self).__init__(value)
214
215     def _valid_slave(self, value):
216         #if slave, had values until master's one
217         masterp = self.context.cfgimpl_get_description().optimpl_get_path_by_opt(
218             self.opt.optimpl_get_master_slaves())
219         mastervalue = getattr(self.context, masterp)
220         masterlen = len(mastervalue)
221         if len(value) > masterlen or (len(value) < masterlen and
222                                       not self.context.cfgimpl_get_values().is_default_owner(self.opt)):
223             raise SlaveError(_("invalid len for the slave: {0}"
224                                " which has {1} as master").format(
225                                    self.opt._name, masterp))
226         elif len(value) < masterlen:
227             for num in range(0, masterlen - len(value)):
228                 value.append(self.opt.optimpl_getdefault_multi())
229         #else: same len so do nothing
230         return value
231
232     def _valid_master(self, value):
233         masterlen = len(value)
234         values = self.context.cfgimpl_get_values()
235         for slave in self.opt._master_slaves:
236             if not values.is_default_owner(slave):
237                 value_slave = values._get_value(slave)
238                 if len(value_slave) > masterlen:
239                     raise SlaveError(_("invalid len for the master: {0}"
240                                        " which has {1} as slave with"
241                                        " greater len").format(
242                                            self.opt._name, slave._name))
243                 elif len(value_slave) < masterlen:
244                     for num in range(0, masterlen - len(value_slave)):
245                         value_slave.append(slave.optimpl_getdefault_multi(), force=True)
246
247     def __setitem__(self, key, value):
248         self._validate(value)
249         #assume not checking mandatory property
250         self.context.cfgimpl_get_values()._setvalue(self.opt, self)
251         super(Multi, self).__setitem__(key, value)
252
253     def append(self, value, force=False):
254         """the list value can be updated (appened)
255         only if the option is a master
256         """
257         if not force:
258             if self.opt.optimpl_get_multitype() == multitypes.slave:
259                 raise SlaveError(_("cannot append a value on a multi option {0}"
260                                    " which is a slave").format(self.opt._name))
261             elif self.opt.optimpl_get_multitype() == multitypes.master:
262                 for slave in self.opt.optimpl_get_master_slaves():
263                     values = self.context.cfgimpl_get_values()
264                     if not values.is_default_owner(slave):
265                         values[slave].append(slave.optimpl_getdefault_multi(),
266                                              force=True)
267         self._validate(value)
268         #assume not checking mandatory property
269         self.context.cfgimpl_get_values()._setvalue(self.opt, self)
270         super(Multi, self).append(value)
271
272     def _validate(self, value):
273         if value is not None and not self.opt._validate(value):
274             raise ValueError(_("invalid value {0} "
275                              "for option {1}").format(str(value),
276                                                       self.opt._name))
277
278     def pop(self, key, force=False):
279         """the list value can be updated (poped)
280         only if the option is a master
281
282         :param key: index of the element to pop
283         :return: the requested element
284         """
285         if not force:
286             if self.opt.optimpl_get_multitype() == multitypes.slave:
287                 raise SlaveError(_("cannot pop a value on a multi option {0}"
288                                    " which is a slave").format(self.opt._name))
289             elif self.opt.optimpl_get_multitype() == multitypes.master:
290                 for slave in self.opt.optimpl_get_master_slaves():
291                     self.context.cfgimpl_get_values()[slave].pop(key, force=True)
292         self.context.cfgimpl_get_values()._setvalue(self.opt, self)
293         return super(Multi, self).pop(key)