Minor style change on imports.

Author: Julian

jsonschema/tests/test_validators.py

@@ -14,18 +14,17 @@
 
 from jsonschema import (
     FormatChecker,
-    SchemaError,
-    ValidationError,
     TypeChecker,
     _types,
+    exceptions,
     validators,
 )
 from jsonschema.compat import PY3, pathname2url
 
 
 def startswith(validator, startswith, instance, schema):
     if not instance.startswith(startswith):
-        yield ValidationError(u"Whoops!")
+        yield exceptions.ValidationError(u"Whoops!")
 
 
 class TestCreateAndExtend(SynchronousTestCase):
@@ -75,7 +74,7 @@ def test_iter_errors(self):
         errors = list(iter_errors(u"hello"))
         self.assertEqual(errors, [])
 
-        expected_error = ValidationError(
+        expected_error = exceptions.ValidationError(
             u"Whoops!",
             instance=u"goodbye",
             schema=schema,
@@ -339,7 +338,7 @@ def test_iter_errors_multiple_failures_one_validator(self):
 class TestValidationErrorMessages(TestCase):
     def message_for(self, instance, schema, *args, **kwargs):
         kwargs.setdefault("cls", validators.Draft3Validator)
-        with self.assertRaises(ValidationError) as e:
+        with self.assertRaises(exceptions.ValidationError) as e:
             validators.validate(instance, schema, *args, **kwargs)
         return e.exception.message
 
@@ -887,11 +886,11 @@ def test_additionalItems_with_items(self):
 class MetaSchemaTestsMixin(object):
     # TODO: These all belong upstream
     def test_invalid_properties(self):
-        with self.assertRaises(SchemaError):
+        with self.assertRaises(exceptions.SchemaError):
             self.Validator.check_schema({"properties": {"test": object()}})
 
     def test_minItems_invalid_string(self):
-        with self.assertRaises(SchemaError):
+        with self.assertRaises(exceptions.SchemaError):
             # needs to be an integer
             self.Validator.check_schema({"minItems": "1"})
 
@@ -919,7 +918,7 @@ def test_it_delegates_to_a_ref_resolver(self):
         resolver = validators.RefResolver("", {}, store={ref: schema})
         validator = self.Validator({"$ref": ref}, resolver=resolver)
 
-        with self.assertRaises(ValidationError):
+        with self.assertRaises(exceptions.ValidationError):
             validator.validate(None)
 
     def test_it_delegates_to_a_legacy_ref_resolver(self):
@@ -938,7 +937,7 @@ def resolving(this, ref):
         resolver = LegacyRefResolver()
         schema = {"$ref": "the ref"}
 
-        with self.assertRaises(ValidationError):
+        with self.assertRaises(exceptions.ValidationError):
             self.Validator(schema, resolver=resolver).validate(None)
 
     def test_is_type_is_true_for_valid_type(self):
@@ -1004,7 +1003,7 @@ def check(value):
         )
 
         validator.validate("good")
-        with self.assertRaises(ValidationError) as cm:
+        with self.assertRaises(exceptions.ValidationError) as cm:
             validator.validate("bad")
 
         # Make sure original cause is attached
@@ -1035,7 +1034,7 @@ def test_it_properly_formats_tuples_in_errors(self):
                 lambda checker, thing: isinstance(thing, tuple),
             )
         )
-        with self.assertRaises(ValidationError) as e:
+        with self.assertRaises(exceptions.ValidationError) as e:
             TupleValidator({"uniqueItems": True}).validate((1, 1))
         self.assertIn("(1, 1) has non-unique elements", str(e.exception))
 
@@ -1046,12 +1045,12 @@ class AntiDraft6LeakMixin(object):
     """
 
     def test_True_is_not_a_schema(self):
-        with self.assertRaises(SchemaError) as e:
+        with self.assertRaises(exceptions.SchemaError) as e:
             self.Validator.check_schema(True)
         self.assertIn("True is not of type", str(e.exception))
 
     def test_False_is_not_a_schema(self):
-        with self.assertRaises(SchemaError) as e:
+        with self.assertRaises(exceptions.SchemaError) as e:
             self.Validator.check_schema(False)
         self.assertIn("False is not of type", str(e.exception))
 
@@ -1089,7 +1088,7 @@ def test_any_type_is_redefinable(self):
         )
         validator = Crazy({"type": "any"})
         validator.validate(12)
-        with self.assertRaises(ValidationError):
+        with self.assertRaises(exceptions.ValidationError):
             validator.validate("foo")
 
     def test_is_type_is_true_for_any_type(self):
@@ -1310,15 +1309,15 @@ def test_draft7_validator_is_the_default(self):
         self.assertUses(schema={}, Validator=validators.Draft7Validator)
 
     def test_validation_error_message(self):
-        with self.assertRaises(ValidationError) as e:
+        with self.assertRaises(exceptions.ValidationError) as e:
             validators.validate(12, {"type": "string"})
         self.assertRegexpMatches(
             str(e.exception),
             "(?s)Failed validating u?'.*' in schema.*On instance",
         )
 
     def test_schema_error_message(self):
-        with self.assertRaises(SchemaError) as e:
+        with self.assertRaises(exceptions.SchemaError) as e:
             validators.validate(12, {"type": 12})
         self.assertRegexpMatches(
             str(e.exception),
@@ -1499,15 +1498,15 @@ def handler(url):
 
         ref = "foo://bar"
         resolver = validators.RefResolver("", {}, handlers={"foo": handler})
-        with self.assertRaises(validators.RefResolutionError) as err:
+        with self.assertRaises(exceptions.RefResolutionError) as err:
             with resolver.resolving(ref):
                 self.fail("Shouldn't get this far!")  # pragma: no cover
-        self.assertEqual(err.exception, validators.RefResolutionError(error))
+        self.assertEqual(err.exception, exceptions.RefResolutionError(error))
 
     def test_helpful_error_message_on_failed_pop_scope(self):
         resolver = validators.RefResolver("", {})
         resolver.pop_scope()
-        with self.assertRaises(validators.RefResolutionError) as exc:
+        with self.assertRaises(exceptions.RefResolutionError) as exc:
             resolver.pop_scope()
         self.assertIn("Failed to pop the scope", str(exc.exception))
 

jsonschema/validators.py

@@ -7,7 +7,7 @@
 
 from six import add_metaclass
 
-from jsonschema import _utils, _validators, _types
+from jsonschema import _utils, _validators, _types, exceptions
 from jsonschema.compat import (
     Sequence,
     int_types,
@@ -20,13 +20,6 @@
     urlopen,
     urlsplit,
 )
-from jsonschema.exceptions import (
-    RefResolutionError,
-    SchemaError,
-    UnknownType,
-    UndefinedTypeCheck,
-    ValidationError,
-)
 
 # Sigh. https://gitlab.com/pycqa/flake8/issues/280
 #       https://github.com/pyga/ebb-lint/issues/7
@@ -259,7 +252,7 @@ def __init__(
         @classmethod
         def check_schema(cls, schema):
             for error in cls(cls.META_SCHEMA).iter_errors(schema):
-                raise SchemaError.create_from(error)
+                raise exceptions.SchemaError.create_from(error)
 
         def iter_errors(self, instance, _schema=None):
             if _schema is None:
@@ -268,7 +261,7 @@ def iter_errors(self, instance, _schema=None):
             if _schema is True:
                 return
             elif _schema is False:
-                yield ValidationError(
+                yield exceptions.ValidationError(
                     "False schema does not allow %r" % (instance,),
                 )
                 return
@@ -319,8 +312,8 @@ def validate(self, *args, **kwargs):
         def is_type(self, instance, type):
             try:
                 return self.TYPE_CHECKER.is_type(instance, type)
-            except UndefinedTypeCheck:
-                raise UnknownType(type, instance, self.schema)
+            except exceptions.UndefinedTypeCheck:
+                raise exceptions.UnknownType(type, instance, self.schema)
 
         def is_valid(self, instance, _schema=None):
             error = next(self.iter_errors(instance, _schema), None)
@@ -662,7 +655,7 @@ def pop_scope(self):
         try:
             self._scopes_stack.pop()
         except IndexError:
-            raise RefResolutionError(
+            raise exceptions.RefResolutionError(
                 "Failed to pop the scope from an empty stack. "
                 "`pop_scope()` should only be called once for every "
                 "`push_scope()`"
@@ -719,7 +712,7 @@ def resolve_from_url(self, url):
             try:
                 document = self.resolve_remote(url)
             except Exception as exc:
-                raise RefResolutionError(exc)
+                raise exceptions.RefResolutionError(exc)
 
         return self.resolve_fragment(document, fragment)
 
@@ -754,7 +747,7 @@ def resolve_fragment(self, document, fragment):
             try:
                 document = document[part]
             except (TypeError, LookupError):
-                raise RefResolutionError(
+                raise exceptions.RefResolutionError(
                     "Unresolvable JSON pointer: %r" % fragment
                 )