Add eitherfloat

src/errors/types.rs

@@ -501,7 +501,7 @@ impl ErrorType {
             Self::IntFromFloat => "Input should be a valid integer, got a number with a fractional part",
             Self::IntParsingSize => "Unable to parse input string as an integer, exceeded maximum size",
             Self::FloatType => "Input should be a valid number",
-            Self::FloatParsing => "Input should be a valid number, unable to parse string as an number",
+            Self::FloatParsing => "Input should be a valid number, unable to parse string as a number",
             Self::BytesType => "Input should be a valid bytes",
             Self::BytesTooShort {..} => "Data should have at least {min_length} bytes",
             Self::BytesTooLong {..} => "Data should have at most {max_length} bytes",

src/input/input_abstract.rs

@@ -8,7 +8,7 @@ use crate::{PyMultiHostUrl, PyUrl};
 
 use super::datetime::{EitherDate, EitherDateTime, EitherTime, EitherTimedelta};
 use super::return_enums::{EitherBytes, EitherInt, EitherString};
-use super::{GenericArguments, GenericIterable, GenericIterator, GenericMapping, JsonInput};
+use super::{EitherFloat, GenericArguments, GenericIterable, GenericIterator, GenericMapping, JsonInput};
 
 #[derive(Debug, Clone, Copy)]
 pub enum InputType {
@@ -136,7 +136,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         self.strict_str()
     }
 
-    fn validate_float(&self, strict: bool, ultra_strict: bool) -> ValResult<f64> {
+    fn validate_float(&'a self, strict: bool, ultra_strict: bool) -> ValResult<EitherFloat<'a>> {
         if ultra_strict {
             self.ultra_strict_float()
         } else if strict {
@@ -145,10 +145,10 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
             self.lax_float()
         }
     }
-    fn ultra_strict_float(&self) -> ValResult<f64>;
-    fn strict_float(&self) -> ValResult<f64>;
+    fn ultra_strict_float(&'a self) -> ValResult<EitherFloat<'a>>;
+    fn strict_float(&'a self) -> ValResult<EitherFloat<'a>>;
     #[cfg_attr(has_no_coverage, no_coverage)]
-    fn lax_float(&self) -> ValResult<f64> {
+    fn lax_float(&'a self) -> ValResult<EitherFloat<'a>> {
         self.strict_float()
     }
 

src/input/input_json.rs

@@ -10,8 +10,8 @@ use super::datetime::{
 use super::parse_json::JsonArray;
 use super::shared::{float_as_int, int_as_bool, map_json_err, str_as_bool, str_as_int};
 use super::{
-    EitherBytes, EitherInt, EitherString, EitherTimedelta, GenericArguments, GenericIterable, GenericIterator,
-    GenericMapping, Input, JsonArgs, JsonInput,
+    EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments, GenericIterable,
+    GenericIterator, GenericMapping, Input, JsonArgs, JsonInput,
 };
 
 impl<'a> Input<'a> for JsonInput {
@@ -135,31 +135,31 @@ impl<'a> Input<'a> for JsonInput {
         }
     }
 
-    fn ultra_strict_float(&self) -> ValResult<f64> {
+    fn ultra_strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
         match self {
-            JsonInput::Float(f) => Ok(*f),
+            JsonInput::Float(f) => Ok(EitherFloat::F64(*f)),
             _ => Err(ValError::new(ErrorType::FloatType, self)),
         }
     }
-    fn strict_float(&self) -> ValResult<f64> {
+    fn strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
         match self {
-            JsonInput::Float(f) => Ok(*f),
-            JsonInput::Int(i) => Ok(*i as f64),
-            JsonInput::Uint(u) => Ok(*u as f64),
+            JsonInput::Float(f) => Ok(EitherFloat::F64(*f)),
+            JsonInput::Int(i) => Ok(EitherFloat::F64(*i as f64)),
+            JsonInput::Uint(u) => Ok(EitherFloat::F64(*u as f64)),
             _ => Err(ValError::new(ErrorType::FloatType, self)),
         }
     }
-    fn lax_float(&self) -> ValResult<f64> {
+    fn lax_float(&'a self) -> ValResult<EitherFloat<'a>> {
         match self {
             JsonInput::Bool(b) => match *b {
-                true => Ok(1.0),
-                false => Ok(0.0),
+                true => Ok(EitherFloat::F64(1.0)),
+                false => Ok(EitherFloat::F64(0.0)),
             },
-            JsonInput::Float(f) => Ok(*f),
-            JsonInput::Int(i) => Ok(*i as f64),
-            JsonInput::Uint(u) => Ok(*u as f64),
+            JsonInput::Float(f) => Ok(EitherFloat::F64(*f)),
+            JsonInput::Int(i) => Ok(EitherFloat::F64(*i as f64)),
+            JsonInput::Uint(u) => Ok(EitherFloat::F64(*u as f64)),
             JsonInput::String(str) => match str.parse::<f64>() {
-                Ok(i) => Ok(i),
+                Ok(i) => Ok(EitherFloat::F64(i)),
                 Err(_) => Err(ValError::new(ErrorType::FloatParsing, self)),
             },
             _ => Err(ValError::new(ErrorType::FloatType, self)),
@@ -372,16 +372,16 @@ impl<'a> Input<'a> for String {
     }
 
     #[cfg_attr(has_no_coverage, no_coverage)]
-    fn ultra_strict_float(&self) -> ValResult<f64> {
+    fn ultra_strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
         self.strict_float()
     }
     #[cfg_attr(has_no_coverage, no_coverage)]
-    fn strict_float(&self) -> ValResult<f64> {
+    fn strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
         Err(ValError::new(ErrorType::FloatType, self))
     }
-    fn lax_float(&self) -> ValResult<f64> {
+    fn lax_float(&'a self) -> ValResult<EitherFloat<'a>> {
         match self.parse() {
-            Ok(i) => Ok(i),
+            Ok(f) => Ok(EitherFloat::F64(f)),
             Err(_) => Err(ValError::new(ErrorType::FloatParsing, self)),
         }
     }

src/input/input_python.rs

@@ -3,7 +3,7 @@ use std::str::from_utf8;
 
 use pyo3::prelude::*;
 use pyo3::types::{
-    PyBool, PyByteArray, PyBytes, PyDate, PyDateTime, PyDelta, PyDict, PyFrozenSet, PyInt, PyIterator, PyList,
+    PyBool, PyByteArray, PyBytes, PyDate, PyDateTime, PyDelta, PyDict, PyFloat, PyFrozenSet, PyInt, PyIterator, PyList,
     PyMapping, PySequence, PySet, PyString, PyTime, PyTuple, PyType,
 };
 #[cfg(not(PyPy))]
@@ -21,8 +21,8 @@ use super::datetime::{
 };
 use super::shared::{float_as_int, int_as_bool, map_json_err, str_as_bool, str_as_int};
 use super::{
-    py_string_str, EitherBytes, EitherInt, EitherString, EitherTimedelta, GenericArguments, GenericIterable,
-    GenericIterator, GenericMapping, Input, JsonInput, PyArgs,
+    py_string_str, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments,
+    GenericIterable, GenericIterator, GenericMapping, Input, JsonInput, PyArgs,
 };
 
 #[cfg(not(PyPy))]
@@ -302,35 +302,40 @@ impl<'a> Input<'a> for PyAny {
         }
     }
 
-    fn ultra_strict_float(&self) -> ValResult<f64> {
+    fn ultra_strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
         if self.is_instance_of::<PyInt>() {
             Err(ValError::new(ErrorType::FloatType, self))
-        } else if let Ok(float) = self.extract::<f64>() {
-            Ok(float)
+        } else if self.is_instance_of::<PyFloat>() {
+            Ok(EitherFloat::Py(self))
         } else {
             Err(ValError::new(ErrorType::FloatType, self))
         }
     }
-    fn strict_float(&self) -> ValResult<f64> {
-        if let Ok(float) = self.extract::<f64>() {
+    fn strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
+        if PyFloat::is_exact_type_of(self) {
+            Ok(EitherFloat::Py(self))
+        } else if let Ok(float) = self.extract::<f64>() {
             // bools are cast to floats as either 0.0 or 1.0, so check for bool type in this specific case
             if (float == 0.0 || float == 1.0) && PyBool::is_exact_type_of(self) {
                 Err(ValError::new(ErrorType::FloatType, self))
             } else {
-                Ok(float)
+                Ok(EitherFloat::Py(self))
             }
         } else {
             Err(ValError::new(ErrorType::FloatType, self))
         }
     }
-    fn lax_float(&self) -> ValResult<f64> {
-        if let Ok(float) = self.extract::<f64>() {
-            Ok(float)
+
+    fn lax_float(&'a self) -> ValResult<EitherFloat<'a>> {
+        if PyFloat::is_exact_type_of(self) {
+            Ok(EitherFloat::Py(self))
         } else if let Some(cow_str) = maybe_as_string(self, ErrorType::FloatParsing)? {
             match cow_str.as_ref().parse::<f64>() {
-                Ok(i) => Ok(i),
+                Ok(i) => Ok(EitherFloat::F64(i)),
                 Err(_) => Err(ValError::new(ErrorType::FloatParsing, self)),
             }
+        } else if let Ok(float) = self.extract::<f64>() {
+            Ok(EitherFloat::F64(float))
         } else {
             Err(ValError::new(ErrorType::FloatType, self))
         }

src/input/mod.rs

@@ -17,7 +17,7 @@ pub(crate) use datetime::{
 pub(crate) use input_abstract::{Input, InputType};
 pub(crate) use parse_json::{JsonInput, JsonObject};
 pub(crate) use return_enums::{
-    py_string_str, AttributesGenericIterator, DictGenericIterator, EitherBytes, EitherInt, EitherString,
+    py_string_str, AttributesGenericIterator, DictGenericIterator, EitherBytes, EitherFloat, EitherInt, EitherString,
     GenericArguments, GenericIterable, GenericIterator, GenericMapping, JsonArgs, JsonObjectGenericIterator,
     MappingGenericIterator, PyArgs,
 };

src/input/return_enums.rs

@@ -892,3 +892,29 @@ impl<'a> IntoPy<PyObject> for EitherInt<'a> {
         }
     }
 }
+
+#[cfg_attr(debug_assertions, derive(Debug))]
+pub enum EitherFloat<'a> {
+    F64(f64),
+    Py(&'a PyAny),
+}
+
+impl<'a> TryInto<f64> for EitherFloat<'a> {
+    type Error = ValError<'a>;
+
+    fn try_into(self) -> ValResult<'a, f64> {
+        match self {
+            EitherFloat::F64(f) => Ok(f),
+            EitherFloat::Py(i) => i.extract().map_err(|_| ValError::new(ErrorType::FloatParsing, i)),
+        }
+    }
+}
+
+impl<'a> IntoPy<PyObject> for EitherFloat<'a> {
+    fn into_py(self, py: Python<'_>) -> PyObject {
+        match self {
+            Self::F64(float) => float.into_py(py),
+            Self::Py(float) => float.into_py(py),
+        }
+    }
+}

src/validators/float.rs

@@ -69,11 +69,13 @@ impl Validator for FloatValidator {
         _definitions: &'data Definitions<CombinedValidator>,
         _recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
-        let float = input.validate_float(extra.strict.unwrap_or(self.strict), extra.ultra_strict)?;
+        let either_float = input.validate_float(extra.strict.unwrap_or(self.strict), extra.ultra_strict)?;
+        let float: f64 = either_float.try_into()?;
         if !self.allow_inf_nan && !float.is_finite() {
             return Err(ValError::new(ErrorType::FiniteNumber, input));
+        } else {
+            Ok(float.into_py(py))
         }
-        Ok(float.into_py(py))
     }
 
     fn different_strict_behavior(
@@ -113,7 +115,8 @@ impl Validator for ConstrainedFloatValidator {
         _definitions: &'data Definitions<CombinedValidator>,
         _recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
-        let float = input.validate_float(extra.strict.unwrap_or(self.strict), extra.ultra_strict)?;
+        let either_float = input.validate_float(extra.strict.unwrap_or(self.strict), extra.ultra_strict)?;
+        let float: f64 = either_float.try_into()?;
         if !self.allow_inf_nan && !float.is_finite() {
             return Err(ValError::new(ErrorType::FiniteNumber, input));
         }

tests/test_errors.py

@@ -232,7 +232,7 @@ def f(input_value, info):
     ('less_than', 'Input should be less than 42.1', {'lt': 42.1}),
     ('less_than_equal', 'Input should be less than or equal to 42.1', {'le': 42.1}),
     ('float_type', 'Input should be a valid number', None),
-    ('float_parsing', 'Input should be a valid number, unable to parse string as an number', None),
+    ('float_parsing', 'Input should be a valid number, unable to parse string as a number', None),
     ('bytes_type', 'Input should be a valid bytes', None),
     ('bytes_too_short', 'Data should have at least 42 bytes', {'min_length': 42}),
     ('bytes_too_long', 'Data should have at most 42 bytes', {'max_length': 42}),

tests/test_json.py

@@ -90,7 +90,7 @@ def test_int(input_value, expected):
         ('"123.4"', 123.4),
         ('"123.0"', 123.0),
         ('"123"', 123.0),
-        ('"string"', Err('Input should be a valid number, unable to parse string as an number [type=float_parsing,')),
+        ('"string"', Err('Input should be a valid number, unable to parse string as a number [type=float_parsing,')),
     ],
 )
 def test_float(input_value, expected):

tests/test_misc.py

@@ -126,7 +126,7 @@ class MyModel:
         {
             'type': 'float_parsing',
             'loc': ('x',),
-            'msg': 'Input should be a valid number, unable to parse string as an number',
+            'msg': 'Input should be a valid number, unable to parse string as a number',
             'input': 'x' * 60,
         },
         {
@@ -139,7 +139,7 @@ class MyModel:
     assert repr(exc_info.value) == (
         '2 validation errors for MyModel\n'
         'x\n'
-        '  Input should be a valid number, unable to parse string as an number '
+        '  Input should be a valid number, unable to parse string as a number '
         "[type=float_parsing, input_value='xxxxxxxxxxxxxxxxxxxxxxxx...xxxxxxxxxxxxxxxxxxxxxxx', input_type=str]\n"
         f'    For further information visit https://errors.pydantic.dev/{__version__}/v/float_parsing\n'
         'y\n'

tests/validators/test_float.py

@@ -10,6 +10,8 @@
 
 from ..conftest import Err, PyAndJson, plain_repr
 
+f64_max = 1.7976931348623157e308
+
 
 @pytest.mark.parametrize(
     'input_value,expected',
@@ -24,7 +26,7 @@
         (1e10, 1e10),
         (True, 1),
         (False, 0),
-        ('wrong', Err('Input should be a valid number, unable to parse string as an number [type=float_parsing')),
+        ('wrong', Err('Input should be a valid number, unable to parse string as a number [type=float_parsing')),
         ([1, 2], Err('Input should be a valid number [type=float_type, input_value=[1, 2], input_type=list]')),
     ],
 )
@@ -161,7 +163,7 @@ def test_union_float_simple(py_and_json: PyAndJson):
         {
             'type': 'float_parsing',
             'loc': ('float',),
-            'msg': 'Input should be a valid number, unable to parse string as an number',
+            'msg': 'Input should be a valid number, unable to parse string as a number',
             'input': 'xxx',
         },
         {
@@ -251,15 +253,15 @@ def test_float_key(py_and_json: PyAndJson):
             'pika',
             True,
             Err(
-                'Input should be a valid number, unable to parse string as an number '
+                'Input should be a valid number, unable to parse string as a number '
                 "[type=float_parsing, input_value='pika', input_type=str]"
             ),
         ),
         (
             'pika',
             False,
             Err(
-                'Input should be a valid number, unable to parse string as an number '
+                'Input should be a valid number, unable to parse string as a number '
                 "[type=float_parsing, input_value='pika', input_type=str]"
             ),
         ),