def load(self, state, raw, source, wrap_exceptions=True): # pylint: disable=too-many-branches
logger.debug('Parsing config from "{}"'.format(source))
log.indent()
try:
state.plugin_cache.add_source(source)
if 'run_name' in raw:
msg = '"run_name" can only be specified in the config '\
'section of an agenda'
raise ConfigError(msg)
if 'id' in raw:
raise ConfigError('"id" cannot be set globally')
merge_augmentations(raw)
# Get WA core configuration
for cfg_point in state.settings.configuration.values():
value = pop_aliased_param(cfg_point, raw)
if value is not None:
logger.debug('Setting meta "{}" to "{}"'.format(
cfg_point.name, value))
state.settings.set(cfg_point.name, value)
# Get run specific configuration
for cfg_point in state.run_config.configuration.values():
value = pop_aliased_param(cfg_point, raw)
if value is not None:
logger.debug('Setting run "{}" to "{}"'.format(
cfg_point.name, value))
state.run_config.set(cfg_point.name, value)
# Get global job spec configuration
for cfg_point in JobSpec.configuration.values():
value = pop_aliased_param(cfg_point, raw)
if value is not None:
logger.debug('Setting global "{}" to "{}"'.format(
cfg_point.name, value))
state.jobs_config.set_global_value(cfg_point.name, value)
for name, values in raw.items():
# Assume that all leftover config is for a plug-in or a global
# alias it is up to PluginCache to assert this assumption
logger.debug('Caching "{}" with "{}"'.format(
identifier(name), values))
state.plugin_cache.add_configs(identifier(name), values,
source)
except ConfigError as e:
if wrap_exceptions:
raise ConfigError('Error in "{}":\n{}'.format(source, str(e)))
else:
raise e
finally:
log.dedent()
def install(cls, target, **params):
if cls.kind is not None:
attr_name = identifier(cls.kind)
else:
attr_name = identifier(cls.name)
if hasattr(target, attr_name):
existing_module = getattr(target, attr_name)
existing_name = getattr(existing_module, 'name', str(existing_module))
message = 'Attempting to install module "{}" which already exists (new: {}, existing: {})'
raise ValueError(message.format(attr_name, cls.name, existing_name))
setattr(target, attr_name, cls(target, **params))
def install(cls, target, **params):
if cls.kind is not None:
attr_name = identifier(cls.kind)
else:
attr_name = identifier(cls.name)
if hasattr(target, attr_name):
existing_module = getattr(target, attr_name)
existing_name = getattr(existing_module, 'name', str(existing_module))
message = 'Attempting to install module "{}" which already exists (new: {}, existing: {})'
raise ValueError(message.format(attr_name, cls.name, existing_name))
setattr(target, attr_name, cls(target, **params))
def load(self, state, raw, source, wrap_exceptions=True): # pylint: disable=too-many-branches
logger.debug('Parsing config from "{}"'.format(source))
log.indent()
try:
state.plugin_cache.add_source(source)
if 'run_name' in raw:
msg = '"run_name" can only be specified in the config '\
'section of an agenda'
raise ConfigError(msg)
if 'id' in raw:
raise ConfigError('"id" cannot be set globally')
merge_augmentations(raw)
# Get WA core configuration
for cfg_point in state.settings.configuration.values():
value = pop_aliased_param(cfg_point, raw)
if value is not None:
logger.debug('Setting meta "{}" to "{}"'.format(cfg_point.name, value))
state.settings.set(cfg_point.name, value)
# Get run specific configuration
for cfg_point in state.run_config.configuration.values():
value = pop_aliased_param(cfg_point, raw)
if value is not None:
logger.debug('Setting run "{}" to "{}"'.format(cfg_point.name, value))
state.run_config.set(cfg_point.name, value)
# Get global job spec configuration
for cfg_point in JobSpec.configuration.values():
value = pop_aliased_param(cfg_point, raw)
if value is not None:
logger.debug('Setting global "{}" to "{}"'.format(cfg_point.name, value))
state.jobs_config.set_global_value(cfg_point.name, value)
for name, values in raw.items():
# Assume that all leftover config is for a plug-in or a global
# alias it is up to PluginCache to assert this assumption
logger.debug('Caching "{}" with "{}"'.format(identifier(name), values))
state.plugin_cache.add_configs(identifier(name), values, source)
except ConfigError as e:
if wrap_exceptions:
raise ConfigError('Error in "{}":\n{}'.format(source, str(e)))
else:
raise e
finally:
log.dedent()
def has(self, modname):
return hasattr(self, identifier(modname))
def get_plugin(self, name=None, kind=None, *args, **kwargs):
return self.plugin_cache.get_plugin(identifier(name), kind, *args,
**kwargs)
def enum(args, start=0, step=1):
"""
Creates a class with attributes named by the first argument.
Each attribute is a ``level`` so they behave is integers in comparisons.
The value of the first attribute is specified by the second argument
(``0`` if not specified).
::
MyEnum = enum(['A', 'B', 'C'])
is roughly equivalent of::
class MyEnum(object):
A = 0
B = 1
C = 2
however it also implement some specialized behaviors for comparisons and
instantiation.
"""
class Enum(with_metaclass(_EnumMeta, object)):
@classmethod
def from_pod(cls, pod):
lv = level.from_pod(pod)
for enum_level in cls.levels:
if enum_level == lv:
return enum_level
msg = 'Unexpected value "{}" for enum.'
raise ValueError(msg.format(pod))
def __new__(cls, name):
for attr_name in dir(cls):
if attr_name.startswith('__'):
continue
attr = getattr(cls, attr_name)
if name == attr:
return attr
try:
return Enum.from_pod(name)
except ValueError:
raise ValueError('Invalid enum value: {}'.format(repr(name)))
reserved = ['values', 'levels', 'names']
levels = []
n = start
for v in args:
id_v = identifier(v)
if id_v in reserved:
message = 'Invalid enum level name "{}"; must not be in {}'
raise ValueError(message.format(v, reserved))
name = caseless_string(id_v)
lv = level(v, n)
setattr(Enum, name, lv)
levels.append(lv)
n += step
setattr(Enum, 'levels', levels)
setattr(Enum, 'values', [lvl.value for lvl in levels])
setattr(Enum, 'names', [lvl.name for lvl in levels])
return Enum
def get_plugin(self, name=None, kind=None, *args, **kwargs):
return self.plugin_cache.get_plugin(identifier(name), kind, *args, **kwargs)
def get_class_name(name, postfix=''):
name = identifier(name)
return ''.join(map(capitalize, name.split('_'))) + postfix
def get_class_name(name, postfix=''):
name = identifier(name)
return ''.join(map(capitalize, name.split('_'))) + postfix
def enum(args, start=0, step=1):
"""
Creates a class with attributes named by the first argument.
Each attribute is a ``level`` so they behave is integers in comparisons.
The value of the first attribute is specified by the second argument
(``0`` if not specified).
::
MyEnum = enum(['A', 'B', 'C'])
is roughly equivalent of::
class MyEnum(object):
A = 0
B = 1
C = 2
however it also implement some specialized behaviors for comparisons and
instantiation.
"""
class Enum(with_metaclass(_EnumMeta, object)):
@classmethod
def from_pod(cls, pod):
lv = level.from_pod(pod)
for enum_level in cls.levels:
if enum_level == lv:
return enum_level
msg = 'Unexpected value "{}" for enum.'
raise ValueError(msg.format(pod))
def __new__(cls, name):
for attr_name in dir(cls):
if attr_name.startswith('__'):
continue
attr = getattr(cls, attr_name)
if name == attr:
return attr
raise ValueError('Invalid enum value: {}'.format(repr(name)))
reserved = ['values', 'levels', 'names']
levels = []
n = start
for v in args:
id_v = identifier(v)
if id_v in reserved:
message = 'Invalid enum level name "{}"; must not be in {}'
raise ValueError(message.format(v, reserved))
name = caseless_string(id_v)
lv = level(v, n)
setattr(Enum, name, lv)
levels.append(lv)
n += step
setattr(Enum, 'levels', levels)
setattr(Enum, 'values', [lvl.value for lvl in levels])
setattr(Enum, 'names', [lvl.name for lvl in levels])
return Enum
