schema.py

"""This module holds schema definitions for validating the various :py:class:`dicts` that make up parts of a
template, and also the helper functions necessary to validate an object against their respective schema.
"""

import json

import numpy as np
from jsonschema import validators, Draft4Validator, FormatChecker, ValidationError
from pkg_resources import resource_filename


# Create a new validator class (based on Draft4Validator) to allow templates to use
# * Python types or numpy dtypes to specify variable data types; and
# * numpy arrays to specify variable data.
TemplateValidator = validators.create(meta_schema=Draft4Validator.META_SCHEMA,
                                      validators=Draft4Validator.VALIDATORS)
format_checker = FormatChecker()


@format_checker.checks('datatype')
def is_python_datatype(value):
    """Return whether the given value is a valid data type specification for a NetCDF variable"""
    if isinstance(value, np.dtype):
        return True
    if isinstance(value, type):
        return issubclass(value, np.number)

    return False


TYPES = {'array': (list, np.ndarray)}

TEMPLATE_SCHEMA_JSON = resource_filename(__name__, 'template_schema.json')
with open(TEMPLATE_SCHEMA_JSON) as f:
    TEMPLATE_SCHEMA = json.load(f)
TemplateValidator.check_schema(TEMPLATE_SCHEMA)

template_validator = TemplateValidator(TEMPLATE_SCHEMA, types=TYPES, format_checker=format_checker)


def validate_template(t):
    template_validator.validate(t)


def validate_dimensions(d):
    validate_template({'_dimensions': d})


def validate_variables(v):
    validate_template({'_variables': v})


def validate_global_attributes(a):
    if hasattr(a, 'keys'):
        special = [k for k in a.keys() if k.startswith('_')]
        if special:
            raise ValidationError('Special attributes {} not allowed in global attributes dict'.format(special))
    template_validator.validate(a)