add SubMulti
[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 it
6 # under the terms of the GNU Lesser General Public License as published by the
7 # Free Software Foundation, either version 3 of the License, or (at your
8 # option) any later version.
9 #
10 # This program is distributed in the hope that it will be useful, but WITHOUT
11 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
12 # FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
13 # details.
14 #
15 # You should have received a copy of the GNU Lesser General Public License
16 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
17 # ____________________________________________________________
18 from time import time
19 import sys
20 import weakref
21 from tiramisu.error import ConfigError, SlaveError, PropertiesOptionError
22 from tiramisu.setting import owners, expires_time, undefined
23 from tiramisu.autolib import carry_out_calculation
24 from tiramisu.i18n import _
25 from tiramisu.option import SymLinkOption, OptionDescription
26
27
28 class Values(object):
29     """The `Config`'s root is indeed  in charge of the `Option()`'s values,
30     but the values are physicaly located here, in `Values`, wich is also
31     responsible of a caching utility.
32     """
33     __slots__ = ('context', '_p_', '__weakref__')
34
35     def __init__(self, context, storage):
36         """
37         Initializes the values's dict.
38
39         :param context: the context is the home config's values
40
41         """
42         self.context = weakref.ref(context)
43         # the storage type is dictionary or sqlite3
44         self._p_ = storage
45
46     def _getcontext(self):
47         """context could be None, we need to test it
48         context is None only if all reference to `Config` object is deleted
49         (for example we delete a `Config` and we manipulate a reference to
50         old `SubConfig`, `Values`, `Multi` or `Settings`)
51         """
52         context = self.context()
53         if context is None:
54             raise ConfigError(_('the context does not exist anymore'))
55         return context
56
57     def _getvalue(self, opt, path, is_default, index=undefined):
58         """actually retrieves the value
59
60         :param opt: the `option.Option()` object
61         :returns: the option's value (or the default value if not set)
62         """
63         setting = self._getcontext().cfgimpl_get_settings()
64         force_default = 'frozen' in setting[opt] and \
65             'force_default_on_freeze' in setting[opt]
66         if not is_default and not force_default:
67             value = self._p_.getvalue(path)
68             if index is not undefined:
69                 try:
70                     return value[index]
71                 except IndexError:
72                     #value is smaller than expected
73                     #so return default value
74                     pass
75             else:
76                 return value
77         #so default value
78         # if value has callback and is not set
79         if opt.impl_has_callback():
80             callback, callback_params = opt.impl_get_callback()
81             if callback_params is None:
82                 callback_params = {}
83             value = carry_out_calculation(opt, config=self._getcontext(),
84                                           callback=callback,
85                                           callback_params=callback_params,
86                                           index=index)
87             try:
88                 if isinstance(value, list) and index is not undefined:
89                     #if submulti and return a list of list, just return list
90                     if opt.impl_is_submulti():
91                         val = value[index]
92                         if isinstance(val, list):
93                             value = val
94                     else:
95                         value = value[index]
96                 return value
97             except IndexError:
98                 pass
99         meta = self._getcontext().cfgimpl_get_meta()
100         if meta is not None:
101             #FIXME : problème de longueur si meta + slave
102             #doit passer de meta à pas meta
103             #en plus il faut gérer la longueur avec les meta !
104             #FIXME SymlinkOption
105             value = meta.cfgimpl_get_values()[opt]
106             if isinstance(value, Multi):
107                 if index is not undefined:
108                     value = value[index]
109                 else:
110                     value = list(value)
111             return value
112         # now try to get default value
113         value = opt.impl_getdefault()
114         if opt.impl_is_multi() and index is not undefined:
115             if value is None:
116                 value = opt.impl_getdefault_multi()
117             else:
118                 try:
119                     value = value[index]
120                 except IndexError:
121                     value = opt.impl_getdefault_multi()
122         return value
123
124     def get_modified_values(self):
125         context = self._getcontext()
126         if context._impl_descr is not None:
127             for opt, path in context.cfgimpl_get_settings(
128             ).get_with_property('force_store_value'):
129                 self._getowner(opt, path, force_permissive=True)
130         return self._p_.get_modified_values()
131
132     def __contains__(self, opt):
133         """
134         implements the 'in' keyword syntax in order provide a pythonic way
135         to kow if an option have a value
136
137         :param opt: the `option.Option()` object
138         """
139         path = self._get_opt_path(opt)
140         return self._contains(path)
141
142     def _contains(self, path):
143         return self._p_.hasvalue(path)
144
145     def __delitem__(self, opt):
146         """overrides the builtins `del()` instructions"""
147         self.reset(opt)
148
149     def reset(self, opt, path=None):
150         if path is None:
151             path = self._get_opt_path(opt)
152         if self._p_.hasvalue(path):
153             context = self._getcontext()
154             setting = context.cfgimpl_get_settings()
155             opt.impl_validate(opt.impl_getdefault(),
156                               context, 'validator' in setting)
157             context.cfgimpl_reset_cache()
158             if opt.impl_is_master_slaves('master'):
159                 opt.impl_get_master_slaves().reset(self)
160             self._p_.resetvalue(path)
161
162     def _isempty(self, opt, value):
163         "convenience method to know if an option is empty"
164         empty = opt._empty
165         if value is not undefined:
166             empty_not_multi = not opt.impl_is_multi() and (value is None or
167                                                            value == empty)
168             empty_multi = opt.impl_is_multi() and (value == [] or
169                                                    None in value or
170                                                    empty in value)
171         else:
172             empty_multi = empty_not_multi = False
173         return empty_not_multi or empty_multi
174
175     def __getitem__(self, opt):
176         "enables us to use the pythonic dictionary-like access to values"
177         return self.getitem(opt)
178
179     def getitem(self, opt, validate=True, force_permissive=False):
180         """
181         """
182         return self._get_cached_item(opt, validate=validate,
183                                      force_permissive=force_permissive)
184
185     def _get_cached_item(self, opt, path=None, validate=True,
186                          force_permissive=False, force_properties=None,
187                          validate_properties=True):
188         if path is None:
189             path = self._get_opt_path(opt)
190         ntime = None
191         setting = self._getcontext().cfgimpl_get_settings()
192         if 'cache' in setting and self._p_.hascache(path):
193             if 'expire' in setting:
194                 ntime = int(time())
195             is_cached, value = self._p_.getcache(path, ntime)
196             if is_cached:
197                 if opt.impl_is_multi() and not isinstance(value, Multi):
198                     #load value so don't need to validate if is not a Multi
199                     value = Multi(value, self.context, opt, path)
200                 return value
201         val = self._getitem(opt, path, validate, force_permissive,
202                             force_properties, validate_properties)
203         if 'cache' in setting and validate and validate_properties and \
204                 force_permissive is False and force_properties is None:
205             if 'expire' in setting:
206                 if ntime is None:
207                     ntime = int(time())
208                 ntime = ntime + expires_time
209             self._p_.setcache(path, val, ntime)
210         return val
211
212     def _getitem(self, opt, path, validate, force_permissive, force_properties,
213                  validate_properties):
214         if opt.impl_is_master_slaves():
215             return opt.impl_get_master_slaves().getitem(self, opt, path,
216                                                         validate,
217                                                         force_permissive,
218                                                         force_properties,
219                                                         validate_properties)
220         else:
221             return self._get_validated_value(opt, path, validate,
222                                              force_permissive,
223                                              force_properties,
224                                              validate_properties)
225
226     def _get_validated_value(self, opt, path, validate, force_permissive,
227                              force_properties, validate_properties,
228                              index=undefined, submulti_index=undefined):
229         """same has getitem but don't touch the cache
230         index is None for slave value, if value returned is not a list, just return []
231         """
232         context = self._getcontext()
233         setting = context.cfgimpl_get_settings()
234         is_default = self._is_default_owner(opt, path,
235                                             validate_properties=False,
236                                             validate_meta=False)
237         try:
238             if index is None:
239                 gv_index = undefined
240             else:
241                 gv_index = index
242             value = self._getvalue(opt, path, is_default, index=gv_index)
243             config_error = None
244         except ConfigError as err:
245             # For calculating properties, we need value (ie for mandatory
246             # value).
247             # If value is calculating with a PropertiesOptionError's option
248             # _getvalue raise a ConfigError.
249             # We can not raise ConfigError if this option should raise
250             # PropertiesOptionError too. So we get config_error and raise
251             # ConfigError if properties did not raise.
252             # cannot assign config_err directly in python 3.3
253             config_error = err
254             # value is not set, for 'undefined' (cannot set None because of
255             # mandatory property)
256             value = undefined
257
258         if config_error is None:
259             if index is undefined:
260                 force_index = None
261             else:
262                 force_index = index
263             if opt.impl_is_multi():
264                 #for slave is a multi
265                 if index is None and not isinstance(value, list):
266                     value = []
267                 if force_index is None:
268                     value = Multi(value, self.context, opt, path)
269                 elif opt.impl_is_submulti() and submulti_index is undefined:
270                     value = SubMulti(value, self.context, opt, path,
271                                      force_index)
272
273             if validate:
274                 if submulti_index is undefined:
275                     force_submulti_index = None
276                 else:
277                     force_submulti_index = submulti_index
278
279                 opt.impl_validate(value, context, 'validator' in setting,
280                                   force_index=force_index,
281                                   force_submulti_index=force_submulti_index)
282             #FIXME pas de test avec les metas ...
283             #FIXME et les symlinkoption ...
284             if is_default and 'force_store_value' in setting[opt]:
285                 if isinstance(value, Multi):
286                     item = list(value)
287                 else:
288                     item = value
289                 self.setitem(opt, item, path, is_write=False,
290                              force_permissive=force_permissive)
291         if validate_properties:
292             setting.validate_properties(opt, False, False, value=value,
293                                         path=path,
294                                         force_permissive=force_permissive,
295                                         force_properties=force_properties)
296         if config_error is not None:
297             raise config_error
298         return value
299
300     def __setitem__(self, opt, value):
301         raise ValueError(_('you should only set value with config'))
302
303     def setitem(self, opt, value, path, force_permissive=False,
304                 is_write=True):
305         # is_write is, for example, used with "force_store_value"
306         # user didn't change value, so not write
307         # valid opt
308         context = self._getcontext()
309         opt.impl_validate(value, context,
310                           'validator' in context.cfgimpl_get_settings())
311         if opt.impl_is_multi():
312             #value = Multi(value, self.context, opt, path)
313             if opt.impl_is_master_slaves():
314                 opt.impl_get_master_slaves().setitem(self, opt, value, path)
315         self._setvalue(opt, path, value, force_permissive=force_permissive,
316                        is_write=is_write)
317
318     def _setvalue(self, opt, path, value, force_permissive=False,
319                   is_write=True, validate_properties=True):
320         context = self._getcontext()
321         context.cfgimpl_reset_cache()
322         if validate_properties:
323             setting = context.cfgimpl_get_settings()
324             setting.validate_properties(opt, False, is_write,
325                                         value=value, path=path,
326                                         force_permissive=force_permissive)
327         owner = context.cfgimpl_get_settings().getowner()
328         if isinstance(value, Multi):
329             value = list(value)
330             if opt.impl_is_submulti():
331                 for idx, val in enumerate(value):
332                     if isinstance(val, SubMulti):
333                         value[idx] = list(val)
334         self._p_.setvalue(path, value, owner)
335
336     def getowner(self, opt, force_permissive=False):
337         """
338         retrieves the option's owner
339
340         :param opt: the `option.Option` object
341         :param force_permissive: behaves as if the permissive property
342                                  was present
343         :returns: a `setting.owners.Owner` object
344         """
345         if isinstance(opt, SymLinkOption):
346             opt = opt._opt
347         path = self._get_opt_path(opt)
348         return self._getowner(opt, path, force_permissive=force_permissive)
349
350     def _getowner(self, opt, path, validate_properties=True,
351                   force_permissive=False, validate_meta=True):
352         if validate_properties:
353             self._getitem(opt, path, True, force_permissive, None, True)
354         owner = self._p_.getowner(path, owners.default)
355         if validate_meta:
356             meta = self._getcontext().cfgimpl_get_meta()
357             if owner is owners.default and meta is not None:
358                 owner = meta.cfgimpl_get_values()._getowner(opt, path)
359         return owner
360
361     def setowner(self, opt, owner):
362         """
363         sets a owner to an option
364
365         :param opt: the `option.Option` object
366         :param owner: a valid owner, that is a `setting.owners.Owner` object
367         """
368         if not isinstance(owner, owners.Owner):
369             raise TypeError(_("invalid generic owner {0}").format(str(owner)))
370
371         path = self._get_opt_path(opt)
372         self._setowner(opt, path, owner)
373
374     def _setowner(self, opt, path, owner):
375         if self._getowner(opt, path) == owners.default:
376             raise ConfigError(_('no value for {0} cannot change owner to {1}'
377                                 '').format(path, owner))
378         self._p_.setowner(path, owner)
379
380     def is_default_owner(self, opt, validate_properties=True,
381                          validate_meta=True):
382         """
383         :param config: *must* be only the **parent** config
384                        (not the toplevel config)
385         :return: boolean
386         """
387         path = self._get_opt_path(opt)
388         return self._is_default_owner(opt, path,
389                                       validate_properties=validate_properties,
390                                       validate_meta=validate_meta)
391
392     def _is_default_owner(self, opt, path, validate_properties=True,
393                           validate_meta=True):
394         return self._getowner(opt, path, validate_properties,
395                               validate_meta=validate_meta) == owners.default
396
397     def reset_cache(self, only_expired):
398         """
399         clears the cache if necessary
400         """
401         if only_expired:
402             self._p_.reset_expired_cache(int(time()))
403         else:
404             self._p_.reset_all_cache()
405
406     def _get_opt_path(self, opt):
407         """
408         retrieve the option's path in the config
409
410         :param opt: the `option.Option` object
411         :returns: a string with points like "gc.dummy.my_option"
412         """
413         return self._getcontext().cfgimpl_get_description(
414         ).impl_get_path_by_opt(opt)
415
416     # information
417     def set_information(self, key, value):
418         """updates the information's attribute
419
420         :param key: information's key (ex: "help", "doc"
421         :param value: information's value (ex: "the help string")
422         """
423         self._p_.set_information(key, value)
424
425     def get_information(self, key, default=undefined):
426         """retrieves one information's item
427
428         :param key: the item string (ex: "help")
429         """
430         try:
431             return self._p_.get_information(key)
432         except ValueError:
433             if default is not undefined:
434                 return default
435             else:
436                 raise ValueError(_("information's item"
437                                    " not found: {0}").format(key))
438
439     def mandatory_warnings(self):
440         """convenience function to trace Options that are mandatory and
441         where no value has been set
442
443         :returns: generator of mandatory Option's path
444
445         """
446         def _mandatory_warnings(description):
447             #if value in cache, properties are not calculated
448             for opt in description.impl_getchildren():
449                 if isinstance(opt, OptionDescription):
450                     _mandatory_warnings(opt)
451                 elif isinstance(opt, SymLinkOption):
452                     pass
453                 else:
454                     path = self._get_opt_path(opt)
455                     try:
456                         self._get_cached_item(opt, path=path,
457                                               force_properties=frozenset(('mandatory',)))
458                     except PropertiesOptionError as err:
459                         if err.proptype == ['mandatory']:
460                             yield path
461         self.reset_cache(False)
462         descr = self._getcontext().cfgimpl_get_description()
463         ret = list(_mandatory_warnings(descr))
464         self.reset_cache(False)
465         return ret
466
467     def force_cache(self):
468         """parse all option to force data in cache
469         """
470         context = self.context()
471         if not 'cache' in context.cfgimpl_get_settings():
472             raise ConfigError(_('can force cache only if cache '
473                                 'is actived in config'))
474         #remove all cached properties and value to update "expired" time
475         context.cfgimpl_reset_cache()
476         for path in context.cfgimpl_get_description().impl_getpaths(
477                 include_groups=True):
478             try:
479                 context.getattr(path)
480             except PropertiesOptionError:
481                 pass
482
483     def __getstate__(self):
484         return {'_p_': self._p_}
485
486     def _impl_setstate(self, storage):
487         self._p_._storage = storage
488
489     def __setstate__(self, states):
490         self._p_ = states['_p_']
491
492
493 # ____________________________________________________________
494 # multi types
495
496 class Multi(list):
497     """multi options values container
498     that support item notation for the values of multi options"""
499     __slots__ = ('opt', 'path', 'context', '__weakref__')
500
501     def __init__(self, value, context, opt, path):
502         """
503         :param value: the Multi wraps a list value
504         :param context: the home config that has the values
505         :param opt: the option object that have this Multi value
506         :param path: path of the option
507         """
508         if value is None:
509             value = []
510         if not opt.impl_is_submulti() and isinstance(value, Multi):
511             raise ValueError(_('{0} is already a Multi ').format(
512                 opt.impl_getname()))
513         self.opt = opt
514         self.path = path
515         if not isinstance(context, weakref.ReferenceType):
516             raise ValueError('context must be a Weakref')
517         self.context = context
518         if not isinstance(value, list):
519             if not '_index' in self.__slots__ and opt.impl_is_submulti():
520                 value = [[value]]
521             else:
522                 value = [value]
523         elif value != [] and not '_index' in self.__slots__ and \
524                 opt.impl_is_submulti() and not isinstance(value[0], list):
525             value = [value]
526         super(Multi, self).__init__(value)
527         if opt.impl_is_submulti():
528             if not '_index' in self.__slots__:
529                 for idx, val in enumerate(self):
530                     if not isinstance(val, SubMulti):
531                         super(Multi, self).__setitem__(idx, SubMulti(val,
532                                                                      context,
533                                                                      opt, path,
534                                                                      idx))
535                     #FIXME weakref ??
536                     self[idx].submulti = weakref.ref(self)
537
538     def _getcontext(self):
539         """context could be None, we need to test it
540         context is None only if all reference to `Config` object is deleted
541         (for example we delete a `Config` and we manipulate a reference to
542         old `SubConfig`, `Values`, `Multi` or `Settings`)
543         """
544         context = self.context()
545         if context is None:
546             raise ConfigError(_('the context does not exist anymore'))
547         return context
548
549     def __setitem__(self, index, value):
550         self._setitem(index, value)
551
552     def _setitem(self, index, value):
553         self._validate(value, index, True)
554         #assume not checking mandatory property
555         super(Multi, self).__setitem__(index, value)
556         self._getcontext().cfgimpl_get_values()._setvalue(self.opt, self.path,
557                                                           self)
558
559     #def __repr__(self, *args, **kwargs):
560     #    print args, kwargs
561     #    return super(Multi, self).__repr__(*args, **kwargs)
562
563     #def __getitem__(self, y):
564     #    return super(Multi, self).__getitem__(y)
565
566     def _get_validated_value(self, index):
567         values = self._getcontext().cfgimpl_get_values()
568         return values._get_validated_value(self.opt, self.path,
569                                            True, False, None, True,
570                                            index=index)
571
572     def append(self, value=undefined, force=False, setitem=True):
573         """the list value can be updated (appened)
574         only if the option is a master
575         """
576         if not force:
577             if self.opt.impl_is_master_slaves('slave'):
578                 raise SlaveError(_("cannot append a value on a multi option {0}"
579                                    " which is a slave").format(self.opt.impl_getname()))
580         index = self.__len__()
581         if value is undefined:
582             try:
583                 value = self._get_validated_value(index)
584             except IndexError:
585                 value = None
586         self._validate(value, index, True)
587         if not '_index' in self.__slots__ and self.opt.impl_is_submulti():
588             if not isinstance(value, SubMulti):
589                 value = SubMulti(value, self.context, self.opt, self.path, index)
590             value.submulti = weakref.ref(self)
591         super(Multi, self).append(value)
592         if setitem:
593             self._store(force)
594
595     def sort(self, cmp=None, key=None, reverse=False):
596         if self.opt.impl_is_master_slaves():
597             raise SlaveError(_("cannot sort multi option {0} if master or slave"
598                                "").format(self.opt.impl_getname()))
599         if sys.version_info[0] >= 3:
600             if cmp is not None:
601                 raise ValueError(_('cmp is not permitted in python v3 or '
602                                    'greater'))
603             super(Multi, self).sort(key=key, reverse=reverse)
604         else:
605             super(Multi, self).sort(cmp=cmp, key=key, reverse=reverse)
606         self._store()
607
608     def reverse(self):
609         if self.opt.impl_is_master_slaves():
610             raise SlaveError(_("cannot reverse multi option {0} if master or "
611                                "slave").format(self.opt.impl_getname()))
612         super(Multi, self).reverse()
613         self._store()
614
615     def insert(self, index, obj):
616         #FIXME obj should be undefined
617         if self.opt.impl_is_master_slaves():
618             raise SlaveError(_("cannot insert multi option {0} if master or "
619                                "slave").format(self.opt.impl_getname()))
620         self._validate(obj, index, True)
621         super(Multi, self).insert(index, obj)
622         self._store()
623
624     def extend(self, iterable):
625         if self.opt.impl_is_master_slaves():
626             raise SlaveError(_("cannot extend multi option {0} if master or "
627                                "slave").format(self.opt.impl_getname()))
628         try:
629             index = self._index
630         except:
631             index = None
632         self._validate(iterable, index)
633         super(Multi, self).extend(iterable)
634         self._store()
635
636     def _validate(self, value, force_index, submulti=False):
637         if value is not None:
638             self.opt.impl_validate(value, context=self._getcontext(),
639                                    force_index=force_index)
640
641     def pop(self, index, force=False):
642         """the list value can be updated (poped)
643         only if the option is a master
644
645         :param index: remove item a index
646         :type index: int
647         :param force: force pop item (withoud check master/slave)
648         :type force: boolean
649         :returns: item at index
650         """
651         context = self._getcontext()
652         if not force:
653             if self.opt.impl_is_master_slaves('slave'):
654                 raise SlaveError(_("cannot pop a value on a multi option {0}"
655                                    " which is a slave").format(self.opt.impl_getname()))
656             if self.opt.impl_is_master_slaves('master'):
657                 self.opt.impl_get_master_slaves().pop(
658                     context.cfgimpl_get_values(), index)
659         #set value without valid properties
660         ret = super(Multi, self).pop(index)
661         self._store(force)
662         return ret
663
664     def _store(self, force=False):
665         self._getcontext().cfgimpl_get_values()._setvalue(self.opt, self.path,
666                                                           self,
667                                                           validate_properties=not force)
668
669
670 class SubMulti(Multi):
671     __slots__ = ('_index', 'submulti')
672
673     def __init__(self, value, context, opt, path, index):
674         """
675         :param index: index (only for slave with submulti)
676         :type index: `int`
677         """
678         self._index = index
679         super(SubMulti, self).__init__(value, context, opt, path)
680
681     def append(self, value=undefined):
682         super(SubMulti, self).append(value, force=True)
683
684     def pop(self, index):
685         return super(SubMulti, self).pop(index, force=True)
686
687     def __setitem__(self, index, value):
688         self._setitem(index, value)
689
690     def _store(self, force=False):
691         #force is unused here
692         self._getcontext().cfgimpl_get_values()._setvalue(self.opt,
693                                                           self.path,
694                                                           self.submulti())
695
696     def _validate(self, value, force_index, submulti=False):
697         if value is not None:
698             if submulti is False:
699                 super(SubMulti, self)._validate(value, force_index)
700             else:
701                 self.opt.impl_validate(value, context=self._getcontext(),
702                                        force_index=self._index,
703                                        force_submulti_index=force_index)
704
705     def _get_validated_value(self, index):
706         values = self._getcontext().cfgimpl_get_values()
707         return values._get_validated_value(self.opt, self.path,
708                                            True, False, None, True,
709                                            index=index,
710                                            submulti_index=self._index)