Possible to breakout of loop for a single node (ie for $ref).

Neglibly slower, BUT reduced stdev and simpler main-loop code.

Author: ankostis

jsonschema/_validators.py

@@ -1,7 +1,7 @@
 import re
 
 from jsonschema import _utils
-from jsonschema.exceptions import FormatError, ValidationError
+from jsonschema.exceptions import FormatError, ValidationError, BreakLoopException
 from jsonschema.compat import iteritems
 
 
@@ -196,6 +196,7 @@ def ref(validator, ref, instance, schema):
     with validator.resolver.resolving(ref) as resolved:
         for error in validator.descend(instance, resolved):
             yield error
+    raise BreakLoopException()
 
 
 def type_draft3(validator, types, instance, schema):

jsonschema/exceptions.py

@@ -165,6 +165,8 @@ def __unicode__(self):
     if PY3:
         __str__ = __unicode__
 
+class BreakLoopException(Exception):
+        pass
 
 class ErrorTree(object):
     """

jsonschema/tests/test_benchmarks.py

@@ -43,8 +43,13 @@ def test_V3_meta_schema(self):
 
         master-19-Aug (9f18270): Time @ Xeon 3.2GHz::
 
-            278 runs in 2.00 sec
-                ms/run: mean(7.17), std(0.56), MIN(6.50), MAX(10.51)
+            286 runs in 2.00 sec
+                ms/run: mean(6.98), std(0.35), MIN(6.50), MAX(9.50)
+
+        break_looop: Time @ Xeon 3.2GHz::
+
+            283 runs in 2.00 sec
+                ms/run: mean(7.05), std(0.28), MIN(6.50), MAX(9.50)
         """
 
         stats = []
@@ -63,8 +68,13 @@ def test_V4_meta_schema(self):
 
         master-19-Aug (9f18270): Time @ Xeon 3.2GHz::
 
-            164 runs in 2.00 sec
-                ms/run: mean(12.15), std(1.36), MIN(11.01), MAX(21.02)
+            174 runs in 2.01 sec
+                ms/run: mean(11.47), std(0.36), MIN(11.00), MAX(13.00)
+
+        break_looop: Time @ Xeon 3.2GHz::
+
+            173 runs in 2.01 sec
+                ms/run: mean(11.53), std(0.28), MIN(11.00), MAX(13.00)
         """
 
         stats = []
@@ -83,8 +93,13 @@ def test_both_meta_schemas(self):
 
         master-19-Aug (9f18270): Time @ Xeon 3.2GHz::
 
-            104 runs in 2.01 sec
-                ms/run: mean(19.13), std(1.12), MIN(18.01), MAX(23.02)
+            108 runs in 2.00 sec
+                ms/run: mean(18.38), std(0.35), MIN(18.00), MAX(19.50)
+
+        break_looop: Time @ Xeon 3.2GHz::
+
+            107 runs in 2.01 sec
+                ms/run: mean(18.62), std(0.38), MIN(18.00), MAX(20.00)
         """
 
         v_classes = [Draft3Validator, Draft4Validator]
@@ -105,8 +120,13 @@ def test_ref_model(self):
 
         master-19-Aug (9f18270): Time @ Xeon 3.2GHz::
 
-            16 runs in 2.00 sec
-                ms/run: mean(117.80), std(4.32), MIN(113.09), MAX(127.60)
+            18 runs in 2.07 sec
+                ms/run: mean(109.21), std(1.33), MIN(107.52), MAX(112.52)
+
+        break_looop: Time @ Xeon 3.2GHz::
+
+            18 runs in 2.09 sec
+                ms/run: mean(109.97), std(0.80), MIN(109.02), MAX(112.02)
         """
 
         stats = []

jsonschema/validators.py

@@ -15,7 +15,7 @@
     str_types, int_types, iteritems,
 )
 from jsonschema.exceptions import ErrorTree  # Backwards compatibility  # noqa
-from jsonschema.exceptions import RefResolutionError, SchemaError, UnknownType
+from jsonschema.exceptions import RefResolutionError, SchemaError, UnknownType, BreakLoopException
 
 
 _unset = _utils.Unset()
@@ -80,29 +80,26 @@ def iter_errors(self, instance, _schema=None):
                 _schema = self.schema
 
             with self.resolver.in_scope(_schema.get(u"id", u"")):
-                ref = _schema.get(u"$ref")
-                if ref is not None:
-                    validators = [(u"$ref", ref)]
-                else:
-                    validators = iteritems(_schema)
-
-                for k, v in validators:
+                for k, v in iteritems(_schema):
                     validator = self.VALIDATORS.get(k)
                     if validator is None:
                         continue
 
-                    errors = validator(self, v, instance, _schema) or ()
-                    for error in errors:
-                        # set details if not already set by the called fn
-                        error._set(
-                            validator=k,
-                            validator_value=v,
-                            instance=instance,
-                            schema=_schema,
-                        )
-                        if k != u"$ref":
-                            error.schema_path.appendleft(k)
-                        yield error
+                    try:
+                        errors = validator(self, v, instance, _schema) or ()
+                        for error in errors:
+                            # set details if not already set by the called fn
+                            error._set(
+                                validator=k,
+                                validator_value=v,
+                                instance=instance,
+                                schema=_schema,
+                            )
+                            if k != u"$ref":
+                                error.schema_path.appendleft(k)
+                            yield error
+                    except BreakLoopException:
+                        break
 
         def descend(self, instance, schema, path=None, schema_path=None):
             for error in self.iter_errors(instance, schema):