Whitespacin'.

Author: Julian

jsonschema/tests/test_exceptions.py

@@ -21,15 +21,15 @@ def best_match(self, errors):
     def test_shallower_errors_are_better_matches(self):
         validator = Draft4Validator(
             {
-                "properties" : {
-                    "foo" : {
-                        "minProperties" : 2,
-                        "properties" : {"bar" : {"type" : "object"}},
+                "properties": {
+                    "foo": {
+                        "minProperties": 2,
+                        "properties": {"bar": {"type": "object"}},
                     },
                 },
             },
         )
-        best = self.best_match(validator.iter_errors({"foo" : {"bar" : []}}))
+        best = self.best_match(validator.iter_errors({"foo": {"bar": []}}))
         self.assertEqual(best.validator, "minProperties")
 
     def test_oneOf_and_anyOf_are_weak_matches(self):
@@ -41,9 +41,9 @@ def test_oneOf_and_anyOf_are_weak_matches(self):
 
         validator = Draft4Validator(
             {
-                "minProperties" : 2,
-                "anyOf" : [{"type" : "string"}, {"type" : "number"}],
-                "oneOf" : [{"type" : "string"}, {"type" : "number"}],
+                "minProperties": 2,
+                "anyOf": [{"type": "string"}, {"type": "number"}],
+                "oneOf": [{"type": "string"}, {"type": "number"}],
             }
         )
         best = self.best_match(validator.iter_errors({}))
@@ -62,17 +62,17 @@ def test_if_the_most_relevant_error_is_anyOf_it_is_traversed(self):
 
         validator = Draft4Validator(
             {
-                "properties" : {
-                    "foo" : {
-                        "anyOf" : [
-                            {"type" : "string"},
-                            {"properties" : {"bar" : {"type" : "array"}}},
+                "properties": {
+                    "foo": {
+                        "anyOf": [
+                            {"type": "string"},
+                            {"properties": {"bar": {"type": "array"}}},
                         ],
                     },
                 },
             },
         )
-        best = self.best_match(validator.iter_errors({"foo" : {"bar" : 12}}))
+        best = self.best_match(validator.iter_errors({"foo": {"bar": 12}}))
         self.assertEqual(best.validator_value, "array")
 
     def test_if_the_most_relevant_error_is_oneOf_it_is_traversed(self):
@@ -88,17 +88,17 @@ def test_if_the_most_relevant_error_is_oneOf_it_is_traversed(self):
 
         validator = Draft4Validator(
             {
-                "properties" : {
-                    "foo" : {
-                        "oneOf" : [
-                            {"type" : "string"},
-                            {"properties" : {"bar" : {"type" : "array"}}},
+                "properties": {
+                    "foo": {
+                        "oneOf": [
+                            {"type": "string"},
+                            {"properties": {"bar": {"type": "array"}}},
                         ],
                     },
                 },
             },
         )
-        best = self.best_match(validator.iter_errors({"foo" : {"bar" : 12}}))
+        best = self.best_match(validator.iter_errors({"foo": {"bar": 12}}))
         self.assertEqual(best.validator_value, "array")
 
     def test_if_the_most_relevant_error_is_allOf_it_is_traversed(self):
@@ -110,32 +110,32 @@ def test_if_the_most_relevant_error_is_allOf_it_is_traversed(self):
 
         validator = Draft4Validator(
             {
-                "properties" : {
-                    "foo" : {
-                        "allOf" : [
-                            {"type" : "string"},
-                            {"properties" : {"bar" : {"type" : "array"}}},
+                "properties": {
+                    "foo": {
+                        "allOf": [
+                            {"type": "string"},
+                            {"properties": {"bar": {"type": "array"}}},
                         ],
                     },
                 },
             },
         )
-        best = self.best_match(validator.iter_errors({"foo" : {"bar" : 12}}))
+        best = self.best_match(validator.iter_errors({"foo": {"bar": 12}}))
         self.assertEqual(best.validator_value, "string")
 
     def test_nested_context_for_oneOf(self):
         validator = Draft4Validator(
             {
-                "properties" : {
-                    "foo" : {
-                        "oneOf" : [
-                            {"type" : "string"},
+                "properties": {
+                    "foo": {
+                        "oneOf": [
+                            {"type": "string"},
                             {
-                                "oneOf" : [
-                                    {"type" : "string"},
+                                "oneOf": [
+                                    {"type": "string"},
                                     {
-                                        "properties" : {
-                                            "bar" : {"type" : "array"},
+                                        "properties": {
+                                            "bar": {"type": "array"},
                                         },
                                     },
                                 ],
@@ -145,11 +145,11 @@ def test_nested_context_for_oneOf(self):
                 },
             },
         )
-        best = self.best_match(validator.iter_errors({"foo" : {"bar" : 12}}))
+        best = self.best_match(validator.iter_errors({"foo": {"bar": 12}}))
         self.assertEqual(best.validator_value, "array")
 
     def test_one_error(self):
-        validator = Draft4Validator({"minProperties" : 2})
+        validator = Draft4Validator({"minProperties": 2})
         error, = validator.iter_errors({})
         self.assertEqual(
             exceptions.best_match(validator.iter_errors({})).validator,
@@ -232,7 +232,7 @@ def test_it_does_not_contain_an_item_if_the_item_had_no_error(self):
     def test_validators_that_failed_appear_in_errors_dict(self):
         error = exceptions.ValidationError("a message", validator="foo")
         tree = exceptions.ErrorTree([error])
-        self.assertEqual(tree.errors, {"foo" : error})
+        self.assertEqual(tree.errors, {"foo": error})
 
     def test_it_creates_a_child_tree_for_each_nested_path(self):
         errors = [
@@ -249,7 +249,7 @@ def test_children_have_their_errors_dicts_built(self):
             exceptions.ValidationError("2", validator="quux", path=["bar", 0]),
         )
         tree = exceptions.ErrorTree([e1, e2])
-        self.assertEqual(tree["bar"][0].errors, {"foo" : e1, "quux" : e2})
+        self.assertEqual(tree["bar"][0].errors, {"foo": e1, "quux": e2})
 
     def test_regression_multiple_errors_with_instance(self):
         e1, e2 = (

jsonschema/tests/test_format.py

@@ -24,7 +24,7 @@ def test_it_raises_a_key_error_for_unknown_formats(self):
     def test_it_can_register_cls_checkers(self):
         with mock.patch.dict(FormatChecker.checkers, clear=True):
             FormatChecker.cls_checks("new")(self.fn)
-            self.assertEqual(FormatChecker.checkers, {"new" : (self.fn, ())})
+            self.assertEqual(FormatChecker.checkers, {"new": (self.fn, ())})
 
     def test_it_can_register_checkers(self):
         checker = FormatChecker()
@@ -55,7 +55,7 @@ def test_format_error_causes_become_validation_error_causes(self):
         checker = FormatChecker()
         checker.checks("foo", raises=ValueError)(self.fn)
         cause = self.fn.side_effect = ValueError()
-        validator = Draft4Validator({"format" : "foo"}, format_checker=checker)
+        validator = Draft4Validator({"format": "foo"}, format_checker=checker)
 
         with self.assertRaises(ValidationError) as cm:
             validator.validate("bar")

jsonschema/tests/test_jsonschema_test_suite.py

@@ -122,14 +122,14 @@ def add_test_methods(test_class):
 class TypesMixin(object):
     @unittest.skipIf(PY3, "In Python 3 json.load always produces unicode")
     def test_string_a_bytestring_is_a_string(self):
-        self.validator_class({"type" : "string"}).validate(b"foo")
+        self.validator_class({"type": "string"}).validate(b"foo")
 
 
 class DecimalMixin(object):
     def test_it_can_validate_with_decimals(self):
-        schema = {"type" : "number"}
+        schema = {"type": "number"}
         validator = self.validator_class(
-            schema, types={"number" : (int, float, Decimal)}
+            schema, types={"number": (int, float, Decimal)}
         )
 
         for valid in [1, 1.1, Decimal(1) / Decimal(8)]:
@@ -158,7 +158,7 @@ def missing_format(case, test):
 class FormatMixin(object):
     def test_it_returns_true_for_formats_it_does_not_know_about(self):
         validator = self.validator_class(
-            {"format" : "carrot"}, format_checker=FormatChecker(),
+            {"format": "carrot"}, format_checker=FormatChecker(),
         )
         validator.validate("bugs")
 
@@ -169,7 +169,7 @@ def test_it_does_not_validate_formats_by_default(self):
     def test_it_validates_formats_if_a_checker_is_provided(self):
         checker = mock.Mock(spec=FormatChecker)
         validator = self.validator_class(
-            {"format" : "foo"}, format_checker=checker,
+            {"format": "foo"}, format_checker=checker,
         )
 
         validator.validate("bar")
@@ -187,7 +187,7 @@ def test_it_validates_formats_if_a_checker_is_provided(self):
     def test_it_validates_formats_of_any_type(self):
         checker = mock.Mock(spec=FormatChecker)
         validator = self.validator_class(
-            {"format" : "foo"}, format_checker=checker,
+            {"format": "foo"}, format_checker=checker,
         )
 
         validator.validate([1, 2, 3])
@@ -224,10 +224,10 @@ def narrow_unicode_build(case, test):  # This isn't, skip nothing.
 @load_json_cases("draft3/optional/zeroTerminatedFloats.json")
 class TestDraft3(unittest.TestCase, TypesMixin, DecimalMixin, FormatMixin):
     validator_class = Draft3Validator
-    validator_kwargs = {"format_checker" : draft3_format_checker}
+    validator_kwargs = {"format_checker": draft3_format_checker}
 
     def test_any_type_is_valid_for_type_any(self):
-        validator = self.validator_class({"type" : "any"})
+        validator = self.validator_class({"type": "any"})
         validator.validate(mock.Mock())
 
     # TODO: we're in need of more meta schema tests
@@ -239,7 +239,7 @@ def test_invalid_properties(self):
     def test_minItems_invalid_string(self):
         with self.assertRaises(SchemaError):
             # needs to be an integer
-            validate([1], {"minItems" : "1"}, cls=self.validator_class)
+            validate([1], {"minItems": "1"}, cls=self.validator_class)
 
 
 @load_json_cases(
@@ -254,7 +254,7 @@ def test_minItems_invalid_string(self):
 @load_json_cases("draft4/optional/zeroTerminatedFloats.json")
 class TestDraft4(unittest.TestCase, TypesMixin, DecimalMixin, FormatMixin):
     validator_class = Draft4Validator
-    validator_kwargs = {"format_checker" : draft4_format_checker}
+    validator_kwargs = {"format_checker": draft4_format_checker}
 
     # TODO: we're in need of more meta schema tests
     def test_invalid_properties(self):
@@ -265,7 +265,7 @@ def test_invalid_properties(self):
     def test_minItems_invalid_string(self):
         with self.assertRaises(SchemaError):
             # needs to be an integer
-            validate([1], {"minItems" : "1"}, cls=self.validator_class)
+            validate([1], {"minItems": "1"}, cls=self.validator_class)
 
 
 class RemoteRefResolutionMixin(object):
@@ -277,7 +277,7 @@ def setUp(self):
 
     def resolve(self, reference):
         _, _, reference = reference.partition("http://localhost:1234/")
-        return mock.Mock(**{"json.return_value" : REMOTES.get(reference)})
+        return mock.Mock(**{"json.return_value": REMOTES.get(reference)})
 
 
 @load_json_cases("draft3/refRemote.json")