tiramisu/option/baseoption.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2014 Team tiramisu (see AUTHORS for all contributors)
   3 #
   4 # This program is free software: you can redistribute it and/or modify it
   5 # under the terms of the GNU Lesser General Public License as published by the
   6 # Free Software Foundation, either version 3 of the License, or (at your
   7 # option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful, but WITHOUT
  10 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  11 # FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
  12 # details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public License
  15 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 #
  17 # The original `Config` design model is unproudly borrowed from
  18 # the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
  19 # the whole pypy projet is under MIT licence
  20 # ____________________________________________________________
  21 import re
  22 from types import FunctionType
  23 import warnings
  24 import sys
  25
  26 from ..i18n import _
  27 from ..setting import log, undefined, debug
  28 from ..autolib import carry_out_calculation
  29 from ..error import (ConfigError, ValueWarning, PropertiesOptionError,
  30     display_list)
  31 from ..storage import get_storages_option
  32 from . import MasterSlaves
  33
  34
  35 StorageBase = get_storages_option('base')
  36 submulti = 2
  37 name_regexp = re.compile(r'^[a-z][a-zA-Z\d\-_]*$')
  38 forbidden_names = frozenset(['iter_all', 'iter_group', 'find', 'find_first',
  39                              'make_dict', 'unwrap_from_path', 'read_only',
  40                              'read_write', 'getowner', 'set_contexts'])
  41
  42
  43 def valid_name(name):
  44     "an option's name is a str and does not start with 'impl' or 'cfgimpl'"
  45     if not isinstance(name, str):  # pragma: optional cover
  46         return False
  47     if re.match(name_regexp, name) is not None and \
  48             name not in forbidden_names and \
  49             not name.startswith('impl_') and \
  50             not name.startswith('cfgimpl_'):
  51         return True
  52     else:  # pragma: optional cover
  53         return False
  54
  55
  56 def validate_callback(callback, callback_params, type_):
  57     if type(callback) != FunctionType:  # pragma: optional cover
  58         raise ValueError(_('{0} must be a function').format(type_))
  59     if callback_params is not None:
  60         if not isinstance(callback_params, dict):  # pragma: optional cover
  61             raise ValueError(_('{0}_params must be a dict').format(type_))
  62         for key, callbacks in callback_params.items():
  63             if key != '' and len(callbacks) != 1:  # pragma: optional cover
  64                 raise ValueError(_("{0}_params with key {1} mustn't have "
  65                                    "length different to 1").format(type_,
  66                                                                    key))
  67             if not isinstance(callbacks, tuple):  # pragma: optional cover
  68                 raise ValueError(_('{0}_params must be tuple for key "{1}"'
  69                                    ).format(type_, key))
  70             for callbk in callbacks:
  71                 if isinstance(callbk, tuple):
  72                     if len(callbk) == 1:
  73                         if callbk != (None,):  # pragma: optional cover
  74                             raise ValueError(_('{0}_params with length of '
  75                                                'tuple as 1 must only have '
  76                                                'None as first value'))
  77                     elif len(callbk) != 2:  # pragma: optional cover
  78                         raise ValueError(_('{0}_params must only have 1 or 2 '
  79                                            'as length'))
  80                     else:
  81                         option, force_permissive = callbk
  82                         if not isinstance(option, Option) and not \
  83                                 isinstance(option, SymLinkOption):  # pragma: optional cover
  84                             raise ValueError(_('{0}_params must have an option'
  85                                                ' not a {0} for first argument'
  86                                                ).format(type_, type(option)))
  87                         if force_permissive not in [True, False]:  # pragma: optional cover
  88                             raise ValueError(_('{0}_params must have a boolean'
  89                                                ' not a {0} for second argument'
  90                                                ).format(type_, type(
  91                                                    force_permissive)))
  92 #____________________________________________________________
  93 #
  94
  95
  96 class Base(StorageBase):
  97     __slots__ = tuple()
  98
  99     def __init__(self, name, doc, default=None, default_multi=None,
 100                  requires=None, multi=False, callback=None,
 101                  callback_params=None, validator=None, validator_params=None,
 102                  properties=None, warnings_only=False, extra=None,
 103                  allow_empty_list=undefined, session=None):
 104         if not valid_name(name):  # pragma: optional cover
 105             raise ValueError(_("invalid name: {0} for option").format(name))
 106         if not multi and default_multi is not None:  # pragma: optional cover
 107             raise ValueError(_("default_multi is set whereas multi is False"
 108                              " in option: {0}").format(name))
 109         if multi is True:
 110             is_multi = True
 111             _multi = 0
 112         elif multi is False:
 113             is_multi = False
 114             _multi = 1
 115         elif multi is submulti:
 116             is_multi = True
 117             _multi = submulti
 118         else:
 119             raise ValueError(_('invalid multi value'))
 120         if requires is not None:
 121             calc_properties, requires = validate_requires_arg(is_multi,
 122                                                               requires, name)
 123         else:
 124             calc_properties = frozenset()
 125             requires = undefined
 126         if properties is None:
 127             properties = tuple()
 128         if not isinstance(properties, tuple):  # pragma: optional cover
 129             raise TypeError(_('invalid properties type {0} for {1},'
 130                             ' must be a tuple').format(
 131                                 type(properties),
 132                                 name))
 133         if validator is not None:
 134             validate_callback(validator, validator_params, 'validator')
 135             self._set_validator(validator, validator_params)
 136         if calc_properties != frozenset([]) and properties is not tuple():  # pragma: optional cover
 137             set_forbidden_properties = calc_properties & set(properties)
 138             if set_forbidden_properties != frozenset():
 139                 raise ValueError('conflict: properties already set in '
 140                                  'requirement {0}'.format(
 141                                      list(set_forbidden_properties)))
 142         if session is None:
 143             session = self.getsession()
 144         StorageBase.__init__(self, name, _multi, warnings_only, doc, extra,
 145                              calc_properties, requires, properties,
 146                              allow_empty_list, session=session)
 147         if multi is not False and default is None:
 148             default = []
 149         err = self.impl_validate(default, is_multi=is_multi)
 150         if err:
 151             raise err
 152         self._set_default_values(default, default_multi, is_multi)
 153         ##callback is False in optiondescription
 154         if callback is not False:
 155             self.impl_set_callback(callback, callback_params, _init=True)
 156         self.commit(session)
 157
 158     def impl_set_callback(self, callback, callback_params=None, _init=False):
 159         if callback is None and callback_params is not None:  # pragma: optional cover
 160                 raise ValueError(_("params defined for a callback function but "
 161                                    "no callback defined"
 162                                    " yet for option {0}").format(
 163                                        self.impl_getname()))
 164         if not _init and self.impl_get_callback()[0] is not None:
 165             raise ConfigError(_("a callback is already set for option {0}, "
 166                                 "cannot set another one's").format(self.impl_getname()))
 167         self._validate_callback(callback, callback_params)
 168         if callback is not None:
 169             validate_callback(callback, callback_params, 'callback')
 170             self._set_callback(callback, callback_params)
 171
 172     def impl_is_optiondescription(self):
 173         return self.__class__.__name__ in ['OptionDescription',
 174                                            'DynOptionDescription',
 175                                            'SynDynOptionDescription']
 176
 177     def impl_is_dynoptiondescription(self):
 178         return self.__class__.__name__ in ['DynOptionDescription',
 179                                            'SynDynOptionDescription']
 180
 181
 182 class BaseOption(Base):
 183     """This abstract base class stands for attribute access
 184     in options that have to be set only once, it is of course done in the
 185     __setattr__ method
 186     """
 187     __slots__ = tuple()
 188
 189     # ____________________________________________________________
 190     # serialize object
 191     def _impl_convert_requires(self, descr, load=False):
 192         """export of the requires during the serialization process
 193
 194         :type descr: :class:`tiramisu.option.OptionDescription`
 195         :param load: `True` if we are at the init of the option description
 196         :type load: bool
 197         """
 198         if not load and self.impl_getrequires() == []:
 199             self._state_requires = None
 200         elif load and self._state_requires is None:
 201             del(self._state_requires)
 202         else:
 203             if load:
 204                 _requires = self._state_requires
 205             else:
 206                 _requires = self.impl_getrequires()
 207             new_value = []
 208             for requires in _requires:
 209                 new_requires = []
 210                 for require in requires:
 211                     if load:
 212                         new_require = [descr.impl_get_opt_by_path(require[0])]
 213                     else:
 214                         new_require = [descr.impl_get_path_by_opt(require[0])]
 215                     new_require.extend(require[1:])
 216                     new_requires.append(tuple(new_require))
 217                 new_value.append(tuple(new_requires))
 218             if load:
 219                 del(self._state_requires)
 220                 if new_value != []:
 221                     self._requires = new_value
 222             else:
 223                 self._state_requires = new_value
 224
 225     # serialize
 226     def _impl_getstate(self, descr):
 227         """the under the hood stuff that need to be done
 228         before the serialization.
 229
 230         :param descr: the parent :class:`tiramisu.option.OptionDescription`
 231         """
 232         self._stated = True
 233         for func in dir(self):
 234             if func.startswith('_impl_convert_'):
 235                 getattr(self, func)(descr)
 236
 237     def __getstate__(self, stated=True):
 238         """special method to enable the serialization with pickle
 239         Usualy, a `__getstate__` method does'nt need any parameter,
 240         but somme under the hood stuff need to be done before this action
 241
 242         :parameter stated: if stated is `True`, the serialization protocol
 243                            can be performed, not ready yet otherwise
 244         :parameter type: bool
 245         """
 246         try:
 247             self._stated
 248         except AttributeError:  # pragma: optional cover
 249             raise SystemError(_('cannot serialize Option, '
 250                                 'only in OptionDescription'))
 251         if isinstance(self, SymLinkOption):
 252             slots = frozenset(['_name', '_state_opt', '_stated'])
 253         else:
 254             slots = self._impl_getattributes()
 255             slots -= frozenset(['_cache_paths', '_cache_consistencies',
 256                                 '__weakref__'])
 257         states = {}
 258         for slot in slots:
 259             # remove variable if save variable converted
 260             # in _state_xxxx variable
 261             if '_state' + slot not in slots:
 262                 try:
 263                     if slot.startswith('_state'):
 264                         states[slot] = getattr(self, slot)
 265                         # remove _state_xxx variable
 266                         self.__delattr__(slot)
 267                     else:
 268                         states[slot] = getattr(self, slot)
 269                 except AttributeError:
 270                     pass
 271         if not stated:
 272             del(states['_stated'])
 273         return states
 274
 275     # unserialize
 276     def _impl_setstate(self, descr):
 277         """the under the hood stuff that need to be done
 278         before the serialization.
 279
 280         :type descr: :class:`tiramisu.option.OptionDescription`
 281         """
 282         for func in dir(self):
 283             if func.startswith('_impl_convert_'):
 284                 getattr(self, func)(descr, load=True)
 285         try:
 286             del(self._stated)
 287         except AttributeError:  # pragma: optional cover
 288             pass
 289
 290     def __setstate__(self, state):
 291         """special method that enables us to serialize (pickle)
 292
 293         Usualy, a `__setstate__` method does'nt need any parameter,
 294         but somme under the hood stuff need to be done before this action
 295
 296         :parameter state: a dict is passed to the loads, it is the attributes
 297                           of the options object
 298         :type state: dict
 299         """
 300         for key, value in state.items():
 301             setattr(self, key, value)
 302
 303     def __setattr__(self, name, value):
 304         """set once and only once some attributes in the option,
 305         like `_name`. `_name` cannot be changed one the option and
 306         pushed in the :class:`tiramisu.option.OptionDescription`.
 307
 308         if the attribute `_readonly` is set to `True`, the option is
 309         "frozen" (which has noting to do with the high level "freeze"
 310         propertie or "read_only" property)
 311         """
 312         if name != '_option' and \
 313                 not isinstance(value, tuple) and \
 314                 not name.startswith('_state') and \
 315                 not name == '_sa_instance_state':
 316             is_readonly = False
 317             # never change _name dans _opt
 318             if name == '_name':
 319                 try:
 320                     if self.impl_getname() is not None:
 321                         #so _name is already set
 322                         is_readonly = True
 323                 except (KeyError, AttributeError):
 324                     pass
 325             elif name == '_opt':
 326                 pass
 327             elif name != '_readonly':
 328                 is_readonly = self.impl_is_readonly()
 329             if is_readonly:  # pragma: optional cover
 330                 raise AttributeError(_("'{0}' ({1}) object attribute '{2}' is"
 331                                        " read-only").format(
 332                                            self.__class__.__name__,
 333                                            self,
 334                                            #self.impl_getname(),
 335                                            name))
 336         super(BaseOption, self).__setattr__(name, value)
 337
 338     def impl_getpath(self, context):
 339         return context.cfgimpl_get_description().impl_get_path_by_opt(self)
 340
 341     def impl_has_callback(self):
 342         "to know if a callback has been defined or not"
 343         return self.impl_get_callback()[0] is not None
 344
 345     def _is_subdyn(self):
 346         return getattr(self, '_subdyn', None) is not None
 347
 348     def _impl_valid_unicode(self, value):
 349         if sys.version_info[0] >= 3:
 350             if not isinstance(value, str):
 351                 return ValueError(_('invalid string'))
 352         else:
 353             if not isinstance(value, unicode) and not isinstance(value, str):
 354                 return ValueError(_('invalid unicode or string'))
 355
 356
 357 class OnlyOption(BaseOption):
 358     __slots__ = tuple()
 359
 360
 361 class Option(OnlyOption):
 362     """
 363     Abstract base class for configuration option's.
 364
 365     Reminder: an Option object is **not** a container for the value.
 366     """
 367     __slots__ = tuple()
 368     _empty = ''
 369
 370     def _launch_consistency(self, current_opt, func, option, value, context,
 371                             index, submulti_index, all_cons_opts, warnings_only,
 372                             transitive):
 373         """Launch consistency now
 374
 375         :param func: function name, this name should start with _cons_
 376         :type func: `str`
 377         :param option: option that value is changing
 378         :type option: `tiramisu.option.Option`
 379         :param value: new value of this option
 380         :param context: Config's context, if None, check default value instead
 381         :type context: `tiramisu.config.Config`
 382         :param index: only for multi option, consistency should be launch for
 383                       specified index
 384         :type index: `int`
 385         :param all_cons_opts: all options concerne by this consistency
 386         :type all_cons_opts: `list` of `tiramisu.option.Option`
 387         :param warnings_only: specific raise error for warning
 388         :type warnings_only: `boolean`
 389         :param transitive: propertyerror is transitive
 390         :type transitive: `boolean`
 391         """
 392         if context is not undefined:
 393             descr = context.cfgimpl_get_description()
 394
 395         all_cons_vals = []
 396         val_consistencies = True
 397         for opt in all_cons_opts:
 398
 399             if (isinstance(opt, DynSymLinkOption) and option._dyn == opt._dyn) or \
 400                     option == opt:
 401                 # option is current option
 402                 # we have already value, so use it
 403                 all_cons_vals.append(value)
 404             else:
 405                 #if context, calculate value, otherwise get default value
 406                 path = None
 407                 if context is not undefined:
 408                     if isinstance(opt, DynSymLinkOption):
 409                         path = opt.impl_getpath(context)
 410                     else:
 411                         path = descr.impl_get_path_by_opt(opt)
 412                     opt_value = context.getattr(path, validate=False,
 413                                                 index=index,
 414                                                 force_permissive=True,
 415                                                 returns_raise=True)
 416                     if isinstance(opt_value, Exception):
 417                         if isinstance(opt_value, PropertiesOptionError):
 418                             if debug:
 419                                 log.debug('propertyerror in _launch_consistency: {0}'.format(opt_value))
 420                             if transitive:
 421                                 return opt_value
 422                             else:
 423                                 opt_value = None
 424                         else:
 425                             return opt_value
 426                 elif index is None:
 427                     opt_value = opt.impl_getdefault()
 428                 else:
 429                     opt_value = opt.impl_getdefault()[index]
 430
 431                 if self.impl_is_multi() and index is None:
 432                     # only check propertyerror for master/slaves is transitive
 433                     val_consistencies = False
 434                 all_cons_vals.append(opt_value)
 435
 436         if val_consistencies:
 437             return getattr(self, func)(current_opt, all_cons_opts, all_cons_vals, warnings_only)
 438
 439     def impl_validate(self, value, context=undefined, validate=True,
 440                       force_index=None, force_submulti_index=None,
 441                       current_opt=undefined, is_multi=None,
 442                       display_warnings=True):
 443         """
 444         :param value: the option's value
 445         :param context: Config's context
 446         :type context: :class:`tiramisu.config.Config`
 447         :param validate: if true enables ``self._validator`` validation
 448         :type validate: boolean
 449         :param force_index: if multi, value has to be a list
 450                             not if force_index is not None
 451         :type force_index: integer
 452         :param force_submulti_index: if submulti, value has to be a list
 453                                      not if force_submulti_index is not None
 454         :type force_submulti_index: integer
 455         """
 456         if not validate:
 457             return
 458         if current_opt is undefined:
 459             current_opt = self
 460
 461         def calculation_validator(val):
 462             validator, validator_params = self.impl_get_validator()
 463             if validator is not None:
 464                 if validator_params != {}:
 465                     validator_params_ = {}
 466                     for val_param, values in validator_params.items():
 467                         validator_params_[val_param] = values
 468                     #inject value in calculation
 469                     if '' in validator_params_:
 470                         lst = list(validator_params_[''])
 471                         lst.insert(0, val)
 472                         validator_params_[''] = tuple(lst)
 473                     else:
 474                         validator_params_[''] = (val,)
 475                 else:
 476                     validator_params_ = {'': (val,)}
 477                 # Raise ValueError if not valid
 478                 value = carry_out_calculation(current_opt, context=context,
 479                                               callback=validator,
 480                                               callback_params=validator_params_,
 481                                               returns_raise=True)
 482                 if isinstance(value, Exception):
 483                     return value
 484
 485         def do_validation(_value, _index, submulti_index):
 486             if _value is None:
 487                 error = warning = None
 488             else:
 489                 # option validation
 490                 err = self._validate(_value, context, current_opt,
 491                                      returns_raise=True)
 492                 if err:
 493                     if debug:
 494                         log.debug('do_validation: value: {0}, index: {1}, '
 495                                   'submulti_index: {2}'.format(_value, _index,
 496                                                                submulti_index),
 497                                   exc_info=True)
 498                     err_msg = '{0}'.format(err)
 499                     name = self.impl_getdoc()
 500                     if name is None or name == '':
 501                         name = self.impl_getname()
 502                     if err_msg:
 503                         msg = _('"{0}" is an invalid {1} for "{2}", {3}'
 504                                 '').format(_value, self._display_name,
 505                                            self.impl_get_display_name(), err_msg)
 506                     else:
 507                         msg = _('"{0}" is an invalid {1} for "{2}"'
 508                                 '').format(_value, self._display_name,
 509                                            self.impl_get_display_name())
 510                     return ValueError(msg)
 511                 warning = None
 512                 error = None
 513                 if display_warnings:
 514                     error = calculation_validator(_value)
 515                     if not error:
 516                         error = self._second_level_validation(_value, self._is_warnings_only())
 517                     if error:
 518                         if debug:
 519                             log.debug(_('do_validation for {0}: error in value').format(
 520                                 self.impl_getname()), exc_info=True)
 521                         if self._is_warnings_only():
 522                             warning = error
 523                             error = None
 524             if error is None and warning is None:
 525                 # if context launch consistency validation
 526                 #if context is not undefined:
 527                 ret = self._valid_consistency(current_opt, _value, context,
 528                                               _index, submulti_index)
 529                 if ret:
 530                     if isinstance(ret, ValueWarning):
 531                         if display_warnings:
 532                             warning = ret
 533                     elif isinstance(ret, ValueError):
 534                         error = ret
 535                     else:
 536                         return ret
 537             if warning:
 538                 msg = _('attention, "{0}" could be an invalid {1} for "{2}", {3}').format(
 539                     _value, self._display_name, self.impl_get_display_name(), warning)
 540                 if context is undefined or 'warnings' in \
 541                         context.cfgimpl_get_settings():
 542                     warnings.warn_explicit(ValueWarning(msg, self),
 543                                            ValueWarning,
 544                                            self.__class__.__name__, 0)
 545             elif error:
 546                 err_msg = '{0}'.format(error)
 547                 if err_msg:
 548                     msg = _('"{0}" is an invalid {1} for "{2}", {3}'
 549                             '').format(_value, self._display_name,
 550                                        self.impl_get_display_name(), err_msg)
 551                 else:
 552                     msg = _('"{0}" is an invalid {1} for "{2}"'
 553                             '').format(_value, self._display_name,
 554                                        self.impl_get_display_name())
 555                 return ValueError(msg)
 556
 557         # generic calculation
 558         #if context is not undefined:
 559         #    descr = context.cfgimpl_get_description()
 560
 561         if is_multi is None:
 562             is_multi = self.impl_is_multi()
 563         if not is_multi:
 564             return do_validation(value, None, None)
 565         elif force_index is not None:
 566             if self.impl_is_submulti() and force_submulti_index is None:
 567                 if not isinstance(value, list):  # pragma: optional cover
 568                     raise ValueError(_("invalid value {0} for option {1} which"
 569                                        " must be a list").format(
 570                                            value, self.impl_getname()))
 571                 for idx, val in enumerate(value):
 572                     err = do_validation(val, force_index, idx)
 573                     if err:
 574                         return err
 575             else:
 576                 return do_validation(value, force_index, force_submulti_index)
 577         elif not isinstance(value, list):  # pragma: optional cover
 578             return ValueError(_("invalid value {0} for option {1} which "
 579                                 "must be a list").format(value,
 580                                                          self.impl_getname()))
 581         elif self.impl_is_submulti() and force_submulti_index is None:
 582             for idx, val in enumerate(value):
 583                 if not isinstance(val, list):  # pragma: optional cover
 584                     return ValueError(_("invalid value {0} for option {1} "
 585                                         "which must be a list of list"
 586                                         "").format(value,
 587                                                    self.impl_getname()))
 588                 for slave_idx, slave_val in enumerate(val):
 589                     err = do_validation(slave_val, idx, slave_idx)
 590                     if err:
 591                         return err
 592         else:
 593             for idx, val in enumerate(value):
 594                 err = do_validation(val, idx, force_submulti_index)
 595                 if err:
 596                     return err
 597             else:
 598                 return self._valid_consistency(current_opt, None, context,
 599                                                None, None)
 600
 601     def impl_is_dynsymlinkoption(self):
 602         return False
 603
 604     def impl_is_master_slaves(self, type_='both'):
 605         """FIXME
 606         """
 607         master_slaves = self.impl_get_master_slaves()
 608         if master_slaves is not None:
 609             if type_ in ('both', 'master') and \
 610                     master_slaves.is_master(self):
 611                 return True
 612             if type_ in ('both', 'slave') and \
 613                     not master_slaves.is_master(self):
 614                 return True
 615         return False
 616
 617     def impl_get_master_slaves(self):
 618         masterslaves = self._get_master_slave()
 619         if masterslaves is None:
 620             return None
 621         if not isinstance(masterslaves, MasterSlaves):
 622             return MasterSlaves(masterslaves)
 623         return masterslaves
 624
 625     def impl_getdoc(self):
 626         "accesses the Option's doc"
 627         return self.impl_get_information('doc')
 628
 629     def impl_get_display_name(self):
 630         name = self.impl_getdoc()
 631         if name is None or name == '':
 632             name = self.impl_getname()
 633         return name
 634
 635     def _valid_consistencies(self, other_opts):
 636         if self._is_subdyn():
 637             dynod = self._impl_getsubdyn()
 638         else:
 639             dynod = None
 640         if self.impl_is_submulti():
 641             raise ConfigError(_('cannot add consistency with submulti option'))
 642         is_multi = self.impl_is_multi()
 643         for opt in other_opts:
 644             if opt.impl_is_submulti():
 645                 raise ConfigError(_('cannot add consistency with submulti option'))
 646             if not isinstance(opt, Option):  # pragma: optional cover
 647                 raise ConfigError(_('consistency must be set with an option'))
 648             if opt._is_subdyn():
 649                 if dynod is None:
 650                     raise ConfigError(_('almost one option in consistency is '
 651                                         'in a dynoptiondescription but not all'))
 652                 if dynod != opt._impl_getsubdyn():
 653                     raise ConfigError(_('option in consistency must be in same'
 654                                         ' dynoptiondescription'))
 655                 dynod = opt._impl_getsubdyn()
 656             elif dynod is not None:
 657                 raise ConfigError(_('almost one option in consistency is in a '
 658                                     'dynoptiondescription but not all'))
 659             if self is opt:  # pragma: optional cover
 660                 raise ConfigError(_('cannot add consistency with itself'))
 661             if is_multi != opt.impl_is_multi():  # pragma: optional cover
 662                 raise ConfigError(_('every options in consistency must be '
 663                                     'multi or none'))
 664
 665     def impl_add_consistency(self, func, *other_opts, **params):
 666         """Add consistency means that value will be validate with other_opts
 667         option's values.
 668
 669         :param func: function's name
 670         :type func: `str`
 671         :param other_opts: options used to validate value
 672         :type other_opts: `list` of `tiramisu.option.Option`
 673         :param params: extra params (warnings_only and transitive are allowed)
 674         """
 675         if self.impl_is_readonly():  # pragma: optional cover
 676             raise AttributeError(_("'{0}' ({1}) cannot add consistency, option is"
 677                                    " read-only").format(
 678                                        self.__class__.__name__,
 679                                        self.impl_getname()))
 680         self._valid_consistencies(other_opts)
 681         func = '_cons_{0}'.format(func)
 682         if func not in dir(self):
 683             raise ConfigError(_('consistency {0} not available for this option').format(func))
 684         all_cons_opts = tuple([self] + list(other_opts))
 685         unknown_params = set(params.keys()) - set(['warnings_only', 'transitive'])
 686         if unknown_params != set():
 687             raise ValueError(_('unknow parameter {0} in consistency').format(unknown_params))
 688         self._add_consistency(func, all_cons_opts, params)
 689         #validate default value when add consistency
 690         err = self.impl_validate(self.impl_getdefault())
 691         if err:
 692             self._del_consistency()
 693             raise err
 694
 695     def _valid_consistency(self, option, value, context, index, submulti_idx):
 696         if context is not undefined:
 697             descr = context.cfgimpl_get_description()
 698             if descr._cache_consistencies is None:
 699                 return
 700             #consistencies is something like [('_cons_not_equal', (opt1, opt2))]
 701             if isinstance(option, DynSymLinkOption):
 702                 consistencies = descr._cache_consistencies.get(option._impl_getopt())
 703             else:
 704                 consistencies = descr._cache_consistencies.get(option)
 705         else:
 706             consistencies = option._get_consistencies()
 707         if consistencies is not None:
 708             for func, all_cons_opts, params in consistencies:
 709                 warnings_only = params.get('warnings_only', False)
 710                 transitive = params.get('transitive', True)
 711                 #all_cons_opts[0] is the option where func is set
 712                 if isinstance(option, DynSymLinkOption):
 713                     subpath = '.'.join(option._dyn.split('.')[:-1])
 714                     namelen = len(option._impl_getopt().impl_getname())
 715                     suffix = option.impl_getname()[namelen:]
 716                     opts = []
 717                     for opt in all_cons_opts:
 718                         name = opt.impl_getname() + suffix
 719                         path = subpath + '.' + name
 720                         opts.append(opt._impl_to_dyn(name, path))
 721                 else:
 722                     opts = all_cons_opts
 723                 err = opts[0]._launch_consistency(self, func, option, value,
 724                                                   context, index, submulti_idx,
 725                                                   opts, warnings_only,
 726                                                   transitive)
 727                 if err:
 728                     if warnings_only:
 729                         return ValueWarning(str(err), option)
 730                     else:
 731                         return err
 732
 733     def _cons_not_equal(self, current_opt, opts, vals, warnings_only):
 734         equal = set()
 735         is_current = False
 736         for idx_inf, val_inf in enumerate(vals):
 737             for idx_sup, val_sup in enumerate(vals[idx_inf + 1:]):
 738                 if val_inf == val_sup is not None:
 739                     for opt_ in [opts[idx_inf], opts[idx_inf + idx_sup + 1]]:
 740                         if opt_ == current_opt:
 741                             is_current = True
 742                         else:
 743                             equal.add('"{}"'.format(opt_.impl_get_display_name()))
 744         if equal:
 745             if debug:
 746                 log.debug(_('_cons_not_equal: {} are not different').format(display_list(list(equal))))
 747             if is_current:
 748                 if warnings_only:
 749                     msg = _('should be different from the value of {}')
 750                 else:
 751                     msg = _('must be different from the value of {}')
 752                 return ValueError(msg.format(display_list(list(equal))))
 753             else:
 754                 if warnings_only:
 755                     msg = _('value for {} should be different')
 756                 else:
 757                     msg = _('value for {} must be different')
 758                 return ValueError(msg.format(display_list(list(equal))))
 759
 760     # serialize/unserialize
 761     def _impl_convert_consistencies(self, descr, load=False):
 762         """during serialization process, many things have to be done.
 763         one of them is the localisation of the options.
 764         The paths are set once for all.
 765
 766         :type descr: :class:`tiramisu.option.OptionDescription`
 767         :param load: `True` if we are at the init of the option description
 768         :type load: bool
 769         """
 770         if not load and self._get_consistencies() == ():
 771             self._state_consistencies = None
 772         elif load and self._state_consistencies is None:
 773             del(self._state_consistencies)
 774         else:
 775             if load:
 776                 consistencies = self._state_consistencies
 777             else:
 778                 consistencies = self._get_consistencies()
 779             new_value = []
 780             for consistency in consistencies:
 781                 values = []
 782                 for obj in consistency[1]:
 783                     if load:
 784                         values.append(descr.impl_get_opt_by_path(obj))
 785                     else:
 786                         values.append(descr.impl_get_path_by_opt(obj))
 787                 new_value.append((consistency[0], tuple(values), consistency[2]))
 788             if load:
 789                 del(self._state_consistencies)
 790                 for new_val in new_value:
 791                     self._add_consistency(new_val[0], new_val[1], new_val[2])
 792             else:
 793                 self._state_consistencies = new_value
 794
 795     def _second_level_validation(self, value, warnings_only):
 796         pass
 797
 798     def _impl_to_dyn(self, name, path):
 799         return DynSymLinkOption(name, self, dyn=path)
 800
 801     def _validate_callback(self, callback, callback_params):
 802         """callback_params:
 803         * None
 804         * {'': ((option, permissive),), 'ip': ((None,), (option, permissive))
 805         """
 806         if callback is None:
 807             return
 808         default_multi = self.impl_getdefault_multi()
 809         is_multi = self.impl_is_multi()
 810         default = self.impl_getdefault()
 811         if (not is_multi and (default is not None or default_multi is not None)) or \
 812                 (is_multi and (default != [] or default_multi is not None)):  # pragma: optional cover
 813             raise ValueError(_("default value not allowed if option: {0} "
 814                              "is calculated").format(self.impl_getname()))
 815
 816
 817 def validate_requires_arg(multi, requires, name):
 818     """check malformed requirements
 819     and tranform dict to internal tuple
 820
 821     :param requires: have a look at the
 822                      :meth:`tiramisu.setting.Settings.apply_requires` method to
 823                      know more about
 824                      the description of the requires dictionary
 825     """
 826     ret_requires = {}
 827     config_action = {}
 828
 829     # start parsing all requires given by user (has dict)
 830     # transforme it to a tuple
 831     for require in requires:
 832         if not isinstance(require, dict):  # pragma: optional cover
 833             raise ValueError(_("malformed requirements type for option:"
 834                                " {0}, must be a dict").format(name))
 835         valid_keys = ('option', 'expected', 'action', 'inverse', 'transitive',
 836                       'same_action')
 837         unknown_keys = frozenset(require.keys()) - frozenset(valid_keys)
 838         if unknown_keys != frozenset():  # pragma: optional cover
 839             raise ValueError(_('malformed requirements for option: {0}'
 840                              ' unknown keys {1}, must only '
 841                              '{2}').format(name,
 842                                            unknown_keys,
 843                                            valid_keys))
 844         # prepare all attributes
 845         if 'option' not in require or 'expected' not in require or \
 846                 'action' not in require:
 847             raise ValueError(_("malformed requirements for option: {0}"
 848                                " require must have option, expected and"
 849                                " action keys").format(name))
 850         option = require['option']
 851         expected = require['expected']
 852         action = require['action']
 853         if action == 'force_store_value':  # pragma: optional cover
 854             raise ValueError(_("malformed requirements for option: {0}"
 855                                " action cannot be force_store_value"
 856                                ).format(name))
 857         inverse = require.get('inverse', False)
 858         if inverse not in [True, False]:  # pragma: optional cover
 859             raise ValueError(_('malformed requirements for option: {0}'
 860                                ' inverse must be boolean'))
 861         transitive = require.get('transitive', True)
 862         if transitive not in [True, False]:  # pragma: optional cover
 863             raise ValueError(_('malformed requirements for option: {0}'
 864                                ' transitive must be boolean'))
 865         same_action = require.get('same_action', True)
 866         if same_action not in [True, False]:  # pragma: optional cover
 867             raise ValueError(_('malformed requirements for option: {0}'
 868                                ' same_action must be boolean'))
 869
 870         if not isinstance(option, Option):  # pragma: optional cover
 871             raise ValueError(_('malformed requirements '
 872                                'must be an option in option {0}').format(name))
 873         if not multi and option.impl_is_multi():
 874             raise ValueError(_('malformed requirements '
 875                                'multi option must not set '
 876                                'as requires of non multi option {0}').format(name))
 877         if expected is not None:
 878             err = option._validate(expected)
 879             if err:
 880                 raise ValueError(_('malformed requirements second argument '
 881                                    'must be valid for option {0}'
 882                                    ': {1}').format(name, err))
 883         if action in config_action:
 884             if inverse != config_action[action]:  # pragma: optional cover
 885                 raise ValueError(_("inconsistency in action types"
 886                                    " for option: {0}"
 887                                    " action: {1}").format(name, action))
 888         else:
 889             config_action[action] = inverse
 890         if action not in ret_requires:
 891             ret_requires[action] = {}
 892         if option not in ret_requires[action]:
 893             ret_requires[action][option] = (option, [expected], action,
 894                                             inverse, transitive, same_action)
 895         else:
 896             ret_requires[action][option][1].append(expected)
 897     # transform dict to tuple
 898     ret = []
 899     for opt_requires in ret_requires.values():
 900         ret_action = []
 901         for require in opt_requires.values():
 902             ret_action.append((require[0], tuple(require[1]), require[2],
 903                                require[3], require[4], require[5]))
 904         ret.append(tuple(ret_action))
 905     return frozenset(config_action.keys()), tuple(ret)
 906
 907
 908 class SymLinkOption(OnlyOption):
 909 #    __slots__ = ('_opt', '_state_opt')
 910
 911     def __init__(self, name, opt):
 912         if not isinstance(opt, Option):  # pragma: optional cover
 913             raise ValueError(_('malformed symlinkoption '
 914                                'must be an option '
 915                                'for symlink {0}').format(name))
 916         session = self.getsession()
 917         super(Base, self).__init__(name, undefined, undefined, undefined,
 918                                    undefined, undefined, undefined, undefined,
 919                                    undefined, opt, session=session)
 920         self.commit(session)
 921
 922     def __getattr__(self, name, context=undefined):
 923         if name in ('_opt', '_readonly', 'impl_getpath', '_name',
 924                     '_state_opt', '_impl_setopt'):
 925             return object.__getattr__(self, name)
 926         else:
 927             return getattr(self._impl_getopt(), name)
 928
 929     def _impl_getstate(self, descr):
 930         self._stated = True
 931         self._state_opt = descr.impl_get_path_by_opt(self._impl_getopt())
 932
 933     def _impl_setstate(self, descr):
 934         self._impl_setopt(descr.impl_get_opt_by_path(self._state_opt))
 935         del(self._state_opt)
 936         del(self._stated)
 937         self._set_readonly(True)
 938
 939     def impl_get_information(self, key, default=undefined):
 940         return self._impl_getopt().impl_get_information(key, default)
 941
 942     def impl_is_readonly(self):
 943         return True
 944
 945     def impl_getproperties(self):
 946         return self._impl_getopt()._properties
 947
 948     def impl_get_callback(self):
 949         return self._impl_getopt().impl_get_callback()
 950
 951     def impl_has_callback(self):
 952         "to know if a callback has been defined or not"
 953         return self._impl_getopt().impl_has_callback()
 954
 955     def impl_is_multi(self):
 956         return self._impl_getopt().impl_is_multi()
 957
 958     def _is_subdyn(self):
 959         return getattr(self._impl_getopt(), '_subdyn', None) is not None
 960
 961     def _get_consistencies(self):
 962         return ()
 963
 964
 965 class DynSymLinkOption(object):
 966     __slots__ = ('_dyn', '_opt', '_name')
 967
 968     def __init__(self, name, opt, dyn):
 969         self._name = name
 970         self._dyn = dyn
 971         self._opt = opt
 972
 973     def __getattr__(self, name, context=undefined):
 974         if name in ('_opt', '_readonly', 'impl_getpath', '_name', '_state_opt'):
 975             return object.__getattr__(self, name)
 976         else:
 977             return getattr(self._impl_getopt(), name)
 978
 979     def impl_getname(self):
 980         return self._name
 981
 982     def _impl_getopt(self):
 983         return self._opt
 984
 985     def impl_getsuffix(self):
 986         return self._dyn.split('.')[-1][len(self._impl_getopt().impl_getname()):]
 987
 988     def impl_getpath(self, context):
 989         path = self._impl_getopt().impl_getpath(context)
 990         base_path = '.'.join(path.split('.')[:-2])
 991         if self.impl_is_master_slaves() and base_path is not '':
 992             base_path = base_path + self.impl_getsuffix()
 993         if base_path == '':
 994             return self._dyn
 995         else:
 996             return base_path + '.' + self._dyn
 997
 998     def impl_validate(self, value, context=undefined, validate=True,
 999                       force_index=None, force_submulti_index=None, is_multi=None,
1000                       display_warnings=True):
1001         return self._impl_getopt().impl_validate(value, context, validate,
1002                                                  force_index,
1003                                                  force_submulti_index,
1004                                                  current_opt=self,
1005                                                  is_multi=is_multi,
1006                                                  display_warnings=display_warnings)
1007
1008     def impl_is_dynsymlinkoption(self):
1009         return True