Add ultra-strict mode for better union decisions (#536)

* make strict float not allow an int

* adding different_strict_behavior()

* revert float test changes

* add tests

* improve testing structure

* support definition references, test

* update validate_float

Author: samuelcolvin

src/input/input_abstract.rs

@@ -129,13 +129,16 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         self.strict_int()
     }
 
-    fn validate_float(&self, strict: bool) -> ValResult<f64> {
-        if strict {
+    fn validate_float(&self, strict: bool, ultra_strict: bool) -> ValResult<f64> {
+        if ultra_strict {
+            self.ultra_strict_float()
+        } else if strict {
             self.strict_float()
         } else {
             self.lax_float()
         }
     }
+    fn ultra_strict_float(&self) -> ValResult<f64>;
     fn strict_float(&self) -> ValResult<f64>;
     #[cfg_attr(has_no_coverage, no_coverage)]
     fn lax_float(&self) -> ValResult<f64> {

src/input/input_json.rs

@@ -141,6 +141,12 @@ impl<'a> Input<'a> for JsonInput {
         }
     }
 
+    fn ultra_strict_float(&self) -> ValResult<f64> {
+        match self {
+            JsonInput::Float(f) => Ok(*f),
+            _ => Err(ValError::new(ErrorType::FloatType, self)),
+        }
+    }
     fn strict_float(&self) -> ValResult<f64> {
         match self {
             JsonInput::Float(f) => Ok(*f),
@@ -368,6 +374,10 @@ impl<'a> Input<'a> for String {
         }
     }
 
+    #[cfg_attr(has_no_coverage, no_coverage)]
+    fn ultra_strict_float(&self) -> ValResult<f64> {
+        self.strict_float()
+    }
     #[cfg_attr(has_no_coverage, no_coverage)]
     fn strict_float(&self) -> ValResult<f64> {
         Err(ValError::new(ErrorType::FloatType, self))

src/input/input_python.rs

@@ -4,8 +4,8 @@ use std::str::from_utf8;
 use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
 use pyo3::types::{
-    PyBool, PyByteArray, PyBytes, PyDate, PyDateTime, PyDelta, PyDict, PyFrozenSet, PyIterator, PyList, PyMapping,
-    PySet, PyString, PyTime, PyTuple, PyType,
+    PyBool, PyByteArray, PyBytes, PyDate, PyDateTime, PyDelta, PyDict, PyFrozenSet, PyInt, PyIterator, PyList,
+    PyMapping, PySet, PyString, PyTime, PyTuple, PyType,
 };
 #[cfg(not(PyPy))]
 use pyo3::types::{PyDictItems, PyDictKeys, PyDictValues};
@@ -289,6 +289,15 @@ impl<'a> Input<'a> for PyAny {
         }
     }
 
+    fn ultra_strict_float(&self) -> ValResult<f64> {
+        if matches!(self.is_instance_of::<PyInt>(), Ok(true)) {
+            Err(ValError::new(ErrorType::FloatType, self))
+        } else if let Ok(float) = self.extract::<f64>() {
+            Ok(float)
+        } else {
+            Err(ValError::new(ErrorType::FloatType, self))
+        }
+    }
     fn strict_float(&self) -> ValResult<f64> {
         if self.extract::<bool>().is_ok() {
             Err(ValError::new(ErrorType::FloatType, self))
@@ -298,7 +307,6 @@ impl<'a> Input<'a> for PyAny {
             Err(ValError::new(ErrorType::FloatType, self))
         }
     }
-
     fn lax_float(&self) -> ValResult<f64> {
         if let Ok(float) = self.extract::<f64>() {
             Ok(float)

src/validators/any.rs

@@ -36,6 +36,14 @@ impl Validator for AnyValidator {
         Ok(input.to_object(py))
     }
 
+    fn different_strict_behavior(
+        &self,
+        _build_context: Option<&BuildContext<CombinedValidator>>,
+        _ultra_strict: bool,
+    ) -> bool {
+        false
+    }
+
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }

src/validators/arguments.rs

@@ -326,6 +326,16 @@ impl Validator for ArgumentsValidator {
         }
     }
 
+    fn different_strict_behavior(
+        &self,
+        build_context: Option<&BuildContext<CombinedValidator>>,
+        ultra_strict: bool,
+    ) -> bool {
+        self.parameters
+            .iter()
+            .any(|p| p.validator.different_strict_behavior(build_context, ultra_strict))
+    }
+
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }

src/validators/bool.rs

@@ -42,6 +42,14 @@ impl Validator for BoolValidator {
         Ok(input.validate_bool(extra.strict.unwrap_or(self.strict))?.into_py(py))
     }
 
+    fn different_strict_behavior(
+        &self,
+        _build_context: Option<&BuildContext<CombinedValidator>>,
+        ultra_strict: bool,
+    ) -> bool {
+        !ultra_strict
+    }
+
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }

src/validators/bytes.rs

@@ -49,6 +49,14 @@ impl Validator for BytesValidator {
         Ok(either_bytes.into_py(py))
     }
 
+    fn different_strict_behavior(
+        &self,
+        _build_context: Option<&BuildContext<CombinedValidator>>,
+        ultra_strict: bool,
+    ) -> bool {
+        !ultra_strict
+    }
+
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
@@ -91,6 +99,14 @@ impl Validator for BytesConstrainedValidator {
         Ok(either_bytes.into_py(py))
     }
 
+    fn different_strict_behavior(
+        &self,
+        _build_context: Option<&BuildContext<CombinedValidator>>,
+        ultra_strict: bool,
+    ) -> bool {
+        !ultra_strict
+    }
+
     fn get_name(&self) -> &str {
         "constrained-bytes"
     }

src/validators/call.rs

@@ -81,6 +81,20 @@ impl Validator for CallValidator {
         }
     }
 
+    fn different_strict_behavior(
+        &self,
+        build_context: Option<&BuildContext<CombinedValidator>>,
+        ultra_strict: bool,
+    ) -> bool {
+        if let Some(return_validator) = &self.return_validator {
+            if return_validator.different_strict_behavior(build_context, ultra_strict) {
+                return true;
+            }
+        }
+        self.arguments_validator
+            .different_strict_behavior(build_context, ultra_strict)
+    }
+
     fn get_name(&self) -> &str {
         &self.name
     }

src/validators/callable.rs

@@ -37,6 +37,14 @@ impl Validator for CallableValidator {
         }
     }
 
+    fn different_strict_behavior(
+        &self,
+        _build_context: Option<&BuildContext<CombinedValidator>>,
+        _ultra_strict: bool,
+    ) -> bool {
+        false
+    }
+
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }

src/validators/chain.rs

@@ -85,6 +85,16 @@ impl Validator for ChainValidator {
         })
     }
 
+    fn different_strict_behavior(
+        &self,
+        build_context: Option<&BuildContext<CombinedValidator>>,
+        ultra_strict: bool,
+    ) -> bool {
+        self.steps
+            .iter()
+            .any(|v| v.different_strict_behavior(build_context, ultra_strict))
+    }
+
     fn get_name(&self) -> &str {
         &self.name
     }