WIP: fix linting errors and added test_fraction.py

Author: CloseChoice

src/input/input_python.rs

@@ -280,7 +280,7 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
                 } else if let Ok(decimal) = self.validate_decimal(true, self.py()) {
                     decimal_as_int(self, &decimal.into_inner())
                 } else if let Ok(fraction) = self.validate_fraction(true, self.py()) {
-                    fraction_as_int(self)
+                    fraction_as_int(self, &fraction.into_inner())
                 } else if let Ok(float) = self.extract::<f64>() {
                     float_as_int(self, float)
                 } else if let Some(enum_val) = maybe_as_enum(self) {

src/input/shared.rs

@@ -228,22 +228,18 @@ pub fn decimal_as_int<'py>(
     Ok(EitherInt::Py(numerator))
 }
 
-pub fn fraction_as_int<'py>(input: &Bound<'py, PyAny>) -> ValResult<EitherInt<'py>> {
-    #[cfg(Py_3_12)]
-    let is_integer = input.call_method0("is_integer")?.extract::<bool>()?;
-    #[cfg(not(Py_3_12))]
-    let is_integer = input.getattr("denominator")?.extract::<i64>().map_or(false, |d| d == 1);
-
-    if is_integer {
-        #[cfg(Py_3_11)]
-        let as_int = input.call_method0("__int__");
-        #[cfg(not(Py_3_11))]
-        let as_int = input.call_method0("__trunc__");
-        match as_int {
-            Ok(i) => Ok(EitherInt::Py(i.as_any().to_owned())),
-            Err(_) => Err(ValError::new(ErrorTypeDefaults::IntType, input)),
-        }
-    } else {
-        Err(ValError::new(ErrorTypeDefaults::IntFromFloat, input))
+pub fn fraction_as_int<'py>(
+    input: &(impl Input<'py> + ?Sized),
+    fraction: &Bound<'py, PyAny>,
+    ) -> ValResult<EitherInt<'py>> {
+    let py = fraction.py();
+
+    let (numerator, denominator) = fraction
+        .call_method0(intern!(py, "as_integer_ratio"))?
+        .extract::<(Bound<'_, PyAny>, Bound<'_, PyAny>)>()?;
+    if denominator.extract::<i64>().map_or(true, |d| d != 1) {
+        return Err(ValError::new(ErrorTypeDefaults::IntFromFloat, input));
     }
+    Ok(EitherInt::Py(numerator))
+
 }

src/validators/fraction.rs

@@ -6,13 +6,11 @@ use pyo3::sync::PyOnceLock;
 use pyo3::types::{PyDict, PyString, PyType};
 use pyo3::{prelude::*, PyTypeInfo};
 
-use crate::build_tools::{is_strict, schema_or_config_same};
-use crate::errors::ErrorType;
+use crate::build_tools::is_strict;
 use crate::errors::ValResult;
-use crate::errors::{ErrorTypeDefaults, Number};
+use crate::errors::ErrorTypeDefaults;
 use crate::errors::{ToErrorValue, ValError};
 use crate::input::Input;
-use crate::tools::SchemaDict;
 
 use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
@@ -64,8 +62,6 @@ impl BuildValidator for FractionValidator {
     ) -> PyResult<Arc<CombinedValidator>> {
         let py = schema.py();
 
-        let allow_inf_nan = schema_or_config_same(schema, config, intern!(py, "allow_inf_nan"))?.unwrap_or(false);
-
         Ok(CombinedValidator::Fraction(Self {
             strict: is_strict(schema, config)?,
             le: validate_as_fraction(py, schema, intern!(py, "le"))?,

tests/serializers/test_fraction.py

@@ -0,0 +1,47 @@
+from fractions import Fraction
+
+import pytest
+
+from pydantic_core import SchemaSerializer, core_schema
+
+
+def test_fraction():
+    v = SchemaSerializer(core_schema.fraction_schema())
+    assert v.to_python(Fraction('3 / 4')) == Fraction(3, 4)
+    assert v.to_python(Fraction(3, 4)) == Fraction(3, 4)
+
+    # check correct casting to int when denominator is 1
+    assert v.to_python(Fraction(10, 10), mode='json') == '1'
+    assert v.to_python(Fraction(1, 10), mode='json') == '1/10'
+
+    assert v.to_json(Fraction(3, 4)) == b'"3/4"'
+
+
+def test_fraction_key():
+    v = SchemaSerializer(core_schema.dict_schema(core_schema.fraction_schema(), core_schema.fraction_schema()))
+    assert v.to_python({Fraction(3, 4): Fraction(1, 10)}) == {Fraction(3, 4): Fraction(1, 10)}
+    assert v.to_python({Fraction(3, 4): Fraction(1, 10)}, mode='json') == {'3/4': '1/10'}
+    assert v.to_json({Fraction(3, 4): Fraction(1, 10)}) == b'{"3/4":"1/10"}'
+
+
+@pytest.mark.parametrize(
+    'value,expected',
+    [
+        (Fraction(3, 4), '3/4'),
+        (Fraction(1, 10), '1/10'),
+        (Fraction(10, 1), '10'),
+        (Fraction(-5, 2), '-5/2'),
+    ],
+)
+def test_fraction_json(value, expected):
+    v = SchemaSerializer(core_schema.fraction_schema())
+    assert v.to_python(value, mode='json') == expected
+    assert v.to_json(value).decode() == f'"{expected}"'
+
+
+def test_any_fraction_key():
+    v = SchemaSerializer(core_schema.dict_schema())
+    input_value = {Fraction(3, 4): 1}
+
+    assert v.to_python(input_value, mode='json') == {'3/4': 1}
+    assert v.to_json(input_value) == b'{"3/4":1}'