feat: Support serde_json's arbitrary_precision feature

Author: jpmckinney

Cargo.toml

@@ -13,6 +13,7 @@ documentation = "https://docs.rs/crate/pythonize/"
 
 [dependencies]
 serde = { version = "1.0", default-features = false, features = ["std"] }
+serde_json = { version = "1.0", optional = true }
 pyo3 = { version = "0.27", default-features = false }
 
 [dev-dependencies]
@@ -22,3 +23,6 @@ serde_json = "1.0"
 serde_bytes = "0.11"
 maplit = "1.0.2"
 serde_path_to_error = "0.1.15"
+
+[features]
+arbitrary_precision = ["serde_json", "serde_json/arbitrary_precision"]

src/ser.rs

@@ -4,6 +4,8 @@ use pyo3::types::{
     PyDict, PyDictMethods, PyList, PyListMethods, PyMapping, PySequence, PyString, PyTuple,
     PyTupleMethods,
 };
+#[cfg(feature = "arbitrary_precision")]
+use pyo3::types::{PyAnyMethods, PyFloat, PyInt};
 use pyo3::{Bound, BoundObject, IntoPyObject, PyAny, PyResult, Python};
 use serde::{ser, Serialize};
 
@@ -229,6 +231,21 @@ pub struct PythonStructVariantSerializer<'py, P: PythonizeTypes> {
     inner: PythonStructDictSerializer<'py, P>,
 }
 
+#[cfg(feature = "arbitrary_precision")]
+#[doc(hidden)]
+pub enum StructSerializer<'py, P: PythonizeTypes> {
+    Struct(PythonStructDictSerializer<'py, P>),
+    Number {
+        py: Python<'py>,
+        number_string: Option<String>,
+        _types: PhantomData<P>,
+    },
+}
+
+#[cfg(not(feature = "arbitrary_precision"))]
+#[doc(hidden)]
+pub type StructSerializer<'py, P> = PythonStructDictSerializer<'py, P>;
+
 #[doc(hidden)]
 pub struct PythonStructDictSerializer<'py, P: PythonizeTypes> {
     py: Python<'py>,
@@ -266,7 +283,7 @@ impl<'py, P: PythonizeTypes> ser::Serializer for Pythonizer<'py, P> {
     type SerializeTupleStruct = PythonCollectionSerializer<'py, P>;
     type SerializeTupleVariant = PythonTupleVariantSerializer<'py, P>;
     type SerializeMap = PythonMapSerializer<'py, P>;
-    type SerializeStruct = PythonStructDictSerializer<'py, P>;
+    type SerializeStruct = StructSerializer<'py, P>;
     type SerializeStructVariant = PythonStructVariantSerializer<'py, P>;
 
     fn serialize_bool(self, v: bool) -> Result<Bound<'py, PyAny>> {
@@ -439,12 +456,34 @@ impl<'py, P: PythonizeTypes> ser::Serializer for Pythonizer<'py, P> {
         self,
         name: &'static str,
         len: usize,
-    ) -> Result<PythonStructDictSerializer<'py, P>> {
-        Ok(PythonStructDictSerializer {
-            py: self.py,
-            builder: P::NamedMap::builder(self.py, len, name)?,
-            _types: PhantomData,
-        })
+    ) -> Result<StructSerializer<'py, P>> {
+        #[cfg(feature = "arbitrary_precision")]
+        {
+            // With arbitrary_precision enabled, a serde_json::Number serializes as a "$serde_json::private::Number"
+            // struct with a "$serde_json::private::Number" field, whose value is the String in Number::n.
+            if name == "$serde_json::private::Number" && len == 1 {
+                return Ok(StructSerializer::Number {
+                    py: self.py,
+                    number_string: None,
+                    _types: PhantomData,
+                });
+            }
+
+            Ok(StructSerializer::Struct(PythonStructDictSerializer {
+                py: self.py,
+                builder: P::NamedMap::builder(self.py, len, name)?,
+                _types: PhantomData,
+            }))
+        }
+
+        #[cfg(not(feature = "arbitrary_precision"))]
+        {
+            Ok(PythonStructDictSerializer {
+                py: self.py,
+                builder: P::NamedMap::builder(self.py, len, name)?,
+                _types: PhantomData,
+            })
+        }
     }
 
     fn serialize_struct_variant(
@@ -569,6 +608,56 @@ impl<'py, P: PythonizeTypes> ser::SerializeMap for PythonMapSerializer<'py, P> {
     }
 }
 
+#[cfg(feature = "arbitrary_precision")]
+impl<'py, P: PythonizeTypes> ser::SerializeStruct for StructSerializer<'py, P> {
+    type Ok = Bound<'py, PyAny>;
+    type Error = PythonizeError;
+
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize,
+    {
+        match self {
+            StructSerializer::Struct(s) => s.serialize_field(key, value),
+            StructSerializer::Number { number_string, .. } => {
+                let serde_json::Value::String(s) = value
+                    .serialize(serde_json::value::Serializer)
+                    .map_err(|e| PythonizeError::msg(format!("Failed to serialize number: {}", e)))?
+                else {
+                    return Err(PythonizeError::msg("Expected string in serde_json::Number"));
+                };
+
+                *number_string = Some(s);
+                Ok(())
+            }
+        }
+    }
+
+    fn end(self) -> Result<Bound<'py, PyAny>> {
+        match self {
+            StructSerializer::Struct(s) => s.end(),
+            StructSerializer::Number {
+                py, number_string: Some(s), ..
+            } => {
+                if let Ok(i) = s.parse::<i64>() {
+                    return Ok(PyInt::new(py, i).into_any());
+                }
+                if let Ok(u) = s.parse::<u64>() {
+                    return Ok(PyInt::new(py, u).into_any());
+                }
+                if let Ok(f) = s.parse::<f64>() {
+                    return Ok(PyFloat::new(py, f).into_any());
+                }
+                // Fall back to Python's int() constructor, which supports arbitrary precision.
+                py.get_type::<PyInt>()
+                    .call1((s.as_str(),))
+                    .map_err(|e| PythonizeError::msg(format!("Invalid number: {}", e)))
+            }
+            StructSerializer::Number { .. } => Err(PythonizeError::msg("Empty serde_json::Number")),
+        }
+    }
+}
+
 impl<'py, P: PythonizeTypes> ser::SerializeStruct for PythonStructDictSerializer<'py, P> {
     type Ok = Bound<'py, PyAny>;
     type Error = PythonizeError;

tests/test_arbitrary_precision.rs

@@ -0,0 +1,61 @@
+#![cfg(feature = "arbitrary_precision")]
+
+use pyo3::prelude::*;
+use pythonize::pythonize;
+
+#[test]
+fn test_serde_json_number_with_arbitrary_precision() {
+    use serde_json::Value;
+
+    Python::attach(|py| {
+        // Parse JSON with arbitrary_precision feature
+        let json_str = r#"{"number": 12345678901234567890}"#;
+        let value: Value = serde_json::from_str(json_str).unwrap();
+
+        // Serialize to Python
+        let result = pythonize(py, &value).unwrap();
+
+        // Extract the number field
+        let number = result.get_item("number").unwrap();
+
+        // Should be a Python int, not a dict
+        assert!(number.is_instance_of::<pyo3::types::PyInt>());
+
+        // Should have the correct value
+        let number_str = number.str().unwrap().to_string();
+        assert_eq!(number_str, "12345678901234567890");
+    });
+}
+
+#[test]
+fn test_serde_json_float_with_arbitrary_precision() {
+    use serde_json::Value;
+
+    Python::attach(|py| {
+        let json_str = r#"{"number": 3.141592653589793238}"#;
+        let value: Value = serde_json::from_str(json_str).unwrap();
+
+        let result = pythonize(py, &value).unwrap();
+        let number = result.get_item("number").unwrap();
+
+        // Should be a Python float, not a dict
+        assert!(number.is_instance_of::<pyo3::types::PyFloat>());
+    });
+}
+
+#[test]
+fn test_serde_json_simple_number_with_arbitrary_precision() {
+    use serde_json::Value;
+
+    Python::attach(|py| {
+        let json_str = r#"2"#;
+        let value: Value = serde_json::from_str(json_str).unwrap();
+
+        let result = pythonize(py, &value).unwrap();
+
+        // Should be a Python int 2, not {'$serde_json::private::Number': '2'}
+        assert!(result.is_instance_of::<pyo3::types::PyInt>());
+        let num: i32 = result.extract().unwrap();
+        assert_eq!(num, 2);
+    });
+}