Improved multipleOf

Author: Zac-HD

CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+#### 0.20.1 - 2021-06-03
+- improved handling for fractional `multipleOf` values
+
 #### 0.20.0 - 2021-06-02
 - Allow `custom_formats` for known string formats (#83)
 

src/hypothesis_jsonschema/__init__.py

@@ -3,7 +3,7 @@
 The only public API is `from_schema`; check the docstring for details.
 """
 
-__version__ = "0.20.0"
+__version__ = "0.20.1"
 __all__ = ["from_schema"]
 
 from ._from_schema import from_schema

src/hypothesis_jsonschema/_canonicalise.py

@@ -16,6 +16,7 @@
 import json
 import math
 import re
+from fractions import Fraction
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 import jsonschema
@@ -263,6 +264,9 @@ def canonicalish(schema: JSONType) -> Dict[str, Any]:
                 k: v if isinstance(v, list) else canonicalish(v)
                 for k, v in schema[key].items()
             }
+    # multipleOf is semantically unaffected by the sign, so ensure it's positive
+    if "multipleOf" in schema:
+        schema["multipleOf"] = abs(schema["multipleOf"])
 
     type_ = get_type(schema)
     if "number" in type_:
@@ -289,6 +293,10 @@ def canonicalish(schema: JSONType) -> Dict[str, Any]:
     if "integer" in type_:
         lo, hi = get_integer_bounds(schema)
         mul = schema.get("multipleOf")
+        if mul is not None and "number" not in type_ and Fraction(mul).numerator == 1:
+            # Every integer is a multiple of 1/n for all natural numbers n.
+            schema.pop("multipleOf")
+            mul = None
         if lo is not None and isinstance(mul, int) and mul > 1 and (lo % mul):
             lo += mul - (lo % mul)
         if hi is not None and isinstance(mul, int) and mul > 1 and (hi % mul):
@@ -303,6 +311,8 @@ def canonicalish(schema: JSONType) -> Dict[str, Any]:
 
         if lo is not None and hi is not None and lo > hi:
             type_.remove("integer")
+        elif type_ == ["integer"] and lo == hi and make_validator(schema).is_valid(lo):
+            return {"const": lo}
 
     if "array" in type_ and "contains" in schema:
         if isinstance(schema.get("items"), dict):
@@ -542,11 +552,8 @@ def canonicalish(schema: JSONType) -> Dict[str, Any]:
             tmp = schema.copy()
             ao = tmp.pop("allOf")
             out = merged([tmp] + ao)
-            if isinstance(out, dict):  # pragma: no branch
+            if out is not None:
                 schema = out
-                # TODO: this assertion is soley because mypy 0.750 doesn't know
-                # that `schema` is a dict otherwise. Needs minimal report upstream.
-                assert isinstance(schema, dict)
     if "oneOf" in schema:
         one_of = schema.pop("oneOf")
         assert isinstance(one_of, list)
@@ -701,8 +708,8 @@ def merged(schemas: List[Any]) -> Optional[Schema]:
             if isinstance(x, int) and isinstance(y, int):
                 out["multipleOf"] = x * y // math.gcd(x, y)
             elif x != y:
-                ratio = max(x, y) / min(x, y)
-                if ratio == int(ratio):  # e.g. x=0.5, y=2
+                ratio = Fraction(max(x, y)) / Fraction(min(x, y))
+                if ratio.denominator == 1:  # e.g. .75, 1.5
                     out["multipleOf"] = max(x, y)
                 else:
                     return None

tests/test_canonicalise.py

@@ -41,6 +41,31 @@ def test_canonicalises_to_equivalent_fixpoint(schema_strategy, data):
     jsonschema.validators.validator_for(schema).check_schema(schema)
 
 
+@pytest.mark.parametrize(
+    "schema, examples",
+    [
+        # See https://github.com/Julian/jsonschema/pull/746
+        pytest.param(
+            {"type": "integer", "multipleOf": 0.75},
+            [1.5e308],
+            marks=pytest.mark.xfail(raises=OverflowError),
+        ),
+    ],
+)
+def test_canonicalises_to_equivalent_fixpoint_examples(schema, examples):
+    """Check that an object drawn from an arbitrary schema is valid.
+
+    This is used to record past regressions from the test above.
+    """
+    cc = canonicalish(schema)
+    assert cc == canonicalish(cc)
+    validator = jsonschema.validators.validator_for(schema)
+    validator.check_schema(schema)
+    validator.check_schema(cc)
+    for instance in examples:
+        assert is_valid(instance, schema) == is_valid(instance, cc)
+
+
 def test_dependencies_canonicalises_to_fixpoint():
     """Check that an object drawn from an arbitrary schema is valid."""
     cc = canonicalish(
@@ -136,6 +161,9 @@ def test_canonicalises_to_empty(schema):
         ({"type": get_type({})}, {}),
         ({"required": []}, {}),
         ({"type": "integer", "not": {"type": "string"}}, {"type": "integer"}),
+        ({"type": "integer", "multipleOf": 1 / 32}, {"type": "integer"}),
+        ({"type": "number", "multipleOf": 1.0}, {"type": "integer"}),
+        ({"type": "number", "multipleOf": -3.0}, {"type": "integer", "multipleOf": 3}),
         (
             {"type": "array", "items": [True, False, True]},
             {"type": "array", "items": [{}], "maxItems": 1},
@@ -276,6 +304,14 @@ def test_canonicalises_to_empty(schema):
             {"if": {"type": "integer"}, "then": {}, "else": {}, "type": "number"},
             {"type": "number"},
         ),
+        (
+            {"allOf": [{"multipleOf": 1.5}], "multipleOf": 1.5},
+            {"multipleOf": 1.5},
+        ),
+        (
+            {"type": "integer", "allOf": [{"multipleOf": 0.5}, {"multipleOf": 1e308}]},
+            {"type": "integer", "multipleOf": 1e308},
+        ),
     ],
 )
 def test_canonicalises_to_expected(schema, expected):