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
pydantic · Apr 12, 2023 · 5c90851 · 5c90851
1 parent dd98ccc
commit 5c90851
Show file tree

Hide file tree

Showing 41 changed files with 668 additions and 21 deletions.
diff --git a/src/input/input_abstract.rs b/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> {

diff --git a/src/input/input_json.rs b/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))

diff --git a/src/input/input_python.rs b/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)

diff --git a/src/validators/any.rs b/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
     }

diff --git a/src/validators/arguments.rs b/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
     }

diff --git a/src/validators/bool.rs b/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
     }

diff --git a/src/validators/bytes.rs b/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"
     }

diff --git a/src/validators/call.rs b/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
     }

diff --git a/src/validators/callable.rs b/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
     }

diff --git a/src/validators/chain.rs b/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
     }

diff --git a/src/validators/custom_error.rs b/src/validators/custom_error.rs
@@ -97,6 +97,14 @@ impl Validator for CustomErrorValidator {
             .map_err(|_| self.custom_error.as_val_error(input))
     }
 
+    fn different_strict_behavior(
+        &self,
+        build_context: Option<&BuildContext<CombinedValidator>>,
+        ultra_strict: bool,
+    ) -> bool {
+        self.validator.different_strict_behavior(build_context, ultra_strict)
+    }
+
     fn get_name(&self) -> &str {
         &self.name
     }

diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
@@ -380,6 +380,16 @@ impl Validator for DataclassArgsValidator {
         }
     }
 
+    fn different_strict_behavior(
+        &self,
+        build_context: Option<&BuildContext<CombinedValidator>>,
+        ultra_strict: bool,
+    ) -> bool {
+        self.fields
+            .iter()
+            .any(|f| f.validator.different_strict_behavior(build_context, ultra_strict))
+    }
+
     fn get_name(&self) -> &str {
         &self.validator_name
     }
@@ -510,6 +520,18 @@ impl Validator for DataclassValidator {
         Ok(obj.to_object(py))
     }
 
+    fn different_strict_behavior(
+        &self,
+        build_context: Option<&BuildContext<CombinedValidator>>,
+        ultra_strict: bool,
+    ) -> bool {
+        if ultra_strict {
+            self.validator.different_strict_behavior(build_context, ultra_strict)
+        } else {
+            true
+        }
+    }
+
     fn get_name(&self) -> &str {
         &self.name
     }

diff --git a/src/validators/date.rs b/src/validators/date.rs
@@ -98,6 +98,14 @@ impl Validator for DateValidator {
         Ok(date.try_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
     }

diff --git a/src/validators/datetime.rs b/src/validators/datetime.rs
@@ -102,6 +102,14 @@ impl Validator for DateTimeValidator {
         Ok(datetime.try_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
     }

diff --git a/src/validators/definitions.rs b/src/validators/definitions.rs
@@ -107,6 +107,20 @@ impl Validator for DefinitionRefValidator {
         }
     }
 
+    fn different_strict_behavior(
+        &self,
+        build_context: Option<&BuildContext<CombinedValidator>>,
+        ultra_strict: bool,
+    ) -> bool {
+        if let Some(build_context) = build_context {
+            // have to unwrap here, because we can't return an error from this function, should be okay
+            let validator = build_context.find_validator(self.validator_id).unwrap();
+            validator.different_strict_behavior(None, ultra_strict)
+        } else {
+            false
+        }
+    }
+
     fn get_name(&self) -> &str {
         &self.inner_name
     }

diff --git a/src/validators/dict.rs b/src/validators/dict.rs
@@ -80,6 +80,19 @@ impl Validator for DictValidator {
         }
     }
 
+    fn different_strict_behavior(
+        &self,
+        build_context: Option<&BuildContext<CombinedValidator>>,
+        ultra_strict: bool,
+    ) -> bool {
+        if ultra_strict {
+            self.key_validator.different_strict_behavior(build_context, true)
+                || self.value_validator.different_strict_behavior(build_context, true)
+        } else {
+            true
+        }
+    }
+
     fn get_name(&self) -> &str {
         &self.name
     }

diff --git a/src/validators/float.rs b/src/validators/float.rs
@@ -68,13 +68,21 @@ impl Validator for FloatValidator {
         _slots: &'data [CombinedValidator],
         _recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
-        let float = input.validate_float(extra.strict.unwrap_or(self.strict))?;
+        let float = input.validate_float(extra.strict.unwrap_or(self.strict), extra.ultra_strict)?;
         if !self.allow_inf_nan && !float.is_finite() {
             return Err(ValError::new(ErrorType::FiniteNumber, input));
         }
         Ok(float.into_py(py))
     }
 
+    fn different_strict_behavior(
+        &self,
+        _build_context: Option<&BuildContext<CombinedValidator>>,
+        _ultra_strict: bool,
+    ) -> bool {
+        true
+    }
+
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
@@ -104,7 +112,7 @@ impl Validator for ConstrainedFloatValidator {
         _slots: &'data [CombinedValidator],
         _recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
-        let float = input.validate_float(extra.strict.unwrap_or(self.strict))?;
+        let float = input.validate_float(extra.strict.unwrap_or(self.strict), extra.ultra_strict)?;
         if !self.allow_inf_nan && !float.is_finite() {
             return Err(ValError::new(ErrorType::FiniteNumber, input));
         }
@@ -142,6 +150,15 @@ impl Validator for ConstrainedFloatValidator {
         }
         Ok(float.into_py(py))
     }
+
+    fn different_strict_behavior(
+        &self,
+        _build_context: Option<&BuildContext<CombinedValidator>>,
+        _ultra_strict: bool,
+    ) -> bool {
+        true
+    }
+
     fn get_name(&self) -> &str {
         "constrained-float"
     }

diff --git a/src/validators/frozenset.rs b/src/validators/frozenset.rs
@@ -60,6 +60,21 @@ impl Validator for FrozenSetValidator {
         Ok(f_set.into_py(py))
     }
 
+    fn different_strict_behavior(
+        &self,
+        build_context: Option<&BuildContext<CombinedValidator>>,
+        ultra_strict: bool,
+    ) -> bool {
+        if ultra_strict {
+            match self.item_validator {
+                Some(ref v) => v.different_strict_behavior(build_context, true),
+                None => false,
+            }
+        } else {
+            true
+        }
+    }
+
     fn get_name(&self) -> &str {
         &self.name
     }