optimize Python float validation (#826)

Author: davidhewitt

src/input/input_python.rs

@@ -316,21 +316,22 @@ impl<'a> Input<'a> for PyAny {
     fn ultra_strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
         if self.is_instance_of::<PyInt>() {
             Err(ValError::new(ErrorType::FloatType, self))
-        } else if self.is_instance_of::<PyFloat>() {
-            Ok(EitherFloat::Py(self))
+        } else if let Ok(float) = self.downcast::<PyFloat>() {
+            Ok(EitherFloat::Py(float))
         } else {
             Err(ValError::new(ErrorType::FloatType, self))
         }
     }
     fn strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
         if PyFloat::is_exact_type_of(self) {
-            Ok(EitherFloat::Py(self))
+            // Safety: self is PyFloat
+            Ok(EitherFloat::Py(unsafe { self.downcast_unchecked::<PyFloat>() }))
         } 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(EitherFloat::Py(self))
+                Ok(EitherFloat::F64(float))
             }
         } else {
             Err(ValError::new(ErrorType::FloatType, self))
@@ -339,7 +340,8 @@ impl<'a> Input<'a> for PyAny {
 
     fn lax_float(&'a self) -> ValResult<EitherFloat<'a>> {
         if PyFloat::is_exact_type_of(self) {
-            Ok(EitherFloat::Py(self))
+            // Safety: self is PyFloat
+            Ok(EitherFloat::Py(unsafe { self.downcast_unchecked::<PyFloat>() }))
         } else if let Some(cow_str) = maybe_as_string(self, ErrorType::FloatParsing)? {
             match cow_str.as_ref().parse::<f64>() {
                 Ok(i) => Ok(EitherFloat::F64(i)),

src/input/return_enums.rs

@@ -10,7 +10,8 @@ use pyo3::exceptions::PyTypeError;
 use pyo3::prelude::*;
 use pyo3::types::iter::PyDictIterator;
 use pyo3::types::{
-    PyByteArray, PyBytes, PyDict, PyFrozenSet, PyIterator, PyList, PyMapping, PySequence, PySet, PyString, PyTuple,
+    PyByteArray, PyBytes, PyDict, PyFloat, PyFrozenSet, PyIterator, PyList, PyMapping, PySequence, PySet, PyString,
+    PyTuple,
 };
 use pyo3::{ffi, intern, AsPyPointer, PyNativeType};
 
@@ -910,18 +911,23 @@ impl<'a> IntoPy<PyObject> for EitherInt<'a> {
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
+#[derive(Copy, Clone)]
 pub enum EitherFloat<'a> {
     F64(f64),
-    Py(&'a PyAny),
+    Py(&'a PyFloat),
 }
 
-impl<'a> TryInto<f64> for EitherFloat<'a> {
-    type Error = ValError<'a>;
-
-    fn try_into(self) -> ValResult<'a, f64> {
+impl<'a> EitherFloat<'a> {
+    pub fn as_f64(self) -> f64 {
         match self {
-            EitherFloat::F64(f) => Ok(f),
-            EitherFloat::Py(i) => i.extract().map_err(|_| ValError::new(ErrorType::FloatParsing, i)),
+            EitherFloat::F64(f) => f,
+
+            EitherFloat::Py(f) => {
+                {
+                    // Safety: known to be a python float
+                    unsafe { ffi::PyFloat_AS_DOUBLE(f.as_ptr()) }
+                }
+            }
         }
     }
 }

src/validators/float.rs

@@ -72,11 +72,10 @@ impl Validator for FloatValidator {
         _recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
         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() {
+        if !self.allow_inf_nan && !either_float.as_f64().is_finite() {
             return Err(ValError::new(ErrorType::FiniteNumber, input));
         }
-        Ok(float.into_py(py))
+        Ok(either_float.into_py(py))
     }
 
     fn different_strict_behavior(
@@ -119,7 +118,7 @@ impl Validator for ConstrainedFloatValidator {
         _recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
         let either_float = input.validate_float(extra.strict.unwrap_or(self.strict), extra.ultra_strict)?;
-        let float: f64 = either_float.try_into()?;
+        let float: f64 = either_float.as_f64();
         if !self.allow_inf_nan && !float.is_finite() {
             return Err(ValError::new(ErrorType::FiniteNumber, input));
         }
@@ -155,7 +154,7 @@ impl Validator for ConstrainedFloatValidator {
                 return Err(ValError::new(ErrorType::GreaterThan { gt: gt.into() }, input));
             }
         }
-        Ok(float.into_py(py))
+        Ok(either_float.into_py(py))
     }
 
     fn different_strict_behavior(