from tiramisu.config import Config
from tiramisu.option import IntOption, FloatOption, StrOption, ChoiceOption, \
BoolOption, UnicodeOption, OptionDescription
+from tiramisu.error import ConflictError
def make_description():
root = OptionDescription('root', '', [d1])
config = Config(root)
raises(ValueError, "config.cfgimpl_get_values()[g1] = 2")
+
+
+def test_duplicated_option():
+ g1 = IntOption('g1', '', 1)
+ #in same OptionDescription
+ raises(ConflictError, "d1 = OptionDescription('od', '', [g1, g1])")
+ d1 = OptionDescription('od1', '', [g1])
+ d2 = OptionDescription('od2', '', [g1])
+ root = OptionDescription('root', '', [d1, d2])
+ #in different OptionDescription
+ raises(ConflictError, "config = Config(root)")
prop = []
try:
conf.gc.dummy = True
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert 'frozen' in prop
setting.remove('everything_frozen')
prop = []
try:
conf.gc.dummy = True
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert 'frozen' in prop
prop = []
try:
config.string = "egg"
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert 'frozen' in prop
prop = []
try:
conf.gc.name = 'framework'
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert 'frozen' in prop
prop = []
try:
conf.boolop = [True]
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert 'frozen' in prop
prop = []
try:
valmulti.append(False)
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert 'frozen' in prop
#from py.test import raises
from tiramisu.config import Config, mandatory_warnings
-from tiramisu.option import StrOption, OptionDescription, UnicodeOption
+from tiramisu.option import StrOption, UnicodeOption, OptionDescription
from tiramisu.error import PropertiesOptionError
prop = []
try:
config.str1
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
config.read_write()
prop = []
try:
config.str
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
prop = []
try:
config.str1
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
prop = []
try:
config.str1
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
prop = []
try:
config.str3
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
config.read_write()
prop = []
try:
config.str3
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
prop = []
try:
config.str3
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
config.read_write()
prop = []
try:
config.str3
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
prop = []
try:
config.str1
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert prop == ['mandatory']
setting[descr.str1].append('disabled')
prop = []
try:
config.str1
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
- assert prop == ['disabled', 'mandatory']
+ assert set(prop) == set(['disabled', 'mandatory'])
def test_mandatory_unicode():
prop = []
try:
config.unicode2
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert prop == ['mandatory']
config.read_write()
prop = []
try:
config.unicode2
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert prop == ['mandatory']
proc = []
try:
config.str
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
proc = err.proptype
assert proc == ['mandatory']
assert list(mandatory_warnings(config)) == ['str', 'str1', 'unicode2', 'str3']
from tiramisu.option import BoolOption, IntOption
-def test_option_comparison():
- "compare :class:`tiramisu.option.BoolOption`"
- dummy1 = BoolOption('dummy1', 'doc dummy')
- dummy2 = BoolOption('dummy2', 'doc dummy')
- dummy3 = BoolOption('dummy1', 'doc dummy')
- assert dummy1 != dummy2
- assert dummy1 == dummy3
+#def test_option_comparison():
+# "compare :class:`tiramisu.option.BoolOption`"
+# dummy1 = BoolOption('dummy1', 'doc dummy')
+# dummy2 = BoolOption('dummy2', 'doc dummy')
+# dummy3 = BoolOption('dummy1', 'doc dummy')
+# assert dummy1 != dummy2
+# assert dummy1 == dummy3
-def test_option_comparison_obj():
- "compare :class:`tiramisu.option.IntOption`"
- dummy1 = BoolOption('dummy1', 'doc dummy')
- dummy2 = IntOption('dummy1', 'doc dummy')
- assert dummy1 != dummy2
+#def test_option_comparison_obj():
+# "compare :class:`tiramisu.option.IntOption`"
+# dummy1 = BoolOption('dummy1', 'doc dummy')
+# dummy2 = IntOption('dummy1', 'doc dummy')
+# assert dummy1 != dummy2
-def test_option_comparison_advanced():
- dummy1 = BoolOption('dummy1', 'doc dummy')
- dummy2 = BoolOption('dummy1', 'doc dummy')
- dummy3 = BoolOption('dummy1', 'doc dummy', None)
- dummy4 = BoolOption('dummy1', 'doc dummy', True)
- dummy5 = BoolOption('dummy1', 'doc dummy', multi=True)
- dummy6 = BoolOption('dummy1', 'doc dummy', properties=tuple())
- dummy7 = BoolOption('dummy1', 'doc dummy', properties=tuple('new',))
- assert dummy1 == dummy2
- assert dummy1 == dummy3
- assert dummy1 != dummy4
- assert dummy1 != dummy5
- assert dummy1 == dummy6
- assert dummy1 != dummy7
+#def test_option_comparison_advanced():
+# dummy1 = BoolOption('dummy1', 'doc dummy')
+# dummy2 = BoolOption('dummy1', 'doc dummy')
+# dummy3 = BoolOption('dummy1', 'doc dummy', None)
+# dummy4 = BoolOption('dummy1', 'doc dummy', True)
+# dummy5 = BoolOption('dummy1', 'doc dummy', multi=True)
+# dummy6 = BoolOption('dummy1', 'doc dummy', properties=tuple())
+# dummy7 = BoolOption('dummy1', 'doc dummy', properties=tuple('new',))
+# assert dummy1 == dummy2
+# assert dummy1 == dummy3
+# assert dummy1 != dummy4
+# assert dummy1 != dummy5
+# assert dummy1 == dummy6
+# assert dummy1 != dummy7
prop = []
try:
config.gc.dummy = False
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert 'hidden' in prop
prop = []
try:
objspace.append('std')
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
prop = err.proptype
assert 'hidden' in prop
setting[obj].remove('hidden')
props = []
try:
config.u1
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
setting.setpermissive(('disabled',))
props = []
try:
config.u1
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
setting.append('permissive')
props = []
try:
config.u1
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
props = []
try:
config.u1
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
- assert props == ['disabled', 'mandatory']
+ assert set(props) == set(['disabled', 'mandatory'])
setting.setpermissive(('mandatory', 'disabled',))
setting.append('permissive')
config.u1
setting.remove('permissive')
try:
config.u1
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
- assert props == ['disabled', 'mandatory']
+ assert set(props) == set(['disabled', 'mandatory'])
def test_permissive_frozen():
setting.setpermissive(('frozen', 'disabled',))
try:
config.u1 = 1
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['frozen', 'disabled']
setting.append('permissive')
setting.remove('permissive')
try:
config.u1 = 1
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['frozen', 'disabled']
props = []
try:
c.ip_address_service
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
props = []
try:
c.activate_service_web
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['new']
#
props = []
try:
c.ip_address_service_web
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
props = []
try:
c.ip_address_service
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
props = []
try:
c.ip_address_service
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
props = []
try:
c.ip_address_service
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
props = []
try:
c.ip_address_service
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
props = []
try:
c.activate_service_web
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
#
props = []
try:
c.ip_address_service_web
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
props = []
try:
c.activate_service_web
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
#
props = []
try:
c.ip_address_service_web
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
props = []
try:
c.activate_service_web
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['hidden']
raises(RequirementError, 'c.ip_address_service_web')
props = []
try:
c.activate_service_web
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
#
props = []
try:
c.ip_address_service
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
c.activate_service = False
props = []
try:
c.ip_address_service
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
props = []
try:
c.ip_address_service
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
props = []
try:
c.ip_address_service
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
props = []
try:
c.ip_address_service
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
props = []
try:
c.ip_address_service
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
props = []
try:
c.ip_address_service
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
props = []
try:
c.ip_address_service
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
props = []
try:
cfg.z
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
for boo in list_bools:
props = []
try:
cfg.z
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
props = []
try:
cfg.z
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
for boo in list_bools:
props = []
try:
cfg.z
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
for boo in list_bools:
props = []
try:
cfg.z
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
props = []
try:
config.s
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
#
props = []
try:
config.c
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
props = err.proptype
assert props == ['disabled']
def test_symlink_slaves():
a = StrOption('a', "", multi=True)
- ip_admin_eth0 = StrOption('ip_admin_eth0', u"ip réseau autorisé", multi=True)
+ ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = SymLinkOption('netmask_admin_eth0', a)
interface1 = OptionDescription('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
raises(ValueError, 'interface1.impl_set_group_type(groups.master)')
try:
opt_value = config._getattr(path, force_permissive=True)
opt = config.unwrap_from_path(path, force_permissive=True)
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
if check_disabled:
continue
raise ConfigError(_('unable to carry out a calculation, '
include_groups=True):
try:
config._getattr(path, force_properties=frozenset(('mandatory',)))
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
if err.proptype == ['mandatory']:
yield path
config.cfgimpl_reset_cache(only=('values',))
#____________________________________________________________
# Exceptions for a Config
-class ConfigError(StandardError):
+class ConfigError(Exception):
"""attempt to change an option's owner without a value
or in case of `_cfgimpl_descr` is None
or if a calculation cannot be carried out"""
pass
-class ConflictError(StandardError):
+class ConflictError(Exception):
"duplicate options are present in a single config"
pass
#____________________________________________________________
# miscellaneous exceptions
-class RequirementError(StandardError):
+class RequirementError(Exception):
"""a recursive loop occurs in the requirements tree
requires
"""
pass
-class SlaveError(StandardError):
+class SlaveError(Exception):
"problem with a slave's value length"
pass
languages += DEFAULT_LANG
mo_location = LOCALE_DIR
-gettext.install(True, localedir=None, unicode=1)
+
+if sys.version_info[0] >= 3:
+ gettext.install(True, localedir=None)
+else:
+ gettext.install(True, localedir=None, unicode=1)
gettext.find(APP_NAME, mo_location)
gettext.textdomain(APP_NAME)
gettext.bind_textdomain_codeset(APP_NAME, "UTF-8")
# the whole pypy projet is under MIT licence
# ____________________________________________________________
import re
+import sys
from copy import copy, deepcopy
from types import FunctionType
from IPy import IP
"""
__slots__ = ('_name', '_requires', '_multi', '_validator',
'_default_multi', '_default', '_properties', '_callback',
- '_multitype', '_master_slaves', '_consistencies', '_empty',
+ '_multitype', '_master_slaves', '_consistencies',
'_calc_properties', '__weakref__')
_empty = ''
if default_multi is not None:
try:
self._validate(default_multi)
- except ValueError, err:
+ except ValueError as err:
raise ValueError(_("invalid default_multi value {0} "
"for option {1}: {2}").format(
str(default_multi), name, err))
self._name))
self._properties = properties # 'hidden', 'disabled'...
- def __eq__(self, other):
- "Option comparison"
- if not isinstance(other, Option):
- return False
- slots = list(self.__slots__ +
- Option.__slots__ +
- BaseInformation.__slots__)
- for var in slots:
- try:
- val1 = getattr(self, var)
- not_in1 = False
- except:
- not_in1 = True
- try:
- val2 = getattr(other, var)
- not_in2 = False
- except:
- not_in2 = True
- if True in (not_in1, not_in2):
- if not_in1 != not_in2:
- return False
- elif val1 != val2:
- return False
- return True
-
- def __ne__(self, other):
- if not isinstance(other, Option):
- return False
- return not self == other
-
def _launch_consistency(self, func, opt, vals, context, index, opt_):
if context is not None:
descr = context.cfgimpl_get_description()
self.__class__.__name__))
try:
self._validate(_value)
- except ValueError, err:
+ except ValueError as err:
raise ValueError(_("invalid value {0} for option {1}: {2}"
"").format(_value, self._name, err))
if context is not None:
The option can also have the value ``None``
"""
- __slots__ = ('_values', '_open_values', '_opt_type')
+ __slots__ = ('_values', '_open_values')
_opt_type = 'string'
def __init__(self, name, doc, values, default=None, default_multi=None,
class BoolOption(Option):
"represents a choice between ``True`` and ``False``"
- __slots__ = ('_opt_type',)
+ __slots__ = tuple()
_opt_type = 'bool'
def _validate(self, value):
class IntOption(Option):
"represents a choice of an integer"
- __slots__ = ('_opt_type',)
+ __slots__ = tuple()
_opt_type = 'int'
def _validate(self, value):
class FloatOption(Option):
"represents a choice of a floating point number"
- __slots__ = ('_opt_type',)
+ __slots__ = tuple()
_opt_type = 'float'
def _validate(self, value):
class StrOption(Option):
"represents the choice of a string"
- __slots__ = ('_opt_type',)
+ __slots__ = tuple()
_opt_type = 'string'
def _validate(self, value):
'{0}').format(type(value)))
-class UnicodeOption(Option):
- "represents the choice of a unicode string"
- __slots__ = ('_opt_type',)
- _opt_type = 'unicode'
- _empty = u''
+if sys.version_info[0] >= 3:
+ #UnicodeOption is same has StrOption in python 3+
+ class UnicodeOption(StrOption):
+ __slots__ = tuple()
+ pass
+else:
+ class UnicodeOption(Option):
+ "represents the choice of a unicode string"
+ __slots__ = tuple()
+ _opt_type = 'unicode'
+ _empty = u''
- def _validate(self, value):
- if not isinstance(value, unicode):
- raise ValueError(_('value must be an unicode'))
+ def _validate(self, value):
+ if not isinstance(value, unicode):
+ raise ValueError(_('value must be an unicode'))
class SymLinkOption(object):
- __slots__ = ('_name', '_opt', '_consistencies')
+ __slots__ = ('_name', '_opt')
_opt_type = 'symlink'
_consistencies = None
class IPOption(Option):
"represents the choice of an ip"
- __slots__ = ('_opt_type', '_only_private')
+ __slots__ = ('_only_private',)
_opt_type = 'ip'
def __init__(self, name, doc, default=None, default_multi=None,
Port number 0 is reserved and can't be used.
see: http://en.wikipedia.org/wiki/Port_numbers
"""
- __slots__ = ('_opt_type', '_allow_range', '_allow_zero', '_min_value',
- '_max_value')
+ __slots__ = ('_allow_range', '_allow_zero', '_min_value', '_max_value')
_opt_type = 'port'
def __init__(self, name, doc, default=None, default_multi=None,
class NetworkOption(Option):
"represents the choice of a network"
- __slots__ = ('_opt_type',)
+ __slots__ = tuple()
_opt_type = 'network'
def _validate(self, value):
class NetmaskOption(Option):
"represents the choice of a netmask"
- __slots__ = ('_opt_type',)
+ __slots__ = tuple()
_opt_type = 'netmask'
def _validate(self, value):
class DomainnameOption(Option):
"represents the choice of a domain name"
- __slots__ = ('_opt_type', '_type', '_allow_ip')
+ __slots__ = ('_type', '_allow_ip')
_opt_type = 'domainname'
def __init__(self, name, doc, default=None, default_multi=None,
valid_child.sort()
old = None
for child in valid_child:
- if id(child) == id(old):
+ if child == old:
raise ConflictError(_('duplicate option name: '
'{0}').format(child))
old = child
attr = option._name
if attr.startswith('_cfgimpl'):
continue
+ if option in cache_option:
+ raise ConflictError(_('duplicate option: {0}').format(option))
+
cache_option.append(option)
cache_path.append(str('.'.join(_currpath + [attr])))
if not isinstance(option, OptionDescription):
_consistencies)
_currpath.pop()
if save:
- #valid no duplicated option
- valid_child = copy(cache_option)
- valid_child.sort()
- old = None
- for child in valid_child:
- if id(child) == id(old):
- raise ConflictError(_('duplicate option: '
- '{0}').format(child))
- old = child
self._cache_paths = (tuple(cache_option), tuple(cache_path))
self._consistencies = _consistencies
' same_action must be boolean'))
if not isinstance(option, Option):
- print option, type(option)
raise ValueError(_('malformed requirements '
'must be an option in option {0}').format(name))
if option.impl_is_multi():
if expected is not None:
try:
option._validate(expected)
- except ValueError, err:
+ except ValueError as err:
raise ValueError(_('malformed requirements second argument '
'must be valid for option {0}'
': {1}').format(name, err))
def set_storage(name, **args):
storage_type.set_storage(name)
settings = __import__(storage_type.get_storage(), globals(), locals(),
- ['Setting'], -1).Setting()
+ ['Setting']).Setting()
for option, value in args.items():
try:
getattr(settings, option)
if session_id is None:
session_id = gen_id(context)
return __import__(storage_type.get_storage(), globals(), locals(),
- ['Storage'], -1).Storage(session_id, persistent)
+ ['Storage']).Storage(session_id, persistent)
def list_sessions():
return __import__(storage_type.get_storage(), globals(), locals(),
- ['list_sessions'], -1).list_sessions()
+ ['list_sessions']).list_sessions()
def delete_session(session_id):
return __import__(storage_type.get_storage(), globals(), locals(),
- ['delete_session'], -1).delete_session(session_id)
+ ['delete_session']).delete_session(session_id)
#____________________________________________________________
self._owner = owners.user
self.context = weakref.ref(context)
import_lib = 'tiramisu.storage.{0}.setting'.format(storage.storage)
- self._p_ = __import__(import_lib, globals(), locals(), ['Settings'],
- -1).Settings(storage)
+ self._p_ = __import__(import_lib, globals(), locals(), ['Settings']
+ ).Settings(storage)
#____________________________________________________________
# properties methods
try:
value = self.context()._getattr(reqpath,
force_permissive=True)
- except PropertiesOptionError, err:
+ except PropertiesOptionError as err:
if not transitive:
continue
properties = err.proptype
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# ____________________________________________________________
-
-
from tiramisu.i18n import _
from tiramisu.error import ConfigError
return path in self._cache
def reset_expired_cache(self, cache_type, exp):
- keys = self._cache.keys()
- for key in keys:
+ for key in tuple(self._cache.keys()):
val, created = self._cache[key]
if exp > created:
del(self._cache[key])
# ____________________________________________________________
from time import time
from copy import copy
+import sys
import weakref
from tiramisu.error import ConfigError, SlaveError
from tiramisu.setting import owners, multitypes, expires_time
# the storage type is dictionary or sqlite3
import_lib = 'tiramisu.storage.{0}.value'.format(storage.storage)
self._p_ = __import__(import_lib, globals(), locals(), ['Values'],
- -1).Values(storage)
+ ).Values(storage)
def _getdefault(self, opt):
"""
multitypes.master]:
raise SlaveError(_("cannot sort multi option {0} if master or slave"
"").format(self.opt._name))
- super(Multi, self).sort(cmp=cmp, key=key, reverse=reverse)
+ if sys.version_info[0] >= 3:
+ if cmp is not None:
+ raise ValueError(_('cmp is not permitted in python v3 or greater'))
+ super(Multi, self).sort(key=key, reverse=reverse)
+ else:
+ super(Multi, self).sort(cmp=cmp, key=key, reverse=reverse)
self.context().cfgimpl_get_values()._setvalue(self.opt, self.path, self)
def reverse(self):
if value is not None:
try:
self.opt._validate(value)
- except ValueError, err:
+ except ValueError as err:
raise ValueError(_("invalid value {0} "
"for option {1}: {2}"
"").format(str(value),