WIP: add fraction

CloseChoice · CloseChoice · commit b46fd16f5719 · 2025-10-07T18:05:34.000+02:00
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
@@ -809,6 +809,62 @@ def decimal_schema(
         serialization=serialization,
     )
 
+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.:
+
+    ```py
+    from fractions import Fraction
+    from pydantic_core import SchemaValidator, core_schema
+
+    schema = core_schema.fraction_schema(le=0.8, ge=0.2)
+    v = SchemaValidator(schema)
+    assert v.validate_python(1, 2) == Fraction(1, 2)
+    ```
+
+    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
+        serialization: Custom serialization schema
+    """
+    return _dict_not_none(
+        type='fraction',
+        gt=gt,
+        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,
+        serialization=serialization,
+    )
 
 class ComplexSchema(TypedDict, total=False):
     type: Required[Literal['complex']]
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
@@ -136,7 +136,16 @@ pub(crate) fn infer_to_python_known(
                 }
                 v.into_py_any(py)?
             }
-            ObType::Decimal => value.to_string().into_py_any(py)?,
+            ObType::Decimal => {
+                // todo: delete before PR ready
+                println!("[RUST] infer_to_python_known - SerMode::Json - serializing ObType::Decimal");
+                value.to_string().into_py_any(py)?
+            },
+            ObType::Fraction => {
+                // todo: delete before PR ready
+                println!("[RUST] infer_to_python_known - SerMode::Json - serializing ObType::Fraction");
+                value.to_string().into_py_any(py)?
+            },
             ObType::StrSubclass => PyString::new(py, value.downcast::<PyString>()?.to_str()?).into(),
             ObType::Bytes => extra
                 .config
@@ -430,7 +439,16 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
             let v = value.extract::<f64>().map_err(py_err_se_err)?;
             type_serializers::float::serialize_f64(v, serializer, extra.config.inf_nan_mode)
         }
-        ObType::Decimal => value.to_string().serialize(serializer),
+        ObType::Decimal => {
+            // todo: delete before PR ready
+            println!("[RUST] infer_serialize_known - serializing ObType::Decimal");
+            value.to_string().serialize(serializer)
+        },
+        ObType::Fraction => {
+            // todo: delete before PR ready
+            println!("[RUST] infer_serialize_known - serializing ObType::Fraction");
+            value.to_string().serialize(serializer)
+        },
         ObType::Str | ObType::StrSubclass => {
             let py_str = value.downcast::<PyString>().map_err(py_err_se_err)?;
             super::type_serializers::string::serialize_py_str(py_str, serializer)
@@ -612,7 +630,16 @@ pub(crate) fn infer_json_key_known<'a>(
                 super::type_serializers::simple::to_str_json_key(key)
             }
         }
-        ObType::Decimal => Ok(Cow::Owned(key.to_string())),
+        ObType::Decimal => {
+            // todo: delete before PR ready
+            println!("[RUST] infer_json_key_known - converting ObType::Decimal to json key");
+            Ok(Cow::Owned(key.to_string()))
+        },
+        ObType::Fraction => {
+            // todo: delete before PR ready
+            println!("[RUST] infer_json_key_known - converting ObType::Fraction to json key");
+            Ok(Cow::Owned(key.to_string()))
+        },
         ObType::Bool => super::type_serializers::simple::bool_json_key(key),
         ObType::Str | ObType::StrSubclass => key.downcast::<PyString>()?.to_cow(),
         ObType::Bytes => extra
diff --git a/src/serializers/ob_type.rs b/src/serializers/ob_type.rs
@@ -23,6 +23,7 @@ pub struct ObTypeLookup {
     dict: usize,
     // other numeric types
     decimal_object: Py<PyAny>,
+    fraction_object: Py<PyAny>,
     // other string types
     bytes: usize,
     bytearray: usize,
@@ -62,14 +63,25 @@ pub enum IsType {
 
 impl ObTypeLookup {
     fn new(py: Python) -> Self {
+        // todo: delete before PR ready
+        println!("[RUST] ObTypeLookup::new");
         Self {
             none: PyNone::type_object_raw(py) as usize,
             int: PyInt::type_object_raw(py) as usize,
             bool: PyBool::type_object_raw(py) as usize,
             float: PyFloat::type_object_raw(py) as usize,
             list: PyList::type_object_raw(py) as usize,
             dict: PyDict::type_object_raw(py) as usize,
-            decimal_object: py.import("decimal").unwrap().getattr("Decimal").unwrap().unbind(),
+            decimal_object: {
+                // todo: delete before PR ready
+                println!("[RUST] ObTypeLookup::new - loading decimal_object");
+                py.import("decimal").unwrap().getattr("Decimal").unwrap().unbind()
+            },
+            fraction_object: {
+                // todo: delete before PR ready
+                println!("[RUST] ObTypeLookup::new - loading fraction_object");
+                py.import("fractions").unwrap().getattr("Fraction").unwrap().unbind()
+            },
             string: PyString::type_object_raw(py) as usize,
             bytes: PyBytes::type_object_raw(py) as usize,
             bytearray: PyByteArray::type_object_raw(py) as usize,
@@ -96,6 +108,7 @@ impl ObTypeLookup {
     }
 
     pub fn is_type(&self, value: &Bound<'_, PyAny>, expected_ob_type: ObType) -> IsType {
+        println!("[RUST] is_type - expected_ob_type: {expected_ob_type}");
         match self.ob_type_is_expected(Some(value), &value.get_type(), &expected_ob_type) {
             IsType::False => {
                 if expected_ob_type == self.fallback_isinstance(value) {
@@ -116,6 +129,7 @@ impl ObTypeLookup {
     ) -> IsType {
         let type_ptr = py_type.as_ptr();
         let ob_type = type_ptr as usize;
+        println!("[RUST] ob_type_is_expected - ob_type: {ob_type}, expected_ob_type: {expected_ob_type}");
         let ans = match expected_ob_type {
             ObType::None => self.none == ob_type,
             ObType::Int => self.int == ob_type,
@@ -137,7 +151,16 @@ impl ObTypeLookup {
             ObType::Str => self.string == ob_type,
             ObType::List => self.list == ob_type,
             ObType::Dict => self.dict == ob_type,
-            ObType::Decimal => self.decimal_object.as_ptr() as usize == ob_type,
+            ObType::Decimal => {
+                // todo: delete before PR ready
+                println!("[RUST] ob_type_is_expected - checking ObType::Decimal");
+                self.decimal_object.as_ptr() as usize == ob_type
+            },
+            ObType::Fraction => {
+                // todo: delete before PR ready
+                println!("[RUST] ob_type_is_expected - checking ObType::Fraction");
+                self.fraction_object.as_ptr() as usize == ob_type
+            },
             ObType::StrSubclass => self.string == ob_type && op_value.is_none(),
             ObType::Tuple => self.tuple == ob_type,
             ObType::Set => self.set == ob_type,
@@ -214,7 +237,13 @@ impl ObTypeLookup {
         } else if ob_type == self.dict {
             ObType::Dict
         } else if ob_type == self.decimal_object.as_ptr() as usize {
+            // todo: delete before PR ready
+            println!("[RUST] lookup_by_ob_type - found ObType::Decimal");
             ObType::Decimal
+        } else if ob_type == self.fraction_object.as_ptr() as usize {
+            // todo: delete before PR ready
+            println!("[RUST] lookup_by_ob_type - found ObType::Fraction");
+            ObType::Fraction
         } else if ob_type == self.bytes {
             ObType::Bytes
         } else if ob_type == self.tuple {
@@ -322,7 +351,13 @@ impl ObTypeLookup {
         } else if value.is_instance_of::<PyMultiHostUrl>() {
             ObType::MultiHostUrl
         } else if value.is_instance(self.decimal_object.bind(py)).unwrap_or(false) {
+            // todo: delete before PR ready
+            println!("[RUST] fallback_isinstance - found ObType::Decimal");
             ObType::Decimal
+        } else if value.is_instance(self.fraction_object.bind(py)).unwrap_or(false) {
+            // todo: delete before PR ready
+            println!("[RUST] fallback_isinstance - found ObType::Fraction");
+            ObType::Fraction
         } else if value.is_instance(self.uuid_object.bind(py)).unwrap_or(false) {
             ObType::Uuid
         } else if value.is_instance(self.enum_object.bind(py)).unwrap_or(false) {
@@ -380,6 +415,7 @@ pub enum ObType {
     Float,
     FloatSubclass,
     Decimal,
+    Fraction,
     // string types
     Str,
     StrSubclass,
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
@@ -118,6 +118,7 @@ combined_serializer! {
         Bool: super::type_serializers::simple::BoolSerializer;
         Float: super::type_serializers::float::FloatSerializer;
         Decimal: super::type_serializers::decimal::DecimalSerializer;
+        Fraction: super::type_serializers::fraction::FractionSerializer;
         Str: super::type_serializers::string::StrSerializer;
         Bytes: super::type_serializers::bytes::BytesSerializer;
         Datetime: super::type_serializers::datetime_etc::DatetimeSerializer;
@@ -321,6 +322,7 @@ impl PyGcTraverse for CombinedSerializer {
             CombinedSerializer::Bool(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Float(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Decimal(inner) => inner.py_gc_traverse(visit),
+            CombinedSerializer::Fraction(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Str(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Bytes(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Datetime(inner) => inner.py_gc_traverse(visit),
diff --git a/src/serializers/type_serializers/fraction.rs b/src/serializers/type_serializers/fraction.rs
@@ -0,0 +1,86 @@
+use std::borrow::Cow;
+use std::sync::Arc;
+
+use pyo3::prelude::*;
+use pyo3::types::PyDict;
+
+use crate::build_tools::LazyLock;
+use crate::definitions::DefinitionsBuilder;
+use crate::serializers::infer::{infer_json_key_known, infer_serialize_known, infer_to_python_known};
+use crate::serializers::ob_type::{IsType, ObType};
+
+use super::{
+    infer_json_key, infer_serialize, infer_to_python, BuildSerializer, CombinedSerializer, Extra, TypeSerializer,
+};
+
+#[derive(Debug)]
+pub struct FractionSerializer {}
+
+static FRACTION_SERIALIZER: LazyLock<Arc<CombinedSerializer>> = LazyLock::new(|| Arc::new(FractionSerializer {}.into()));
+
+impl BuildSerializer for FractionSerializer {
+    const EXPECTED_TYPE: &'static str = "decimal";
+
+    fn build(
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
+        _definitions: &mut DefinitionsBuilder<Arc<CombinedSerializer>>,
+    ) -> PyResult<Arc<CombinedSerializer>> {
+        Ok(FRACTION_SERIALIZER.clone())
+    }
+}
+
+impl_py_gc_traverse!(FractionSerializer {});
+
+impl TypeSerializer for FractionSerializer {
+    fn to_python(
+        &self,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
+        extra: &Extra,
+    ) -> PyResult<Py<PyAny>> {
+        let _py = value.py();
+        println!("[RUST] FractionSerializer to_python called");
+        match extra.ob_type_lookup.is_type(value, ObType::Fraction) {
+            IsType::Exact | IsType::Subclass => infer_to_python_known(ObType::Fraction, value, include, exclude, extra),
+            IsType::False => {
+                extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
+                infer_to_python(value, include, exclude, extra)
+            }
+        }
+    }
+
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
+        match extra.ob_type_lookup.is_type(key, ObType::Fraction) {
+            IsType::Exact | IsType::Subclass => infer_json_key_known(ObType::Fraction, key, extra),
+            IsType::False => {
+                extra.warnings.on_fallback_py(self.get_name(), key, extra)?;
+                infer_json_key(key, extra)
+            }
+        }
+    }
+
+    fn serde_serialize<S: serde::ser::Serializer>(
+        &self,
+        value: &Bound<'_, PyAny>,
+        serializer: S,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
+        extra: &Extra,
+    ) -> Result<S::Ok, S::Error> {
+        match extra.ob_type_lookup.is_type(value, ObType::Fraction) {
+            IsType::Exact | IsType::Subclass => {
+                infer_serialize_known(ObType::Fraction, value, serializer, include, exclude, extra)
+            }
+            IsType::False => {
+                extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
+                infer_serialize(value, serializer, include, exclude, extra)
+            }
+        }
+    }
+
+    fn get_name(&self) -> &str {
+        Self::EXPECTED_TYPE
+    }
+}
diff --git a/src/serializers/type_serializers/mod.rs b/src/serializers/type_serializers/mod.rs
@@ -4,6 +4,7 @@ pub mod complex;
 pub mod dataclass;
 pub mod datetime_etc;
 pub mod decimal;
+pub mod fraction;
 pub mod definitions;
 pub mod dict;
 pub mod enum_;
