dependencies: Resolve #218 by adopting the new resolver interface.

+ Deprecates "memory:" URIs in favor of the registry behavior.
+ Fixes a bunch of tests that referenced completely invalid
  specifications.

Author: cwacek

python_jsonschema_objects/__init__.py

@@ -8,12 +8,17 @@
 import inflection
 import jsonschema
 import six
-from jsonschema import Draft4Validator
-
 import python_jsonschema_objects.classbuilder as classbuilder
 import python_jsonschema_objects.markdown_support
 import python_jsonschema_objects.util
 from python_jsonschema_objects.validators import ValidationError
+from typing import Optional
+
+from jsonschema_specifications import REGISTRY as SPECIFICATIONS
+from referencing import Registry, Resource
+import referencing.typing
+import referencing.jsonschema
+import referencing.retrieval
 
 
 logger = logging.getLogger(__name__)
@@ -23,15 +28,20 @@
 FILE = __file__
 
 SUPPORTED_VERSIONS = (
-    "http://json-schema.org/draft-03/schema#",
-    "http://json-schema.org/draft-04/schema#",
+    "http://json-schema.org/draft-03/schema",
+    "http://json-schema.org/draft-04/schema",
 )
 
 
 class ObjectBuilder(object):
-    def __init__(self, schema_uri, resolved={}, resolver=None, validatorClass=None):
-        self.mem_resolved = resolved
-
+    def __init__(
+        self,
+        schema_uri,
+        resolved={},
+        registry: Optional[referencing.Registry] = None,
+        resolver: Optional[referencing.typing.Retrieve] = None,
+        specification_uri: str = "http://json-schema.org/draft-04/schema",
+    ):
         if isinstance(schema_uri, six.string_types):
             uri = os.path.normpath(schema_uri)
             self.basedir = os.path.dirname(uri)
@@ -44,7 +54,7 @@ def __init__(self, schema_uri, resolved={}, resolver=None, validatorClass=None):
 
         if (
             "$schema" in self.schema
-            and self.schema["$schema"] not in SUPPORTED_VERSIONS
+            and self.schema["$schema"].rstrip("#") not in SUPPORTED_VERSIONS
         ):
             warnings.warn(
                 "Schema version {} not recognized. Some "
@@ -53,15 +63,78 @@ def __init__(self, schema_uri, resolved={}, resolver=None, validatorClass=None):
                 )
             )
 
-        self.resolver = resolver or jsonschema.RefResolver.from_schema(self.schema)
-        self.resolver.handlers.update(
-            {"file": self.relative_file_resolver, "memory": self.memory_resolver}
-        )
+        if registry is not None:
+            if not isinstance(registry, referencing.Registry):
+                raise TypeError("registry must be a Registry instance")
+
+            if resolver is not None:
+                raise AttributeError(
+                    "Cannot specify both registry and resolver. If you provide your own registry, pass the resolver directly to that"
+                )
+            self.registry = registry
+        else:
+            if resolver is not None:
+
+                def file_and_memory_handler(uri):
+                    if uri.startswith("file:"):
+                        return Resource.from_contents(self.relative_file_resolver(uri))
+                    return resolver(uri)
+
+                self.registry = Registry(retrieve=file_and_memory_handler)
+            else:
+
+                def file_and_memory_handler(uri):
+                    if uri.startswith("file:"):
+                        return Resource.from_contents(self.relative_file_resolver(uri))
+                    raise RuntimeError(
+                        "No remote resource resolver provided. Cannot resolve {}".format(
+                            uri
+                        )
+                    )
 
-        validatorClass = validatorClass or Draft4Validator
-        meta_validator = validatorClass(validatorClass.META_SCHEMA)
+                self.registry = Registry(retrieve=file_and_memory_handler)
+
+        if len(resolved) > 0:
+            warnings.warn(
+                "Use of 'memory:' URIs is deprecated. Provide a registry with properly resolved references "
+                "if you want to resolve items externally.",
+                DeprecationWarning,
+            )
+        for uri, contents in resolved.items():
+            self.registry = self.registry.with_resource(
+                "memory:" + uri,
+                referencing.Resource.from_contents(contents, specification_uri),
+            )
+
+        if "$schema" not in self.schema:
+            warnings.warn("Schema version not specified. Defaulting to draft4")
+            updated = {"$schema": specification_uri}
+            updated.update(self.schema)
+            self.schema = updated
+
+        schema = Resource.from_contents(self.schema)
+        if schema.id() is None:
+            warnings.warn("Schema id not specified. Defaulting to 'self'")
+            updated = {"$id": "self", "id": "self"}
+            updated.update(self.schema)
+            self.schema = updated
+            schema = Resource.from_contents(self.schema)
+
+        self.registry = self.registry.with_resource("", schema)
+        self.resolver = self.registry.resolver()
+
+        if specification_uri is not None:
+            validatorClass = jsonschema.validators.validator_for(
+                {"$schema": specification_uri}
+            )
+        else:
+            validatorClass = jsonschema.validators.validator_for(self.schema)
+
+        meta_validator = validatorClass(
+            validatorClass.META_SCHEMA, registry=self.registry
+        )
         meta_validator.validate(self.schema)
-        self.validator = validatorClass(self.schema, resolver=self.resolver)
+        self.validator = validatorClass(self.schema, registry=self.registry)
 
         self._classes = None
         self._resolved = None
@@ -88,9 +161,6 @@ def get_class(self, uri):
             self._classes = self.build_classes()
         return self._resolved.get(uri, None)
 
-    def memory_resolver(self, uri):
-        return self.mem_resolved[uri[7:]]
-
     def relative_file_resolver(self, uri):
         path = os.path.join(self.basedir, uri[8:])
         with codecs.open(path, "r", "utf-8") as fin:
@@ -129,10 +199,11 @@ def build_classes(self, strict=False, named_only=False, standardize_names=True):
         kw = {"strict": strict}
         builder = classbuilder.ClassBuilder(self.resolver)
         for nm, defn in six.iteritems(self.schema.get("definitions", {})):
+            resolved = self.resolver.lookup("#/definitions/" + nm)
             uri = python_jsonschema_objects.util.resolve_ref_uri(
-                self.resolver.resolution_scope, "#/definitions/" + nm
+                self.resolver._base_uri, "#/definitions/" + nm
             )
-            builder.construct(uri, defn, **kw)
+            builder.construct(uri, resolved.contents, **kw)
 
         if standardize_names:
             name_transform = lambda t: inflection.camelize(

python_jsonschema_objects/classbuilder.py

@@ -1,3 +1,5 @@
+import referencing._core
+
 import python_jsonschema_objects.util as util
 import python_jsonschema_objects.validators as validators
 import python_jsonschema_objects.pattern_properties as pattern_properties
@@ -444,7 +446,7 @@ def __call__(self, *a, **kw):
 
 
 class ClassBuilder(object):
-    def __init__(self, resolver):
+    def __init__(self, resolver: referencing._core.Resolver):
         self.resolver = resolver
         self.resolved = {}
         self.under_construction = set()
@@ -464,7 +466,7 @@ def expand_references(self, source_uri, iterable):
 
     def resolve_type(self, ref, source):
         """Return a resolved type for a URI, potentially constructing one if necessary"""
-        uri = util.resolve_ref_uri(self.resolver.resolution_scope, ref)
+        uri = util.resolve_ref_uri(self.resolver._base_uri, ref)
         if uri in self.resolved:
             return self.resolved[uri]
 
@@ -483,9 +485,9 @@ def resolve_type(self, ref, source):
                     "Resolving direct reference object {0} -> {1}", source, uri
                 )
             )
-            with self.resolver.resolving(ref) as resolved:
-                self.resolved[uri] = self.construct(uri, resolved, (ProtocolBase,))
-                return self.resolved[uri]
+            resolved = self.resolver.lookup(ref)
+            self.resolved[uri] = self.construct(uri, resolved.contents, (ProtocolBase,))
+            return self.resolved[uri]
 
     def construct(self, uri, *args, **kw):
         """Wrapper to debug things"""

python_jsonschema_objects/examples/README.md

@@ -219,7 +219,7 @@ The schema and code example below show how this works.
 
 The `$ref` operator is supported in nearly all locations, and
 dispatches the actual reference resolution to the
-`jsonschema.RefResolver`.
+`referencing.Registry` resolver.
 
 This example shows using the memory URI (described in more detail
 below) to create a wrapper object that is just a string literal.
@@ -298,6 +298,9 @@ ValidationError: '[u'author']' are required attributes for B
 
 #### The "memory:" URI
 
+**"memory:" URIs are deprecated (although they still work). Load resources into a
+`referencing.Registry` instead and pass those in**
+
 The ObjectBuilder can be passed a dictionary specifying
 'memory' schemas when instantiated. This will allow it to
 resolve references where the referenced schemas are retrieved

setup.py

@@ -41,7 +41,7 @@
         install_requires=[
             "inflection>=0.2",
             "Markdown>=2.4",
-            "jsonschema>=2.3,<4.18",
+            "jsonschema>=2.3",
             "six>=1.5.2",
         ],
         cmdclass=versioneer.get_cmdclass(),

test/test_nondefault_resolver_validator.py

@@ -1,24 +1,52 @@
 import pytest  # noqa
-from jsonschema import RefResolver, Draft3Validator
-from jsonschema._utils import load_schema, URIDict
+import referencing
+import json
+import referencing.jsonschema
+import referencing.exceptions
 import python_jsonschema_objects as pjo
 
 
-def test_non_default_resolver_validator(markdown_examples):
-    ms = URIDict()
-    draft3 = load_schema("draft3")
-    draft4 = load_schema("draft4")
-    ms[draft3["id"]] = draft3
-    ms[draft4["id"]] = draft4
-    resolver_with_store = RefResolver(draft3["id"], draft3, ms)
-
-    # 'Other' schema should be valid with draft3
+def test_custom_spec_validator(markdown_examples):
+    # This schema shouldn't be valid under DRAFT-03
+    schema = {
+        "$schema": "http://json-schema.org/draft-04/schema",
+        "title": "other",
+        "oneOf": [{"type": "string"}, {"type": "number"}],
+    }
     builder = pjo.ObjectBuilder(
-        markdown_examples["Other"],
-        resolver=resolver_with_store,
-        validatorClass=Draft3Validator,
+        schema,
+        specification_uri="http://json-schema.org/draft-03/schema",
         resolved=markdown_examples,
     )
     klasses = builder.build_classes()
-    a = klasses.Other(MyAddress="where I live")
-    assert a.MyAddress == "where I live"
+    a = klasses.Other("foo")
+    assert a == "foo"
+
+
+def test_non_default_resolver_finds_refs():
+    registry = referencing.Registry()
+
+    remote_schema = {
+        "$schema": "http://json-schema.org/draft-04/schema",
+        "type": "number",
+    }
+    registry = registry.with_resource(
+        "https://example.org/schema/example",
+        referencing.Resource.from_contents(remote_schema),
+    )
+
+    schema = {
+        "$schema": "http://json-schema.org/draft-04/schema",
+        "title": "other",
+        "type": "object",
+        "properties": {
+            "local": {"type": "string"},
+            "remote": {"$ref": "https://example.org/schema/example"},
+        },
+    }
+
+    builder = pjo.ObjectBuilder(
+        schema,
+        registry=registry,
+    )
+    builder.build_classes()