# Copyright (c) IPython Development Team. # Distributed under the terms of the Modified BSD License. from __future__ import print_function import json import os import pprint import sys import warnings try: from jsonschema import ValidationError from jsonschema import Draft4Validator as Validator except ImportError as e: verbose_msg = """ Jupyter notebook format depends on the jsonschema package: https://pypi.python.org/pypi/jsonschema Please install it first. """ raise ImportError(str(e) + verbose_msg) from ipython_genutils.importstring import import_item validators = {} def _relax_additional_properties(obj): """relax any `additionalProperties`""" if isinstance(obj, dict): for key, value in obj.items(): if key == 'additionalProperties': value = True else: value = _relax_additional_properties(value) obj[key] = value elif isinstance(obj, list): for i, value in enumerate(obj): obj[i] = _relax_additional_properties(value) return obj def _allow_undefined(schema): schema['definitions']['cell']['oneOf'].append( {"$ref": "#/definitions/unrecognized_cell"} ) schema['definitions']['output']['oneOf'].append( {"$ref": "#/definitions/unrecognized_output"} ) return schema def get_validator(version=None, version_minor=None, relax_add_props=False): """Load the JSON schema into a Validator""" if version is None: from .. import current_nbformat version = current_nbformat v = import_item("nbformat.v%s" % version) current_minor = getattr(v, 'nbformat_minor', 0) if version_minor is None: version_minor = current_minor version_tuple = (version, version_minor) if version_tuple not in validators: try: schema_json = _get_schema_json(v) except AttributeError: return None if current_minor < version_minor: # notebook from the future, relax all `additionalProperties: False` requirements schema_json = _relax_additional_properties(schema_json) # and allow undefined cell types and outputs schema_json = _allow_undefined(schema_json) validators[version_tuple] = Validator(schema_json) if relax_add_props: try: schema_json = _get_schema_json(v) except AttributeError: return None # this allows properties to be added for intermediate # representations while validating for all other kinds of errors schema_json = _relax_additional_properties(schema_json) validators[version_tuple] = Validator(schema_json) return validators[version_tuple] def _get_schema_json(v): """ Gets the json schema from a given imported library a nbformat version. """ schema_path = os.path.join(os.path.dirname(v.__file__), v.nbformat_schema) with open(schema_path) as f: schema_json = json.load(f) return schema_json def isvalid(nbjson, ref=None, version=None, version_minor=None): """Checks whether the given notebook JSON conforms to the current notebook format schema. Returns True if the JSON is valid, and False otherwise. To see the individual errors that were encountered, please use the `validate` function instead. """ try: validate(nbjson, ref, version, version_minor) except ValidationError: return False else: return True def _format_as_index(indices): """ (from jsonschema._utils.format_as_index, copied to avoid relying on private API) Construct a single string containing indexing operations for the indices. For example, [1, 2, "foo"] -> [1][2]["foo"] """ if not indices: return "" return "[%s]" % "][".join(repr(index) for index in indices) _ITEM_LIMIT = 16 _STR_LIMIT = 64 def _truncate_obj(obj): """Truncate objects for use in validation tracebacks Cell and output lists are squashed, as are long strings, lists, and dicts. """ if isinstance(obj, dict): truncated = { k:_truncate_obj(v) for k,v in list(obj.items())[:_ITEM_LIMIT] } if isinstance(truncated.get('cells'), list): truncated['cells'] = ['...%i cells...' % len(obj['cells'])] if isinstance(truncated.get('outputs'), list): truncated['outputs'] = ['...%i outputs...' % len(obj['outputs'])] if len(obj) > _ITEM_LIMIT: truncated['...'] = '%i keys truncated' % (len(obj) - _ITEM_LIMIT) return truncated elif isinstance(obj, list): truncated = [ _truncate_obj(item) for item in obj[:_ITEM_LIMIT] ] if len(obj) > _ITEM_LIMIT: truncated.append('...%i items truncated...' % (len(obj) - _ITEM_LIMIT)) return truncated elif isinstance(obj, str): truncated = obj[:_STR_LIMIT] if len(obj) > _STR_LIMIT: truncated += '...' return truncated else: return obj class NotebookValidationError(ValidationError): """Schema ValidationError with truncated representation to avoid massive verbose tracebacks. """ def __init__(self, original, ref=None): self.original = original self.ref = getattr(self.original, 'ref', ref) self.message = self.original.message def __getattr__(self, key): return getattr(self.original, key) def __unicode__(self): """Custom str for validation errors avoids dumping full schema and notebook to logs """ error = self.original instance = _truncate_obj(error.instance) return u'\n'.join([ error.message, u'', u"Failed validating %r in %s%s:" % ( error.validator, self.ref or 'notebook', _format_as_index(list(error.relative_schema_path)[:-1])), u'', u'On instance%s:' % _format_as_index(error.relative_path), pprint.pformat(instance, width=78), ]) if sys.version_info >= (3,): __str__ = __unicode__ def better_validation_error(error, version, version_minor): """Get better ValidationError on oneOf failures oneOf errors aren't informative. if it's a cell type or output_type error, try validating directly based on the type for a better error message """ key = error.schema_path[-1] ref = None if key.endswith('Of'): if isinstance(error.instance, dict): if 'cell_type' in error.instance: ref = error.instance['cell_type'] + "_cell" elif 'output_type' in error.instance: ref = error.instance['output_type'] if ref: try: validate(error.instance, ref, version=version, version_minor=version_minor, ) except ValidationError as sub_error: # keep extending relative path error.relative_path.extend(sub_error.relative_path) sub_error.relative_path = error.relative_path better = better_validation_error(sub_error, version, version_minor) if better.ref is None: better.ref = ref return better except Exception: # if it fails for some reason, # let the original error through pass return NotebookValidationError(error, ref) def validate(nbjson, ref=None, version=None, version_minor=None, relax_add_props=False): """Checks whether the given notebook JSON conforms to the current notebook format schema. Raises ValidationError if not valid. """ if version is None: from .reader import get_version (version, version_minor) = get_version(nbjson) validator = get_validator(version, version_minor, relax_add_props=relax_add_props) if validator is None: # no validator warnings.warn("No schema for validating v%s notebooks" % version, UserWarning) return try: if ref: return validator.validate(nbjson, {'$ref' : '#/definitions/%s' % ref}) else: return validator.validate(nbjson) except ValidationError as e: raise better_validation_error(e, version, version_minor)