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