def __init__(self, definition=None, do_validate=False):
"""Constructor
"""
if not definition:
definition = {}
self._definition = definition
if 'version' not in self._definition:
self._definition['version'] = SCHEMA_VERSION
if self._definition['version'] not in SCHEMA_VERSIONS:
msg = '%s is an unsupported version number'
raise InvalidDataSetDefinition('INVALID_VERSION', msg % self._definition['version'])
try:
self._populate_default_values(do_validate=do_validate)
if do_validate:
validate(self._definition, DATASET_DEFINITION_SCHEMA)
if 'global_data' in definition:
dd = self.get_definition()
dd.validate()
except ValidationError as ex:
raise InvalidDataSetDefinition('INVALID_DATASET_DEFINITION', 'Error validating against schema: %s' % unicode(ex))
except InvalidData as ex:
raise InvalidDataSetDefinition('INVALID_GLOBAL_DATA', 'Error validating global data: %s' % unicode(ex))
self._check_for_name_collisions()
def _populate_default_values(self, do_validate=False):
"""Populates any missing JSON fields that have default values
"""
if 'parameters' not in self._definition:
self._definition['parameters'] = InterfaceV6().get_dict()
elif type(self._definition['parameters']) is not dict:
raise InvalidDataSetDefinition('INVALID_DATASET_DEFINITION', '"parameters" is not a dictionary')
else:
self._definition['parameters'] = InterfaceV6(interface=self._definition['parameters'], do_validate=do_validate).get_dict()
rest_utils.strip_schema_version(self._definition['parameters'])
if 'global_parameters' not in self._definition:
self._definition['global_parameters'] = InterfaceV6().get_dict()
elif type(self._definition['global_parameters']) is not dict:
raise InvalidDataSetDefinition('INVALID_DATASET_DEFINITION', '"global_parameters" is not a dictionary')
else:
self._definition['global_parameters'] = InterfaceV6(interface=self._definition['global_parameters'], do_validate=do_validate).get_dict()
rest_utils.strip_schema_version(self._definition['global_parameters'])
if 'global_data' not in self._definition:
self._definition['global_data'] = DataV6().get_dict()
elif type(self._definition['global_data']) is not dict:
raise InvalidDataSetDefinition('INVALID_DATASET_DEFINITION', '"global_data" is not a dictionary')
else:
self._definition['global_data'] = DataV6(data=self._definition['global_data'], do_validate=do_validate).get_dict()
rest_utils.strip_schema_version(self._definition['global_data'])
def __init__(self, definition=None):
"""Constructor
:param definition: Parameters of the definition
:type defintion: dict
"""
if not definition:
definition = {}
self._definition = definition
self.param_names = set()
self.parameters = {}
if 'parameters' in self._definition:
self.parameters = InterfaceV6(
interface=definition['parameters']).get_interface()
self.param_names = set(self.parameters.parameters.keys())
self.global_parameters = {}
if 'global_parameters' in self._definition:
self.global_parameters = InterfaceV6(
definition['global_parameters']).get_interface()
keys = self.global_parameters.parameters.keys()
dupes = self.param_names.intersection(keys)
if dupes:
raise InvalidDataSetDefinition(
'DUPLICATE_PARAMETER',
'Invalid dataset definition: Names must be unique. %s defined more than once'
% dupes)
self.param_names.update(keys)
self.global_data = {}
if 'global_data' in self._definition:
self.global_data = DataV6(definition['global_data']).get_data()
def add_global_parameter(self, parameter):
"""Adds a new global parameter to the dataset definition
:param parameter: The parameter to add
:type parameter: :class:`data.interface.parameter.Parameter`
"""
if parameter.name in self.param_names:
raise InvalidDataSetDefinition(
'DUPLICATE_PARAMETER',
'Invalid dataset definition: %s cannot be defined more than once'
% parameter.name)
else:
self.param_names.add(parameter.name)
if self.global_parameters:
self.global_parameters.add_parameter(parameter)
else:
self.global_parameters = InterfaceV6().get_interface()
self.global_parameters.add_parameter(parameter)
def _check_for_name_collisions(self):
"""Ensures all global and regular parameter names are unique, and throws a
:class:`data.dataset.exceptions.InvalidDataSetDefinition` if they are not unique.
"""
names = []
for file_dict in self._definition['parameters']['files']:
names.append(file_dict['name'])
for json_dict in self._definition['parameters']['json']:
names.append(json_dict['name'])
for file_dict in self._definition['global_parameters']['files']:
names.append(file_dict['name'])
for json_dict in self._definition['global_parameters']['json']:
names.append(json_dict['name'])
if len(names) != len(set(names)):
raise InvalidDataSetDefinition('NAME_COLLISION_ERROR','Parameter names must be unique.' )
def validate(self, data=None):
"""Validates the dataset definition
:returns: A list of warnings discovered during validation
:rtype: :class:[`util.validation.ValidationWarning`]
"""
# validate definition parameters
warnings = self._validate_parameters()
if self.global_parameters and self.global_parameters.parameters:
if not self.global_data:
raise InvalidDataSetDefinition(
'MISSING_GLOBAL_DATA',
'Global parameters are defined without global data to match'
)
warnings.append(self.global_data.validate(self.global_parameters))
if data:
warnings.append(self.validate_data(data))
return warnings