when change len of calculated master, change len of slave too
[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, undefined
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 _getcontext(self):
50         """context could be None, we need to test it
51         context is None only if all reference to `Config` object is deleted
52         (for example we delete a `Config` and we manipulate a reference to
53         old `SubConfig`, `Values`, `Multi` or `Settings`)
54         """
55         context = self.context()
56         if context is None:
57             raise ConfigError(_('the context does not exist anymore'))
58         return context
59
60     def _getdefault(self, opt):
61         """
62         actually retrieves the default value
63
64         :param opt: the `option.Option()` object
65         """
66         meta = self._getcontext().cfgimpl_get_meta()
67         if meta is not None:
68             value = meta.cfgimpl_get_values()[opt]
69         else:
70             value = opt.impl_getdefault()
71         if opt.impl_is_multi():
72             return copy(value)
73         else:
74             return value
75
76     def _getvalue(self, opt, path):
77         """actually retrieves the value
78
79         :param opt: the `option.Option()` object
80         :returns: the option's value (or the default value if not set)
81         """
82         if not self._p_.hasvalue(path):
83             # if there is no value
84             value = self._getdefault(opt)
85         else:
86             # if there is a value
87             value = self._p_.getvalue(path)
88         return value
89
90     def get_modified_values(self):
91         return self._p_.get_modified_values()
92
93     def __contains__(self, opt):
94         """
95         implements the 'in' keyword syntax in order provide a pythonic way
96         to kow if an option have a value
97
98         :param opt: the `option.Option()` object
99         """
100         path = self._get_opt_path(opt)
101         return self._contains(path)
102
103     def _contains(self, path):
104         return self._p_.hasvalue(path)
105
106     def __delitem__(self, opt):
107         """overrides the builtins `del()` instructions"""
108         self.reset(opt)
109
110     def reset(self, opt, path=None):
111         if path is None:
112             path = self._get_opt_path(opt)
113         if self._p_.hasvalue(path):
114             context = self._getcontext()
115             setting = context.cfgimpl_get_settings()
116             opt.impl_validate(opt.impl_getdefault(),
117                               context, 'validator' in setting)
118             context.cfgimpl_reset_cache()
119             if (opt.impl_is_multi() and
120                     opt.impl_get_multitype() == multitypes.master):
121                 for slave in opt.impl_get_master_slaves():
122                     self.reset(slave)
123             self._p_.resetvalue(path)
124
125     def _isempty(self, opt, value):
126         "convenience method to know if an option is empty"
127         empty = opt._empty
128         if (not opt.impl_is_multi() and (value is None or value == empty)) or \
129            (opt.impl_is_multi() and (value == [] or
130                                      None in value or empty in value)):
131             return True
132         return False
133
134     def _getcallback_value(self, opt, index=None, max_len=None):
135         """
136         retrieves a value for the options that have a callback
137
138         :param opt: the `option.Option()` object
139         :param index: if an option is multi, only calculates the nth value
140         :type index: int
141         :returns: a calculated value
142         """
143         callback, callback_params = opt._callback
144         if callback_params is None:
145             callback_params = {}
146         return carry_out_calculation(opt, config=self._getcontext(),
147                                      callback=callback,
148                                      callback_params=callback_params,
149                                      index=index, max_len=max_len)
150
151     def __getitem__(self, opt):
152         "enables us to use the pythonic dictionary-like access to values"
153         return self.getitem(opt)
154
155     def getitem(self, opt, path=None, validate=True, force_permissive=False,
156                 force_properties=None, validate_properties=True):
157         if path is None:
158             path = self._get_opt_path(opt)
159         ntime = None
160         setting = self._getcontext().cfgimpl_get_settings()
161         if 'cache' in setting and self._p_.hascache(path):
162             if 'expire' in setting:
163                 ntime = int(time())
164             is_cached, value = self._p_.getcache(path, ntime)
165             if is_cached:
166                 if opt.impl_is_multi() and not isinstance(value, Multi):
167                     #load value so don't need to validate if is not a Multi
168                     value = Multi(value, self.context, opt, path, validate=False)
169                 return value
170         val = self._getitem(opt, path, validate, force_permissive,
171                             force_properties, validate_properties)
172         if 'cache' in setting and validate and validate_properties and \
173                 force_permissive is False and force_properties is None:
174             if 'expire' in setting:
175                 if ntime is None:
176                     ntime = int(time())
177                 ntime = ntime + expires_time
178             self._p_.setcache(path, val, ntime)
179
180         return val
181
182     def _getitem(self, opt, path, validate, force_permissive, force_properties,
183                  validate_properties):
184         # options with callbacks
185         context = self._getcontext()
186         setting = context.cfgimpl_get_settings()
187         is_frozen = 'frozen' in setting[opt]
188         # For calculating properties, we need value (ie for mandatory value).
189         # If value is calculating with a PropertiesOptionError's option
190         # _getcallback_value raise a ConfigError.
191         # We can not raise ConfigError if this option should raise
192         # PropertiesOptionError too. So we get config_error and raise
193         # ConfigError if properties did not raise.
194         config_error = None
195         force_permissives = None
196         # if value has callback and is not set
197         # or frozen with force_default_on_freeze
198         if opt.impl_has_callback() and (
199                 self._is_default_owner(path) or
200                 (is_frozen and 'force_default_on_freeze' in setting[opt])):
201             lenmaster = None
202             no_value_slave = False
203             if (opt.impl_is_multi() and
204                     opt.impl_get_multitype() == multitypes.slave):
205                 masterp = self._get_opt_path(opt.impl_get_master_slaves())
206                 mastervalue = context._getattr(masterp, validate=validate)
207                 lenmaster = len(mastervalue)
208                 if lenmaster == 0:
209                     value = []
210                     no_value_slave = True
211
212             if not no_value_slave:
213                 try:
214                     value = self._getcallback_value(opt, max_len=lenmaster)
215                 except ConfigError as err:
216                     # cannot assign config_err directly in python 3.3
217                     config_error = err
218                     value = None
219                     # should not raise PropertiesOptionError if option is
220                     # mandatory
221                     force_permissives = set(['mandatory'])
222                 else:
223                     if (opt.impl_is_multi() and
224                             opt.impl_get_multitype() == multitypes.slave):
225                         if not isinstance(value, list):
226                             value = [value for i in range(lenmaster)]
227             if config_error is None:
228                 if opt.impl_is_multi():
229                     value = Multi(value, self.context, opt, path, validate)
230                 # suppress value if already set
231                 self.reset(opt, path)
232         # frozen and force default
233         elif is_frozen and 'force_default_on_freeze' in setting[opt]:
234             value = self._getdefault(opt)
235             if opt.impl_is_multi():
236                 value = Multi(value, self.context, opt, path, validate)
237         else:
238             value = self._getvalue(opt, path)
239             if opt.impl_is_multi():
240                 # load value so don't need to validate if is not a Multi
241                 value = Multi(value, self.context, opt, path, validate=validate)
242         if config_error is None and validate:
243             opt.impl_validate(value, context, 'validator' in setting)
244         if config_error is None and self._is_default_owner(path) and \
245                 'force_store_value' in setting[opt]:
246             self.setitem(opt, value, path, is_write=False)
247         if validate_properties:
248             setting.validate_properties(opt, False, False, value=value, path=path,
249                                         force_permissive=force_permissive,
250                                         force_properties=force_properties,
251                                         force_permissives=force_permissives)
252         if config_error is not None:
253             raise config_error
254         return value
255
256     def __setitem__(self, opt, value):
257         raise ValueError('you should only set value with config')
258
259     def setitem(self, opt, value, path, force_permissive=False,
260                 is_write=True):
261         # is_write is, for example, used with "force_store_value"
262         # user didn't change value, so not write
263         # valid opt
264         context = self._getcontext()
265         opt.impl_validate(value, context,
266                           'validator' in context.cfgimpl_get_settings())
267         if opt.impl_is_multi():
268             value = Multi(value, self.context, opt, path, setitem=True)
269             # Save old value
270             if opt.impl_get_multitype() == multitypes.master and \
271                     self._p_.hasvalue(path):
272                 old_value = self._p_.getvalue(path)
273                 old_owner = self._p_.getowner(path, None)
274             else:
275                 old_value = undefined
276                 old_owner = undefined
277         self._setvalue(opt, path, value, force_permissive=force_permissive,
278                        is_write=is_write)
279         if opt.impl_is_multi() and opt.impl_get_multitype() == multitypes.master:
280             try:
281                 value._valid_master()
282             except Exception, err:
283                 if old_value is not undefined:
284                     self._p_.setvalue(path, old_value, old_owner)
285                 else:
286                     self._p_.resetvalue(path)
287                 raise err
288
289     def _setvalue(self, opt, path, value, force_permissive=False,
290                   force_properties=None,
291                   is_write=True, validate_properties=True):
292         context = self._getcontext()
293         context.cfgimpl_reset_cache()
294         if validate_properties:
295             setting = context.cfgimpl_get_settings()
296             setting.validate_properties(opt, False, is_write,
297                                         value=value, path=path,
298                                         force_permissive=force_permissive,
299                                         force_properties=force_properties)
300         owner = context.cfgimpl_get_settings().getowner()
301         if isinstance(value, Multi):
302             value = list(value)
303         self._p_.setvalue(path, value, owner)
304
305     def getowner(self, opt):
306         """
307         retrieves the option's owner
308
309         :param opt: the `option.Option` object
310         :returns: a `setting.owners.Owner` object
311         """
312         if isinstance(opt, SymLinkOption):
313             opt = opt._opt
314         path = self._get_opt_path(opt)
315         return self._getowner(path)
316
317     def _getowner(self, path):
318         owner = self._p_.getowner(path, owners.default)
319         meta = self._getcontext().cfgimpl_get_meta()
320         if owner is owners.default and meta is not None:
321             owner = meta.cfgimpl_get_values()._getowner(path)
322         return owner
323
324     def setowner(self, opt, owner):
325         """
326         sets a owner to an option
327
328         :param opt: the `option.Option` object
329         :param owner: a valid owner, that is a `setting.owners.Owner` object
330         """
331         if not isinstance(owner, owners.Owner):
332             raise TypeError(_("invalid generic owner {0}").format(str(owner)))
333
334         path = self._get_opt_path(opt)
335         self._setowner(path, owner)
336
337     def _setowner(self, path, owner):
338         if self._getowner(path) == owners.default:
339             raise ConfigError(_('no value for {0} cannot change owner to {1}'
340                                 '').format(path, owner))
341         self._p_.setowner(path, owner)
342
343     def is_default_owner(self, opt):
344         """
345         :param config: *must* be only the **parent** config
346                        (not the toplevel config)
347         :return: boolean
348         """
349         path = self._get_opt_path(opt)
350         return self._is_default_owner(path)
351
352     def _is_default_owner(self, path):
353         return self._getowner(path) == owners.default
354
355     def reset_cache(self, only_expired):
356         """
357         clears the cache if necessary
358         """
359         if only_expired:
360             self._p_.reset_expired_cache(int(time()))
361         else:
362             self._p_.reset_all_cache()
363
364     def _get_opt_path(self, opt):
365         """
366         retrieve the option's path in the config
367
368         :param opt: the `option.Option` object
369         :returns: a string with points like "gc.dummy.my_option"
370         """
371         return self._getcontext().cfgimpl_get_description().impl_get_path_by_opt(opt)
372
373     # information
374     def set_information(self, key, value):
375         """updates the information's attribute
376
377         :param key: information's key (ex: "help", "doc"
378         :param value: information's value (ex: "the help string")
379         """
380         self._p_.set_information(key, value)
381
382     def get_information(self, key, default=None):
383         """retrieves one information's item
384
385         :param key: the item string (ex: "help")
386         """
387         try:
388             return self._p_.get_information(key)
389         except ValueError:
390             if default is not None:
391                 return default
392             else:
393                 raise ValueError(_("information's item"
394                                    " not found: {0}").format(key))
395
396     def __getstate__(self):
397         return {'_p_': self._p_}
398
399     def _impl_setstate(self, storage):
400         self._p_._storage = storage
401
402     def __setstate__(self, states):
403         self._p_ = states['_p_']
404
405
406 # ____________________________________________________________
407 # multi types
408
409
410 class Multi(list):
411     """multi options values container
412     that support item notation for the values of multi options"""
413     __slots__ = ('opt', 'path', 'context')
414
415     def __init__(self, value, context, opt, path, validate=True,
416                  setitem=False):
417         """
418         :param value: the Multi wraps a list value
419         :param context: the home config that has the values
420         :param opt: the option object that have this Multi value
421         :param setitem: only if set a value
422         """
423         if isinstance(value, Multi):
424             raise ValueError(_('{0} is already a Multi ').format(opt._name))
425         self.opt = opt
426         self.path = path
427         if not isinstance(context, weakref.ReferenceType):
428             raise ValueError('context must be a Weakref')
429         self.context = context
430         if not isinstance(value, list):
431             value = [value]
432         if validate and self.opt.impl_get_multitype() == multitypes.slave:
433             value = self._valid_slave(value, setitem)
434         elif not setitem and validate and \
435                 self.opt.impl_get_multitype() == multitypes.master:
436             self._valid_master()
437         super(Multi, self).__init__(value)
438
439     def _getcontext(self):
440         """context could be None, we need to test it
441         context is None only if all reference to `Config` object is deleted
442         (for example we delete a `Config` and we manipulate a reference to
443         old `SubConfig`, `Values`, `Multi` or `Settings`)
444         """
445         context = self.context()
446         if context is None:
447             raise ConfigError(_('the context does not exist anymore'))
448         return context
449
450     def _valid_slave(self, value, setitem):
451         #if slave, had values until master's one
452         context = self._getcontext()
453         values = context.cfgimpl_get_values()
454         masterp = context.cfgimpl_get_description().impl_get_path_by_opt(
455             self.opt.impl_get_master_slaves())
456         mastervalue = context._getattr(masterp, validate=False)
457         masterlen = len(mastervalue)
458         valuelen = len(value)
459         if valuelen > masterlen or (valuelen < masterlen and setitem):
460             raise SlaveError(_("invalid len for the slave: {0}"
461                                " which has {1} as master").format(
462                                    self.opt._name, masterp))
463         elif valuelen < masterlen:
464             for num in range(0, masterlen - valuelen):
465                 if self.opt.impl_has_callback():
466                     # if callback add a value, but this value will not change
467                     # anymore automaticly (because this value has owner)
468                     index = value.__len__()
469                     value.append(values._getcallback_value(self.opt,
470                                                            index=index))
471                 else:
472                     value.append(self.opt.impl_getdefault_multi())
473         #else: same len so do nothing
474         return value
475
476     def _valid_master(self):
477         #masterlen = len(value)
478         values = self._getcontext().cfgimpl_get_values()
479         for slave in self.opt._master_slaves:
480             path = values._get_opt_path(slave)
481             Multi(values._getvalue(slave, path), self.context, slave, path)
482
483     def __setitem__(self, index, value):
484         self._validate(value, index)
485         #assume not checking mandatory property
486         super(Multi, self).__setitem__(index, value)
487         self._getcontext().cfgimpl_get_values()._setvalue(self.opt, self.path, self)
488
489     def append(self, value=undefined, force=False):
490         """the list value can be updated (appened)
491         only if the option is a master
492         """
493         context = self._getcontext()
494         if not force:
495             if self.opt.impl_get_multitype() == multitypes.slave:
496                 raise SlaveError(_("cannot append a value on a multi option {0}"
497                                    " which is a slave").format(self.opt._name))
498             elif self.opt.impl_get_multitype() == multitypes.master:
499                 values = context.cfgimpl_get_values()
500                 if value is undefined and self.opt.impl_has_callback():
501                     value = values._getcallback_value(self.opt)
502                     #Force None il return a list
503                     if isinstance(value, list):
504                         value = None
505         index = self.__len__()
506         if value is undefined:
507             value = self.opt.impl_getdefault_multi()
508         self._validate(value, index)
509         super(Multi, self).append(value)
510         context.cfgimpl_get_values()._setvalue(self.opt, self.path,
511                                                self,
512                                                validate_properties=not force)
513         if not force and self.opt.impl_get_multitype() == multitypes.master:
514             for slave in self.opt.impl_get_master_slaves():
515                 path = values._get_opt_path(slave)
516                 if not values._is_default_owner(path):
517                     if slave.impl_has_callback():
518                         dvalue = values._getcallback_value(slave, index=index)
519                     else:
520                         dvalue = slave.impl_getdefault_multi()
521                     old_value = values.getitem(slave, path, validate=False,
522                                                validate_properties=False)
523                     if len(old_value) + 1 != self.__len__():
524                         raise SlaveError(_("invalid len for the slave: {0}"
525                                            " which has {1} as master").format(
526                                                self.opt._name, self.__len__()))
527                     values.getitem(slave, path, validate=False,
528                                    validate_properties=False).append(
529                                        dvalue, force=True)
530
531     def sort(self, cmp=None, key=None, reverse=False):
532         if self.opt.impl_get_multitype() in [multitypes.slave,
533                                              multitypes.master]:
534             raise SlaveError(_("cannot sort multi option {0} if master or slave"
535                                "").format(self.opt._name))
536         if sys.version_info[0] >= 3:
537             if cmp is not None:
538                 raise ValueError(_('cmp is not permitted in python v3 or greater'))
539             super(Multi, self).sort(key=key, reverse=reverse)
540         else:
541             super(Multi, self).sort(cmp=cmp, key=key, reverse=reverse)
542         self._getcontext().cfgimpl_get_values()._setvalue(self.opt, self.path, self)
543
544     def reverse(self):
545         if self.opt.impl_get_multitype() in [multitypes.slave,
546                                              multitypes.master]:
547             raise SlaveError(_("cannot reverse multi option {0} if master or "
548                                "slave").format(self.opt._name))
549         super(Multi, self).reverse()
550         self._getcontext().cfgimpl_get_values()._setvalue(self.opt, self.path, self)
551
552     def insert(self, index, obj):
553         if self.opt.impl_get_multitype() in [multitypes.slave,
554                                              multitypes.master]:
555             raise SlaveError(_("cannot insert multi option {0} if master or "
556                                "slave").format(self.opt._name))
557         super(Multi, self).insert(index, obj)
558         self._getcontext().cfgimpl_get_values()._setvalue(self.opt, self.path, self)
559
560     def extend(self, iterable):
561         if self.opt.impl_get_multitype() in [multitypes.slave,
562                                              multitypes.master]:
563             raise SlaveError(_("cannot extend multi option {0} if master or "
564                                "slave").format(self.opt._name))
565         super(Multi, self).extend(iterable)
566         self._getcontext().cfgimpl_get_values()._setvalue(self.opt, self.path, self)
567
568     def _validate(self, value, force_index):
569         if value is not None:
570             try:
571                 self.opt.impl_validate(value, context=self._getcontext(),
572                                        force_index=force_index)
573             except ValueError as err:
574                 raise ValueError(_("invalid value {0} "
575                                    "for option {1}: {2}"
576                                    "").format(str(value),
577                                               self.opt._name, err))
578
579     def pop(self, index, force=False):
580         """the list value can be updated (poped)
581         only if the option is a master
582
583         :param index: remove item a index
584         :type index: int
585         :param force: force pop item (withoud check master/slave)
586         :type force: boolean
587         :returns: item at index
588         """
589         context = self._getcontext()
590         if not force:
591             if self.opt.impl_get_multitype() == multitypes.slave:
592                 raise SlaveError(_("cannot pop a value on a multi option {0}"
593                                    " which is a slave").format(self.opt._name))
594             if self.opt.impl_get_multitype() == multitypes.master:
595                 for slave in self.opt.impl_get_master_slaves():
596                     values = context.cfgimpl_get_values()
597                     if not values.is_default_owner(slave):
598                         #get multi without valid properties
599                         values.getitem(slave, validate=False,
600                                        validate_properties=False
601                                        ).pop(index, force=True)
602         #set value without valid properties
603         ret = super(Multi, self).pop(index)
604         context.cfgimpl_get_values()._setvalue(self.opt, self.path, self, validate_properties=not force)
605         return ret