port the add OPT_DISALLOW_NAN PR too.

yilei · yilei · commit 9ed59ed3484f · 2026-02-06T16:18:21.000-08:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,6 +1,12 @@
 # Changelog
 
 
+## 3.11.7-post3
+
+### Added
+
+- `OPT_DISALLOW_NAN` option flag for `dumps()`. When set, raises `JSONEncodeError` if a float value is NaN, Infinity, or -Infinity. Default behavior (allowing NaN/Infinity) is unchanged.
+
 ## 3.11.7-post2
 
 ### Added
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "orjson"
-version = "3.11.7-post2"
+version = "3.11.7-post3"
 authors = ["ijl <ijl@mailbox.org>"]
 description = "Fast, correct Python JSON library supporting dataclasses, datetimes, and numpy"
 repository = "https://github.com/ijl/orjson"
diff --git a/pyproject.toml b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "orjson"
-version = "3.11.7-post2"
+version = "3.11.7-post3"
 repository = "https://github.com/ijl/orjson"
 description = "Fast, correct Python JSON library supporting dataclasses, datetimes, and numpy"
 requires-python = ">=3.10"
diff --git a/pysrc/orjson/__init__.py b/pysrc/orjson/__init__.py
@@ -12,6 +12,7 @@
     "JSONEncodeError",
     "loads",
     "OPT_APPEND_NEWLINE",
+    "OPT_DISALLOW_NAN",
     "OPT_INDENT_2",
     "OPT_NAIVE_UTC",
     "OPT_NON_STR_KEYS",
diff --git a/pysrc/orjson/__init__.pyi b/pysrc/orjson/__init__.pyi
@@ -21,6 +21,7 @@ class Fragment(tuple):
     contents: bytes | str
 
 OPT_APPEND_NEWLINE: int
+OPT_DISALLOW_NAN: int
 OPT_INDENT_2: int
 OPT_NAIVE_UTC: int
 OPT_NON_STR_KEYS: int
diff --git a/src/lib.rs b/src/lib.rs
@@ -149,6 +149,7 @@ pub(crate) unsafe extern "C" fn orjson_init_exec(mptr: *mut PyObject) -> c_int {
         add!(mptr, c"Fragment", typeref::FRAGMENT_TYPE.cast::<PyObject>());
 
         opt!(mptr, c"OPT_APPEND_NEWLINE", opt::APPEND_NEWLINE);
+        opt!(mptr, c"OPT_DISALLOW_NAN", opt::DISALLOW_NAN);
         opt!(mptr, c"OPT_INDENT_2", opt::INDENT_2);
         opt!(mptr, c"OPT_NAIVE_UTC", opt::NAIVE_UTC);
         opt!(mptr, c"OPT_NON_STR_KEYS", opt::NON_STR_KEYS);
diff --git a/src/opt.rs b/src/opt.rs
@@ -15,6 +15,7 @@ pub(crate) const PASSTHROUGH_SUBCLASS: Opt = 1 << 8;
 pub(crate) const PASSTHROUGH_DATETIME: Opt = 1 << 9;
 pub(crate) const APPEND_NEWLINE: Opt = 1 << 10;
 pub(crate) const PASSTHROUGH_DATACLASS: Opt = 1 << 11;
+pub(crate) const DISALLOW_NAN: Opt = 1 << 12;
 
 // deprecated
 pub(crate) const SERIALIZE_DATACLASS: Opt = 0;
@@ -27,6 +28,7 @@ pub(crate) const NOT_PASSTHROUGH: Opt =
 
 #[allow(clippy::cast_possible_wrap)]
 pub(crate) const MAX_OPT: i32 = (APPEND_NEWLINE
+    | DISALLOW_NAN
     | INDENT_2
     | NAIVE_UTC
     | NON_STR_KEYS
diff --git a/src/serialize/error.rs b/src/serialize/error.rs
@@ -7,6 +7,7 @@ use core::ptr::NonNull;
 pub(crate) enum SerializeError {
     DatetimeLibraryUnsupported,
     DefaultRecursionLimit,
+    FloatNotFinite,
     Integer53Bits,
     Integer64Bits,
     InvalidStr,
@@ -36,6 +37,9 @@ impl core::fmt::Display for SerializeError {
             SerializeError::DefaultRecursionLimit => {
                 write!(f, "default serializer exceeds recursion limit")
             }
+            SerializeError::FloatNotFinite => {
+                write!(f, "Cannot serialize Infinity or NaN")
+            }
             SerializeError::Integer53Bits => write!(f, "Integer exceeds 53-bit range"),
             SerializeError::Integer64Bits => write!(f, "Integer exceeds 64-bit range"),
             SerializeError::InvalidStr => write!(f, "{}", crate::util::INVALID_STR),
diff --git a/src/serialize/per_type/dict.rs b/src/serialize/per_type/dict.rs
@@ -125,7 +125,7 @@ macro_rules! impl_serialize_entry {
                 $map.serialize_key($key).unwrap();
                 $map.serialize_value(&FloatSerializer::new(unsafe {
                     PyFloatRef::from_ptr_unchecked($value)
-                }))?;
+                }, $self.state.opts()))?;
             }
             ObType::Bool => {
                 $map.serialize_key($key).unwrap();
@@ -434,10 +434,17 @@ fn non_str_uuid(key: PyUuidRef) -> Result<String, SerializeError> {
 #[allow(clippy::unnecessary_wraps)]
 #[cold]
 #[inline(never)]
-fn non_str_float(key: *mut crate::ffi::PyObject) -> Result<String, SerializeError> {
+fn non_str_float(
+    key: *mut crate::ffi::PyObject,
+    opts: crate::opt::Opt,
+) -> Result<String, SerializeError> {
     let val = ffi!(PyFloat_AS_DOUBLE(key));
     if !val.is_finite() {
-        Ok(String::from("null"))
+        if opt_enabled!(opts, crate::opt::DISALLOW_NAN) {
+            Err(SerializeError::FloatNotFinite)
+        } else {
+            Ok(String::from("null"))
+        }
     } else {
         Ok(String::from(zmij::Buffer::new().format_finite(val)))
     }
@@ -487,7 +494,7 @@ impl DictNonStrKey {
                     }
                 }
                 ObType::Int => non_str_int(key),
-                ObType::Float => non_str_float(key),
+                ObType::Float => non_str_float(key, opts),
                 ObType::Datetime => non_str_datetime(key, opts),
                 ObType::Date => non_str_date(key),
                 ObType::Time => non_str_time(key, opts),
diff --git a/src/serialize/per_type/float.rs b/src/serialize/per_type/float.rs
@@ -2,16 +2,18 @@
 // Copyright ijl (2018-2026)
 
 use crate::ffi::PyFloatRef;
+use crate::opt::{Opt, DISALLOW_NAN};
+use crate::serialize::error::SerializeError;
 use serde::ser::{Serialize, Serializer};
 
-#[repr(transparent)]
 pub(crate) struct FloatSerializer {
     ob: PyFloatRef,
+    opts: Opt,
 }
 
 impl FloatSerializer {
-    pub fn new(ptr: PyFloatRef) -> Self {
-        FloatSerializer { ob: ptr }
+    pub fn new(ptr: PyFloatRef, opts: Opt) -> Self {
+        FloatSerializer { ob: ptr, opts: opts }
     }
 }
 
@@ -21,6 +23,10 @@ impl Serialize for FloatSerializer {
     where
         S: Serializer,
     {
-        serializer.serialize_f64(self.ob.value())
+        let value = self.ob.value();
+        if opt_enabled!(self.opts, DISALLOW_NAN) && !value.is_finite() {
+            err!(SerializeError::FloatNotFinite)
+        }
+        serializer.serialize_f64(value)
     }
 }
diff --git a/src/serialize/per_type/list.rs b/src/serialize/per_type/list.rs
@@ -117,7 +117,7 @@ impl Serialize for ListTupleSerializer {
                 ObType::Float => {
                     seq.serialize_element(&FloatSerializer::new(unsafe {
                         PyFloatRef::from_ptr_unchecked(value)
-                    }))?;
+                    }, self.state.opts()))?;
                 }
                 ObType::Bool => {
                     seq.serialize_element(&BoolSerializer::new(unsafe {
diff --git a/src/serialize/serializer.rs b/src/serialize/serializer.rs
@@ -79,7 +79,7 @@ impl Serialize for PyObjectSerializer {
                 )
                 .serialize(serializer),
                 ObType::None => NoneSerializer::new().serialize(serializer),
-                ObType::Float => FloatSerializer::new(PyFloatRef::from_ptr_unchecked(self.ptr))
+                ObType::Float => FloatSerializer::new(PyFloatRef::from_ptr_unchecked(self.ptr), self.state.opts())
                     .serialize(serializer),
                 ObType::Bool => {
                     BoolSerializer::new(unsafe { PyBoolRef::from_ptr_unchecked(self.ptr) })
diff --git a/test/test_api.py b/test/test_api.py
@@ -209,7 +209,7 @@ def test_option_range_high(self):
         dumps() option out of range high
         """
         with pytest.raises(orjson.JSONEncodeError):
-            orjson.dumps(True, option=1 << 12)
+            orjson.dumps(True, option=1 << 13)
 
     def test_opts_multiple(self):
         """
diff --git a/test/test_type.py b/test/test_type.py
@@ -400,6 +400,46 @@ def test_infinity_loads(self):
         result = orjson.loads("[-Infinity]")
         assert result == [-math.inf]
 
+    def test_disallow_nan_raises(self):
+        """
+        OPT_DISALLOW_NAN raises on NaN and Infinity
+        """
+        for val in (float("nan"), float("inf"), float("-inf")):
+            with pytest.raises(orjson.JSONEncodeError):
+                orjson.dumps(val, option=orjson.OPT_DISALLOW_NAN)
+
+    def test_disallow_nan_finite_ok(self):
+        """
+        OPT_DISALLOW_NAN allows finite floats
+        """
+        assert orjson.dumps(3.14, option=orjson.OPT_DISALLOW_NAN) == b"3.14"
+        assert orjson.dumps(0.0, option=orjson.OPT_DISALLOW_NAN) == b"0.0"
+        assert orjson.dumps(-1.5, option=orjson.OPT_DISALLOW_NAN) == b"-1.5"
+
+    def test_disallow_nan_in_list(self):
+        """
+        OPT_DISALLOW_NAN raises on NaN inside a list
+        """
+        with pytest.raises(orjson.JSONEncodeError):
+            orjson.dumps([1.0, float("nan"), 3.0], option=orjson.OPT_DISALLOW_NAN)
+
+    def test_disallow_nan_in_dict(self):
+        """
+        OPT_DISALLOW_NAN raises on Infinity inside a dict value
+        """
+        with pytest.raises(orjson.JSONEncodeError):
+            orjson.dumps({"x": float("inf")}, option=orjson.OPT_DISALLOW_NAN)
+
+    def test_disallow_nan_dict_key(self):
+        """
+        OPT_DISALLOW_NAN raises on NaN as a dict key with OPT_NON_STR_KEYS
+        """
+        with pytest.raises(orjson.JSONEncodeError):
+            orjson.dumps(
+                {float("nan"): 1},
+                option=orjson.OPT_DISALLOW_NAN | orjson.OPT_NON_STR_KEYS,
+            )
+
     def test_int_53(self):
         """
         int 53-bit
