fix: reject NaN in numeric comparison keywords (minimum, maximum, exclusiveMinimum, exclusiveMaximum)

jsonschema/_keywords.py

@@ -21,7 +21,10 @@ def patternProperties(validator, patternProperties, instance, schema):
         for k, v in instance.items():
             if re.search(pattern, k):
                 yield from validator.descend(
-                    v, subschema, path=k, schema_path=pattern,
+                    v,
+                    subschema,
+                    path=k,
+                    schema_path=pattern,
                 )
 
 
@@ -128,7 +131,7 @@ def exclusiveMinimum(validator, minimum, instance, schema):
     if not validator.is_type(instance, "number"):
         return
 
-    if instance <= minimum:
+    if not (instance > minimum):
         yield ValidationError(
             f"{instance!r} is less than or equal to "
             f"the minimum of {minimum!r}",
@@ -139,7 +142,7 @@ def exclusiveMaximum(validator, maximum, instance, schema):
     if not validator.is_type(instance, "number"):
         return
 
-    if instance >= maximum:
+    if not (instance < maximum):
         yield ValidationError(
             f"{instance!r} is greater than or equal "
             f"to the maximum of {maximum!r}",
@@ -150,7 +153,7 @@ def minimum(validator, minimum, instance, schema):
     if not validator.is_type(instance, "number"):
         return
 
-    if instance < minimum:
+    if not (instance >= minimum):
         message = f"{instance!r} is less than the minimum of {minimum!r}"
         yield ValidationError(message)
 
@@ -159,7 +162,7 @@ def maximum(validator, maximum, instance, schema):
     if not validator.is_type(instance, "number"):
         return
 
-    if instance > maximum:
+    if not (instance <= maximum):
         message = f"{instance!r} is greater than the maximum of {maximum!r}"
         yield ValidationError(message)
 
@@ -204,18 +207,13 @@ def maxItems(validator, mI, instance, schema):
 
 
 def uniqueItems(validator, uI, instance, schema):
-    if (
-        uI
-        and validator.is_type(instance, "array")
-        and not uniq(instance)
-    ):
+    if uI and validator.is_type(instance, "array") and not uniq(instance):
         yield ValidationError(f"{instance!r} has non-unique elements")
 
 
 def pattern(validator, patrn, instance, schema):
-    if (
-        validator.is_type(instance, "string")
-        and not re.search(patrn, instance)
+    if validator.is_type(instance, "string") and not re.search(
+        patrn, instance,
     ):
         yield ValidationError(f"{instance!r} does not match {patrn!r}")
 
@@ -262,7 +260,9 @@ def dependentSchemas(validator, dependentSchemas, instance, schema):
         if property not in instance:
             continue
         yield from validator.descend(
-            instance, dependency, schema_path=property,
+            instance,
+            dependency,
+            schema_path=property,
         )
 
 
@@ -312,7 +312,8 @@ def required(validator, required, instance, schema):
 def minProperties(validator, mP, instance, schema):
     if validator.is_type(instance, "object") and len(instance) < mP:
         message = (
-            "should be non-empty" if mP == 1
+            "should be non-empty"
+            if mP == 1
             else "does not have enough properties"
         )
         yield ValidationError(f"{instance!r} {message}")
@@ -323,8 +324,7 @@ def maxProperties(validator, mP, instance, schema):
         return
     if validator.is_type(instance, "object") and len(instance) > mP:
         message = (
-            "is expected to be empty" if mP == 0
-            else "has too many properties"
+            "is expected to be empty" if mP == 0 else "has too many properties"
         )
         yield ValidationError(f"{instance!r} {message}")
 
@@ -364,7 +364,8 @@ def oneOf(validator, oneOf, instance, schema):
         )
 
     more_valid = [
-        each for _, each in subschemas
+        each
+        for _, each in subschemas
         if validator.evolve(schema=each).is_valid(instance)
     ]
     if more_valid:
@@ -393,10 +394,13 @@ 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,
+        validator,
+        instance,
+        schema,
     )
     unevaluated_items = [
-        item for index, item in enumerate(instance)
+        item
+        for index, item in enumerate(instance)
         if index not in evaluated_item_indexes
     ]
     if unevaluated_items:
@@ -408,7 +412,9 @@ def unevaluatedProperties(validator, unevaluatedProperties, instance, schema):
     if not validator.is_type(instance, "object"):
         return
     evaluated_keys = find_evaluated_property_keys_by_schema(
-        validator, instance, schema,
+        validator,
+        instance,
+        schema,
     )
     unevaluated_keys = []
     for property in instance:

jsonschema/_legacy_keywords.py

@@ -31,7 +31,9 @@ def dependencies_draft3(validator, dependencies, instance, schema):
 
         if validator.is_type(dependency, "object"):
             yield from validator.descend(
-                instance, dependency, schema_path=property,
+                instance,
+                dependency,
+                schema_path=property,
             )
         elif validator.is_type(dependency, "string"):
             if dependency not in instance:
@@ -70,7 +72,9 @@ def dependencies_draft4_draft6_draft7(
                     yield ValidationError(message)
         else:
             yield from validator.descend(
-                instance, dependency, schema_path=property,
+                instance,
+                dependency,
+                schema_path=property,
             )
 
 
@@ -99,14 +103,16 @@ def items_draft3_draft4(validator, items, instance, schema):
     else:
         for (index, item), subschema in zip(enumerate(instance), items):
             yield from validator.descend(
-                item, subschema, path=index, schema_path=index,
+                item,
+                subschema,
+                path=index,
+                schema_path=index,
             )
 
 
 def additionalItems(validator, aI, instance, schema):
-    if (
-        not validator.is_type(instance, "array")
-        or validator.is_type(schema.get("items", {}), "object")
+    if not validator.is_type(instance, "array") or validator.is_type(
+        schema.get("items", {}), "object",
     ):
         return
 
@@ -117,7 +123,8 @@ def additionalItems(validator, aI, instance, schema):
     elif not aI and len(instance) > len(schema.get("items", [])):
         error = "Additional items are not allowed (%s %s unexpected)"
         yield ValidationError(
-            error % _utils.extras_msg(instance[len(schema.get("items", [])):]),
+            error
+            % _utils.extras_msg(instance[len(schema.get("items", [])) :]),
         )
 
 
@@ -128,7 +135,10 @@ def items_draft6_draft7_draft201909(validator, items, instance, schema):
     if validator.is_type(items, "array"):
         for (index, item), subschema in zip(enumerate(instance), items):
             yield from validator.descend(
-                item, subschema, path=index, schema_path=index,
+                item,
+                subschema,
+                path=index,
+                schema_path=index,
             )
     else:
         for index, item in enumerate(instance):
@@ -140,10 +150,10 @@ def minimum_draft3_draft4(validator, minimum, instance, schema):
         return
 
     if schema.get("exclusiveMinimum", False):
-        failed = instance <= minimum
+        failed = not (instance > minimum)
         cmp = "less than or equal to"
     else:
-        failed = instance < minimum
+        failed = not (instance >= minimum)
         cmp = "less than"
 
     if failed:
@@ -156,10 +166,10 @@ def maximum_draft3_draft4(validator, maximum, instance, schema):
         return
 
     if schema.get("exclusiveMaximum", False):
-        failed = instance >= maximum
+        failed = not (instance < maximum)
         cmp = "greater than or equal to"
     else:
-        failed = instance > maximum
+        failed = not (instance <= maximum)
         cmp = "greater than"
 
     if failed:
@@ -203,7 +213,7 @@ def type_draft3(validator, types, instance, schema):
                 return
             all_errors.extend(errors)
         elif validator.is_type(instance, type):
-                return
+            return
 
     reprs = []
     for type in types:
@@ -288,15 +298,21 @@ def find_evaluated_item_indexes_by_schema(validator, instance, schema):
     if "if" in schema:
         if validator.evolve(schema=schema["if"]).is_valid(instance):
             evaluated_indexes += find_evaluated_item_indexes_by_schema(
-                validator, instance, schema["if"],
+                validator,
+                instance,
+                schema["if"],
             )
             if "then" in schema:
                 evaluated_indexes += find_evaluated_item_indexes_by_schema(
-                    validator, instance, schema["then"],
+                    validator,
+                    instance,
+                    schema["then"],
                 )
         elif "else" in schema:
             evaluated_indexes += find_evaluated_item_indexes_by_schema(
-                validator, instance, schema["else"],
+                validator,
+                instance,
+                schema["else"],
             )
 
     for keyword in ["contains", "unevaluatedItems"]:
@@ -311,7 +327,9 @@ def find_evaluated_item_indexes_by_schema(validator, instance, schema):
                 errs = next(validator.descend(instance, subschema), None)
                 if errs is None:
                     evaluated_indexes += find_evaluated_item_indexes_by_schema(
-                        validator, instance, subschema,
+                        validator,
+                        instance,
+                        subschema,
                     )
 
     return evaluated_indexes
@@ -321,10 +339,13 @@ def unevaluatedItems_draft2019(validator, unevaluatedItems, instance, schema):
     if not validator.is_type(instance, "array"):
         return
     evaluated_item_indexes = find_evaluated_item_indexes_by_schema(
-        validator, instance, schema,
+        validator,
+        instance,
+        schema,
     )
     unevaluated_items = [
-        item for index, item in enumerate(instance)
+        item
+        for index, item in enumerate(instance)
         if index not in evaluated_item_indexes
     ]
     if unevaluated_items:
@@ -388,7 +409,9 @@ def find_evaluated_property_keys_by_schema(validator, instance, schema):
             if property not in instance:
                 continue
             evaluated_keys += find_evaluated_property_keys_by_schema(
-                validator, instance, subschema,
+                validator,
+                instance,
+                subschema,
             )
 
     for keyword in ["allOf", "oneOf", "anyOf"]:
@@ -397,21 +420,29 @@ def find_evaluated_property_keys_by_schema(validator, instance, schema):
                 errs = next(validator.descend(instance, subschema), None)
                 if errs is None:
                     evaluated_keys += find_evaluated_property_keys_by_schema(
-                        validator, instance, subschema,
+                        validator,
+                        instance,
+                        subschema,
                     )
 
     if "if" in schema:
         if validator.evolve(schema=schema["if"]).is_valid(instance):
             evaluated_keys += find_evaluated_property_keys_by_schema(
-                validator, instance, schema["if"],
+                validator,
+                instance,
+                schema["if"],
             )
             if "then" in schema:
                 evaluated_keys += find_evaluated_property_keys_by_schema(
-                    validator, instance, schema["then"],
+                    validator,
+                    instance,
+                    schema["then"],
                 )
         elif "else" in schema:
             evaluated_keys += find_evaluated_property_keys_by_schema(
-                validator, instance, schema["else"],
+                validator,
+                instance,
+                schema["else"],
             )
 
     return evaluated_keys
@@ -421,7 +452,9 @@ def unevaluatedProperties_draft2019(validator, uP, instance, schema):
     if not validator.is_type(instance, "object"):
         return
     evaluated_keys = find_evaluated_property_keys_by_schema(
-        validator, instance, schema,
+        validator,
+        instance,
+        schema,
     )
     unevaluated_keys = []
     for property in instance: