Merge pull request #2396 from Carreau/json_schema

create a ipynbv3 json schema and a validator

IPython/external/jsonpointer/VERSION.txt

@@ -0,0 +1,4 b''
+_jsonpointer.py
+
+extracted from jsonpointer.py following commit :
+97a06ecb9dde82bd54dc269052841035ca2a1390

IPython/external/jsonpointer/__init__.py

@@ -0,0 +1,4 b''
+try:
+    from jsonpointer import *
+except ImportError :
+    from _jsonpointer import *

IPython/external/jsonpointer/_jsonpointer.py

@@ -0,0 +1,228 b''
+# -*- coding: utf-8 -*-
+#
+# python-json-pointer - An implementation of the JSON Pointer syntax
+# https://github.com/stefankoegl/python-json-pointer
+#
+# Copyright (c) 2011 Stefan Kögl <[e-mail]>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+# 3. The name of the author may not be used to endorse or promote products
+#    derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+""" Identify specific nodes in a JSON document according to
+http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-04 """
+
+# Will be parsed by setup.py to determine package metadata
+__author__ = 'Stefan Kögl <[e-mail]>'
+__version__ = '0.3'
+__website__ = 'https://github.com/stefankoegl/python-json-pointer'
+__license__ = 'Modified BSD License'
+
+
+try:
+    from urllib import unquote
+    from itertools import izip
+except ImportError: # Python 3
+    from urllib.parse import unquote
+    izip = zip
+
+from itertools import tee
+
+
+class JsonPointerException(Exception):
+    pass
+
+
+_nothing = object()
+
+
+def resolve_pointer(doc, pointer, default=_nothing):
+    """
+    Resolves pointer against doc and returns the referenced object
+
+    >>> obj = {"foo": {"anArray": [ {"prop": 44}], "another prop": {"baz": "A string" }}}
+
+    >>> resolve_pointer(obj, '') == obj
+    True
+
+    >>> resolve_pointer(obj, '/foo') == obj['foo']
+    True
+
+    >>> resolve_pointer(obj, '/foo/another%20prop') == obj['foo']['another prop']
+    True
+
+    >>> resolve_pointer(obj, '/foo/another%20prop/baz') == obj['foo']['another prop']['baz']
+    True
+
+    >>> resolve_pointer(obj, '/foo/anArray/0') == obj['foo']['anArray'][0]
+    True
+
+    >>> resolve_pointer(obj, '/some/path', None) == None
+    True
+
+    """
+
+    pointer = JsonPointer(pointer)
+    return pointer.resolve(doc, default)
+
+
+def set_pointer(doc, pointer, value):
+    """
+    Set a field to a given value
+
+    The field is indicates by a base location that is given in the constructor,
+    and an optional relative location in the call to set. If the path doesn't
+    exist, it is created if possible
+
+    >>> obj = {"foo": 2}
+    >>> pointer = JsonPointer('/bar')
+    >>> pointer.set(obj, 'one', '0')
+    >>> pointer.set(obj, 'two', '1')
+    >>> obj
+    {'foo': 2, 'bar': ['one', 'two']}
+
+    >>> obj = {"foo": 2, "bar": []}
+    >>> pointer = JsonPointer('/bar')
+    >>> pointer.set(obj, 5, '0/x')
+    >>> obj
+    {'foo': 2, 'bar': [{'x': 5}]}
+
+    >>> obj = {'foo': 2, 'bar': [{'x': 5}]}
+    >>> pointer = JsonPointer('/bar/0')
+    >>> pointer.set(obj, 10, 'y/0')
+    >>> obj == {'foo': 2, 'bar': [{'y': [10], 'x': 5}]}
+    True
+    """
+
+    pointer = JsonPointer(pointer)
+    pointer.set(doc, value)
+
+
+class JsonPointer(object):
+    """ A JSON Pointer that can reference parts of an JSON document """
+
+    def __init__(self, pointer):
+        parts = pointer.split('/')
+        if parts.pop(0) != '':
+            raise JsonPointerException('location must starts with /')
+
+        parts = map(unquote, parts)
+        parts = [part.replace('~1', '/') for part in parts]
+        parts = [part.replace('~0', '~') for part in parts]
+        self.parts = parts
+
+
+
+    def resolve(self, doc, default=_nothing):
+        """Resolves the pointer against doc and returns the referenced object"""
+
+        for part in self.parts:
+
+            try:
+                doc = self.walk(doc, part)
+            except JsonPointerException:
+                if default is _nothing:
+                    raise
+                else:
+                    return default
+
+        return doc
+
+
+    get = resolve
+
+
+    def set(self, doc, value, path=None):
+        """ Sets a field of doc to value
+
+        The location of the field is given by the pointers base location and
+        the optional path which is relative to the base location """
+
+        fullpath = list(self.parts)
+
+        if path:
+            fullpath += path.split('/')
+
+
+        for part, nextpart in pairwise(fullpath):
+            try:
+                doc = self.walk(doc, part)
+            except JsonPointerException:
+                step_val = [] if nextpart.isdigit() else {}
+                doc = self._set_value(doc, part, step_val)
+
+        self._set_value(doc, fullpath[-1], value)
+
+
+    @staticmethod
+    def _set_value(doc, part, value):
+        part = int(part) if part.isdigit() else part
+
+        if isinstance(doc, dict):
+            doc[part] = value
+
+        if isinstance(doc, list):
+            if len(doc) < part:
+                doc[part] = value
+
+            if len(doc) == part:
+                doc.append(value)
+
+            else:
+                raise IndexError
+
+        return doc[part]
+
+
+    def walk(self, doc, part):
+        """ Walks one step in doc and returns the referenced part """
+
+        # Its not clear if a location "1" should be considered as 1 or "1"
+        # We prefer the integer-variant if possible
+        part_variants = self._try_parse(part) + [part]
+
+        for variant in part_variants:
+            try:
+                return doc[variant]
+            except:
+                continue
+
+        raise JsonPointerException("'%s' not found in %s" % (part, doc))
+
+
+    @staticmethod
+    def _try_parse(val, cls=int):
+        try:
+            return [cls(val)]
+        except:
+            return []
+
+
+
+def pairwise(iterable):
+    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
+    a, b = tee(iterable)
+    for _ in b:
+        break
+    return izip(a, b)

IPython/external/jsonschema/COPYING

@@ -0,0 +1,19 b''
+Copyright (c) 2011 Julian Berman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

IPython/external/jsonschema/VERSION

@@ -0,0 +1,3 b''
+_jsonschema from commit : 
+3ddd80543bd6da56eeea84b2f364febaeadf31b9
+

IPython/external/jsonschema/__init__.py

@@ -0,0 +1,4 b''
+try:
+    from jsonschema import *
+except ImportError :
+    from _jsonschema import *

IPython/external/jsonschema/_jsonschema.py

@@ -0,0 +1,734 b''
+"""
+An implementation of JSON Schema for Python
+
+The main functionality is provided by the validator classes for each of the
+supported JSON Schema versions.
+
+Most commonly, the :function:`validate` function is the quickest way to simply
+validate a given instance under a schema, and will create a validator for you.
+
+"""
+
+from __future__ import division, unicode_literals
+
+import collections
+import itertools
+import operator
+import re
+import sys
+import warnings
+
+
+__version__ = "0.7"
+
+FLOAT_TOLERANCE = 10 ** -15
+PY3 = sys.version_info[0] >= 3
+
+if PY3:
+    basestring = unicode = str
+    iteritems = operator.methodcaller("items")
+    from urllib.parse import unquote
+else:
+    from itertools import izip as zip
+    iteritems = operator.methodcaller("iteritems")
+    from urllib import unquote
+
+
+class UnknownType(Exception):
+    """
+    An unknown type was given.
+
+    """
+
+
+class InvalidRef(Exception):
+    """
+    An invalid reference was given.
+
+    """
+
+
+class SchemaError(Exception):
+    """
+    The provided schema is malformed.
+
+    The same attributes exist for ``SchemaError``s as for ``ValidationError``s.
+
+    """
+
+    validator = None
+
+    def __init__(self, message):
+        super(SchemaError, self).__init__(message)
+        self.message = message
+        self.path = []
+
+
+class ValidationError(Exception):
+    """
+    The instance didn't properly validate with the provided schema.
+
+    Relevant attributes are:
+        * ``message`` : a human readable message explaining the error
+        * ``path`` : a list containing the path to the offending element (or []
+                     if the error happened globally) in *reverse* order (i.e.
+                     deepest index first).
+
+    """
+
+    # the failing validator will be set externally at whatever recursion level
+    # is immediately above the validation failure
+    validator = None
+
+    def __init__(self, message):
+        super(ValidationError, self).__init__(message)
+        self.message = message
+
+        # Any validator that recurses must append to the ValidationError's
+        # path (e.g., properties and items)
+        self.path = []
+
+
+class Draft3Validator(object):
+    """
+    A validator for JSON Schema draft 3.
+
+    """
+
+    DEFAULT_TYPES = {
+        "array" : list, "boolean" : bool, "integer" : int, "null" : type(None),
+        "number" : (int, float), "object" : dict, "string" : basestring,
+    }
+
+    def __init__(self, schema, types=()):
+        """
+        Initialize a validator.
+
+        ``schema`` should be a *valid* JSON Schema object already converted to
+        a native Python object (typically a dict via ``json.load``).
+
+        ``types`` is a mapping (or iterable of 2-tuples) containing additional
+        types or alternate types to verify via the 'type' property. For
+        instance, the default types for the 'number' JSON Schema type are
+        ``int`` and ``float``.  To override this behavior (e.g. for also
+        allowing ``decimal.Decimal``), pass ``types={"number" : (int, float,
+        decimal.Decimal)} *including* the default types if so desired, which
+        are fairly obvious but can be accessed via the ``DEFAULT_TYPES``
+        attribute on this class if necessary.
+
+        """
+
+        self._types = dict(self.DEFAULT_TYPES)
+        self._types.update(types)
+        self._types["any"] = tuple(self._types.values())
+
+        self.schema = schema
+
+    def is_type(self, instance, type):
+        """
+        Check if an ``instance`` is of the provided (JSON Schema) ``type``.
+
+        """
+
+        if type not in self._types:
+            raise UnknownType(type)
+        type = self._types[type]
+
+        # bool inherits from int, so ensure bools aren't reported as integers
+        if isinstance(instance, bool):
+            type = _flatten(type)
+            if int in type and bool not in type:
+                return False
+        return isinstance(instance, type)
+
+    def is_valid(self, instance, _schema=None):
+        """
+        Check if the ``instance`` is valid under the current schema.
+
+        Returns a bool indicating whether validation succeeded.
+
+        """
+
+        error = next(self.iter_errors(instance, _schema), None)
+        return error is None
+
+    @classmethod
+    def check_schema(cls, schema):
+        """
+        Validate a ``schema`` against the meta-schema to see if it is valid.
+
+        """
+
+        for error in cls(cls.META_SCHEMA).iter_errors(schema):
+            s = SchemaError(error.message)
+            s.path = error.path
+            s.validator = error.validator
+            # I think we're safer raising these always, not yielding them
+            raise s
+
+    def iter_errors(self, instance, _schema=None):
+        """
+        Lazily yield each of the errors in the given ``instance``.
+
+        """
+
+        if _schema is None:
+            _schema = self.schema
+
+        for k, v in iteritems(_schema):
+            validator = getattr(self, "validate_%s" % (k.lstrip("$"),), None)
+
+            if validator is None:
+                continue
+
+            errors = validator(v, instance, _schema) or ()
+            for error in errors:
+                # if the validator hasn't already been set (due to recursion)
+                # make sure to set it
+                error.validator = error.validator or k
+                yield error
+
+    def validate(self, *args, **kwargs):
+        """
+        Validate an ``instance`` under the given ``schema``.
+
+        """
+
+        for error in self.iter_errors(*args, **kwargs):
+            raise error
+
+    def validate_type(self, types, instance, schema):
+        types = _list(types)
+
+        for type in types:
+            # Ouch. Brain hurts. Two paths here, either we have a schema, then
+            # check if the instance is valid under it
+            if ((
+                self.is_type(type, "object") and
+                self.is_valid(instance, type)
+
+            # Or we have a type as a string, just check if the instance is that
+            # type. Also, HACK: we can reach the `or` here if skip_types is
+            # something other than error. If so, bail out.
+
+            ) or (
+                self.is_type(type, "string") and
+                (self.is_type(instance, type) or type not in self._types)
+            )):
+                return
+        else:
+            yield ValidationError(_types_msg(instance, types))
+
+    def validate_properties(self, properties, instance, schema):
+        if not self.is_type(instance, "object"):
+            return
+
+        for property, subschema in iteritems(properties):
+            if property in instance:
+                for error in self.iter_errors(instance[property], subschema):
+                    error.path.append(property)
+                    yield error
+            elif subschema.get("required", False):
+                error = ValidationError(
+                    "%r is a required property" % (property,)
+                )
+                error.path.append(property)
+                error.validator = "required"
+                yield error
+
+    def validate_patternProperties(self, patternProperties, instance, schema):
+        for pattern, subschema in iteritems(patternProperties):
+            for k, v in iteritems(instance):
+                if re.match(pattern, k):
+                    for error in self.iter_errors(v, subschema):
+                        yield error
+
+    def validate_additionalProperties(self, aP, instance, schema):
+        if not self.is_type(instance, "object"):
+            return
+
+        extras = set(_find_additional_properties(instance, schema))
+
+        if self.is_type(aP, "object"):
+            for extra in extras:
+                for error in self.iter_errors(instance[extra], aP):
+                    yield error
+        elif not aP and extras:
+            error = "Additional properties are not allowed (%s %s unexpected)"
+            yield ValidationError(error % _extras_msg(extras))
+
+    def validate_dependencies(self, dependencies, instance, schema):
+        if not self.is_type(instance, "object"):
+            return
+
+        for property, dependency in iteritems(dependencies):
+            if property not in instance:
+                continue
+
+            if self.is_type(dependency, "object"):
+                for error in self.iter_errors(instance, dependency):
+                    yield error
+            else:
+                dependencies = _list(dependency)
+                for dependency in dependencies:
+                    if dependency not in instance:
+                        yield ValidationError(
+                            "%r is a dependency of %r" % (dependency, property)
+                        )
+
+    def validate_items(self, items, instance, schema):
+        if not self.is_type(instance, "array"):
+            return
+
+        if self.is_type(items, "object"):
+            for index, item in enumerate(instance):
+                for error in self.iter_errors(item, items):
+                    error.path.append(index)
+                    yield error
+        else:
+            for (index, item), subschema in zip(enumerate(instance), items):
+                for error in self.iter_errors(item, subschema):
+                    error.path.append(index)
+                    yield error
+
+    def validate_additionalItems(self, aI, instance, schema):
+        if not self.is_type(instance, "array"):
+            return
+        if not self.is_type(schema.get("items"), "array"):
+            return
+
+        if self.is_type(aI, "object"):
+            for item in instance[len(schema):]:
+                for error in self.iter_errors(item, aI):
+                    yield error
+        elif not aI and len(instance) > len(schema.get("items", [])):
+            error = "Additional items are not allowed (%s %s unexpected)"
+            yield ValidationError(
+                error % _extras_msg(instance[len(schema.get("items", [])):])
+            )
+
+    def validate_minimum(self, minimum, instance, schema):
+        if not self.is_type(instance, "number"):
+            return
+
+        instance = float(instance)
+        if schema.get("exclusiveMinimum", False):
+            failed = instance <= minimum
+            cmp = "less than or equal to"
+        else:
+            failed = instance < minimum
+            cmp = "less than"
+
+        if failed:
+            yield ValidationError(
+                "%r is %s the minimum of %r" % (instance, cmp, minimum)
+            )
+
+    def validate_maximum(self, maximum, instance, schema):
+        if not self.is_type(instance, "number"):
+            return
+
+        instance = float(instance)
+        if schema.get("exclusiveMaximum", False):
+            failed = instance >= maximum
+            cmp = "greater than or equal to"
+        else:
+            failed = instance > maximum
+            cmp = "greater than"
+
+        if failed:
+            yield ValidationError(
+                "%r is %s the maximum of %r" % (instance, cmp, maximum)
+            )
+
+    def validate_minItems(self, mI, instance, schema):
+        if self.is_type(instance, "array") and len(instance) < mI:
+            yield ValidationError("%r is too short" % (instance,))
+
+    def validate_maxItems(self, mI, instance, schema):
+        if self.is_type(instance, "array") and len(instance) > mI:
+            yield ValidationError("%r is too long" % (instance,))
+
+    def validate_uniqueItems(self, uI, instance, schema):
+        if uI and self.is_type(instance, "array") and not _uniq(instance):
+            yield ValidationError("%r has non-unique elements" % instance)
+
+    def validate_pattern(self, patrn, instance, schema):
+        if self.is_type(instance, "string") and not re.match(patrn, instance):
+            yield ValidationError("%r does not match %r" % (instance, patrn))
+
+    def validate_minLength(self, mL, instance, schema):
+        if self.is_type(instance, "string") and len(instance) < mL:
+            yield ValidationError("%r is too short" % (instance,))
+
+    def validate_maxLength(self, mL, instance, schema):
+        if self.is_type(instance, "string") and len(instance) > mL:
+            yield ValidationError("%r is too long" % (instance,))
+
+    def validate_enum(self, enums, instance, schema):
+        if instance not in enums:
+            yield ValidationError("%r is not one of %r" % (instance, enums))
+
+    def validate_divisibleBy(self, dB, instance, schema):
+        if not self.is_type(instance, "number"):
+            return
+
+        if isinstance(dB, float):
+            mod = instance % dB
+            failed = (mod > FLOAT_TOLERANCE) and (dB - mod) > FLOAT_TOLERANCE
+        else:
+            failed = instance % dB
+
+        if failed:
+            yield ValidationError("%r is not divisible by %r" % (instance, dB))
+
+    def validate_disallow(self, disallow, instance, schema):
+        for disallowed in _list(disallow):
+            if self.is_valid(instance, {"type" : [disallowed]}):
+                yield ValidationError(
+                    "%r is disallowed for %r" % (disallowed, instance)
+                )
+
+    def validate_extends(self, extends, instance, schema):
+        if self.is_type(extends, "object"):
+            extends = [extends]
+        for subschema in extends:
+            for error in self.iter_errors(instance, subschema):
+                yield error
+
+    def validate_ref(self, ref, instance, schema):
+        if ref != "#" and not ref.startswith("#/"):
+            warnings.warn("jsonschema only supports json-pointer $refs")
+            return
+
+        resolved = resolve_json_pointer(self.schema, ref)
+        for error in self.iter_errors(instance, resolved):
+            yield error
+
+
+Draft3Validator.META_SCHEMA = {
+    "$schema" : "http://json-schema.org/draft-03/schema#",
+    "id" : "http://json-schema.org/draft-03/schema#",
+    "type" : "object",
+
+    "properties" : {
+        "type" : {
+            "type" : ["string", "array"],
+            "items" : {"type" : ["string", {"$ref" : "#"}]},
+            "uniqueItems" : True,
+            "default" : "any"
+        },
+        "properties" : {
+            "type" : "object",
+            "additionalProperties" : {"$ref" : "#", "type": "object"},
+            "default" : {}
+        },
+        "patternProperties" : {
+            "type" : "object",
+            "additionalProperties" : {"$ref" : "#"},
+            "default" : {}
+        },
+        "additionalProperties" : {
+            "type" : [{"$ref" : "#"}, "boolean"], "default" : {}
+        },
+        "items" : {
+            "type" : [{"$ref" : "#"}, "array"],
+            "items" : {"$ref" : "#"},
+            "default" : {}
+        },
+        "additionalItems" : {
+            "type" : [{"$ref" : "#"}, "boolean"], "default" : {}
+        },
+        "required" : {"type" : "boolean", "default" : False},
+        "dependencies" : {
+            "type" : ["string", "array", "object"],
+            "additionalProperties" : {
+                "type" : ["string", "array", {"$ref" : "#"}],
+                "items" : {"type" : "string"}
+            },
+            "default" : {}
+        },
+        "minimum" : {"type" : "number"},
+        "maximum" : {"type" : "number"},
+        "exclusiveMinimum" : {"type" : "boolean", "default" : False},
+        "exclusiveMaximum" : {"type" : "boolean", "default" : False},
+        "minItems" : {"type" : "integer", "minimum" : 0, "default" : 0},
+        "maxItems" : {"type" : "integer", "minimum" : 0},
+        "uniqueItems" : {"type" : "boolean", "default" : False},
+        "pattern" : {"type" : "string", "format" : "regex"},
+        "minLength" : {"type" : "integer", "minimum" : 0, "default" : 0},
+        "maxLength" : {"type" : "integer"},
+        "enum" : {"type" : "array", "minItems" : 1, "uniqueItems" : True},
+        "default" : {"type" : "any"},
+        "title" : {"type" : "string"},
+        "description" : {"type" : "string"},
+        "format" : {"type" : "string"},
+        "maxDecimal" : {"type" : "number", "minimum" : 0},
+        "divisibleBy" : {
+            "type" : "number",
+            "minimum" : 0,
+            "exclusiveMinimum" : True,
+            "default" : 1
+        },
+        "disallow" : {
+            "type" : ["string", "array"],
+            "items" : {"type" : ["string", {"$ref" : "#"}]},
+            "uniqueItems" : True
+        },
+        "extends" : {
+            "type" : [{"$ref" : "#"}, "array"],
+            "items" : {"$ref" : "#"},
+            "default" : {}
+        },
+        "id" : {"type" : "string", "format" : "uri"},
+        "$ref" : {"type" : "string", "format" : "uri"},
+        "$schema" : {"type" : "string", "format" : "uri"},
+    },
+    "dependencies" : {
+        "exclusiveMinimum" : "minimum", "exclusiveMaximum" : "maximum"
+    },
+}
+
+
+class Validator(Draft3Validator):
+    """
+    Deprecated: Use :class:`Draft3Validator` instead.
+
+    """
+
+    def __init__(
+        self, version=None, unknown_type="skip", unknown_property="skip",
+        *args, **kwargs
+    ):
+        super(Validator, self).__init__({}, *args, **kwargs)
+        warnings.warn(
+            "Validator is deprecated and will be removed. "
+            "Use Draft3Validator instead.",
+            DeprecationWarning, stacklevel=2,
+        )
+
+
+class ErrorTree(object):
+    """
+    ErrorTrees make it easier to check which validations failed.
+
+    """
+
+    def __init__(self, errors=()):
+        self.errors = {}
+        self._contents = collections.defaultdict(self.__class__)
+
+        for error in errors:
+            container = self
+            for element in reversed(error.path):
+                container = container[element]
+            container.errors[error.validator] = error
+
+    def __contains__(self, k):
+        return k in self._contents
+
+    def __getitem__(self, k):
+        return self._contents[k]
+
+    def __setitem__(self, k, v):
+        self._contents[k] = v
+
+    def __iter__(self):
+        return iter(self._contents)
+
+    def __len__(self):
+        child_errors = sum(len(tree) for _, tree in iteritems(self._contents))
+        return len(self.errors) + child_errors
+
+    def __repr__(self):
+        return "<%s (%s errors)>" % (self.__class__.__name__, len(self))
+
+
+def resolve_json_pointer(schema, ref):
+    """
+    Resolve a local reference ``ref`` within the given root ``schema``.
+
+    ``ref`` should be a local ref whose ``#`` is still present.
+
+    """
+
+    if ref == "#":
+        return schema
+
+    parts = ref.lstrip("#/").split("/")
+
+    parts = map(unquote, parts)
+    parts = [part.replace('~1', '/').replace('~0', '~') for part in parts]
+
+    try:
+        for part in parts:
+            schema = schema[part]
+    except KeyError:
+        raise InvalidRef("Unresolvable json-pointer %r" % ref)
+    else:
+        return schema
+
+
+def _find_additional_properties(instance, schema):
+    """
+    Return the set of additional properties for the given ``instance``.
+
+    Weeds out properties that should have been validated by ``properties`` and
+    / or ``patternProperties``.
+
+    Assumes ``instance`` is dict-like already.
+
+    """
+
+    properties = schema.get("properties", {})
+    patterns = "|".join(schema.get("patternProperties", {}))
+    for property in instance:
+        if property not in properties:
+            if patterns and re.search(patterns, property):
+                continue
+            yield property
+
+
+def _extras_msg(extras):
+    """
+    Create an error message for extra items or properties.
+
+    """
+
+    if len(extras) == 1:
+        verb = "was"
+    else:
+        verb = "were"
+    return ", ".join(repr(extra) for extra in extras), verb
+
+
+def _types_msg(instance, types):
+    """
+    Create an error message for a failure to match the given types.
+
+    If the ``instance`` is an object and contains a ``name`` property, it will
+    be considered to be a description of that object and used as its type.
+
+    Otherwise the message is simply the reprs of the given ``types``.
+
+    """
+
+    reprs = []
+    for type in types:
+        try:
+            reprs.append(repr(type["name"]))
+        except Exception:
+            reprs.append(repr(type))
+    return "%r is not of type %s" % (instance, ", ".join(reprs))
+
+
+def _flatten(suitable_for_isinstance):
+    """
+    isinstance() can accept a bunch of really annoying different types:
+        * a single type
+        * a tuple of types
+        * an arbitrary nested tree of tuples
+
+    Return a flattened tuple of the given argument.
+
+    """
+
+    types = set()
+
+    if not isinstance(suitable_for_isinstance, tuple):
+        suitable_for_isinstance = (suitable_for_isinstance,)
+    for thing in suitable_for_isinstance:
+        if isinstance(thing, tuple):
+            types.update(_flatten(thing))
+        else:
+            types.add(thing)
+    return tuple(types)
+
+
+def _list(thing):
+    """
+    Wrap ``thing`` in a list if it's a single str.
+
+    Otherwise, return it unchanged.
+
+    """
+
+    if isinstance(thing, basestring):
+        return [thing]
+    return thing
+
+
+def _delist(thing):
+    """
+    Unwrap ``thing`` to a single element if its a single str in a list.
+
+    Otherwise, return it unchanged.
+
+    """
+
+    if (
+        isinstance(thing, list) and
+        len(thing) == 1
+        and isinstance(thing[0], basestring)
+    ):
+        return thing[0]
+    return thing
+
+
+def _uniq(container):
+    """
+    Check if all of a container's elements are unique.
+
+    Successively tries first to rely that the elements are hashable, then
+    falls back on them being sortable, and finally falls back on brute
+    force.
+
+    """
+
+    try:
+        return len(set(container)) == len(container)
+    except TypeError:
+        try:
+            sort = sorted(container)
+            sliced = itertools.islice(container, 1, None)
+            for i, j in zip(container, sliced):
+                if i == j:
+                    return False
+        except (NotImplementedError, TypeError):
+            seen = []
+            for e in container:
+                if e in seen:
+                    return False
+                seen.append(e)
+    return True
+
+
+def validate(instance, schema, cls=Draft3Validator, *args, **kwargs):
+    """
+    Validate an ``instance`` under the given ``schema``.
+
+    First verifies that the provided schema is itself valid, since not doing so
+    can lead to less obvious failures when validating. If you know it is or
+    don't care, use ``YourValidator(schema).validate(instance)`` directly
+    instead (e.g. ``Draft3Validator``).
+
+    ``cls`` is a validator class that will be used to validate the instance.
+    By default this is a draft 3 validator.  Any other provided positional and
+    keyword arguments will be provided to this class when constructing a
+    validator.
+
+    """
+
+
+    meta_validate = kwargs.pop("meta_validate", None)
+
+    if meta_validate is not None:
+        warnings.warn(
+            "meta_validate is deprecated and will be removed. If you do not "
+            "want to validate a schema, use Draft3Validator.validate instead.",
+            DeprecationWarning, stacklevel=2,
+        )
+
+    if meta_validate is not False:  # yes this is needed since True was default
+        cls.check_schema(schema)
+    cls(schema, *args, **kwargs).validate(instance)

IPython/nbformat/v3/v3.withref.json

@@ -0,0 +1,171 b''
+{
+    "description": "custom json structure with references to generate notebook schema",
+    "notebook":{
+      "type": "object",
+      "description": "notebook v3.0 root schema",
+      "$schema": "http://json-schema.org/draft-03/schema",
+      "id": "#notebook",
+      "required": true,
+      "additionalProperties": false,
+      "properties":{
+        "metadata": {
+          "type": "object",
+          "id": "metadata",
+          "required": true,
+          "description": "the metadata atribute can contain any additionnal information",
+          "additionalProperties": true,
+          "properties":{
+            "name": {
+              "id": "name",
+              "description": "the title of the notebook",
+              "type": "string",
+              "id": "name",
+              "required": true
+            }
+          }
+        },
+        "nbformat_minor": {
+          "description": "Notebook format, minor number. Incremented for slight variation of notebook format.",
+          "type": "integer",
+          "minimum": 0,
+          "id": "nbformat_minor",
+          "required": true
+        },
+        "nbformat": {
+          "description": "Notebook format, major number. Incremented between backward incompatible change is introduced.",
+          "type": "integer",
+          "minimum": 3,
+          "id": "nbformat",
+          "required": true
+        },
+        "worksheets": {
+          "description": "Array of worksheet, not used by the current implementation of ipython yet",
+          "type": "array",
+          "id": "worksheets",
+          "required": true,
+          "items": {"$ref": "/worksheet"}
+        }
+      }
+    },
+
+    "worksheet": {
+      "additionalProperties": false,
+      "properties":{
+        "cells": {
+          "type": "array",
+          "$schema": "http://json-schema.org/draft-03/schema",
+          "description": "array of cells of the current worksheet",
+          "id": "#cells",
+          "required": true,
+          "items": {"$ref": "/any_cell"}
+
+        },
+        "metadata": {
+          "type": "object",
+          "description": "metadata of the current worksheet",
+          "id": "metadata",
+          "required": true
+        }
+      }
+    },
+
+    "text_cell": {
+      "type": "object",
+      "description": "scheme for text cel and childrenm (level only optionnal argument for HEader cell)",
+      "$schema": "http://json-schema.org/draft-03/schema",
+      "id": "#cell",
+      "required": true,
+      "additionalProperties": false,
+      "properties":{
+        "cell_type": {
+          "type": "string",
+          "id": "cell_type",
+          "required": true
+        },
+        "level": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 6,
+          "id": "level",
+          "required": false
+        },
+        "metadata": {
+          "type": "object",
+          "id": "metadata",
+          "required": true
+        },
+        "source": {
+          "description": "for code cell, the source code",
+          "type": "array",
+          "id": "source",
+          "required": true,
+          "items":
+            {
+              "type": "string",
+              "description": "each item represent one line of the source code written, terminated by \n",
+              "id": "0",
+              "required": true
+            }
+        }
+      }
+
+    },
+
+    "any_cell": {
+        "description": "Meta cell type that match any cell type",
+        "type": [{"$ref": "/text_cell"},{"$ref":"/code_cell"}],
+        "$schema": "http://json-schema.org/draft-03/schema"
+    },
+
+    "code_cell":{
+      "type": "object",
+      "$schema": "http://json-schema.org/draft-03/schema",
+      "description": "Cell used to execute code",
+      "id": "#cell",
+      "required": true,
+      "additionalProperties": false,
+      "properties":{
+        "cell_type": {
+          "type": "string",
+          "id": "cell_type",
+          "required": true
+        },
+        "metadata": {
+          "type": "object",
+          "id": "metadata",
+          "required": true
+        },
+        "collapsed": {
+          "type": "boolean",
+          "required": true
+        },
+        "input": {
+          "description": "user input for text cells",
+          "type": "array",
+          "id": "input",
+          "required": true,
+          "items":
+            {
+              "type": "string",
+              "id": "input",
+              "required": true
+            }
+        },
+        "outputs": {
+            "description": "output for code cell, to be definied",
+            "required": true,
+            "type": "array"
+        },
+        "prompt_number": {
+            "type": ["integer","null"],
+            "required": true,
+            "minimum": 0
+        },
+        "language": {
+            "type": "string",
+            "required": true
+        }
+      }
+
+    }
+}

IPython/nbformat/v3/validator.py

@@ -0,0 +1,88 b''
+#!/usr/bin/env python
+# -*- coding: utf8 -*-
+
+from IPython.external.jsonschema import  Draft3Validator, validate, ValidationError
+import IPython.external.jsonpointer as jsonpointer
+from IPython.external import argparse
+import traceback
+import json
+
+def nbvalidate(nbjson, schema='v3.withref.json', key=None,verbose=True):
+    v3schema = resolve_ref(json.load(open(schema,'r')))
+    if key :
+        v3schema = jsonpointer.resolve_pointer(v3schema,key)
+    errors = 0
+    v = Draft3Validator(v3schema);
+    for error in v.iter_errors(nbjson):
+        errors = errors + 1
+        if verbose:
+            print(error)
+    return errors
+
+def resolve_ref(json, base=None):
+    """return a json with resolved internal references
+
+    only support local reference to the same json
+    """
+    if not base :
+        base = json
+
+    temp = None
+    if type(json) is list:
+        temp = [];
+        for item in json:
+            temp.append(resolve_ref(item, base=base))
+    elif type(json) is dict:
+        temp = {};
+        for key,value in json.iteritems():
+            if key == '$ref':
+                return resolve_ref(jsonpointer.resolve_pointer(base,value), base=base)
+            else :
+                temp[key]=resolve_ref(value, base=base)
+    else :
+        return json
+    return temp
+
+def convert(namein, nameout, indent=2):
+    """resolve the references of namein, save the result in nameout"""
+    jsn = None
+    with open(namein) as file :
+        jsn = json.load(file)
+    v = resolve_ref(jsn, base=jsn)
+    x = jsonpointer.resolve_pointer(v, '/notebook')
+    with open(nameout,'w') as file:
+        json.dump(x,file,indent=indent)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-s', '--schema',
+                    type=str, default='v3.withref.json')
+
+    parser.add_argument('-k', '--key',
+                    type=str, default='/notebook',
+                    help='subkey to extract json schema from json file')
+
+    parser.add_argument("-v", "--verbose", action="store_true",
+                    help="increase output verbosity")
+
+    parser.add_argument('filename',
+            type=str,
+            help="file to validate",
+            nargs='*',
+            metavar='names')
+
+    args = parser.parse_args()
+    for name in args.filename :
+        nerror = nbvalidate(json.load(open(name,'r')),
+                            schema=args.schema,
+                            key=args.key,
+                            verbose=args.verbose)
+        if nerror is 0:
+            print u"[Pass]",name
+        else :
+            print u"[    ]",name,'(%d)'%(nerror)
+        if args.verbose :
+            print '=================================================='
+
+