コード例 #1
0
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
コード例 #2
0
ファイル: mapping.py プロジェクト: nathanhilbert/FPA_Core
def attribute_dimension_schema(name, state):
    schema = property_schema(name, state)
    schema.add(key('column', validator=chained(
            nonempty_string,
        )))
    schema.add(key('datatype', validator=chained(
            nonempty_string,
            valid_datatype,
        )))
    return schema
コード例 #3
0
ファイル: mapping.py プロジェクト: nathanhilbert/FPA_Core
def measure_schema(name, state):
    schema = property_schema(name, state)
    schema.add(key('column', validator=chained(
            nonempty_string,
        )))
    schema.add(key('datatype', validator=chained(
            nonempty_string,
            specific_datatype('float')
        )))
    return schema
コード例 #4
0
ファイル: mapping.py プロジェクト: nathanhilbert/FPA_Core
def date_schema(name, state):
    schema = property_schema(name, state)
    schema.add(key('column', validator=chained(
            nonempty_string,
        )))
    schema.add(key('format', missing=None))
    schema.add(key('datatype', validator=chained(
            nonempty_string,
            specific_datatype('date')
        )))
    return schema
コード例 #5
0
ファイル: dataset.py プロジェクト: nathanhilbert/FPA_Core
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
コード例 #6
0
ファイル: mapping.py プロジェクト: nathanhilbert/FPA_Core
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
コード例 #7
0
ファイル: source.py プロジェクト: ToroidalATLAS/openspending
def source_schema():
    schema = mapping('source')
    schema.add(key('url', validator=chained(
        nonempty_string,
        valid_url
    )))
    return schema
コード例 #8
0
ファイル: dataset.py プロジェクト: nathanhilbert/FPA_Core
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
コード例 #9
0
ファイル: mapping.py プロジェクト: nathanhilbert/FPA_Core
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
コード例 #10
0
ファイル: mapping.py プロジェクト: nathanhilbert/FPA_Core
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
コード例 #11
0
ファイル: views.py プロジェクト: nathanhilbert/FPA_Core
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
コード例 #12
0
ファイル: mapping.py プロジェクト: nathanhilbert/FPA_Core
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