From 2fda1556ef7714d562317049f46db6ff59db5c2f Mon Sep 17 00:00:00 2001
From: "Kostis Anagnostopoulos @ STUW025" <ankostis@gmail.com>
Date: Wed, 24 Sep 2014 03:20:07 +0200
Subject: [PATCH 1/7] issue #158: TRY to speed-up scope & $ref url-handling by
 keeping fragments separated from URL (and avoid redunant frag/defrag).
 Conflicts: 	jsonschema/tests/test_benchmarks.py

issue #158: Use try-finally to ensure resolver scopes_stack empty when
iteration breaks (no detectable performance penalty).

* Replace non-python-2.6 DefragResult with named-tuple.
* Add test-case checking scopes_stack empty.
Conflicts:
	jsonschema/tests/test_validators.py
	jsonschema/validators.py
---
 jsonschema/compat.py     | 10 +++++--
 jsonschema/validators.py | 58 +++++++++++++++++++++++++---------------
 2 files changed, 45 insertions(+), 23 deletions(-)

diff --git a/jsonschema/compat.py b/jsonschema/compat.py
index 6ca49ab..0afd9ea 100644
--- a/jsonschema/compat.py
+++ b/jsonschema/compat.py
@@ -1,6 +1,9 @@
 from __future__ import unicode_literals
-import sys
+
+from collections import namedtuple
 import operator
+import sys
+
 
 try:
     from collections import MutableMapping, Sequence  # noqa
@@ -40,6 +43,9 @@ def urlsplit(url):
     return SplitResult(scheme, netloc, path, query, fragment)
 
 
+DefragResult = namedtuple('DefragResult', 'url fragment')
+
+
 def urldefrag(url):
     if "#" in url:
         s, n, p, q, frag = urlsplit(url)
@@ -47,7 +53,7 @@ def urldefrag(url):
     else:
         defrag = url
         frag = ''
-    return defrag, frag
+    return DefragResult(defrag, frag)
 
 
 # flake8: noqa
diff --git a/jsonschema/validators.py b/jsonschema/validators.py
index c347bf1..8f48062 100644
--- a/jsonschema/validators.py
+++ b/jsonschema/validators.py
@@ -11,7 +11,8 @@ except ImportError:
 
 from jsonschema import _utils, _validators
 from jsonschema.compat import (
-    Sequence, urljoin, urlsplit, urldefrag, unquote, urlopen,
+    Sequence, urljoin, urlsplit, urldefrag, unquote, urlopen, DefragResult,
+
     str_types, int_types, iteritems,
 )
 from jsonschema.exceptions import ErrorTree  # Backwards compatibility  # noqa
@@ -79,7 +80,10 @@ def create(meta_schema, validators=(), version=None, default_types=None):  # noq
             if _schema is None:
                 _schema = self.schema
 
-            with self.resolver.in_scope(_schema.get(u"id", u"")):
+            scope = _schema.get(u"id")
+            if scope:
+                self.resolver.push_scope(scope)
+            try:
                 ref = _schema.get(u"$ref")
                 if ref is not None:
                     validators = [(u"$ref", ref)]
@@ -103,6 +107,9 @@ def create(meta_schema, validators=(), version=None, default_types=None):  # noq
                         if k != u"$ref":
                             error.schema_path.appendleft(k)
                         yield error
+            finally:
+                if scope:
+                    self.resolver.pop_scope()
 
         def descend(self, instance, schema, path=None, schema_path=None):
             for error in self.iter_errors(instance, schema):
@@ -222,7 +229,7 @@ class RefResolver(object):
 
     :argument str base_uri: URI of the referring document
     :argument referrer: the actual referring document
-    :argument dict store: a mapping from URIs to documents to cache
+    :argument dict store: a mapping from URIs (without fragments!) to documents to cache
     :argument bool cache_remote: whether remote refs should be cached after
         first resolution
     :argument dict handlers: a mapping from URI schemes to functions that
@@ -233,6 +240,7 @@ 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
@@ -240,12 +248,13 @@ class RefResolver(object):
         self.cache_remote = cache_remote
         self.handlers = dict(handlers)
 
+        self.scopes_stack = []
         self.store = _utils.URIDict(
             (id, validator.META_SCHEMA)
             for id, validator in iteritems(meta_schemas)
         )
         self.store.update(store)
-        self.store[base_uri] = referrer
+        self.store[base_uri.url] = referrer
 
     @classmethod
     def from_schema(cls, schema, *args, **kwargs):
@@ -259,14 +268,19 @@ class RefResolver(object):
 
         return cls(schema.get(u"id", u""), schema, *args, **kwargs)
 
-    @contextlib.contextmanager
-    def in_scope(self, scope):
+    def push_scope(self, scope, is_defragged=False):
         old_scope = self.resolution_scope
-        self.resolution_scope = urljoin(old_scope, scope)
-        try:
-            yield
-        finally:
-            self.resolution_scope = old_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 pop_scope(self):
+        self.resolution_scope = self.scopes_stack.pop()
 
     @contextlib.contextmanager
     def resolving(self, ref):
@@ -278,24 +292,26 @@ class RefResolver(object):
 
         """
 
-        full_uri = urljoin(self.resolution_scope, ref)
-        uri, fragment = urldefrag(full_uri)
-        if not uri:
-            uri = self.base_uri
+        ref = urldefrag(ref)
 
-        if uri in self.store:
-            document = self.store[uri]
-        else:
+        url = urljoin(self.resolution_scope.url, ref.url, allow_fragments=False) \
+                if ref.url else self.resolution_scope.url
+
+        try:
+            document = self.store[url]
+        except KeyError:
             try:
-                document = self.resolve_remote(uri)
+                document = self.resolve_remote(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:
-            with self.in_scope(uri):
-                yield self.resolve_fragment(document, fragment)
+            yield self.resolve_fragment(document, ref.fragment)
         finally:
+            self.pop_scope()
             self.base_uri = old_base_uri
 
     def resolve_fragment(self, document, fragment):

From 22701dc6526433201d2781b77566a6dba42768a8 Mon Sep 17 00:00:00 2001
From: Daniel Nephin <dnephin@gmail.com>
Date: Fri, 27 Feb 2015 19:53:54 -0500
Subject: [PATCH 2/7] Fix test failures

---
 jsonschema/tests/test_validators.py |  4 ++--
 jsonschema/validators.py            | 13 +++++++++----
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/jsonschema/tests/test_validators.py b/jsonschema/tests/test_validators.py
index 2b14372..b3512ed 100644
--- a/jsonschema/tests/test_validators.py
+++ b/jsonschema/tests/test_validators.py
@@ -815,7 +815,7 @@ class TestRefResolver(unittest.TestCase):
     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, "foo")
+        self.assertEqual(resolver.base_uri.url, "foo")
         with resolver.resolving("") as resolved:
             self.assertEqual(resolved, schema)
         with resolver.resolving("#") as resolved:
@@ -828,7 +828,7 @@ class TestRefResolver(unittest.TestCase):
     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, "")
+        self.assertEqual(resolver.base_uri.url, "")
         with resolver.resolving("") as resolved:
             self.assertEqual(resolved, schema)
         with resolver.resolving("#") as resolved:
diff --git a/jsonschema/validators.py b/jsonschema/validators.py
index 8f48062..d0431f3 100644
--- a/jsonschema/validators.py
+++ b/jsonschema/validators.py
@@ -229,7 +229,7 @@ class RefResolver(object):
 
     :argument str base_uri: URI of the referring document
     :argument referrer: the actual referring document
-    :argument dict store: a mapping from URIs (without fragments!) to documents to cache
+    :argument dict store: a mapping from URIs to documents to cache
     :argument bool cache_remote: whether remote refs should be cached after
         first resolution
     :argument dict handlers: a mapping from URI schemes to functions that
@@ -275,7 +275,7 @@ class RefResolver(object):
             scope = urldefrag(scope)
         self.resolution_scope = DefragResult(
             urljoin(old_scope.url, scope.url, allow_fragments=False)
-                    if scope.url else old_scope.url,
+            if scope.url else old_scope.url,
             scope.fragment
         )
 
@@ -294,8 +294,13 @@ class RefResolver(object):
 
         ref = urldefrag(ref)
 
-        url = urljoin(self.resolution_scope.url, ref.url, allow_fragments=False) \
-                if ref.url else self.resolution_scope.url
+        if ref.url:
+            url = urljoin(
+                self.resolution_scope.url,
+                ref.url,
+                allow_fragments=False)
+        else:
+            url = self.resolution_scope.url
 
         try:
             document = self.store[url]

From 812392bbd4359718eab86e892c32211823b229e5 Mon Sep 17 00:00:00 2001
From: Daniel Nephin <dnephin@gmail.com>
Date: Sun, 1 Mar 2015 17:58:35 -0500
Subject: [PATCH 3/7] Add benchmark script.

---
 bench.py | 74 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 74 insertions(+)
 create mode 100644 bench.py

diff --git a/bench.py b/bench.py
new file mode 100644
index 0000000..e7318ed
--- /dev/null
+++ b/bench.py
@@ -0,0 +1,74 @@
+#!/usr/env/bin python
+"""
+Benchmark the performance of jsonschema.
+
+Example benchmark:
+
+    wget http://swagger.io/v2/schema.json
+    wget http://petstore.swagger.io/v2/swagger.json
+    python bench.py -r 5 schema.json swagger.json
+
+"""
+from __future__ import print_function
+import argparse
+import cProfile
+import json
+import time
+
+import jsonschema
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('schema', help="path to a schema used to benchmark")
+    parser.add_argument('document', help="document to validate with schema")
+    parser.add_argument('-r', '--repeat', type=int, help="number of iterations")
+    parser.add_argument('--profile',
+                        help="Enable profiling, write profile to this filepath")
+    return parser.parse_args()
+
+
+def run(filename, schema, document):
+    resolver = jsonschema.RefResolver(
+        'file://{0}'.format(filename),
+        schema,
+        store={schema['id']: schema})
+    jsonschema.validate(document, schema, resolver=resolver)
+
+
+def format_time(time_):
+    return "%.3fms" % (time_ * 1000)
+
+
+def run_timeit(schema_filename, document_filename, repeat, profile):
+    with open(schema_filename) as schema_file:
+        schema = json.load(schema_file)
+
+    with open(document_filename) as fh:
+        document = json.load(fh)
+
+    if profile:
+        profiler = cProfile.Profile()
+        profiler.enable()
+
+    times = []
+    for _ in range(repeat):
+        start_time = time.time()
+        run(schema_filename, schema, document)
+        times.append(time.time() - start_time)
+
+    if profile:
+        profiler.disable()
+        profiler.dump_stats(profile)
+
+    print(", ".join(map(format_time, sorted(times))))
+    print("Mean: {0}".format(format_time(sum(times) / repeat)))
+
+
+def main():
+    args = parse_args()
+    run_timeit(args.schema, args.document, args.repeat, args.profile)
+
+
+if __name__ == "__main__":
+    main()

From 613cf3e1a0ed9c09f9a13634dd05416594694e40 Mon Sep 17 00:00:00 2001
From: Daniel Nephin <dnephin@gmail.com>
Date: Fri, 27 Feb 2015 21:15:08 -0500
Subject: [PATCH 4/7] Perf improvements by using a cache.

---
 jsonschema/_utils.py                | 16 +++++++
 jsonschema/tests/test_validators.py | 12 ++---
 jsonschema/validators.py            | 73 +++++++++++++----------------
 3 files changed, 54 insertions(+), 47 deletions(-)

diff --git a/jsonschema/_utils.py b/jsonschema/_utils.py
index ae7e2b5..c13711c 100644
--- a/jsonschema/_utils.py
+++ b/jsonschema/_utils.py
@@ -38,6 +38,22 @@ class URIDict(MutableMapping):
         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.
diff --git a/jsonschema/tests/test_validators.py b/jsonschema/tests/test_validators.py
index b3512ed..0f4c825 100644
--- a/jsonschema/tests/test_validators.py
+++ b/jsonschema/tests/test_validators.py
@@ -775,11 +775,11 @@ class TestRefResolver(unittest.TestCase):
             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 @@ class TestRefResolver(unittest.TestCase):
     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 @@ class TestRefResolver(unittest.TestCase):
     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 @@ class TestRefResolver(unittest.TestCase):
         )
         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"
diff --git a/jsonschema/validators.py b/jsonschema/validators.py
index d0431f3..a69accb 100644
--- a/jsonschema/validators.py
+++ b/jsonschema/validators.py
@@ -11,8 +11,7 @@ except ImportError:
 
 from jsonschema import _utils, _validators
 from jsonschema.compat import (
-    Sequence, urljoin, urlsplit, urldefrag, unquote, urlopen, DefragResult,
-
+    Sequence, urljoin, urlsplit, urldefrag, unquote, urlopen,
     str_types, int_types, iteritems,
 )
 from jsonschema.exceptions import ErrorTree  # Backwards compatibility  # noqa
@@ -109,7 +108,7 @@ def create(meta_schema, validators=(), version=None, default_types=None):  # noq
                         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 +239,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.urljoin_cache = _utils.Cache(urljoin)
+        self.resolve_cache = _utils.Cache(self.resolve_from_url)
 
     @classmethod
     def from_schema(cls, schema, *args, **kwargs):
@@ -268,19 +267,21 @@ class RefResolver(object):
 
         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.urljoin_cache(self.resolution_scope, scope))
 
-    def pop_scope(self):
-        self.resolution_scope = self.scopes_stack.pop()
+    @property
+    def resolution_scope(self):
+        return self.scopes_stack[-1]
+
+    @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 @@ class RefResolver(object):
         :argument str ref: reference to resolve
 
         """
+        url = self.urljoin_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:
-            document = self.store[url]
+            yield self.resolve_cache(url)
+        finally:
+            self.scopes_stack.pop()
+
+    def resolve_from_url(self, url):
+        ref = urldefrag(url)
+        try:
+            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):
         """

From d1e24483aabea8844bf7498b52649498f6b3ff5a Mon Sep 17 00:00:00 2001
From: Daniel Nephin <dnephin@gmail.com>
Date: Sun, 1 Mar 2015 20:52:20 -0500
Subject: [PATCH 5/7] Remove context manager from ref() validation.

---
 jsonschema/_validators.py           |  7 ++++++-
 jsonschema/tests/test_validators.py |  8 ++------
 jsonschema/validators.py            | 27 +++++++++++++++++++--------
 3 files changed, 27 insertions(+), 15 deletions(-)

diff --git a/jsonschema/_validators.py b/jsonschema/_validators.py
index 7e5956d..a51681e 100644
--- a/jsonschema/_validators.py
+++ b/jsonschema/_validators.py
@@ -190,9 +190,14 @@ def enum(validator, enums, instance, schema):
 
 
 def ref(validator, ref, instance, schema):
-    with validator.resolver.resolving(ref) as resolved:
+    scope, resolved = validator.resolver.resolve(ref)
+    validator.resolver.push_scope(scope)
+
+    try:
         for error in validator.descend(instance, resolved):
             yield error
+    finally:
+        validator.resolver.pop_scope()
 
 
 def type_draft3(validator, types, instance, schema):
diff --git a/jsonschema/tests/test_validators.py b/jsonschema/tests/test_validators.py
index 0f4c825..f3bb854 100644
--- a/jsonschema/tests/test_validators.py
+++ b/jsonschema/tests/test_validators.py
@@ -633,12 +633,8 @@ class ValidatorTestMixin(object):
         resolver = RefResolver("", {})
         schema = {"$ref" : mock.Mock()}
 
-        @contextmanager
-        def resolving():
-            yield {"type": "integer"}
-
-        with mock.patch.object(resolver, "resolving") as resolve:
-            resolve.return_value = resolving()
+        with mock.patch.object(resolver, "resolve") as resolve:
+            resolve.return_value = "url", {"type": "integer"}
             with self.assertRaises(ValidationError):
                 self.validator_class(schema, resolver=resolver).validate(None)
 
diff --git a/jsonschema/validators.py b/jsonschema/validators.py
index a69accb..435b8db 100644
--- a/jsonschema/validators.py
+++ b/jsonschema/validators.py
@@ -108,7 +108,7 @@ def create(meta_schema, validators=(), version=None, default_types=None):  # noq
                         yield error
             finally:
                 if scope:
-                    self.resolver.scopes_stack.pop()
+                    self.resolver.pop_scope()
 
         def descend(self, instance, schema, path=None, schema_path=None):
             for error in self.iter_errors(instance, schema):
@@ -271,20 +271,36 @@ class RefResolver(object):
         self.scopes_stack.append(
             self.urljoin_cache(self.resolution_scope, scope))
 
+    def pop_scope(self):
+        self.scopes_stack.pop()
+
     @property
     def resolution_scope(self):
         return self.scopes_stack[-1]
 
+
+    # Deprecated, this function is no longer used, but is preserved for
+    # backwards compatibility
     @contextlib.contextmanager
     def in_scope(self, scope):
         self.push_scope(scope)
         try:
             yield
         finally:
-            self.scopes_stack.pop()
+            self.pop_scope()
 
+    # Deprecated, this function is no longer used, but is preserved for
+    # backwards compatibility
     @contextlib.contextmanager
     def resolving(self, ref):
+        url, resolved = self.resolve(ref)
+        self.push_scope(url)
+        try:
+            yield resolved
+        finally:
+            self.pop_scope()
+
+    def resolve(self, ref):
         """
         Context manager which resolves a JSON ``ref`` and enters the
         resolution scope of this ref.
@@ -293,12 +309,7 @@ class RefResolver(object):
 
         """
         url = self.urljoin_cache(self.resolution_scope, ref)
-
-        self.push_scope(url)
-        try:
-            yield self.resolve_cache(url)
-        finally:
-            self.scopes_stack.pop()
+        return url, self.resolve_cache(url)
 
     def resolve_from_url(self, url):
         ref = urldefrag(url)

From ca59f3fa87cda8b0f101d3997dcbc8711e5a19c2 Mon Sep 17 00:00:00 2001
From: Daniel Nephin <dnephin@gmail.com>
Date: Tue, 3 Mar 2015 16:09:42 -0500
Subject: [PATCH 6/7] Remove DefragResult.

---
 jsonschema/compat.py     | 6 +-----
 jsonschema/validators.py | 8 ++++----
 2 files changed, 5 insertions(+), 9 deletions(-)

diff --git a/jsonschema/compat.py b/jsonschema/compat.py
index 0afd9ea..b3156f9 100644
--- a/jsonschema/compat.py
+++ b/jsonschema/compat.py
@@ -1,6 +1,5 @@
 from __future__ import unicode_literals
 
-from collections import namedtuple
 import operator
 import sys
 
@@ -43,9 +42,6 @@ def urlsplit(url):
     return SplitResult(scheme, netloc, path, query, fragment)
 
 
-DefragResult = namedtuple('DefragResult', 'url fragment')
-
-
 def urldefrag(url):
     if "#" in url:
         s, n, p, q, frag = urlsplit(url)
@@ -53,7 +49,7 @@ def urldefrag(url):
     else:
         defrag = url
         frag = ''
-    return DefragResult(defrag, frag)
+    return defrag, frag
 
 
 # flake8: noqa
diff --git a/jsonschema/validators.py b/jsonschema/validators.py
index 435b8db..2343908 100644
--- a/jsonschema/validators.py
+++ b/jsonschema/validators.py
@@ -312,16 +312,16 @@ class RefResolver(object):
         return url, self.resolve_cache(url)
 
     def resolve_from_url(self, url):
-        ref = urldefrag(url)
+        url, fragment = urldefrag(url)
         try:
-            document = self.store[ref.url]
+            document = self.store[url]
         except KeyError:
             try:
-                document = self.resolve_remote(ref.url)
+                document = self.resolve_remote(url)
             except Exception as exc:
                 raise RefResolutionError(exc)
 
-        return self.resolve_fragment(document, ref.fragment)
+        return self.resolve_fragment(document, fragment)
 
     def resolve_fragment(self, document, fragment):
         """

From ee1a256fc856a616940fb1eddcb3f4d8f7cb2f22 Mon Sep 17 00:00:00 2001
From: Daniel Nephin <dnephin@gmail.com>
Date: Wed, 4 Mar 2015 15:57:31 -0500
Subject: [PATCH 7/7] Use lru_cache

---
 jsonschema/__init__.py              |  4 +---
 jsonschema/_utils.py                | 16 ---------------
 jsonschema/compat.py                |  2 ++
 jsonschema/tests/test_validators.py |  8 +++++++-
 jsonschema/validators.py            | 32 +++++++++++++++++++----------
 jsonschema/version.py               |  1 +
 setup.py                            | 15 ++++++++++++--
 7 files changed, 45 insertions(+), 33 deletions(-)
 create mode 100644 jsonschema/version.py

diff --git a/jsonschema/__init__.py b/jsonschema/__init__.py
index 16c9843..e23168d 100644
--- a/jsonschema/__init__.py
+++ b/jsonschema/__init__.py
@@ -19,8 +19,6 @@ from jsonschema.validators import (
     Draft3Validator, Draft4Validator, RefResolver, validate
 )
 
-
-__version__ = "2.5.0-dev"
-
+from jsonschema.version import __version__
 
 # flake8: noqa
diff --git a/jsonschema/_utils.py b/jsonschema/_utils.py
index c13711c..ae7e2b5 100644
--- a/jsonschema/_utils.py
+++ b/jsonschema/_utils.py
@@ -38,22 +38,6 @@ class URIDict(MutableMapping):
         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.
diff --git a/jsonschema/compat.py b/jsonschema/compat.py
index b3156f9..9f52ded 100644
--- a/jsonschema/compat.py
+++ b/jsonschema/compat.py
@@ -13,6 +13,7 @@ PY3 = sys.version_info[0] >= 3
 
 if PY3:
     zip = zip
+    from functools import lru_cache
     from io import StringIO
     from urllib.parse import (
         unquote, urljoin, urlunsplit, SplitResult, urlsplit as _urlsplit
@@ -23,6 +24,7 @@ if PY3:
     iteritems = operator.methodcaller("items")
 else:
     from itertools import izip as zip  # noqa
+    from repoze.lru import lru_cache
     from StringIO import StringIO
     from urlparse import (
         urljoin, urlunsplit, SplitResult, urlsplit as _urlsplit # noqa
diff --git a/jsonschema/tests/test_validators.py b/jsonschema/tests/test_validators.py
index f3bb854..1f03294 100644
--- a/jsonschema/tests/test_validators.py
+++ b/jsonschema/tests/test_validators.py
@@ -1,5 +1,4 @@
 from collections import deque
-from contextlib import contextmanager
 import json
 
 from jsonschema import FormatChecker, ValidationError
@@ -870,6 +869,13 @@ class TestRefResolver(unittest.TestCase):
                 pass
         self.assertEqual(str(err.exception), "Oh no! What's this?")
 
+    def test_helpful_error_message_on_failed_pop_scope(self):
+        resolver = RefResolver("", {})
+        resolver.pop_scope()
+        with self.assertRaises(RefResolutionError) as exc:
+            resolver.pop_scope()
+        self.assertIn("Failed to pop the scope", str(exc.exception))
+
 
 def sorted_errors(errors):
     def key(error):
diff --git a/jsonschema/validators.py b/jsonschema/validators.py
index 2343908..c84a3db 100644
--- a/jsonschema/validators.py
+++ b/jsonschema/validators.py
@@ -12,7 +12,7 @@ except ImportError:
 from jsonschema import _utils, _validators
 from jsonschema.compat import (
     Sequence, urljoin, urlsplit, urldefrag, unquote, urlopen,
-    str_types, int_types, iteritems,
+    str_types, int_types, iteritems, lru_cache,
 )
 from jsonschema.exceptions import ErrorTree  # Backwards compatibility  # noqa
 from jsonschema.exceptions import RefResolutionError, SchemaError, UnknownType
@@ -233,18 +233,22 @@ class RefResolver(object):
         first resolution
     :argument dict handlers: a mapping from URI schemes to functions that
         should be used to retrieve them
-
+    :arguments callable cache_func: a function decorator used to cache
+        expensive calls. Should support the `functools.lru_cache` interface.
+    :argument int cache_maxsize: number of items to store in the cache. Set
+        this to 0 to disable caching. Defaults to 1000.
     """
 
     def __init__(
         self, base_uri, referrer, store=(), cache_remote=True, handlers=(),
+        cache_func=lru_cache, cache_maxsize=1000,
     ):
         # 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 = [base_uri]
+        self._scopes_stack = [base_uri]
         self.store = _utils.URIDict(
             (id, validator.META_SCHEMA)
             for id, validator in iteritems(meta_schemas)
@@ -252,8 +256,8 @@ class RefResolver(object):
         self.store.update(store)
         self.store[base_uri] = referrer
 
-        self.urljoin_cache = _utils.Cache(urljoin)
-        self.resolve_cache = _utils.Cache(self.resolve_from_url)
+        self._urljoin_cache = cache_func(cache_maxsize)(urljoin)
+        self._resolve_cache = cache_func(cache_maxsize)(self.resolve_from_url)
 
     @classmethod
     def from_schema(cls, schema, *args, **kwargs):
@@ -268,15 +272,21 @@ class RefResolver(object):
         return cls(schema.get(u"id", u""), schema, *args, **kwargs)
 
     def push_scope(self, scope):
-        self.scopes_stack.append(
-            self.urljoin_cache(self.resolution_scope, scope))
+        self._scopes_stack.append(
+            self._urljoin_cache(self.resolution_scope, scope))
 
     def pop_scope(self):
-        self.scopes_stack.pop()
+        try:
+            self._scopes_stack.pop()
+        except IndexError:
+            raise RefResolutionError(
+                "Failed to pop the scope from an empty stack. "
+                "`pop_scope()` should only be called once for every "
+                "`push_scope()`")
 
     @property
     def resolution_scope(self):
-        return self.scopes_stack[-1]
+        return self._scopes_stack[-1]
 
 
     # Deprecated, this function is no longer used, but is preserved for
@@ -308,8 +318,8 @@ class RefResolver(object):
         :argument str ref: reference to resolve
 
         """
-        url = self.urljoin_cache(self.resolution_scope, ref)
-        return url, self.resolve_cache(url)
+        url = self._urljoin_cache(self.resolution_scope, ref)
+        return url, self._resolve_cache(url)
 
     def resolve_from_url(self, url):
         url, fragment = urldefrag(url)
diff --git a/jsonschema/version.py b/jsonschema/version.py
new file mode 100644
index 0000000..9509105
--- /dev/null
+++ b/jsonschema/version.py
@@ -0,0 +1 @@
+__version__ = "2.5.0-dev"
diff --git a/setup.py b/setup.py
index 6b47714..ffd61f1 100644
--- a/setup.py
+++ b/setup.py
@@ -1,7 +1,12 @@
+import os.path
 from setuptools import setup
+import sys
 
-from jsonschema import __version__
-
+# Load __version__ info globals without importing anything
+with open(
+    os.path.join(os.path.dirname(__file__), 'jsonschema', 'version.py')
+) as fh:
+    exec(fh.read())
 
 with open("README.rst") as readme:
     long_description = readme.read()
@@ -21,6 +26,11 @@ classifiers = [
     "Programming Language :: Python :: Implementation :: PyPy",
 ]
 
+install_requires = []
+
+if sys.version_info < (3, 2):
+    install_requires.append('repoze.lru >= 0.6')
+
 setup(
     name="jsonschema",
     version=__version__,
@@ -34,4 +44,5 @@ setup(
     long_description=long_description,
     url="http://github.com/Julian/jsonschema",
     entry_points={"console_scripts": ["jsonschema = jsonschema.cli:main"]},
+    install_requires=install_requires,
 )