remove unnecessary code parts

Author: CloseChoice

src/input/input_python.rs

@@ -343,29 +343,16 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
             return Ok(ValidationMatch::exact(self.to_owned().clone()));
         }
 
-        if !strict {
-            if self.is_instance_of::<PyString>() || (self.is_instance_of::<PyInt>() && !self.is_instance_of::<PyBool>())
-            {
-                // Checking isinstance for str / int / bool is fast compared to decimal / float
-                return create_fraction(self, self).map(ValidationMatch::lax);
-            }
-
-            if self.is_instance_of::<PyFloat>() {
-                return create_fraction(self.str()?.as_any(), self).map(ValidationMatch::lax);
-            }
-        }
-
-        if self.is_instance(fraction_type)? {
-            // Upcast subclasses to decimal
-            return create_decimal(self, self).map(ValidationMatch::strict);
+        if !strict && self.is_instance_of::<PyString>() {
+            return create_fraction(self, self).map(ValidationMatch::lax);
         }
 
         let error_type = if strict {
             ErrorType::IsInstanceOf {
                 class: fraction_type
                     .qualname()
                     .and_then(|name| name.extract())
-                    .unwrap_or_else(|_| "Decimal".to_owned()),
+                    .unwrap_or_else(|_| "Fraction".to_owned()),
                 context: None,
             }
         } else {

src/input/shared.rs

@@ -234,6 +234,7 @@ pub fn fraction_as_int<'py>(
 ) -> ValResult<EitherInt<'py>> {
     let py = fraction.py();
 
+    // as_integer_ratio was added in Python 3.8, so this should be fine
     let (numerator, denominator) = fraction
         .call_method0(intern!(py, "as_integer_ratio"))?
         .extract::<(Bound<'_, PyAny>, Bound<'_, PyAny>)>()?;

src/serializers/ob_type.rs

@@ -63,7 +63,6 @@ pub enum IsType {
 
 impl ObTypeLookup {
     fn new(py: Python) -> Self {
-        // todo: delete before PR ready
         Self {
             none: PyNone::type_object_raw(py) as usize,
             int: PyInt::type_object_raw(py) as usize,

src/validators/fraction.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use pyo3::exceptions::{PyTypeError, PyValueError, PyZeroDivisionError};
+use pyo3::exceptions::{PyTypeError, PyValueError};
 use pyo3::intern;
 use pyo3::sync::PyOnceLock;
 use pyo3::types::{PyDict, PyString, PyType};
@@ -37,7 +37,7 @@ fn validate_as_fraction(
         Some(value) => match value.validate_fraction(false, py) {
             Ok(v) => Ok(Some(v.into_inner().unbind())),
             Err(_) => Err(PyValueError::new_err(format!(
-                "'{key}' must be coercible to a Decimal instance",
+                "'{key}' must be coercible to a Fraction instance",
             ))),
         },
         None => Ok(None),
@@ -147,13 +147,13 @@ impl Validator for FractionValidator {
 
 pub(crate) fn create_fraction<'py>(arg: &Bound<'py, PyAny>, input: impl ToErrorValue) -> ValResult<Bound<'py, PyAny>> {
     let py = arg.py();
-    get_fraction_type(py).call1((arg,)).map_err(|e| {
-        handle_fraction_new_error(input, e)
-    })
+    get_fraction_type(py)
+        .call1((arg,))
+        .map_err(|e| handle_fraction_new_error(input, e))
 }
 
 fn handle_fraction_new_error(input: impl ToErrorValue, error: PyErr) -> ValError {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         if error.matches(py, PyValueError::type_object(py)).unwrap_or(false) {
             ValError::new(ErrorTypeDefaults::FractionParsing, input)
         } else if error.matches(py, PyTypeError::type_object(py)).unwrap_or(false) {