def _ensure_inherits(name, subtype, base):
if inspect.isclass(subtype) and issubclass(subtype, base):
return
basename = base.__name__ if base else None
subtypename = subtype.__name__ if subtype else None
message = '{}: {} does not inherit from {}'
message = message.format(name, subtypename, basename)
raise DefinitionError(message)
def _instantiate(self, *args, **kwargs):
try:
return self._type(*args, **kwargs)
except (ValueError, TypeError) as error:
message = '{}: cannot instantiate {} from args={} and kwargs={}'
message = message.format(
self._name, self._type.__name__, args, kwargs)
message += '. ' + str(error)
raise DefinitionError(message)
def _parse_mapping(self, name, schema, definition):
"""
Definition should contain a dict used as only argument.
"""
if not isinstance(definition, dict):
message = '{}: mapping must be a dict'.format(name)
raise DefinitionError(message)
mapping = {k: v.default for k, v in schema.mapping.items()}
mapping.update(definition)
for key, value in mapping.items():
if key not in schema.mapping:
message = '{}: unexpected mapping key {}'.format(name, key)
raise DefinitionError(message)
subname = '{}.{}'.format(name, key)
subschema = schema.mapping[key]
mapping[key] = self._parse(subname, subschema, value)
base = self._find_type(schema.module, schema.type)
return Candidate(name, base, mapping)
def _parse_elements(self, name, schema, definition):
"""
Definition chould contain a list used as only argument.
"""
if not isinstance(definition, list):
raise DefinitionError('elements must be a list')
elements = [self._parse('{}[{}]'.format(name, i), schema.elements, x)
for i, x in enumerate(definition)]
base = self._find_type(schema.module, schema.type)
return Candidate(name, base, elements)
def _parse_default(self, name, schema):
"""
Parse default from schema or try to construct the type from the schema.
Raise an error if no default is specified and the type requires
arguments that have no defaults.
"""
if schema and 'default' in schema:
return self._parse(name, schema, schema.default)
if schema and 'mapping' in schema:
return self._parse(name, schema, {})
if schema and 'type' in schema:
return self._parse_arguments(name, schema, {'type': schema.type})
message = '{}: omitted value that has no default'.format(name)
raise DefinitionError(message)
def _resolve(self, candidate, deps):
if isinstance(candidate, str) and candidate.startswith('$'):
name = 'root.' + candidate[1:]
if name not in deps:
message = 'reference {} with target {} not found'
message = message.format(candidate, name)
raise DefinitionError(message)
return self._resolve(deps[name], deps)
if isinstance(candidate, dict):
return {k: self._resolve(v, deps) for k, v in candidate.items()}
if isinstance(candidate, (tuple, list)):
return [self._resolve(x, deps) for x in candidate]
if isinstance(candidate, Candidate):
return candidate(deps)
return candidate