WIP: add fraction decimal

Author: CloseChoice

python/pydantic_core/core_schema.py

@@ -10,6 +10,7 @@
 from collections.abc import Hashable, Mapping
 from datetime import date, datetime, time, timedelta
 from decimal import Decimal
+from fractions import Fraction
 from re import Pattern
 from typing import TYPE_CHECKING, Any, Callable, Literal, Union
 
@@ -809,23 +810,30 @@ def decimal_schema(
         serialization=serialization,
     )
 
+class FractionSchema(TypedDict, total=False):
+    type: Required[Literal['decimal']]
+    le: Decimal
+    ge: Decimal
+    lt: Decimal
+    gt: Decimal
+    strict: bool
+    ref: str
+    metadata: dict[str, Any]
+    serialization: SerSchema
+
 def fraction_schema(
     *,
-    allow_inf_nan: bool | None = None,
-    multiple_of: Fraction | None = None,
     le: Fraction | None = None,
     ge: Fraction | None = None,
     lt: Fraction | None = None,
     gt: Fraction | None = None,
-    max_digits: int | None = None,
-    decimal_places: int | None = None,
     strict: bool | None = None,
     ref: str | None = None,
     metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> FractionSchema:
     """
-    Returns a schema that matches a decimal value, e.g.:
+    Returns a schema that matches a fraction value, e.g.:
 
     ```py
     from fractions import Fraction
@@ -837,14 +845,10 @@ def fraction_schema(
     ```
 
     Args:
-        allow_inf_nan: Whether to allow inf and nan values
-        multiple_of: The value must be a multiple of this number
         le: The value must be less than or equal to this number
         ge: The value must be greater than or equal to this number
         lt: The value must be strictly less than this number
         gt: The value must be strictly greater than this number
-        max_digits: The maximum number of decimal digits allowed
-        decimal_places: The maximum number of decimal places allowed
         strict: Whether the value should be a float or a value that can be converted to a float
         ref: optional unique identifier of the schema, used to reference the schema in other places
         metadata: Any other information you want to include with the schema, not used by pydantic-core
@@ -856,10 +860,6 @@ def fraction_schema(
         ge=ge,
         lt=lt,
         le=le,
-        max_digits=max_digits,
-        decimal_places=decimal_places,
-        multiple_of=multiple_of,
-        allow_inf_nan=allow_inf_nan,
         strict=strict,
         ref=ref,
         metadata=metadata,

src/errors/types.rs

@@ -430,6 +430,9 @@ error_types! {
     DecimalWholeDigits {
         whole_digits: {ctx_type: u64, ctx_fn: field_from_context},
     },
+    // Fraction errors
+    FractionType {},
+    FractionParsing {},
     // Complex errors
     ComplexType {},
     ComplexStrParsing {},
@@ -579,6 +582,8 @@ impl ErrorType {
             Self::DecimalMaxDigits {..} => "Decimal input should have no more than {max_digits} digit{expected_plural} in total",
             Self::DecimalMaxPlaces {..} => "Decimal input should have no more than {decimal_places} decimal place{expected_plural}",
             Self::DecimalWholeDigits {..} => "Decimal input should have no more than {whole_digits} digit{expected_plural} before the decimal point",
+            Self::FractionParsing {..} => "Fraction input should be an integer, float, string or Fraction object",
+            Self::FractionType {..} => "Fraction input should be an integer, float, string or Fraction object",
             Self::ComplexType {..} => "Input should be a valid python complex object, a number, or a valid complex string following the rules at https://docs.python.org/3/library/functions.html#complex",
             Self::ComplexStrParsing {..} => "Input should be a valid complex string following the rules at https://docs.python.org/3/library/functions.html#complex",
         }

src/input/input_abstract.rs

@@ -115,6 +115,8 @@ pub trait Input<'py>: fmt::Debug {
 
     fn validate_decimal(&self, strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>>;
 
+    fn validate_fraction(&self, strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>>;
+
     type Dict<'a>: ValidatedDict<'py>
     where
         Self: 'a;

src/input/input_json.rs

@@ -12,6 +12,7 @@ use crate::input::return_enums::EitherComplex;
 use crate::lookup_key::{LookupKey, LookupPath};
 use crate::validators::complex::string_to_complex;
 use crate::validators::decimal::create_decimal;
+use crate::validators::fraction::create_fraction;
 use crate::validators::{TemporalUnitMode, ValBytesMode};
 
 use super::datetime::{
@@ -199,6 +200,15 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
         }
     }
 
+    fn validate_fraction(&self, _strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
+        match self {
+            JsonValue::Str(..) | JsonValue::Int(..) | JsonValue::BigInt(..) => {
+                create_fraction(&self.into_pyobject(py)?, self).map(ValidationMatch::strict)
+            }
+            _ => Err(ValError::new(ErrorTypeDefaults::DecimalType, self)),
+        }
+    }
+
     type Dict<'a>
         = &'a JsonObject<'data>
     where
@@ -454,6 +464,10 @@ impl<'py> Input<'py> for str {
         create_decimal(self.into_pyobject(py)?.as_any(), self).map(ValidationMatch::lax)
     }
 
+    fn validate_fraction(&self, _strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
+        create_fraction(self.into_pyobject(py)?.as_any(), self).map(ValidationMatch::lax)
+    }
+
     type Dict<'a> = Never;
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]

src/input/input_python.rs

@@ -18,6 +18,7 @@ use crate::errors::{ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError,
 use crate::tools::{extract_i64, safe_repr};
 use crate::validators::complex::string_to_complex;
 use crate::validators::decimal::{create_decimal, get_decimal_type};
+use crate::validators::fraction::{create_fraction, get_fraction_type};
 use crate::validators::Exactness;
 use crate::validators::TemporalUnitMode;
 use crate::validators::ValBytesMode;
@@ -50,18 +51,6 @@ use super::{
 
 static FRACTION_TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
 
-pub fn get_fraction_type(py: Python<'_>) -> &Bound<'_, PyType> {
-    FRACTION_TYPE
-        .get_or_init(py, || {
-            py.import("fractions")
-                .and_then(|fractions_module| fractions_module.getattr("Fraction"))
-                .unwrap()
-                .extract()
-                .unwrap()
-        })
-        .bind(py)
-}
-
 pub(crate) fn downcast_python_input<'py, T: PyTypeCheck>(input: &(impl Input<'py> + ?Sized)) -> Option<&Bound<'py, T>> {
     input.as_python().and_then(|any| any.downcast::<T>().ok())
 }
@@ -70,6 +59,7 @@ pub(crate) fn input_as_python_instance<'a, 'py>(
     input: &'a (impl Input<'py> + ?Sized),
     class: &Bound<'py, PyType>,
 ) -> Option<&'a Bound<'py, PyAny>> {
+    println!("input_as_python_instance: class={:?}", class);
     input.as_python().filter(|any| any.is_instance(class).unwrap_or(false))
 }
 
@@ -168,6 +158,7 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         strict: bool,
         coerce_numbers_to_str: bool,
     ) -> ValResult<ValidationMatch<EitherString<'_, 'py>>> {
+        println!("[RUST]: Call validate_str with {:?}, and strict {:?}", self, strict);
         if let Ok(py_str) = self.downcast_exact::<PyString>() {
             return Ok(ValidationMatch::exact(py_str.clone().into()));
         } else if let Ok(py_str) = self.downcast::<PyString>() {
@@ -284,13 +275,14 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
 
         'lax: {
             if !strict {
+                println!("[RUST]: validate_int lax path for {:?}", self);
                 return if let Some(s) = maybe_as_string(self, ErrorTypeDefaults::IntParsing)? {
                     str_as_int(self, s)
                 } else if self.is_exact_instance_of::<PyFloat>() {
                     float_as_int(self, self.extract::<f64>()?)
                 } else if let Ok(decimal) = self.validate_decimal(true, self.py()) {
                     decimal_as_int(self, &decimal.into_inner())
-                } else if self.is_instance(get_fraction_type(self.py()))? {
+                } else if let Ok(fraction) = self.validate_fraction(true, self.py()) {
                     fraction_as_int(self)
                 } else if let Ok(float) = self.extract::<f64>() {
                     float_as_int(self, float)
@@ -349,7 +341,49 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         Err(ValError::new(ErrorTypeDefaults::FloatType, self))
     }
 
+    fn validate_fraction(&self, strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
+        println!("[RUST]: Call validate_fraction with {:?}, and strict {:?}", self, strict);
+        let fraction_type = get_fraction_type(py);
+
+        // Fast path for existing decimal objects
+        if self.is_exact_instance(fraction_type) {
+            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);
+        }
+
+        let error_type = if strict {
+            ErrorType::IsInstanceOf {
+                class: fraction_type
+                    .qualname()
+                    .and_then(|name| name.extract())
+                    .unwrap_or_else(|_| "Decimal".to_owned()),
+                context: None,
+            }
+        } else {
+            ErrorTypeDefaults::FractionType
+        };
+
+        Err(ValError::new(error_type, self))
+    }
+
     fn validate_decimal(&self, strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
+        println!("[RUST]: Call validate_decimal with {:?}, and strict {:?}", self, strict);
         let decimal_type = get_decimal_type(py);
 
         // Fast path for existing decimal objects

src/input/input_string.rs

@@ -9,6 +9,7 @@ use crate::lookup_key::{LookupKey, LookupPath};
 use crate::tools::safe_repr;
 use crate::validators::complex::string_to_complex;
 use crate::validators::decimal::create_decimal;
+use crate::validators::fraction::create_fraction;
 use crate::validators::{TemporalUnitMode, ValBytesMode};
 
 use super::datetime::{
@@ -154,6 +155,13 @@ impl<'py> Input<'py> for StringMapping<'py> {
         }
     }
 
+    fn validate_fraction(&self, _strict: bool, _py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
+        match self {
+            Self::String(s) => create_fraction(s, self).map(ValidationMatch::strict),
+            Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::DecimalType, self)),
+        }
+    }
+
     type Dict<'a>
         = StringMappingDict<'py>
     where