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