Switch to coerce_types on validator __init__.

Author: lovelydinosaur

tests/test_fields.py

@@ -152,8 +152,8 @@ def test_integer():
     value, error = validator.validate_or_error(float("nan"))
     assert error == ValidationError(text="Must be an integer.", code="integer")
 
-    validator = Integer()
-    value, error = validator.validate_or_error("123", strict=True)
+    validator = Integer(coerce_types=False)
+    value, error = validator.validate_or_error("123")
     assert error == ValidationError(text="Must be a number.", code="type")
 
     validator = Integer(allow_null=True)
@@ -166,8 +166,8 @@ def test_integer():
     assert value is None
     assert error is None
 
-    validator = Integer(allow_null=True)
-    value, error = validator.validate_or_error("", strict=True)
+    validator = Integer(allow_null=True, coerce_types=False)
+    value, error = validator.validate_or_error("")
     assert error == ValidationError(text="Must be a number.", code="type")
 
     validator = Integer(maximum=10)
@@ -242,8 +242,8 @@ def test_float():
     value, error = validator.validate_or_error(float("nan"))
     assert error == ValidationError(text="Must be finite.", code="finite")
 
-    validator = Float()
-    value, error = validator.validate_or_error("123", strict=True)
+    validator = Float(coerce_types=False)
+    value, error = validator.validate_or_error("123")
     assert error == ValidationError(text="Must be a number.", code="type")
 
     validator = Float(allow_null=True)
@@ -361,8 +361,8 @@ def test_boolean():
     assert value is None
     assert error is None
 
-    validator = Boolean()
-    value, error = validator.validate_or_error("True", strict=True)
+    validator = Boolean(coerce_types=False)
+    value, error = validator.validate_or_error("True")
     assert error == ValidationError(text="Must be a boolean.", code="type")
 
 

tests/test_json_schema.py

@@ -78,7 +78,7 @@ def load_test_cases():
 @pytest.mark.parametrize("schema,data,is_valid,description", test_cases)
 def test_json_schema(schema, data, is_valid, description):
     validator = from_json_schema(schema)
-    value, error = validator.validate_or_error(data, strict=True)
+    value, error = validator.validate_or_error(data)
     if is_valid:
         assert error is None, description
     else:
@@ -104,16 +104,12 @@ def test_to_from_json_schema(schema, data, is_valid, description):
     """
     validator = from_json_schema(schema)
 
-    value_before_convert, error_before_convert = validator.validate_or_error(
-        data, strict=True
-    )
+    value_before_convert, error_before_convert = validator.validate_or_error(data)
 
     schema_after = to_json_schema(validator)
     validator = from_json_schema(schema_after)
 
-    value_after_convert, error_after_convert = validator.validate_or_error(
-        data, strict=True
-    )
+    value_after_convert, error_after_convert = validator.validate_or_error(data)
 
     assert error_before_convert == error_after_convert
     assert value_before_convert == value_after_convert

typesystem/composites.py

@@ -16,7 +16,7 @@ def __init__(self, **kwargs: typing.Any) -> None:
         assert "allow_null" not in kwargs
         super().__init__(**kwargs)
 
-    def validate(self, value: typing.Any, strict: bool = False) -> typing.Any:
+    def validate(self, value: typing.Any) -> typing.Any:
         raise self.validation_error("never")
 
 
@@ -38,11 +38,11 @@ def __init__(self, one_of: typing.List[Field], **kwargs: typing.Any) -> None:
         super().__init__(**kwargs)
         self.one_of = one_of
 
-    def validate(self, value: typing.Any, strict: bool = False) -> typing.Any:
+    def validate(self, value: typing.Any) -> typing.Any:
         candidate = None
         match_count = 0
         for child in self.one_of:
-            validated, error = child.validate_or_error(value, strict=strict)
+            validated, error = child.validate_or_error(value)
             if error is None:
                 match_count += 1
                 candidate = validated
@@ -67,9 +67,9 @@ def __init__(self, all_of: typing.List[Field], **kwargs: typing.Any) -> None:
         super().__init__(**kwargs)
         self.all_of = all_of
 
-    def validate(self, value: typing.Any, strict: bool = False) -> typing.Any:
+    def validate(self, value: typing.Any) -> typing.Any:
         for child in self.all_of:
-            child.validate(value, strict=strict)
+            child.validate(value)
         return value
 
 
@@ -87,8 +87,8 @@ def __init__(self, negated: Field, **kwargs: typing.Any) -> None:
         super().__init__(**kwargs)
         self.negated = negated
 
-    def validate(self, value: typing.Any, strict: bool = False) -> typing.Any:
-        _, error = self.negated.validate_or_error(value, strict=strict)
+    def validate(self, value: typing.Any) -> typing.Any:
+        _, error = self.negated.validate_or_error(value)
         if error:
             return value
         raise self.validation_error("negated")
@@ -114,9 +114,9 @@ def __init__(
         self.then_clause = Any() if then_clause is None else then_clause
         self.else_clause = Any() if else_clause is None else else_clause
 
-    def validate(self, value: typing.Any, strict: bool = False) -> typing.Any:
-        _, error = self.if_clause.validate_or_error(value, strict=strict)
+    def validate(self, value: typing.Any) -> typing.Any:
+        _, error = self.if_clause.validate_or_error(value)
         if error is None:
-            return self.then_clause.validate(value, strict=strict)
+            return self.then_clause.validate(value)
         else:
-            return self.else_clause.validate(value, strict=strict)
+            return self.else_clause.validate(value)

typesystem/fields.py

@@ -47,14 +47,12 @@ def __init__(
         self._creation_counter = Field._creation_counter
         Field._creation_counter += 1
 
-    def validate(self, value: typing.Any, *, strict: bool = False) -> typing.Any:
+    def validate(self, value: typing.Any) -> typing.Any:
         raise NotImplementedError()  # pragma: no cover
 
-    def validate_or_error(
-        self, value: typing.Any, *, strict: bool = False
-    ) -> ValidationResult:
+    def validate_or_error(self, value: typing.Any) -> ValidationResult:
         try:
-            value = self.validate(value, strict=strict)
+            value = self.validate(value)
         except ValidationError as error:
             return ValidationResult(value=None, error=error)
         return ValidationResult(value=value, error=None)
@@ -112,6 +110,7 @@ def __init__(
         min_length: int = None,
         pattern: typing.Union[str, typing.Pattern] = None,
         format: str = None,
+        coerce_types: bool = True,
         **kwargs: typing.Any,
     ) -> None:
         super().__init__(**kwargs)
@@ -129,6 +128,7 @@ def __init__(
         self.max_length = max_length
         self.min_length = min_length
         self.format = format
+        self.coerce_types = coerce_types
 
         if pattern is None:
             self.pattern = None
@@ -140,10 +140,10 @@ def __init__(
             self.pattern = pattern.pattern
             self.pattern_regex = pattern
 
-    def validate(self, value: typing.Any, *, strict: bool = False) -> typing.Any:
+    def validate(self, value: typing.Any) -> typing.Any:
         if value is None and self.allow_null:
             return None
-        elif value is None and self.allow_blank and not strict:
+        elif value is None and self.allow_blank and self.coerce_types:
             # Leniently cast nulls to empty strings if allow_blank.
             return ""
         elif value is None:
@@ -161,7 +161,7 @@ def validate(self, value: typing.Any, *, strict: bool = False) -> typing.Any:
             value = value.strip()
 
         if not self.allow_blank and not value:
-            if self.allow_null and not strict:
+            if self.allow_null and self.coerce_types:
                 # Leniently cast empty strings (after trimming) to null if allow_null.
                 return None
             raise self.validation_error("blank")
@@ -212,6 +212,7 @@ def __init__(
         exclusive_maximum: typing.Union[int, float, decimal.Decimal] = None,
         precision: str = None,
         multiple_of: typing.Union[int, float, decimal.Decimal] = None,
+        coerce_types: bool = True,
         **kwargs: typing.Any,
     ):
         super().__init__(**kwargs)
@@ -234,11 +235,12 @@ def __init__(
         self.exclusive_maximum = exclusive_maximum
         self.multiple_of = multiple_of
         self.precision = precision
+        self.coerce_types = coerce_types
 
-    def validate(self, value: typing.Any, *, strict: bool = False) -> typing.Any:
+    def validate(self, value: typing.Any) -> typing.Any:
         if value is None and self.allow_null:
             return None
-        elif value == "" and self.allow_null and not strict:
+        elif value == "" and self.allow_null and self.coerce_types:
             return None
         elif value is None:
             raise self.validation_error("null")
@@ -250,7 +252,7 @@ def validate(self, value: typing.Any, *, strict: bool = False) -> typing.Any:
             and not value.is_integer()
         ):
             raise self.validation_error("integer")
-        elif not isinstance(value, (int, float)) and strict:
+        elif not isinstance(value, (int, float)) and not self.coerce_types:
             raise self.validation_error("type")
 
         try:
@@ -328,15 +330,19 @@ class Boolean(Field):
     }
     coerce_null_values = {"", "null", "none"}
 
-    def validate(self, value: typing.Any, *, strict: bool = False) -> typing.Any:
+    def __init__(self, *, coerce_types: bool = True, **kwargs: typing.Any) -> None:
+        super().__init__(**kwargs)
+        self.coerce_types = coerce_types
+
+    def validate(self, value: typing.Any) -> typing.Any:
         if value is None and self.allow_null:
             return None
 
         elif value is None:
             raise self.validation_error("null")
 
         elif not isinstance(value, bool):
-            if strict:
+            if not self.coerce_types:
                 raise self.validation_error("type")
 
             if isinstance(value, str):
@@ -364,23 +370,25 @@ def __init__(
         self,
         *,
         choices: typing.Sequence[typing.Union[str, typing.Tuple[str, str]]] = None,
+        coerce_types: bool = True,
         **kwargs: typing.Any,
     ) -> None:
         super().__init__(**kwargs)
         self.choices = [
             (choice if isinstance(choice, (tuple, list)) else (choice, choice))
             for choice in choices or []
         ]
+        self.coerce_types = coerce_types
         assert all(len(choice) == 2 for choice in self.choices)
 
-    def validate(self, value: typing.Any, *, strict: bool = False) -> typing.Any:
+    def validate(self, value: typing.Any) -> typing.Any:
         if value is None and self.allow_null:
             return None
         elif value is None:
             raise self.validation_error("null")
         elif value not in Uniqueness([key for key, value in self.choices]):
             if value == "":
-                if self.allow_null and not strict:
+                if self.allow_null and self.coerce_types:
                     return None
                 raise self.validation_error("required")
             raise self.validation_error("choice")
@@ -443,7 +451,7 @@ def __init__(
         self.max_properties = max_properties
         self.required = required
 
-    def validate(self, value: typing.Any, *, strict: bool = False) -> typing.Any:
+    def validate(self, value: typing.Any) -> typing.Any:
         if value is None and self.allow_null:
             return None
         elif value is None:
@@ -492,7 +500,7 @@ def validate(self, value: typing.Any, *, strict: bool = False) -> typing.Any:
                     validated[key] = child_schema.get_default_value()
                 continue
             item = value[key]
-            child_value, error = child_schema.validate_or_error(item, strict=strict)
+            child_value, error = child_schema.validate_or_error(item)
             if not error:
                 validated[key] = child_value
             else:
@@ -504,9 +512,7 @@ def validate(self, value: typing.Any, *, strict: bool = False) -> typing.Any:
                 for pattern, child_schema in self.pattern_properties.items():
                     if isinstance(key, str) and re.search(pattern, key):
                         item = value[key]
-                        child_value, error = child_schema.validate_or_error(
-                            item, strict=strict
-                        )
+                        child_value, error = child_schema.validate_or_error(item)
                         if not error:
                             validated[key] = child_value
                         else:
@@ -535,7 +541,7 @@ def validate(self, value: typing.Any, *, strict: bool = False) -> typing.Any:
             child_schema = self.additional_properties
             for key in remaining:
                 item = value[key]
-                child_value, error = child_schema.validate_or_error(item, strict=strict)
+                child_value, error = child_schema.validate_or_error(item)
                 if not error:
                     validated[key] = child_value
                 else:
@@ -599,7 +605,7 @@ def __init__(
         self.max_items = max_items
         self.unique_items = unique_items
 
-    def validate(self, value: typing.Any, *, strict: bool = False) -> typing.Any:
+    def validate(self, value: typing.Any) -> typing.Any:
         if value is None and self.allow_null:
             return None
         elif value is None:
@@ -639,7 +645,7 @@ def validate(self, value: typing.Any, *, strict: bool = False) -> typing.Any:
             if validator is None:
                 validated.append(item)
             else:
-                item, error = validator.validate_or_error(item, strict=strict)
+                item, error = validator.validate_or_error(item)
                 if error:
                     error_messages += error.messages(add_prefix=pos)
                 else:
@@ -704,15 +710,15 @@ def __init__(self, any_of: typing.List[Field], **kwargs: typing.Any):
         if any([child.allow_null for child in any_of]):
             self.allow_null = True
 
-    def validate(self, value: typing.Any, strict: bool = False) -> typing.Any:
+    def validate(self, value: typing.Any) -> typing.Any:
         if value is None and self.allow_null:
             return None
         elif value is None:
             raise self.validation_error("null")
 
         candidate_errors = []
         for child in self.any_of:
-            validated, error = child.validate_or_error(value, strict=strict)
+            validated, error = child.validate_or_error(value)
             if error is None:
                 return validated
             else:
@@ -738,7 +744,7 @@ class Any(Field):
     Always matches.
     """
 
-    def validate(self, value: typing.Any, strict: bool = False) -> typing.Any:
+    def validate(self, value: typing.Any) -> typing.Any:
         return value
 
 
@@ -754,7 +760,7 @@ def __init__(self, const: typing.Any, **kwargs: typing.Any):
         super().__init__(**kwargs)
         self.const = const
 
-    def validate(self, value: typing.Any, strict: bool = False) -> typing.Any:
+    def validate(self, value: typing.Any) -> typing.Any:
         if value != self.const:
             if self.const is None:
                 raise self.validation_error("only_null")

typesystem/json_schema.py

@@ -212,6 +212,7 @@ def from_json_schema_type(
             "exclusive_maximum": data.get("exclusiveMaximum", None),
             "multiple_of": data.get("multipleOf", None),
             "default": data.get("default", NO_DEFAULT),
+            "coerce_types": False,
         }
         return Float(**kwargs)
 
@@ -224,6 +225,7 @@ def from_json_schema_type(
             "exclusive_maximum": data.get("exclusiveMaximum", None),
             "multiple_of": data.get("multipleOf", None),
             "default": data.get("default", NO_DEFAULT),
+            "coerce_types": False,
         }
         return Integer(**kwargs)
 
@@ -237,11 +239,16 @@ def from_json_schema_type(
             "format": data.get("format"),
             "pattern": data.get("pattern", None),
             "default": data.get("default", NO_DEFAULT),
+            "coerce_types": False,
         }
         return String(**kwargs)
 
     elif type_string == "boolean":
-        kwargs = {"allow_null": allow_null, "default": data.get("default", NO_DEFAULT)}
+        kwargs = {
+            "allow_null": allow_null,
+            "default": data.get("default", NO_DEFAULT),
+            "coerce_types": False,
+        }
         return Boolean(**kwargs)
 
     elif type_string == "array":