Detect version from definition

Author: horejsek

Makefile

@@ -1,4 +1,4 @@
-.PHONY: all venv lint test test-lf benchmark benchmark-save performance doc upload deb clean
+.PHONY: all venv lint jsonschemasuitcases test test-lf benchmark benchmark-save performance printcode doc upload deb clean
 SHELL=/bin/bash
 
 VENV_NAME?=venv

docs/conf.py

@@ -23,7 +23,7 @@
 
 # General information about the project.
 project = u'fastjsonschema'
-copyright = u'2016-{}, Seznam.cz'.format(time.strftime("%Y"))
+copyright = u'2016-{}, Michal Horejsek'.format(time.strftime("%Y"))
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the

fastjsonschema/__init__.py

@@ -23,48 +23,47 @@
 .. code-block:: bash
 
     $ make performance
-    fast_compiled        valid      ==> 0.026877017982769758
-    fast_compiled        invalid    ==> 0.0015628149849362671
-    fast_file            valid      ==> 0.025493122986517847
-    fast_file            invalid    ==> 0.0012430319911800325
-    fast_not_compiled    valid      ==> 4.790547857992351
-    fast_not_compiled    invalid    ==> 1.2642899919883348
-    jsonschema           valid      ==> 5.036152001994196
-    jsonschema           invalid    ==> 1.1929481109953485
-    jsonspec             valid      ==> 7.196442283981014
-    jsonspec             invalid    ==> 1.7245555499684997
-    validictory          valid      ==> 0.36818933801259845
-    validictory          invalid    ==> 0.022672351042274386
-
-This library follows and implements `JSON schema draft-04 <http://json-schema.org>`_. Sometimes
-it's not perfectly clear so I recommend also check out this `understaning json schema
-<https://spacetelescope.github.io/understanding-json-schema>`_.
+    fast_compiled        valid      ==> 0.030474655970465392
+    fast_compiled        invalid    ==> 0.0017561429995112121
+    fast_file            valid      ==> 0.028758891974575818
+    fast_file            invalid    ==> 0.0017655809642747045
+    fast_not_compiled    valid      ==> 4.597834145999514
+    fast_not_compiled    invalid    ==> 1.139162228035275
+    jsonschema           valid      ==> 5.014410221017897
+    jsonschema           invalid    ==> 1.1362981660058722
+    jsonspec             valid      ==> 8.1144932230236
+    jsonspec             invalid    ==> 2.0143173419637606
+    validictory          valid      ==> 0.4084212710149586
+    validictory          invalid    ==> 0.026061681972350925
+
+This library follows and implements `JSON schema draft-04, draft-06 and draft-07
+<http://json-schema.org>`_. Sometimes it's not perfectly clear so I recommend also
+check out this `understaning json schema <https://spacetelescope.github.io/understanding-json-schema>`_.
 
 Note that there are some differences compared to JSON schema standard:
 
  * Regular expressions are full Python ones, not only what JSON schema allows. It's easier
    to allow everything and also it's faster to compile without limits. So keep in mind that when
-   you will use more advanced regular expression, it may not work with other library.
+   you will use more advanced regular expression, it may not work with other library or in
+   other language.
  * JSON schema says you can use keyword ``default`` for providing default values. This implementation
    uses that and always returns transformed input data.
 
 Support only for Python 3.3 and higher.
 """
 
-from os.path import exists
-
-from .exceptions import JsonSchemaException
 from .draft04 import CodeGeneratorDraft04
 from .draft06 import CodeGeneratorDraft06
 from .draft07 import CodeGeneratorDraft07
+from .exceptions import JsonSchemaException
 from .ref_resolver import RefResolver
 from .version import VERSION
 
 __all__ = ('VERSION', 'JsonSchemaException', 'compile', 'compile_to_code')
 
 
 # pylint: disable=redefined-builtin,dangerous-default-value,exec-used
-def compile(definition, version=7, handlers={}):
+def compile(definition, handlers={}):
     """
     Generates validation function for validating JSON schema by ``definition``. Example:
 
@@ -89,22 +88,31 @@ def compile(definition, version=7, handlers={}):
         data = validate({})
         assert data == {'a': 42}
 
-    Args:
-        definition (dict): Json schema definition
-        handlers (dict): A mapping from URI schemes to functions
-        that should be used to retrieve them.
+    Supported implementations are draft-04, draft-06 and draft-07. Which version
+    should be used is determined by `$draft` in your ``definition``. When not
+    specified, the latest implementation is used (draft-07).
+
+    .. code-block:: python
+
+        validate = fastjsonschema.compile({
+            '$schema': 'http://json-schema.org/draft-04/schema',
+            'type': 'number',
+        })
+
+    You can pass mapping from URI to function that should be used to retrieve
+    remote schemes used in your ``definition`` in parameter ``handlers``.
 
     Exception :any:`JsonSchemaException` is thrown when validation fails.
     """
-    resolver, code_generator = _factory(definition, version, handlers)
+    resolver, code_generator = _factory(definition, handlers)
     global_state = code_generator.global_state
     # Do not pass local state so it can recursively call itself.
     exec(code_generator.func_code, global_state)
     return global_state[resolver.get_scope_name()]
 
 
 # pylint: disable=dangerous-default-value
-def compile_to_code(definition, version=7, handlers={}):
+def compile_to_code(definition, handlers={}):
     """
     Generates validation function for validating JSON schema by ``definition``
     and returns compiled code. Example:
@@ -126,25 +134,26 @@ def compile_to_code(definition, version=7, handlers={}):
 
     Exception :any:`JsonSchemaException` is thrown when validation fails.
     """
-    _, code_generator = _factory(definition, version, handlers)
+    _, code_generator = _factory(definition, handlers)
     return (
         'VERSION = "' + VERSION + '"\n' +
         code_generator.global_state_code + '\n' +
         code_generator.func_code
     )
 
 
-def _factory(definition, version, handlers):
+def _factory(definition, handlers):
     resolver = RefResolver.from_schema(definition, handlers=handlers)
-    code_generator = _get_code_generator_class(version)(definition, resolver=resolver)
+    code_generator = _get_code_generator_class(definition)(definition, resolver=resolver)
     return resolver, code_generator
 
 
-def _get_code_generator_class(version):
-    if version == 4:
-        return CodeGeneratorDraft04
-    if version == 6:
-        return CodeGeneratorDraft06
-    if version == 7:
-        return CodeGeneratorDraft07
-    raise JsonSchemaException('Unsupported JSON schema version. Supported are 4, 6 and 7.')
+def _get_code_generator_class(schema):
+    # Schema in from draft-06 can be just the boolean value.
+    if isinstance(schema, dict):
+        schema_version = schema.get('$schema', '')
+        if 'draft-04' in schema_version:
+            return CodeGeneratorDraft04
+        if 'draft-06' in schema_version:
+            return CodeGeneratorDraft06
+    return CodeGeneratorDraft07

fastjsonschema/version.py

@@ -1 +1 @@
-VERSION = '1.6'
+VERSION = '2.0dev'

performance.py

@@ -11,6 +11,7 @@
 NUMBER = 1000
 
 JSON_SCHEMA = {
+    '$schema': 'http://json-schema.org/draft-04/schema#',
     'type': 'array',
     'items': [
         {

tests/conftest.py

@@ -21,7 +21,10 @@ def f(definition, value, expected):
         print(code_generator.func_code)
         pprint(code_generator.global_state)
 
-        validator = compile(definition, version=4)
+        # By default old tests are written for draft-04.
+        definition.setdefault('$schema', 'http://json-schema.org/draft-04/schema')
+
+        validator = compile(definition)
         if isinstance(expected, JsonSchemaException):
             with pytest.raises(JsonSchemaException) as exc:
                 validator(value)

tests/json_schema/test_draft04.py

@@ -5,15 +5,14 @@
 
 def pytest_generate_tests(metafunc):
     param_values, param_ids = resolve_param_values_and_ids(
-        version=4,
+        schema_version='http://json-schema.org/draft-04/schema',
         suite_dir='JSON-Schema-Test-Suite/tests/draft4',
         ignored_suite_files=[
             # Optional.
             'ecmascript-regex.json',
         ],
-        ignore_tests=[],
     )
-    metafunc.parametrize(['version', 'schema', 'data', 'is_valid'], param_values, ids=param_ids)
+    metafunc.parametrize(['schema_version', 'schema', 'data', 'is_valid'], param_values, ids=param_ids)
 
 
 # Real test function to be used with parametrization by previous hook function.

tests/json_schema/test_draft06.py

@@ -5,14 +5,14 @@
 
 def pytest_generate_tests(metafunc):
     param_values, param_ids = resolve_param_values_and_ids(
-        version=6,
+        schema_version='http://json-schema.org/draft-06/schema',
         suite_dir='JSON-Schema-Test-Suite/tests/draft6',
         ignored_suite_files=[
             # Optional.
             'ecmascript-regex.json',
         ],
     )
-    metafunc.parametrize(['version', 'schema', 'data', 'is_valid'], param_values, ids=param_ids)
+    metafunc.parametrize(['schema_version', 'schema', 'data', 'is_valid'], param_values, ids=param_ids)
 
 
 # Real test function to be used with parametrization by previous hook function.

tests/json_schema/test_draft07.py

@@ -5,15 +5,15 @@
 
 def pytest_generate_tests(metafunc):
     param_values, param_ids = resolve_param_values_and_ids(
-        version=7,
+        schema_version='http://json-schema.org/draft-07/schema',
         suite_dir='JSON-Schema-Test-Suite/tests/draft7',
         ignored_suite_files=[
             # Optional.
             'ecmascript-regex.json',
             'idn-hostname.json',
         ],
     )
-    metafunc.parametrize(['version', 'schema', 'data', 'is_valid'], param_values, ids=param_ids)
+    metafunc.parametrize(['schema_version', 'schema', 'data', 'is_valid'], param_values, ids=param_ids)
 
 
 # Real test function to be used with parametrization by previous hook function.

tests/json_schema/utils.py

@@ -29,7 +29,7 @@ def remotes_handler(uri):
     return requests.get(uri).json()
 
 
-def resolve_param_values_and_ids(version, suite_dir, ignored_suite_files=[], ignore_tests=[]):
+def resolve_param_values_and_ids(schema_version, suite_dir, ignored_suite_files=[], ignore_tests=[]):
     suite_dir_path = Path(suite_dir).resolve()
     test_file_paths = sorted(set(suite_dir_path.glob("**/*.json")))
 
@@ -41,7 +41,7 @@ def resolve_param_values_and_ids(version, suite_dir, ignored_suite_files=[], ign
             for test_case in test_cases:
                 for test_data in test_case['tests']:
                     param_values.append(pytest.param(
-                        version,
+                        schema_version,
                         test_case['schema'],
                         test_data['data'],
                         test_data['valid'],
@@ -58,16 +58,21 @@ def resolve_param_values_and_ids(version, suite_dir, ignored_suite_files=[], ign
     return param_values, param_ids
 
 
-def template_test(version, schema, data, is_valid):
+def template_test(schema_version, schema, data, is_valid):
     """
     Test function to be used (imported) in final test file to run the tests
     which are generated by `pytest_generate_tests` hook.
     """
     # For debug purposes. When test fails, it will print stdout.
     resolver = RefResolver.from_schema(schema, handlers={'http': remotes_handler})
-    print(_get_code_generator_class(version)(schema, resolver=resolver).func_code)
+    print(_get_code_generator_class(schema_version)(schema, resolver=resolver).func_code)
 
-    validate = compile(schema, version=version, handlers={'http': remotes_handler})
+    # JSON schema test suits do not contain schema version.
+    # Our library needs to know that or it would use always the latest implementation.
+    if isinstance(schema, dict):
+        schema.setdefault('$schema', schema_version)
+
+    validate = compile(schema, handlers={'http': remotes_handler})
     try:
         result = validate(data)
         print('Validate result:', result)