def view_schema(state):
schema = mapping('view')
schema.add(key('name', validator=chained(nonempty_string, database_name)))
schema.add(key('label', validator=nonempty_string))
schema.add(key('dimension', validator=dimension_or_dataset(state)))
schema.add(
key('drilldown', validator=dimension_or_not(state), missing=None))
schema.add(mapping('cuts', validator=key_is_attribute(state), missing={}))
return schema
def view_schema(state):
schema = mapping('view')
schema.add(key('name', validator=chained(
nonempty_string,
database_name
)))
schema.add(key('label', validator=nonempty_string))
schema.add(key('dimension',
validator=dimension_or_dataset(state)))
schema.add(key('drilldown',
validator=dimension_or_not(state),
missing=None))
schema.add(mapping('cuts',
validator=key_is_attribute(state),
missing={}))
return schema
def source_schema():
schema = mapping('source')
schema.add(key('url', validator=chained(
nonempty_string,
valid_url
)))
return schema
def dataset_schema(state):
schema = mapping('dataset')
schema.add(key('name', validator=chained(
nonempty_string,
reserved_name,
database_name,
no_double_underscore
),
preparer=lambda x: x.lower().strip() if x else None))
schema.add(key('currency', validator=chained(
valid_currency
)))
schema.add(key('category', validator=chained(
valid_category
)))
schema.add(key('label', validator=chained(
nonempty_string,
)))
schema.add(key('description', validator=chained(
nonempty_string,
)))
schema.add(sequence('languages',
key('language', validator=valid_language),
missing=[]))
schema.add(sequence('territories',
key('territory', validator=valid_country),
missing=[]))
return schema
def dataset_schema(state):
schema = mapping('dataset')
schema.add(
key('name',
validator=chained(nonempty_string, reserved_name, database_name,
no_double_underscore),
preparer=lambda x: x.lower().strip() if x else None))
return schema
def dataset_schema(state):
schema = mapping('dataset')
schema.add(key('name', validator=chained(
nonempty_string,
reserved_name,
database_name,
no_double_underscore
),
preparer=lambda x: x.lower().strip() if x else None))
return schema
def dimension_attribute_schema(name, state):
schema = mapping(name,
validator=chained(
name_wrap(nonempty_string, name),
name_wrap(reserved_name, name),
name_wrap(database_name, name),
))
schema.add(key('column', validator=chained(nonempty_string, )))
schema.add(
key('datatype', validator=chained(nonempty_string, valid_datatype)))
return schema
def source_schema(state):
schema = mapping('source')
schema.add(key('name', validator=chained(
nonempty_string
),
preparer=lambda x: x.lower().strip() if x else None))
schema.add(key('url', validator=chained(
validURL
),
preparer=lambda x: x.strip() if x else None))
return schema
def source_schema(state):
schema = mapping('source')
schema.add(
key('name',
validator=chained(nonempty_string),
preparer=lambda x: x.lower().strip() if x else None))
schema.add(
key('url',
validator=chained(validURL),
preparer=lambda x: x.strip() if x else None))
return schema
def dimension_attribute_schema(name, state):
schema = mapping(name, validator=chained(
name_wrap(nonempty_string, name),
name_wrap(reserved_name, name),
name_wrap(database_name, name),
))
schema.add(key('column', validator=chained(
nonempty_string,
)))
schema.add(key('datatype', validator=chained(
nonempty_string,
valid_datatype
)))
return schema
def compound_dimension_schema(name, state):
schema = property_schema(name, state)
attributes = mapping('attributes',
validator=chained(
compound_attributes_include_name,
compound_attributes_include_label,
compound_attribute_name_is_id_type,
compound_attribute_label_is_string_type))
for attribute in state.dimension_attributes(name):
attributes.add(dimension_attribute_schema(attribute, state))
schema.add(attributes)
return schema
def compound_dimension_schema(name, state):
schema = property_schema(name, state)
attributes = mapping('attributes',
validator=chained(
compound_attributes_include_name,
compound_attributes_include_label,
compound_attribute_name_is_id_type,
compound_attribute_label_is_string_type
))
for attribute in state.dimension_attributes(name):
attributes.add(dimension_attribute_schema(attribute, state))
schema.add(attributes)
return schema
def property_schema(name, state):
""" This is validation which is common to all properties,
i.e. both dimensions and measures. """
schema = mapping(name,
validator=chained(
name_wrap(nonempty_string, name),
name_wrap(reserved_name, name),
name_wrap(database_name, name),
name_wrap(no_entry_namespace_overlap, name),
no_dimension_id_overlap(name, state)))
schema.add(key('label', validator=chained(nonempty_string, )))
schema.add(key('type', validator=chained(nonempty_string, )))
schema.add(
key('description', validator=chained(nonempty_string, ), missing=None))
return schema
def mapping_schema(state):
schema = mapping('mapping',
validator=chained(require_time_dimension,
require_amount_dimension,
require_one_key_column,
must_be_compound_dimension('to'),
must_be_compound_dimension('from')))
for name, meta in state.mapping_items:
type_schema = {
'measure': measure_schema,
'value': attribute_dimension_schema,
'attribute': attribute_dimension_schema,
'date': date_schema,
}.get(meta.get('type'), compound_dimension_schema)
schema.add(type_schema(name, state))
return schema
def mapping_schema(state):
schema = mapping('mapping', validator=chained(
require_time_dimension,
require_amount_dimension,
require_one_key_column,
must_be_compound_dimension('to'),
must_be_compound_dimension('from')
))
for name, meta in state.mapping_items:
type_schema = {
'measure': measure_schema,
'value': attribute_dimension_schema,
'attribute': attribute_dimension_schema,
'date': date_schema,
}.get(meta.get('type'),
compound_dimension_schema)
schema.add(type_schema(name, state))
return schema
def property_schema(name, state):
""" This is validation which is common to all properties,
i.e. both dimensions and measures. """
schema = mapping(name, validator=chained(
name_wrap(nonempty_string, name),
name_wrap(reserved_name, name),
name_wrap(database_name, name),
name_wrap(no_entry_namespace_overlap, name),
no_dimension_id_overlap(name, state)
))
schema.add(key('label', validator=chained(
nonempty_string,
)))
schema.add(key('type', validator=chained(
nonempty_string,
)))
schema.add(key('description', validator=chained(
nonempty_string,
), missing=None))
return schema
def source_schema():
schema = mapping('source')
schema.add(key('url', validator=chained(nonempty_string, valid_url)))
return schema