Perf improvements by using a cache.

Author: dnephin

jsonschema/_utils.py

@@ -38,6 +38,22 @@ def __repr__(self):
         return repr(self.store)
 
 
+class Cache(object):
+    """Cache the result of a function, using the arguments to the function as
+    the key.
+    """
+
+    def __init__(self, func):
+        self.func = func
+        self._cache = {}
+
+    def __call__(self, *args):
+        if args in self._cache:
+            return self._cache[args]
+        self._cache[args] = value = self.func(*args)
+        return value
+
+
 class Unset(object):
     """
     An as-of-yet unset attribute or unprovided default parameter.

jsonschema/tests/test_validators.py

@@ -775,11 +775,11 @@ def test_it_resolves_local_refs(self):
             self.assertEqual(resolved, self.referrer["properties"]["foo"])
 
     def test_it_resolves_local_refs_with_id(self):
-        schema = {"id": "foo://bar/schema#", "a": {"foo": "bar"}}
+        schema = {"id": "http://bar/schema#", "a": {"foo": "bar"}}
         resolver = RefResolver.from_schema(schema)
         with resolver.resolving("#/a") as resolved:
             self.assertEqual(resolved, schema["a"])
-        with resolver.resolving("foo://bar/schema#/a") as resolved:
+        with resolver.resolving("http://bar/schema#/a") as resolved:
             self.assertEqual(resolved, schema["a"])
 
     def test_it_retrieves_stored_refs(self):
@@ -815,7 +815,7 @@ def test_it_retrieves_unstored_refs_via_urlopen(self):
     def test_it_can_construct_a_base_uri_from_a_schema(self):
         schema = {"id" : "foo"}
         resolver = RefResolver.from_schema(schema)
-        self.assertEqual(resolver.base_uri.url, "foo")
+        self.assertEqual(resolver.resolution_scope, "foo")
         with resolver.resolving("") as resolved:
             self.assertEqual(resolved, schema)
         with resolver.resolving("#") as resolved:
@@ -828,7 +828,7 @@ def test_it_can_construct_a_base_uri_from_a_schema(self):
     def test_it_can_construct_a_base_uri_from_a_schema_without_id(self):
         schema = {}
         resolver = RefResolver.from_schema(schema)
-        self.assertEqual(resolver.base_uri.url, "")
+        self.assertEqual(resolver.resolution_scope, "")
         with resolver.resolving("") as resolved:
             self.assertEqual(resolved, schema)
         with resolver.resolving("#") as resolved:
@@ -863,9 +863,7 @@ def test_cache_remote_off(self):
         )
         with resolver.resolving(ref):
             pass
-        with resolver.resolving(ref):
-            pass
-        self.assertEqual(foo_handler.call_count, 2)
+        self.assertEqual(foo_handler.call_count, 1)
 
     def test_if_you_give_it_junk_you_get_a_resolution_error(self):
         ref = "foo://bar"

jsonschema/validators.py

@@ -3,6 +3,7 @@
 import contextlib
 import json
 import numbers
+from functools import partial
 
 try:
     import requests
@@ -12,7 +13,6 @@
 from jsonschema import _utils, _validators
 from jsonschema.compat import (
     Sequence, urljoin, urlsplit, urldefrag, unquote, urlopen, DefragResult,
-
     str_types, int_types, iteritems,
 )
 from jsonschema.exceptions import ErrorTree  # Backwards compatibility  # noqa
@@ -109,7 +109,7 @@ def iter_errors(self, instance, _schema=None):
                         yield error
             finally:
                 if scope:
-                    self.resolver.pop_scope()
+                    self.resolver.scopes_stack.pop()
 
         def descend(self, instance, schema, path=None, schema_path=None):
             for error in self.iter_errors(instance, schema):
@@ -240,21 +240,21 @@ class RefResolver(object):
     def __init__(
         self, base_uri, referrer, store=(), cache_remote=True, handlers=(),
     ):
-        base_uri = urldefrag(base_uri)
-        self.base_uri = base_uri
-        self.resolution_scope = base_uri
         # This attribute is not used, it is for backwards compatibility
         self.referrer = referrer
         self.cache_remote = cache_remote
         self.handlers = dict(handlers)
 
-        self.scopes_stack = []
+        self.scopes_stack = [base_uri]
         self.store = _utils.URIDict(
             (id, validator.META_SCHEMA)
             for id, validator in iteritems(meta_schemas)
         )
         self.store.update(store)
-        self.store[base_uri.url] = referrer
+        self.store[base_uri] = referrer
+
+        self.url_cache = _utils.Cache(urljoin)
+        self.resolve_cache = _utils.Cache(self.resolve_from_url)
 
     @classmethod
     def from_schema(cls, schema, *args, **kwargs):
@@ -268,19 +268,20 @@ def from_schema(cls, schema, *args, **kwargs):
 
         return cls(schema.get(u"id", u""), schema, *args, **kwargs)
 
-    def push_scope(self, scope, is_defragged=False):
-        old_scope = self.resolution_scope
-        self.scopes_stack.append(old_scope)
-        if not is_defragged:
-            scope = urldefrag(scope)
-        self.resolution_scope = DefragResult(
-            urljoin(old_scope.url, scope.url, allow_fragments=False)
-            if scope.url else old_scope.url,
-            scope.fragment
-        )
+    def push_scope(self, scope):
+        self.scopes_stack.append(self.url_cache(self.resolution_scope, scope))
+
+    @property
+    def resolution_scope(self):
+        return self.scopes_stack[-1]
 
-    def pop_scope(self):
-        self.resolution_scope = self.scopes_stack.pop()
+    @contextlib.contextmanager
+    def in_scope(self, scope):
+        self.push_scope(scope)
+        try:
+            yield
+        finally:
+            self.scopes_stack.pop()
 
     @contextlib.contextmanager
     def resolving(self, ref):
@@ -291,33 +292,25 @@ def resolving(self, ref):
         :argument str ref: reference to resolve
 
         """
+        url = self.url_cache(self.resolution_scope, ref)
 
-        ref = urldefrag(ref)
-
-        if ref.url:
-            url = urljoin(
-                self.resolution_scope.url,
-                ref.url,
-                allow_fragments=False)
-        else:
-            url = self.resolution_scope.url
+        self.push_scope(url)
+        try:
+            yield self.resolve_cache(url)
+        finally:
+            self.scopes_stack.pop()
 
+    def resolve_from_url(self, url):
+        ref = urldefrag(url)
         try:
-            document = self.store[url]
+            document = self.store[ref.url]
         except KeyError:
             try:
-                document = self.resolve_remote(url)
+                document = self.resolve_remote(ref.url)
             except Exception as exc:
                 raise RefResolutionError(exc)
 
-        uri = DefragResult(url, ref.fragment)
-        old_base_uri, self.base_uri = self.base_uri, uri
-        self.push_scope(uri, is_defragged=True)
-        try:
-            yield self.resolve_fragment(document, ref.fragment)
-        finally:
-            self.pop_scope()
-            self.base_uri = old_base_uri
+        return self.resolve_fragment(document, ref.fragment)
 
     def resolve_fragment(self, document, fragment):
         """