#782: Adapt validator test for draft2020-12, fixes code styles

Author: nezhar

jsonschema/_format.py

@@ -168,14 +168,16 @@ def wrap(func):
         if draft7:
             func = _draft_checkers["draft7"].checks(draft7, raises)(func)
         if draft202012:
-            func = _draft_checkers["draft202012"].checks(draft202012, raises)(func)
+            func = _draft_checkers["draft202012"].checks(
+                draft202012, raises
+            )(func)
 
         # Oy. This is bad global state, but relied upon for now, until
         # deprecation. See https://github.com/Julian/jsonschema/issues/519
         # and test_format_checkers_come_with_defaults
-        FormatChecker.cls_checks(draft202012 or draft7 or draft6 or draft4 or draft3, raises)(
-            func,
-        )
+        FormatChecker.cls_checks(
+            draft202012 or draft7 or draft6 or draft4 or draft3, raises
+        )(func)
         return func
     return wrap
 

jsonschema/_legacy_validators.py

@@ -27,12 +27,17 @@ def dependencies_draft3(validator, dependencies, instance, schema):
                     yield ValidationError(message % (each, property))
 
 
-def dependencies_draft4_draft6_draft7(validator, dependencies, instance, schema):
+def dependencies_draft4_draft6_draft7(
+        validator,
+        dependencies,
+        instance,
+        schema,
+):
     """
     Support for the ``dependencies`` validator from pre-draft 2019-09.
 
-    In later drafts, the validator was split into separate ``dependentRequired``
-    and ``dependentSchemas`` validators.
+    In later drafts, the validator was split into separate
+    ``dependentRequired`` and ``dependentSchemas`` validators.
     """
     if not validator.is_type(instance, "object"):
         return

jsonschema/_utils.py

@@ -256,12 +256,12 @@ def find_evaluated_item_indexes_by_schema(validator, instance, schema):
     """
     Get all indexes of items that get evaluated under the current schema
 
-    Covers all keywords related to unevaluatedItems: items, prefixItems, if, then, else, 'contains', 'unevaluatedItems',
-    'allOf', 'oneOf', 'anyOf'
+    Covers all keywords related to unevaluatedItems: items, prefixItems, if,
+    then, else, 'contains', 'unevaluatedItems', 'allOf', 'oneOf', 'anyOf'
     """
     if not validator.is_type(schema, "object"):
         return []
-    evaluated_item_indexes = []
+    evaluated_indexes = []
 
     if 'items' in schema:
         return list(range(0, len(instance)))
@@ -273,49 +273,61 @@ def find_evaluated_item_indexes_by_schema(validator, instance, schema):
             validator.resolver.push_scope(scope)
 
             try:
-                evaluated_item_indexes += find_evaluated_item_indexes_by_schema(validator, instance, resolved)
+                evaluated_indexes += find_evaluated_item_indexes_by_schema(
+                    validator, instance, resolved)
             finally:
                 validator.resolver.pop_scope()
 
     if 'prefixItems' in schema:
-        if validator.is_valid(instance, {'prefixItems': schema['prefixItems']}):
-            evaluated_item_indexes += list(range(0, len(schema['prefixItems'])))
+        if validator.is_valid(
+                instance, {'prefixItems': schema['prefixItems']}
+        ):
+            evaluated_indexes += list(range(0, len(schema['prefixItems'])))
 
     if 'if' in schema:
         if validator.is_valid(instance, schema['if']):
-            evaluated_item_indexes += find_evaluated_item_indexes_by_schema(validator, instance, schema['if'])
+            evaluated_indexes += find_evaluated_item_indexes_by_schema(
+                validator, instance, schema['if']
+            )
             if 'then' in schema:
-                evaluated_item_indexes += find_evaluated_item_indexes_by_schema(validator, instance, schema['then'])
+                evaluated_indexes += find_evaluated_item_indexes_by_schema(
+                    validator, instance, schema['then']
+                )
         else:
             if 'else' in schema:
-                evaluated_item_indexes += find_evaluated_item_indexes_by_schema(validator, instance, schema['else'])
+                evaluated_indexes += find_evaluated_item_indexes_by_schema(
+                    validator, instance, schema['else']
+                )
 
     for keyword in ['contains', 'unevaluatedItems']:
         if keyword in schema:
             for k, v in enumerate(instance):
                 if validator.is_valid(v, schema[keyword]):
-                    evaluated_item_indexes.append(k)
+                    evaluated_indexes.append(k)
 
     for keyword in ['allOf', 'oneOf', 'anyOf']:
         if keyword in schema:
             for subschema in schema[keyword]:
                 errs = list(validator.descend(instance, subschema))
                 if not errs:
-                    evaluated_item_indexes += find_evaluated_item_indexes_by_schema(validator, instance, subschema)
+                    evaluated_indexes += find_evaluated_item_indexes_by_schema(
+                        validator, instance, subschema
+                    )
 
-    return evaluated_item_indexes
+    return evaluated_indexes
 
 
 def find_evaluated_property_keys_by_schema(validator, instance, schema):
     """
     Get all keys of items that get evaluated under the current schema
 
-    Covers all keywords related to unevaluatedProperties: properties, 'additionalProperties', 'unevaluatedProperties',
-    patternProperties, dependentSchemas, 'allOf', 'oneOf', 'anyOf', if, then, else
+    Covers all keywords related to unevaluatedProperties: properties,
+    'additionalProperties', 'unevaluatedProperties', patternProperties,
+    dependentSchemas, 'allOf', 'oneOf', 'anyOf', if, then, else
     """
     if not validator.is_type(schema, "object"):
         return []
-    evaluated_property_keys = []
+    evaluated_keys = []
 
     if '$ref' in schema:
         resolve = getattr(validator.resolver, "resolve", None)
@@ -324,28 +336,36 @@ def find_evaluated_property_keys_by_schema(validator, instance, schema):
             validator.resolver.push_scope(scope)
 
             try:
-                evaluated_property_keys += find_evaluated_property_keys_by_schema(validator, instance, resolved)
+                evaluated_keys += find_evaluated_property_keys_by_schema(
+                    validator, instance, resolved
+                )
             finally:
                 validator.resolver.pop_scope()
 
-    for keyword in ['properties', 'additionalProperties', 'unevaluatedProperties']:
+    for keyword in [
+        'properties', 'additionalProperties', 'unevaluatedProperties'
+    ]:
         if keyword in schema:
             if validator.is_type(schema[keyword], "boolean"):
                 for property, value in instance.items():
                     if validator.is_valid({property: value}, schema[keyword]):
-                        evaluated_property_keys.append(property)
+                        evaluated_keys.append(property)
 
             if validator.is_type(schema[keyword], "object"):
                 for property, subschema in schema[keyword].items():
-                    if property in instance and validator.is_valid(instance[property], subschema):
-                        evaluated_property_keys.append(property)
+                    if property in instance and validator.is_valid(
+                            instance[property], subschema
+                    ):
+                        evaluated_keys.append(property)
 
     if 'patternProperties' in schema:
         for property, value in instance.items():
             for pattern, subschema in schema['patternProperties'].items():
                 if re.search(pattern, property):
-                    if validator.is_valid({property: value}, schema['patternProperties']):
-                        evaluated_property_keys.append(property)
+                    if validator.is_valid(
+                            {property: value}, schema['patternProperties']
+                    ):
+                        evaluated_keys.append(property)
 
     if 'dependentSchemas' in schema:
         for property, subschema in schema['dependentSchemas'].items():
@@ -354,22 +374,32 @@ def find_evaluated_property_keys_by_schema(validator, instance, schema):
 
             errs = list(validator.descend(instance, subschema))
             if not errs:
-                evaluated_property_keys += find_evaluated_property_keys_by_schema(validator, instance, subschema)
+                evaluated_keys += find_evaluated_property_keys_by_schema(
+                    validator, instance, subschema
+                )
 
     for keyword in ['allOf', 'oneOf', 'anyOf']:
         if keyword in schema:
             for subschema in schema[keyword]:
                 errs = list(validator.descend(instance, subschema))
                 if not errs:
-                    evaluated_property_keys += find_evaluated_property_keys_by_schema(validator, instance, subschema)
+                    evaluated_keys += find_evaluated_property_keys_by_schema(
+                        validator, instance, subschema
+                    )
 
     if 'if' in schema:
         if validator.is_valid(instance, schema['if']):
-            evaluated_property_keys += find_evaluated_property_keys_by_schema(validator, instance, schema['if'])
+            evaluated_keys += find_evaluated_property_keys_by_schema(
+                validator, instance, schema['if']
+            )
             if 'then' in schema:
-                evaluated_property_keys += find_evaluated_property_keys_by_schema(validator, instance, schema['then'])
+                evaluated_keys += find_evaluated_property_keys_by_schema(
+                    validator, instance, schema['then']
+                )
         else:
             if 'else' in schema:
-                evaluated_property_keys += find_evaluated_property_keys_by_schema(validator, instance, schema['else'])
+                evaluated_keys += find_evaluated_property_keys_by_schema(
+                    validator, instance, schema['else']
+                )
 
-    return evaluated_property_keys
+    return evaluated_keys

jsonschema/_validators.py

@@ -76,7 +76,9 @@ def items(validator, items, instance, schema):
     if validator.is_type(items, "boolean") and 'prefixItems' in schema:
         if not items:
             if len(instance) > len(schema['prefixItems']):
-                yield ValidationError("%r has more items than defined in prefixItems" % instance)
+                yield ValidationError(
+                    "%r has more items than defined in prefixItems" % instance
+                )
             else:
                 for error in validator.descend(
                         instance,
@@ -86,7 +88,11 @@ def items(validator, items, instance, schema):
                     yield error
     else:
         if 'prefixItems' in schema:
-            for error in validator.descend(instance, {'prefixItems': schema['prefixItems']}, path='items__prefixItems'):
+            for error in validator.descend(
+                    instance,
+                    {'prefixItems': schema['prefixItems']},
+                    path='items__prefixItems',
+            ):
                 yield error
 
             # Remove evaluated prefixItems indexes
@@ -132,23 +138,30 @@ def contains(validator, contains, instance, schema):
         min_contains = schema['minContains']
         if not validator.is_type(min_contains, "integer"):
             yield ValidationError(
-                "minContains of %r in not valid under the given schema" % (min_contains,)
+                "minContains of %r in not valid under the given schema" % (
+                    min_contains,
+                )
             )
             return
 
     if 'maxContains' in schema:
         max_contains = schema['maxContains']
         if not validator.is_type(max_contains, "integer"):
             yield ValidationError(
-                "maxContains of %r is not valid under the given schema" % (instance,)
+                "maxContains of %r is not valid under the given schema" % (
+                    instance,
+                )
             )
             return
 
     # minContains set to 0 will ignore contains
     if min_contains == 0:
         return
 
-    matches = len(list(filter(lambda x: x, [validator.is_valid(element, contains) for element in instance])))
+    matches = len(list(
+        filter(lambda x: x, [validator.is_valid(element, contains) for
+                             element in instance]))
+    )
 
     # default contains behavior
     if not matches:
@@ -160,7 +173,8 @@ def contains(validator, contains, instance, schema):
     if min_contains and max_contains is None:
         if matches < min_contains:
             yield ValidationError(
-                "Invalid number or matches of %r under the given schema, expected min %d, got %d" % (
+                "Invalid number or matches of %r under the given schema, "
+                "expected min %d, got %d" % (
                     instance, min_contains, matches
                 )
             )
@@ -169,7 +183,8 @@ def contains(validator, contains, instance, schema):
     if min_contains is None and max_contains:
         if matches > max_contains:
             yield ValidationError(
-                "Invalid number or matches of %r under the given schema, expected max %d, got %d" % (
+                "Invalid number or matches of %r under the given schema, "
+                "expected max %d, got %d" % (
                     instance, max_contains, matches
                 )
             )
@@ -178,7 +193,8 @@ def contains(validator, contains, instance, schema):
     if min_contains and max_contains:
         if matches < min_contains or matches > max_contains:
             yield ValidationError(
-                "Invalid number or matches of %r under the given schema, expected min %d and max %d, got %d" % (
+                "Invalid number or matches of %r under the given schema, "
+                "expected min %d and max %d, got %d" % (
                     instance, min_contains, max_contains, matches
                 )
             )
@@ -366,8 +382,10 @@ def dynamicRef(validator, dynamicRef, instance, schema):
     scope_stack = validator.resolver.scopes_stack_copy
 
     for url in scope_stack:
-        with validator.resolver.resolving(urljoin(url, dynamicRef)) as lookup_schema:
-            if "$dynamicAnchor" in lookup_schema and fragment == lookup_schema["$dynamicAnchor"]:
+        lookup_url = urljoin(url, dynamicRef)
+        with validator.resolver.resolving(lookup_url) as lookup_schema:
+            if "$dynamicAnchor" in lookup_schema \
+                    and fragment == lookup_schema["$dynamicAnchor"]:
                 subschema = lookup_schema
                 for error in validator.descend(instance, subschema):
                     yield error
@@ -505,18 +523,24 @@ def unevaluatedItems(validator, unevaluatedItems, instance, schema):
     if not validator.is_type(instance, "array"):
         return
 
-    evaluated_item_indexes = find_evaluated_item_indexes_by_schema(validator, instance, schema)
+    evaluated_item_indexes = find_evaluated_item_indexes_by_schema(
+        validator, instance, schema
+    )
     for k, v in enumerate(instance):
         if k not in evaluated_item_indexes:
-            for error in validator.descend(v, unevaluatedItems, schema_path="unevaluatedItems"):
+            for error in validator.descend(
+                    v, unevaluatedItems, schema_path="unevaluatedItems"
+            ):
                 yield error
 
 
 def unevaluatedProperties(validator, unevaluatedProperties, instance, schema):
     if not validator.is_type(instance, "object"):
         return
 
-    evaluated_property_keys = find_evaluated_property_keys_by_schema(validator, instance, schema)
+    evaluated_property_keys = find_evaluated_property_keys_by_schema(
+        validator, instance, schema
+    )
     for property, subschema in instance.items():
         if property not in evaluated_property_keys:
             for error in validator.descend(
@@ -534,5 +558,7 @@ def prefixItems(validator, prefixItems, instance, schema):
 
     for k, v in enumerate(instance):
         if k < len(prefixItems):
-            for error in validator.descend(v, prefixItems[k], schema_path="prefixItems"):
+            for error in validator.descend(
+                    v, prefixItems[k], schema_path="prefixItems"
+            ):
                 yield error