Split out resolution logic

Author: Zac-HD

src/hypothesis_jsonschema/_canonicalise.py

@@ -16,8 +16,7 @@
 import json
 import math
 import re
-from copy import deepcopy
-from typing import Any, Dict, List, NoReturn, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 import jsonschema
 from hypothesis.errors import InvalidArgument
@@ -569,69 +568,6 @@ def canonicalish(schema: JSONType) -> Dict[str, Any]:
 FALSEY = canonicalish(False)
 
 
-class LocalResolver(jsonschema.RefResolver):
-    def resolve_remote(self, uri: str) -> NoReturn:
-        raise HypothesisRefResolutionError(
-            f"hypothesis-jsonschema does not fetch remote references (uri={uri!r})"
-        )
-
-
-def resolve_all_refs(
-    schema: Union[bool, Schema], *, resolver: LocalResolver = None
-) -> Schema:
-    """
-    Resolve all references in the given schema.
-
-    This handles nested definitions, but not recursive definitions.
-    The latter require special handling to convert to strategies and are much
-    less common, so we just ignore them (and error out) for now.
-    """
-    if isinstance(schema, bool):
-        return canonicalish(schema)
-    assert isinstance(schema, dict), schema
-    if resolver is None:
-        resolver = LocalResolver.from_schema(deepcopy(schema))
-    if not isinstance(resolver, jsonschema.RefResolver):
-        raise InvalidArgument(
-            f"resolver={resolver} (type {type(resolver).__name__}) is not a RefResolver"
-        )
-
-    if "$ref" in schema:
-        s = dict(schema)
-        ref = s.pop("$ref")
-        with resolver.resolving(ref) as got:
-            if s == {}:
-                return resolve_all_refs(got, resolver=resolver)
-            m = merged([s, got])
-            if m is None:  # pragma: no cover
-                msg = f"$ref:{ref!r} had incompatible base schema {s!r}"
-                raise HypothesisRefResolutionError(msg)
-            return resolve_all_refs(m, resolver=resolver)
-    assert "$ref" not in schema
-
-    for key in SCHEMA_KEYS:
-        val = schema.get(key, False)
-        if isinstance(val, list):
-            schema[key] = [
-                resolve_all_refs(v, resolver=resolver) if isinstance(v, dict) else v
-                for v in val
-            ]
-        elif isinstance(val, dict):
-            schema[key] = resolve_all_refs(val, resolver=resolver)
-        else:
-            assert isinstance(val, bool)
-    for key in SCHEMA_OBJECT_KEYS:  # values are keys-to-schema-dicts, not schemas
-        if key in schema:
-            subschema = schema[key]
-            assert isinstance(subschema, dict)
-            schema[key] = {
-                k: resolve_all_refs(v, resolver=resolver) if isinstance(v, dict) else v
-                for k, v in subschema.items()
-            }
-    assert isinstance(schema, dict)
-    return schema
-
-
 def merged(schemas: List[Any]) -> Optional[Schema]:
     """Merge *n* schemas into a single schema, or None if result is invalid.
 

src/hypothesis_jsonschema/_from_schema.py

@@ -26,9 +26,9 @@
     get_type,
     make_validator,
     merged,
-    resolve_all_refs,
 )
 from ._encode import JSONType, encode_canonical_json
+from ._resolve import resolve_all_refs
 
 JSON_STRATEGY: st.SearchStrategy[JSONType] = st.recursive(
     st.none()

src/hypothesis_jsonschema/_resolve.py

@@ -0,0 +1,91 @@
+"""
+Canonicalisation logic for JSON schemas.
+
+The canonical format that we transform to is not intended for human consumption.
+Instead, it prioritises locality of reasoning - for example, we convert oneOf
+arrays into an anyOf of allOf (each sub-schema being the original plus not anyOf
+the rest).  Resolving references and merging subschemas is also really helpful.
+
+All this effort is justified by the huge performance improvements that we get
+when converting to Hypothesis strategies.  To the extent possible there is only
+one way to generate any given value... but much more importantly, we can do
+most things by construction instead of by filtering.  That's the difference
+between "I'd like it to be faster" and "doesn't finish at all".
+"""
+from copy import deepcopy
+from typing import NoReturn, Union
+
+import jsonschema
+from hypothesis.errors import InvalidArgument
+
+from ._canonicalise import (
+    SCHEMA_KEYS,
+    SCHEMA_OBJECT_KEYS,
+    HypothesisRefResolutionError,
+    Schema,
+    canonicalish,
+    merged,
+)
+
+
+class LocalResolver(jsonschema.RefResolver):
+    def resolve_remote(self, uri: str) -> NoReturn:
+        raise HypothesisRefResolutionError(
+            f"hypothesis-jsonschema does not fetch remote references (uri={uri!r})"
+        )
+
+
+def resolve_all_refs(
+    schema: Union[bool, Schema], *, resolver: LocalResolver = None
+) -> Schema:
+    """
+    Resolve all references in the given schema.
+
+    This handles nested definitions, but not recursive definitions.
+    The latter require special handling to convert to strategies and are much
+    less common, so we just ignore them (and error out) for now.
+    """
+    if isinstance(schema, bool):
+        return canonicalish(schema)
+    assert isinstance(schema, dict), schema
+    if resolver is None:
+        resolver = LocalResolver.from_schema(deepcopy(schema))
+    if not isinstance(resolver, jsonschema.RefResolver):
+        raise InvalidArgument(
+            f"resolver={resolver} (type {type(resolver).__name__}) is not a RefResolver"
+        )
+
+    if "$ref" in schema:
+        s = dict(schema)
+        ref = s.pop("$ref")
+        with resolver.resolving(ref) as got:
+            m = merged([s, resolve_all_refs(got, resolver=resolver)])
+            if m is None:  # pragma: no cover
+                msg = f"$ref:{ref!r} had incompatible base schema {s!r}"
+                raise HypothesisRefResolutionError(msg)
+            assert "$ref" not in m
+            return m
+    assert "$ref" not in schema
+
+    for key in SCHEMA_KEYS:
+        val = schema.get(key, False)
+        if isinstance(val, list):
+            schema[key] = [
+                resolve_all_refs(v, resolver=resolver) if isinstance(v, dict) else v
+                for v in val
+            ]
+        elif isinstance(val, dict):
+            schema[key] = resolve_all_refs(val, resolver=resolver)
+        else:
+            assert isinstance(val, bool)
+    for key in SCHEMA_OBJECT_KEYS:  # values are keys-to-schema-dicts, not schemas
+        if key in schema:
+            subschema = schema[key]
+            assert isinstance(subschema, dict)
+            schema[key] = {
+                k: resolve_all_refs(v, resolver=resolver) if isinstance(v, dict) else v
+                for k, v in subschema.items()
+            }
+    assert isinstance(schema, dict)
+    assert "$ref" not in schema
+    return schema

tests/test_canonicalise.py

@@ -14,9 +14,9 @@
     make_validator,
     merged,
     next_up,
-    resolve_all_refs,
 )
 from hypothesis_jsonschema._from_schema import JSON_STRATEGY
+from hypothesis_jsonschema._resolve import resolve_all_refs
 
 
 def is_valid(instance, schema):

tests/test_from_schema.py

@@ -24,9 +24,9 @@
 from hypothesis_jsonschema._canonicalise import (
     HypothesisRefResolutionError,
     canonicalish,
-    resolve_all_refs,
 )
 from hypothesis_jsonschema._from_schema import from_schema, rfc3339
+from hypothesis_jsonschema._resolve import resolve_all_refs
 
 # We use this as a placeholder for all schemas which resolve to nothing()
 # but do not canonicalise to FALSEY