Use Decimal for multipleOf when the value is float

Author: horejsek

CHANGELOG.txt

@@ -1,6 +1,7 @@
 === unreleased
 
 * Fix of `additionalProperties=true` for JSON schema 4
+* Use decimal for multipleOf implementation and add respective tests
 
 
 === 2.14.1 (2019-10-09)

fastjsonschema/draft04.py

@@ -1,3 +1,4 @@
+import decimal
 import re
 
 from .exceptions import JsonSchemaDefinitionException
@@ -301,8 +302,14 @@ def generate_multiple_of(self):
         with self.l('if isinstance({variable}, (int, float)):'):
             if not isinstance(self._definition['multipleOf'], (int, float)):
                 raise JsonSchemaDefinitionException('multipleOf must be a number')
-            self.l('from decimal import Decimal')
-            self.l('quotient = Decimal(repr({variable})) / Decimal(repr({multipleOf}))')
+            # For proper multiplication check of floats we need to use decimals,
+            # because for example 19.01 / 0.01 = 1901.0000000000002.
+            if isinstance(self._definition['multipleOf'], float):
+                self._extra_imports_lines.append('from decimal import Decimal')
+                self._extra_imports_objects['Decimal'] = decimal.Decimal
+                self.l('quotient = Decimal(repr({variable})) / Decimal(repr({multipleOf}))')
+            else:
+                self.l('quotient = {variable} / {multipleOf}')
             with self.l('if int(quotient) != quotient:'):
                 self.exc('{name} must be multiple of {multipleOf}', rule='multipleOf')
 

fastjsonschema/generator.py

@@ -32,6 +32,12 @@ def __init__(self, definition, resolver=None):
         self._code = []
         self._compile_regexps = {}
 
+        # Any extra library should be here to be imported only once.
+        # Lines are imports to be printed in the file and objects
+        # key-value pair to pass to compile function directly.
+        self._extra_imports_lines = []
+        self._extra_imports_objects = {}
+
         self._variables = set()
         self._indent = 0
         self._indent_last_line = None
@@ -74,6 +80,7 @@ def global_state(self):
         self._generate_func_code()
 
         return dict(
+            **self._extra_imports_objects,
             REGEX_PATTERNS=self._compile_regexps,
             re=re,
             JsonSchemaException=JsonSchemaException,
@@ -88,26 +95,22 @@ def global_state_code(self):
         self._generate_func_code()
 
         if not self._compile_regexps:
-            return '\n'.join(
-                [
-                    'from fastjsonschema import JsonSchemaException',
-                    '',
-                    '',
-                ]
-            )
-        regexs = ['"{}": re.compile(r"{}")'.format(key, value.pattern) for key, value in self._compile_regexps.items()]
-        return '\n'.join(
-            [
-                'import re',
+            return '\n'.join(self._extra_imports_lines + [
                 'from fastjsonschema import JsonSchemaException',
                 '',
                 '',
-                'REGEX_PATTERNS = {',
-                '    ' + ',\n    '.join(regexs),
-                '}',
-                '',
-            ]
-        )
+            ])
+        regexs = ['"{}": re.compile(r"{}")'.format(key, value.pattern) for key, value in self._compile_regexps.items()]
+        return '\n'.join(self._extra_imports_lines + [
+            'import re',
+            'from fastjsonschema import JsonSchemaException',
+            '',
+            '',
+            'REGEX_PATTERNS = {',
+            '    ' + ',\n    '.join(regexs),
+            '}',
+            '',
+        ])
 
 
     def _generate_func_code(self):

tests/json_schema/utils.py

@@ -67,7 +67,10 @@ def template_test(schema_version, schema, data, is_valid):
     """
     # For debug purposes. When test fails, it will print stdout.
     resolver = RefResolver.from_schema(schema, handlers={'http': remotes_handler})
-    print(_get_code_generator_class(schema_version)(schema, resolver=resolver).func_code)
+
+    debug_generator = _get_code_generator_class(schema_version)(schema, resolver=resolver)
+    print(debug_generator.global_state_code)
+    print(debug_generator.func_code)
 
     # JSON schema test suits do not contain schema version.
     # Our library needs to know that or it would use always the latest implementation.

tests/test_number.py

@@ -111,7 +111,6 @@ def test_multiple_of(asserter, number_type, value, expected):
     }, value, expected)
 
 
-
 exc = JsonSchemaException('data must be multiple of 0.0001', value='{data}', name='data', definition='{definition}', rule='multipleOf')
 @pytest.mark.parametrize('value, expected', [
     (0.00751, exc),
@@ -123,18 +122,23 @@ def test_multiple_of_float(asserter, value, expected):
         'multipleOf': 0.0001,
     }, value, expected)
 
-exc = JsonSchemaException('data must be multiple of 1.5', value='{data}', name='data', definition='{definition}', rule='multipleOf')
+
+exc = JsonSchemaException('data must be multiple of 0.01', value='{data}', name='data', definition='{definition}', rule='multipleOf')
 @pytest.mark.parametrize('value, expected', [
     (0, 0),
-    (4.5, 4.5),
-    (35, exc),
+    (0.01, 0.01),
+    (0.1, 0.1),
+    (19.01, 19.01),
+    (0.001, exc),
+    (19.001, exc),
 ])
 def test_multiple_of_float_1_5(asserter, value, expected):
     asserter({
         'type': 'number',
-        'multipleOf': 1.5,
+        'multipleOf': 0.01,
     }, value, expected)
 
+
 @pytest.mark.parametrize('value', (
     1.0,
     0.1,