feat(python): Support for decimal.Decimal type in both schemas and instances

Signed-off-by: Dmitry Dygalo <[email protected]>

Author: Stranger6667

crates/jsonschema-py/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## [Unreleased]
 
+### Added
+
+- Support for `decimal.Decimal` type in both schemas and instances. [#319](https://github.com/Stranger6667/jsonschema/issues/319)
+
 ### Performance
 
 - `jsonschema_rs.validate()` and `Validator.validate()` run 5–10% faster in some workloads thanks to slimmer `ValidationError` objects.

crates/jsonschema-py/python/jsonschema_rs/__init__.pyi

@@ -4,8 +4,8 @@ from typing import Any, Callable, List, Protocol, TypeAlias, TypeVar, TypedDict,
 
 _SchemaT = TypeVar("_SchemaT", bool, dict[str, Any])
 _FormatFunc = TypeVar("_FormatFunc", bound=Callable[[str], bool])
-JSONType: TypeAlias = dict[str, Any] | list | str | int | float | bool | None
-JSONPrimitive: TypeAlias = str | int | float | bool | None
+JSONType: TypeAlias = dict[str, Any] | list | str | int | float | Decimal | bool | None
+JSONPrimitive: TypeAlias = str | int | float | Decimal | bool | None
 
 class EvaluationAnnotation(TypedDict):
     schemaLocation: str

crates/jsonschema-py/src/ser.rs

@@ -36,6 +36,7 @@ pub enum ObjectType {
     Dict,
     Tuple,
     Enum,
+    Decimal,
     Unknown,
 }
 
@@ -203,6 +204,8 @@ pub fn get_object_type(object_type: *mut pyo3::ffi::PyTypeObject) -> ObjectType
         ObjectType::Float
     } else if object_type == unsafe { types::NONE_TYPE } {
         ObjectType::None
+    } else if object_type == unsafe { types::DECIMAL_TYPE } {
+        ObjectType::Decimal
     } else if is_dict_subclass(object_type) {
         ObjectType::Dict
     } else if object_type == unsafe { types::TUPLE_TYPE } {
@@ -448,6 +451,33 @@ impl Serialize for SerializePyObject {
                     sequence.end()
                 }
             }
+            ObjectType::Decimal => {
+                // Convert Decimal to string and parse as serde_json::Number
+                // With arbitrary_precision enabled, this preserves exact decimal precision
+                let str_obj = unsafe { pyo3::ffi::PyObject_Str(self.object) };
+                if str_obj.is_null() {
+                    return Err(ser::Error::custom("Failed to convert Decimal to string"));
+                }
+                let mut str_size: pyo3::ffi::Py_ssize_t = 0;
+                let ptr = unsafe { pyo3::ffi::PyUnicode_AsUTF8AndSize(str_obj, &raw mut str_size) };
+                if ptr.is_null() {
+                    unsafe { pyo3::ffi::Py_DecRef(str_obj) };
+                    return Err(ser::Error::custom("Failed to get UTF-8 representation"));
+                }
+                let slice = unsafe {
+                    std::str::from_utf8_unchecked(std::slice::from_raw_parts(
+                        ptr.cast::<u8>(),
+                        str_size as usize,
+                    ))
+                };
+                let result = if let Ok(num) = serde_json::Number::from_str(slice) {
+                    serializer.serialize_some(&num)
+                } else {
+                    Err(ser::Error::custom("Failed to parse Decimal as number"))
+                };
+                unsafe { pyo3::ffi::Py_DecRef(str_obj) };
+                result
+            }
             ObjectType::Enum => {
                 let value = unsafe { PyObject_GetAttr(self.object, types::VALUE_STR) };
                 #[allow(clippy::arithmetic_side_effects)]

crates/jsonschema-py/src/types.rs

@@ -20,6 +20,7 @@ pub static mut DICT_TYPE: *mut PyTypeObject = std::ptr::null_mut::<PyTypeObject>
 pub static mut TUPLE_TYPE: *mut PyTypeObject = std::ptr::null_mut::<PyTypeObject>();
 pub static mut ENUM_TYPE: *mut PyTypeObject = std::ptr::null_mut::<PyTypeObject>();
 pub static mut ENUM_BASE: *mut PyTypeObject = std::ptr::null_mut::<PyTypeObject>();
+pub static mut DECIMAL_TYPE: *mut PyTypeObject = std::ptr::null_mut::<PyTypeObject>();
 pub static mut VALUE_STR: *mut PyObject = std::ptr::null_mut::<PyObject>();
 
 static INIT: PyOnceLock<()> = PyOnceLock::new();
@@ -41,6 +42,18 @@ fn look_up_enum_types(py: Python<'_>) -> (*mut PyTypeObject, *mut PyTypeObject)
     (enum_meta.as_type_ptr(), enum_base.as_type_ptr())
 }
 
+fn look_up_decimal_type(py: Python<'_>) -> *mut PyTypeObject {
+    let module = py
+        .import("decimal")
+        .expect("failed to import the stdlib decimal module");
+    let decimal_type = module
+        .getattr("Decimal")
+        .expect("decimal.Decimal is missing")
+        .cast_into::<PyType>()
+        .expect("decimal.Decimal is not a type");
+    decimal_type.as_type_ptr()
+}
+
 /// Set empty type object pointers with their actual values.
 /// We need these Python-side type objects for direct comparison during conversion to serde types
 /// NOTE. This function should be called before any serialization logic
@@ -58,6 +71,7 @@ pub fn init(py: Python<'_>) {
         let (enum_meta, enum_base) = look_up_enum_types(py);
         ENUM_TYPE = enum_meta;
         ENUM_BASE = enum_base;
+        DECIMAL_TYPE = look_up_decimal_type(py);
         VALUE_STR = ffi::PyUnicode_InternFromString(c"value".as_ptr());
     });
 }

crates/jsonschema-py/tests-py/test_jsonschema.py

@@ -848,3 +848,25 @@ def test_float_precision_from_string_schema(instance, expected):
     # Schema values are no longer converted to f64, maintaining better precision
     validator = validator_for('{"multipleOf": 0.01}')
     assert validator.is_valid(instance) == expected
+
+
+@pytest.mark.parametrize(
+    "instance, expected",
+    [
+        (Decimal("10.5"), True),
+        (Decimal("5.5"), False),
+        (Decimal("99999999999999999999.123456789"), True),
+    ],
+)
+def test_decimal_support(instance, expected):
+    # Python's Decimal type should be supported, preserving precision
+    validator = validator_for({"type": "number", "minimum": 10})
+    assert validator.is_valid(instance) == expected
+
+
+def test_decimal_in_schema():
+    # Test that Decimal can be used in schema definitions too
+    validator = validator_for({"type": "number", "minimum": Decimal("10.5")})
+    assert validator.is_valid(11) is True
+    assert validator.is_valid(10) is False
+    assert validator.is_valid(Decimal("10.6")) is True