deepdiff-rs 0.9.0__tar.gz → 0.9.1__tar.gz

{deepdiff_rs-0.9.0 → deepdiff_rs-0.9.1}/Cargo.lock

@@ -629,7 +629,7 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "onix-arrow"
-version = "0.9.0"
+version = "0.9.1"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -646,7 +646,7 @@ dependencies = [
 
 [[package]]
 name = "onix-cli"
-version = "0.9.0"
+version = "0.9.1"
 dependencies = [
  "onix-core",
  "serde_json",
@@ -654,7 +654,7 @@ dependencies = [
 
 [[package]]
 name = "onix-core"
-version = "0.9.0"
+version = "0.9.1"
 dependencies = [
  "proptest",
  "serde",
@@ -665,7 +665,7 @@ dependencies = [
 
 [[package]]
 name = "onix-py"
-version = "0.9.0"
+version = "0.9.1"
 dependencies = [
  "arrow-array",
  "arrow-ipc",
@@ -997,7 +997,7 @@ checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.4",
+ "syn 3.0.5",
 ]
 
 [[package]]
@@ -1050,9 +1050,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "3.0.4"
+version = "3.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6275cddf4610d1775e6d1fe9469b2e77d0f39fd98fb7450901b821e0c53649f"
+checksum = "12df2e0110f65b775f769bb17ef989067a1d931b2eb822bd4346631eeada89f9"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1199,7 +1199,7 @@ dependencies = [
  "bumpalo",
  "proc-macro2",
  "quote",
- "syn 3.0.4",
+ "syn 3.0.5",
  "wasm-bindgen-shared",
 ]
 

{deepdiff_rs-0.9.0 → deepdiff_rs-0.9.1}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "3"
 members = ["crates/onix-core", "crates/onix-py", "crates/onix-arrow"]
 
 [workspace.package]
-version = "0.9.0"
+version = "0.9.1"
 edition = "2024"
 license = "MIT"
 

{deepdiff_rs-0.9.0 → deepdiff_rs-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepdiff-rs
-Version: 0.9.0
+Version: 0.9.1
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: MIT License
@@ -236,10 +236,11 @@ perf/              # cross-language benchmark harness and RESULTS.md
 ## Known limitations
 
 - Only the core diff is implemented: `exclude_paths`, `significant_digits`, custom operators, `verbose_level != 2`, and delta/patch are not (yet) supported.
-- Supported value types are `None`, `bool`, `int`, `float`, `str`, `dict`, `list`, `tuple`, `set`, `frozenset`, `datetime.datetime`, `datetime.date`, `datetime.time`, and `datetime.timedelta`; a `set`/`frozenset` member may be any of these except a `list`, `dict` or `set`, matching Python's own hashability rule, transitively through whatever the member nests, and a `dict` key may be `str`, `None`, `bool`, `int`, `float`, `datetime.datetime`, `datetime.date`, or a `tuple` of those (never nested). `int`s must fit in `i64`/`u64`, `float`s must be finite, and anything else — a custom object, an arbitrary-precision `int`, or a non-finite `float` — raises `TypeError`/`ValueError` naming the exact path it was found at. A non-`str` key's path renders via Python's own `repr()`, except a `tuple` key, which splits into one bracket group per element (`root[1][2]` for `(1, 2)`, never `root[(1, 2)]`, with one deliberate exception for a real DeepDiff bug on the empty tuple — see [`tests/golden/README.md`](tests/golden/README.md)). A nested dict value's own `bool`/`None`/`int`/`float` key stringifies the way `json.dumps` does, but its `datetime`/`date`/`tuple` key renders that same `repr()` text where DeepDiff's own `to_json()` raises `TypeError` on one — a superset, not a difference in the findings (see [`tests/golden/README.md`](tests/golden/README.md)). `1`/`1.0`/`True` match as the same key between two dicts (Python `dict`/`set` equality). The **Datetimes** and **Sets** bullets below cover the deliberate divergences for those types. See [`crates/onix-py/src/convert.rs`](crates/onix-py/src/convert.rs) and [`tests/golden/README.md`](tests/golden/README.md).
+- Supported value types are `None`, `bool`, `int`, `float` (`NaN`/`Infinity`/`-Infinity` included), `str`, `dict`, `list`, `tuple`, `set`, `frozenset`, `datetime.datetime`, `datetime.date`, `datetime.time`, and `datetime.timedelta`; a `set`/`frozenset` member may be any of these except a `list`, `dict` or `set`, matching Python's own hashability rule, transitively through whatever the member nests, and a `dict` key may be `str`, `None`, `bool`, `int`, `float`, `datetime.datetime`, `datetime.date`, or a `tuple` of those (never nested). `int`s must fit in `i64`/`u64`, and anything else — a custom object or an arbitrary-precision `int` — raises `TypeError`/`ValueError` naming the exact path it was found at. A non-`str` key's path renders via Python's own `repr()`, except a `tuple` key, which splits into one bracket group per element (`root[1][2]` for `(1, 2)`, never `root[(1, 2)]`, with one deliberate exception for a real DeepDiff bug on the empty tuple, and another on a non-finite-float key — see [`tests/golden/README.md`](tests/golden/README.md)). A nested dict value's own `bool`/`None`/`int`/`float` key stringifies the way `json.dumps` does, but its `datetime`/`date`/`tuple` key renders that same `repr()` text where DeepDiff's own `to_json()` raises `TypeError` on one — a superset, not a difference in the findings (see [`tests/golden/README.md`](tests/golden/README.md)). `1`/`1.0`/`True` match as the same key between two dicts (Python `dict`/`set` equality). The **Datetimes**, **Sets** and **Non-finite floats** bullets below cover the deliberate divergences for those types. See [`crates/onix-py/src/convert.rs`](crates/onix-py/src/convert.rs) and [`tests/golden/README.md`](tests/golden/README.md).
 - A subclass of a supported type (a `tuple`, `set` or `frozenset` subclass including `namedtuple`, a `datetime`/`date`/`time`/`timedelta` subclass such as pandas' `Timestamp`) raises `TypeError` rather than being diffed as its base type, because DeepDiff reports each value's own type name. A `type_changes` entry's `old_type`/`new_type` are type *names* in `to_dict()`, where DeepDiff returns the type objects. Both are described in [`tests/golden/README.md`](tests/golden/README.md).
 - **Datetimes** compare by instant, with a naive value read as UTC, matching DeepDiff. A changed pair is reported normalized to UTC (`to_json()` renders `...+00:00`, `to_dict()` returns UTC-aware `datetime`s); everywhere else a datetime keeps its raw value. Three deliberate departures: `to_json()` renders a `date` as `YYYY-MM-DD` where DeepDiff's own `to_json()` raises `TypeError` (a documented superset); a `zoneinfo`/`pytz` tzinfo comes back from `to_dict()` as a fixed-offset `datetime.timezone` carrying the offset it was in force at, not the original zone object; and a set holding both a naive and an aware value at one instant reports both as members, where DeepDiff's own digest cache can report only one (see [`crates/onix-py/src/convert.rs`](crates/onix-py/src/convert.rs)). Comparing two datetimes whose UTC form would leave year 1..=9999 raises `ValueError` naming the path, where DeepDiff raises `OverflowError`; under `ignore_order` DeepDiff's hasher normalizes every datetime and so raises for such a value even when it is only added, removed, or shuffled, where onix hashes by instant and reports it normally (see [`tests/golden/README.md`](tests/golden/README.md)). `truncate_datetime` is not supported; the normalized-versus-raw split is documented there too. A `time`/`timedelta`, unlike a datetime, is never normalized for report (DeepDiff compares `time`/`date`/`timedelta` with a plain `!=`), and a naive `time` is never equal to an aware one; `to_json()` renders a `time` as `time.isoformat()`'s bytes and a `timedelta` as `str(timedelta)`'s, both supersets. Under `ignore_order`, `DeepHash` hashes a `time` by whole seconds-of-day only — dropping the microsecond and any offset, a confirmed upstream quirk — while a `timedelta` hashes exactly; see [`tests/golden/README.md`](tests/golden/README.md)'s "Known DeepDiff quirks" section.
 - **Sets** are diffed deterministically, where DeepDiff's own answers depend on the order the running process happens to iterate a set in (hash order, and `PYTHONHASHSEED`-dependent for `str` members) or on how its digest cache/computation handles a tuple, frozenset, or calendar member independently of Python's own `==`. Each consequence — entry order, which member of an equality class is reported, set-versus-sequence coercion, and a tuple/frozenset member's own (positional, not order-/repetition-insensitive) matching rule — is shown with both tools' output in [`tests/golden/README.md`](tests/golden/README.md)'s "Set iteration order" section. A report holding a `frozenset` value also serializes to JSON here, where DeepDiff's own `to_json()` raises `TypeError` — a superset, not a difference in the findings.
+- **Non-finite floats** (`NaN`, `Infinity`, `-Infinity`) compare and hash like real Python: two `NaN`s are never equal, `Infinity == Infinity`, `to_json()` renders the same bare `NaN`/`Infinity`/`-Infinity` tokens Python's `json.dumps` does, and `ignore_order` matching treats every `NaN` as one shared item, matching `DeepHash`. The one divergence, always deterministic: this crate's value model carries no Python object identity, so two independently-obtained `NaN`s always compare unequal here, where DeepDiff sometimes reports no difference (`t1 is t2`) or lets one collapse into another (a `set` member, an ordered-list match) when the two objects, or their containers, happen to be the same one. See [`tests/golden/README.md`](tests/golden/README.md)'s "Non-finite floats" section.
 - A `str` containing a lone (unpaired) surrogate code point (e.g. `'\udc80'`, legal in Python but not encodable as UTF-8) raises `ValueError` naming the exact path on either side, before the two values are ever compared — including a pair DeepDiff would call equal and report as no change, since DeepDiff's scalar equality is plain Python `==` and never hits the encoding problem; DeepDiff does report a plain change for a *differing* pair, and crashes with an unhandled `UnicodeEncodeError` if such a string is ever hashed (a `set`/`frozenset` member). See [`tests/golden/README.md`](tests/golden/README.md)'s "Known DeepDiff quirks" section.
 - A `str` inside a `tuple` or `frozenset` set item is escaped exactly as Python's `repr()` escapes it, against Unicode 16.0.0; on a Python older than 3.14 (an older `unicodedata` table), a code point assigned to Unicode after that Python's own version is escaped by DeepDiff and rendered literally by onix. See [`tests/golden/README.md`](tests/golden/README.md)'s "Pinned versions" section.
 - Adversarially deep input raises `MaxDepthError` instead of crashing: the default `max_depth` is 512 and the hard ceiling is `MAX_DEPTH_CEILING` (20,000). See [`crates/onix-py/src/guard.rs`](crates/onix-py/src/guard.rs).

{deepdiff_rs-0.9.0 → deepdiff_rs-0.9.1}/README.md

@@ -218,10 +218,11 @@ perf/              # cross-language benchmark harness and RESULTS.md
 ## Known limitations
 
 - Only the core diff is implemented: `exclude_paths`, `significant_digits`, custom operators, `verbose_level != 2`, and delta/patch are not (yet) supported.
-- Supported value types are `None`, `bool`, `int`, `float`, `str`, `dict`, `list`, `tuple`, `set`, `frozenset`, `datetime.datetime`, `datetime.date`, `datetime.time`, and `datetime.timedelta`; a `set`/`frozenset` member may be any of these except a `list`, `dict` or `set`, matching Python's own hashability rule, transitively through whatever the member nests, and a `dict` key may be `str`, `None`, `bool`, `int`, `float`, `datetime.datetime`, `datetime.date`, or a `tuple` of those (never nested). `int`s must fit in `i64`/`u64`, `float`s must be finite, and anything else — a custom object, an arbitrary-precision `int`, or a non-finite `float` — raises `TypeError`/`ValueError` naming the exact path it was found at. A non-`str` key's path renders via Python's own `repr()`, except a `tuple` key, which splits into one bracket group per element (`root[1][2]` for `(1, 2)`, never `root[(1, 2)]`, with one deliberate exception for a real DeepDiff bug on the empty tuple — see [`tests/golden/README.md`](tests/golden/README.md)). A nested dict value's own `bool`/`None`/`int`/`float` key stringifies the way `json.dumps` does, but its `datetime`/`date`/`tuple` key renders that same `repr()` text where DeepDiff's own `to_json()` raises `TypeError` on one — a superset, not a difference in the findings (see [`tests/golden/README.md`](tests/golden/README.md)). `1`/`1.0`/`True` match as the same key between two dicts (Python `dict`/`set` equality). The **Datetimes** and **Sets** bullets below cover the deliberate divergences for those types. See [`crates/onix-py/src/convert.rs`](crates/onix-py/src/convert.rs) and [`tests/golden/README.md`](tests/golden/README.md).
+- Supported value types are `None`, `bool`, `int`, `float` (`NaN`/`Infinity`/`-Infinity` included), `str`, `dict`, `list`, `tuple`, `set`, `frozenset`, `datetime.datetime`, `datetime.date`, `datetime.time`, and `datetime.timedelta`; a `set`/`frozenset` member may be any of these except a `list`, `dict` or `set`, matching Python's own hashability rule, transitively through whatever the member nests, and a `dict` key may be `str`, `None`, `bool`, `int`, `float`, `datetime.datetime`, `datetime.date`, or a `tuple` of those (never nested). `int`s must fit in `i64`/`u64`, and anything else — a custom object or an arbitrary-precision `int` — raises `TypeError`/`ValueError` naming the exact path it was found at. A non-`str` key's path renders via Python's own `repr()`, except a `tuple` key, which splits into one bracket group per element (`root[1][2]` for `(1, 2)`, never `root[(1, 2)]`, with one deliberate exception for a real DeepDiff bug on the empty tuple, and another on a non-finite-float key — see [`tests/golden/README.md`](tests/golden/README.md)). A nested dict value's own `bool`/`None`/`int`/`float` key stringifies the way `json.dumps` does, but its `datetime`/`date`/`tuple` key renders that same `repr()` text where DeepDiff's own `to_json()` raises `TypeError` on one — a superset, not a difference in the findings (see [`tests/golden/README.md`](tests/golden/README.md)). `1`/`1.0`/`True` match as the same key between two dicts (Python `dict`/`set` equality). The **Datetimes**, **Sets** and **Non-finite floats** bullets below cover the deliberate divergences for those types. See [`crates/onix-py/src/convert.rs`](crates/onix-py/src/convert.rs) and [`tests/golden/README.md`](tests/golden/README.md).
 - A subclass of a supported type (a `tuple`, `set` or `frozenset` subclass including `namedtuple`, a `datetime`/`date`/`time`/`timedelta` subclass such as pandas' `Timestamp`) raises `TypeError` rather than being diffed as its base type, because DeepDiff reports each value's own type name. A `type_changes` entry's `old_type`/`new_type` are type *names* in `to_dict()`, where DeepDiff returns the type objects. Both are described in [`tests/golden/README.md`](tests/golden/README.md).
 - **Datetimes** compare by instant, with a naive value read as UTC, matching DeepDiff. A changed pair is reported normalized to UTC (`to_json()` renders `...+00:00`, `to_dict()` returns UTC-aware `datetime`s); everywhere else a datetime keeps its raw value. Three deliberate departures: `to_json()` renders a `date` as `YYYY-MM-DD` where DeepDiff's own `to_json()` raises `TypeError` (a documented superset); a `zoneinfo`/`pytz` tzinfo comes back from `to_dict()` as a fixed-offset `datetime.timezone` carrying the offset it was in force at, not the original zone object; and a set holding both a naive and an aware value at one instant reports both as members, where DeepDiff's own digest cache can report only one (see [`crates/onix-py/src/convert.rs`](crates/onix-py/src/convert.rs)). Comparing two datetimes whose UTC form would leave year 1..=9999 raises `ValueError` naming the path, where DeepDiff raises `OverflowError`; under `ignore_order` DeepDiff's hasher normalizes every datetime and so raises for such a value even when it is only added, removed, or shuffled, where onix hashes by instant and reports it normally (see [`tests/golden/README.md`](tests/golden/README.md)). `truncate_datetime` is not supported; the normalized-versus-raw split is documented there too. A `time`/`timedelta`, unlike a datetime, is never normalized for report (DeepDiff compares `time`/`date`/`timedelta` with a plain `!=`), and a naive `time` is never equal to an aware one; `to_json()` renders a `time` as `time.isoformat()`'s bytes and a `timedelta` as `str(timedelta)`'s, both supersets. Under `ignore_order`, `DeepHash` hashes a `time` by whole seconds-of-day only — dropping the microsecond and any offset, a confirmed upstream quirk — while a `timedelta` hashes exactly; see [`tests/golden/README.md`](tests/golden/README.md)'s "Known DeepDiff quirks" section.
 - **Sets** are diffed deterministically, where DeepDiff's own answers depend on the order the running process happens to iterate a set in (hash order, and `PYTHONHASHSEED`-dependent for `str` members) or on how its digest cache/computation handles a tuple, frozenset, or calendar member independently of Python's own `==`. Each consequence — entry order, which member of an equality class is reported, set-versus-sequence coercion, and a tuple/frozenset member's own (positional, not order-/repetition-insensitive) matching rule — is shown with both tools' output in [`tests/golden/README.md`](tests/golden/README.md)'s "Set iteration order" section. A report holding a `frozenset` value also serializes to JSON here, where DeepDiff's own `to_json()` raises `TypeError` — a superset, not a difference in the findings.
+- **Non-finite floats** (`NaN`, `Infinity`, `-Infinity`) compare and hash like real Python: two `NaN`s are never equal, `Infinity == Infinity`, `to_json()` renders the same bare `NaN`/`Infinity`/`-Infinity` tokens Python's `json.dumps` does, and `ignore_order` matching treats every `NaN` as one shared item, matching `DeepHash`. The one divergence, always deterministic: this crate's value model carries no Python object identity, so two independently-obtained `NaN`s always compare unequal here, where DeepDiff sometimes reports no difference (`t1 is t2`) or lets one collapse into another (a `set` member, an ordered-list match) when the two objects, or their containers, happen to be the same one. See [`tests/golden/README.md`](tests/golden/README.md)'s "Non-finite floats" section.
 - A `str` containing a lone (unpaired) surrogate code point (e.g. `'\udc80'`, legal in Python but not encodable as UTF-8) raises `ValueError` naming the exact path on either side, before the two values are ever compared — including a pair DeepDiff would call equal and report as no change, since DeepDiff's scalar equality is plain Python `==` and never hits the encoding problem; DeepDiff does report a plain change for a *differing* pair, and crashes with an unhandled `UnicodeEncodeError` if such a string is ever hashed (a `set`/`frozenset` member). See [`tests/golden/README.md`](tests/golden/README.md)'s "Known DeepDiff quirks" section.
 - A `str` inside a `tuple` or `frozenset` set item is escaped exactly as Python's `repr()` escapes it, against Unicode 16.0.0; on a Python older than 3.14 (an older `unicodedata` table), a code point assigned to Unicode after that Python's own version is escaped by DeepDiff and rendered literally by onix. See [`tests/golden/README.md`](tests/golden/README.md)'s "Pinned versions" section.
 - Adversarially deep input raises `MaxDepthError` instead of crashing: the default `max_depth` is 512 and the hard ceiling is `MAX_DEPTH_CEILING` (20,000). See [`crates/onix-py/src/guard.rs`](crates/onix-py/src/guard.rs).

{deepdiff_rs-0.9.0 → deepdiff_rs-0.9.1}/crates/onix-core/src/diff/scalar.rs

@@ -207,14 +207,17 @@ pub(crate) fn numbers_equal(old: &Number, new: &Number) -> bool {
 }
 /// Compares two floats for exact equality.
 ///
-/// This mirrors Python's `==` semantics for floats (including
-/// `0.0 == -0.0`), with no implicit epsilon; NaN/Infinity are out of scope
-/// for this JSON value model, so exact IEEE-754 equality is the correct
+/// This mirrors Python's `==` semantics for floats: `0.0 == -0.0`, and —
+/// with no special-casing needed — `NaN != NaN` (matching real `DeepDiff`
+/// for two independently-obtained `NaN` values; see `tests/golden/README.md`'s
+/// "Non-finite floats" section for the one case this crate cannot
+/// reproduce, where `DeepDiff` short-circuits on `t1 is t2`), no implicit
+/// epsilon, and `Infinity == Infinity`. Exact IEEE-754 `==` is the correct
 /// (and only) rule here.
 fn floats_equal(a: f64, b: f64) -> bool {
     #[allow(
         clippy::float_cmp,
-        reason = "exact IEEE-754 equality is the intended rule (Python == semantics, including 0.0 == -0.0); NaN/Infinity are out of scope for this JSON value model"
+        reason = "exact IEEE-754 equality is the intended rule (Python == semantics, including 0.0 == -0.0 and NaN != NaN)"
     )]
     {
         a == b

{deepdiff_rs-0.9.0 → deepdiff_rs-0.9.1}/crates/onix-core/src/ignore_order/distance.rs

@@ -519,7 +519,7 @@ fn coerce_for_type_change(old_value: &Value, new_value: &Value) -> Option<Value>
     match new_value {
         Value::Bool(_) => Some(Value::Bool(is_truthy(old_value))),
         Value::Number(n) if n.is_f64() => {
-            coerce_to_f64(old_value).and_then(|f| Number::from_f64(f).map(Value::Number))
+            coerce_to_f64(old_value).map(|f| Value::Number(Number::from_f64(f)))
         }
         Value::Number(_) => coerce_to_i64(old_value).map(|i| Value::Number(Number::from_i64(i))),
         Value::Str(_) => coerce_to_python_str(old_value).map(|s| Value::Str(s.into_boxed_str())),

{deepdiff_rs-0.9.0 → deepdiff_rs-0.9.1}/crates/onix-core/src/ignore_order/fxhash.rs

@@ -59,6 +59,14 @@ pub(crate) type HashSet<T> = std::collections::HashSet<T, BuildHasherDefault<FxH
 /// hence `mix_float_bits`, so the hazard does not reach the new key either — a
 /// *non-adversarial* run of integral/half-integer floats, whose raw bit
 /// patterns share ~50 trailing zeros, does not accidentally collide.
+/// `ItemKey::Float` additionally maps *every* `NaN`, regardless of its own
+/// bits, onto one fixed representative (`deephash_float_bits`, matching
+/// `DeepHash`'s `str(obj)`-based digest — see that function's own doc): a
+/// deliberate full key collapse, not merely a hash collision, so a run of
+/// `NaN`s in one of these tables costs *less* than the equivalent run of
+/// distinct floats would (they fold to a single entry), not more — this
+/// changes which values these tables treat as the same item, not their
+/// per-lookup cost.
 ///
 /// For those remaining `ignore_order`-only tables the trade is deliberate and
 /// measured. Re-keying them to `SipHash` (`RandomState`) added a material,

{deepdiff_rs-0.9.0 → deepdiff_rs-0.9.1}/crates/onix-core/src/ignore_order/hash.rs

@@ -189,9 +189,11 @@ pub(crate) enum ItemKey {
     /// `serde_json::Number`'s non-float representation is always an `i64`
     /// or `u64`, both of which fit losslessly in `i128`.
     Int(i128),
-    /// A JSON value `serde_json` parsed as a float, keyed by its exact bit
-    /// pattern — kept as its own bucket even when whole-numbered (`5.0`
-    /// never collides with `Int(5)`; see this type's own doc).
+    /// A float, keyed by [`deephash_float_bits`] — its exact bit pattern for
+    /// any finite value (kept as its own bucket even when whole-numbered:
+    /// `5.0` never collides with `Int(5)`; see this type's own doc), but one
+    /// fixed representative for *every* `NaN` regardless of its bits, since
+    /// `DeepHash` digests any `NaN` the same way (see that function's doc).
     Float(u64),
     Str(String),
     /// A `datetime`, keyed by its instant with a naive value read as UTC —
@@ -678,15 +680,44 @@ fn scalar_content_key(value: &Value) -> ItemKey {
     }
 }
 
+/// The bit pattern [`ItemKey::Float`] keys a float by:
+/// [`crate::value::fold_signed_zero`] for every finite value (agreeing with
+/// [`crate::value::Number`]'s `PartialEq` and `canonical_cmp`'s
+/// `number_cmp`), and one fixed representative for *every* `NaN`,
+/// regardless of its own sign or payload bits.
+///
+/// This is deliberately **coarser** than [`crate::value::fold_signed_zero`]
+/// (which leaves a `NaN`'s bits alone) and coarser than
+/// [`crate::value::Number`]'s own `PartialEq` (under which no two `NaN`s are
+/// ever equal): `DeepHash._prep_number`
+/// builds its digest from `str(obj)` when `significant_digits` is unset (the
+/// only mode this crate reproduces), and `str()` of *any* `NaN` — whatever
+/// its bits — is the same three characters, `"nan"`. Collapsing every `NaN`
+/// onto one [`ItemKey`] is what makes `onix`'s `ignore_order` item/member
+/// matching agree with that: two list elements, dict values, or set members
+/// that are each independently a `NaN` hash-match here exactly as they do
+/// under real `DeepHash`, confirmed against `deepdiff==9.1.0` (`[nan_a]` vs
+/// `[nan_b]`, two *distinct* `NaN` objects, is `{}` under `ignore_order`).
+/// `Infinity`/`-Infinity` need no such collapse: `str(inf)` and `str(-inf)`
+/// already differ, matching their (already distinct) bit patterns.
+fn deephash_float_bits(f: f64) -> u64 {
+    if f.is_nan() {
+        f64::NAN.to_bits()
+    } else {
+        crate::value::fold_signed_zero(f).to_bits()
+    }
+}
+
 /// The type-distinct key for a bare number, mirroring [`ItemKey`]'s own
-/// number rule (see [`crate::value::fold_signed_zero`] for the signed-zero
-/// note).
+/// number rule (see [`deephash_float_bits`] for the float rule, including
+/// its `NaN` collapse, and [`crate::value::fold_signed_zero`] for the
+/// signed-zero note).
 fn number_key(n: &crate::value::Number) -> ItemKey {
     if n.is_f64() {
         let f = n
             .as_f64()
             .expect("Number::is_f64 guarantees as_f64 succeeds");
-        return ItemKey::Float(crate::value::fold_signed_zero(f).to_bits());
+        return ItemKey::Float(deephash_float_bits(f));
     }
     if let Some(i) = n.as_i64() {
         return ItemKey::Int(i128::from(i));
@@ -742,13 +773,14 @@ fn keyed(value: &Value, memo: &IgnoreOrderMemo, want_part: bool) -> (ItemKey, Op
                 let f = n
                     .as_f64()
                     .expect("Number::is_f64 guarantees as_f64 succeeds");
-                // See `crate::value::fold_signed_zero`: it is the identity on
-                // every float but `-0.0`, so an integral float like `2.0`
+                // See `deephash_float_bits`: it is the identity on every
+                // finite float but `-0.0`, so an integral float like `2.0`
                 // keeps a distinct `Float` key from the integer `2` (this
                 // deliberately does NOT take the ordered path's `ScalarKey`
                 // integral-to-`Int` canonicalization — the two paths have
-                // genuinely different number semantics).
-                ItemKey::Float(crate::value::fold_signed_zero(f).to_bits())
+                // genuinely different number semantics), and it collapses
+                // every `NaN` onto one shared key regardless of bits.
+                ItemKey::Float(deephash_float_bits(f))
             } else if let Some(i) = n.as_i64() {
                 ItemKey::Int(i128::from(i))
             } else {

{deepdiff_rs-0.9.0 → deepdiff_rs-0.9.1}/crates/onix-core/src/ignore_order/memo.rs

@@ -177,12 +177,14 @@ pub(crate) struct IgnoreOrderMemo {
     node_table: RefCell<BTreeMap<MemberHashKey, (NodeId, RepId)>>,
     /// Set-member content interning: each distinct [`MemberContent`] gets one
     /// [`RepId`] (its `usize` index), so content-equal members — a naive and an
-    /// aware datetime at one instant included — collapse to one id. A
-    /// [`BTreeMap`] for the same collision-immunity reason as `node_table`;
-    /// per-lookup cost is `O(log n)` comparisons, each a full walk of the
-    /// probed `MemberContent` — a `MemberContent::UnhashableDict` key is
-    /// itself keyed by each of the dict's own keys' `ItemKey` trees (a
-    /// `tuple` dict key included), not a cheap string ordering.
+    /// aware datetime at one instant, and (via the [`ItemKey::Float`] a
+    /// `MemberContent::Scalar` embeds) every `NaN` regardless of its own
+    /// bits — collapse to one id. A [`BTreeMap`] for the same
+    /// collision-immunity reason as `node_table`; per-lookup cost is
+    /// `O(log n)` comparisons, each a full walk of the probed
+    /// `MemberContent` — a `MemberContent::UnhashableDict` key is itself
+    /// keyed by each of the dict's own keys' `ItemKey` trees (a `tuple`
+    /// dict key included), not a cheap string ordering.
     member_content: RefCell<BTreeMap<MemberContent, RepId>>,
     enabled: bool,
     /// Total number of times [`Self::put`] has actually run — every distance

{deepdiff_rs-0.9.0 → deepdiff_rs-0.9.1}/crates/onix-core/src/ignore_order/tests.rs

@@ -3065,7 +3065,7 @@ fn dist_hash(value: &CValue) -> u64 {
 /// aware pair shifted by its offset to the same moment).
 #[test]
 fn dist_key_hash_agrees_with_equality_on_tricky_equal_values() {
-    let float = |f: f64| CValue::Number(crate::value::Number::from_f64(f).unwrap());
+    let float = |f: f64| CValue::Number(crate::value::Number::from_f64(f));
     let nested_set = |order: [i64; 3]| {
         CValue::Set(SetItems::new(vec![
             ctup(&[json!(order[0])]),
@@ -3116,6 +3116,37 @@ fn dist_key_hash_agrees_with_equality_on_tricky_equal_values() {
     }
 }
 
+/// `NaN` cannot appear among the pairs above — no two `NaN`s are ever
+/// `Value`-equal (`NaN != NaN`, matching Python), so there is no equal-values
+/// case to add. What NEEDS pinning instead is the deliberately *coarser*
+/// hash: `DistKey`'s `Hash` collapses every `NaN` bit pattern onto one bucket
+/// (`crate::ignore_order::hash::number_key`, matching `DeepHash`'s own
+/// `NaN`-insensitive digest — see that function's own doc), so two
+/// genuinely distinct, never-`Value`-equal `NaN`s hash *equal* here — the
+/// opposite direction from the property above, and safe only because a hash
+/// collision is not itself a lookup match: `DistKey`'s `Eq` is `Value`'s
+/// real equality, and it must still tell the two apart, or the memo would
+/// silently hand one `NaN`'s cached distance to the other.
+#[test]
+fn dist_key_hash_collision_on_distinct_nans_never_becomes_equality() {
+    let nan_a = CValue::Number(crate::value::Number::from_f64(f64::NAN));
+    let nan_b = CValue::Number(crate::value::Number::from_f64(-f64::NAN));
+
+    assert_ne!(nan_a, nan_b, "two NaN values are never Value-equal");
+    assert_eq!(
+        dist_hash(&nan_a),
+        dist_hash(&nan_b),
+        "NaN's dist-key hash deliberately ignores sign/payload"
+    );
+
+    let key_a = super::hash::DistKey::new(&nan_a);
+    let key_b = super::hash::DistKey::new(&nan_b);
+    assert!(
+        key_a != key_b,
+        "a hash collision must not make DistKey::eq treat two distinct NaNs as the same cache entry"
+    );
+}
+
 /// An `arbitrary` compact value covering every equality class the distance-key
 /// hash must respect — including the ones JSON cannot express, so they are
 /// actually generated: tuples, sets, frozensets, datetimes (naive and aware),
@@ -3137,15 +3168,28 @@ fn arb_cvalue() -> impl Strategy<Value = CValue> {
     )
         .prop_map(|(y, mo, d, h, mi, s, off)| cdt_at(y, mo, d, h, mi, s, 0, off));
     let arb_date = (2000i32..2025, 1u8..=12, 1u8..=28).prop_map(|(y, m, d)| cdate(y, m, d));
+    // `NaN` is excluded, not `any::<f64>()`'s non-finite values generally:
+    // `Infinity`/`-Infinity` are ordinary equal-to-themselves floats and
+    // `structural_twin` leaves them untouched (only a signed zero gets
+    // perturbed), so they exercise this property harmlessly. A `NaN` cannot:
+    // `Value::eq` never calls two `NaN`s equal (matching Python's
+    // `nan != nan`), so `prop_assert_eq!(&value, &twin)` below would fail on
+    // any tree containing one, structural twin or not — this proptest is
+    // about the hash/equality *agreement*, which a `NaN` leaf has no
+    // meaningful instance of (see
+    // `dist_key_hash_collision_on_distinct_nans_never_becomes_equality` for
+    // the coverage a `NaN` does need).
     let arb_float = prop_oneof![
         Just(0.0f64),
         Just(-0.0f64),
         Just(1.0f64),
         Just(2.0f64),
+        Just(f64::INFINITY),
+        Just(f64::NEG_INFINITY),
         any::<f64>(),
     ]
-    .prop_filter_map("finite floats only", |f| {
-        crate::value::Number::from_f64(f).map(CValue::Number)
+    .prop_filter_map("not NaN", |f| {
+        (!f.is_nan()).then(|| CValue::Number(crate::value::Number::from_f64(f)))
     });
     let leaf = prop_oneof![
         Just(CValue::Null),
@@ -3283,9 +3327,7 @@ fn structural_twin(value: &CValue, in_set: bool) -> CValue {
         CValue::Number(n) if n.is_f64() => {
             let f = n.as_f64().expect("is_f64 guarantees as_f64");
             let flipped = if f == 0.0 { -f } else { f };
-            CValue::Number(
-                crate::value::Number::from_f64(flipped).expect("finite float stays finite"),
-            )
+            CValue::Number(crate::value::Number::from_f64(flipped))
         }
         scalar => scalar.clone(),
     }

{deepdiff_rs-0.9.0 → deepdiff_rs-0.9.1}/crates/onix-core/src/lcs.rs

@@ -92,6 +92,9 @@ pub(crate) enum ScalarKey {
     /// Bit pattern of a non-integral (or too-large-to-be-exact) float —
     /// hashed through [`mix_float_bits`]; see this type's hand-written `Hash`.
     Float(u64),
+    /// A `NaN`, keyed by the address of the [`Value`] node it was read from
+    /// — see [`python_scalar_key`]'s `NaN` case for why.
+    Nan(usize),
     /// A `datetime`, keyed by whether it is aware and by its instant —
     /// Python's own `datetime.__eq__`/`__hash__` pair, which compares two
     /// aware values by instant (so `10:00+00:00 == 12:00+02:00`) but never
@@ -150,6 +153,13 @@ impl std::hash::Hash for ScalarKey {
             Self::Str(s) => s.hash(state),
             Self::Int(i) => i.hash(state),
             Self::Float(bits) => mix_float_bits(*bits).hash(state),
+            // A `Value` node's address is 8/16-byte-aligned like any other
+            // pointer, so its low bits carry no entropy; avalanche it the
+            // same way as a trailing-zero-heavy float bit pattern (see
+            // `mix_float_bits`'s own doc) rather than trust the raw address.
+            // `usize as u64` never truncates: `u64` is at least as wide as
+            // `usize` on every target this crate builds for.
+            Self::Nan(id) => mix_float_bits(*id as u64).hash(state),
             Self::DateTime { aware, instant } | Self::Time { aware, instant } => {
                 aware.hash(state);
                 instant.hash(state);
@@ -219,6 +229,26 @@ fn scalar_key(value: &Value) -> ScalarKey {
 /// `==`; `crate::ignore_order` needs the same rule twice more, for
 /// `DeepHash`'s cache identity and for the `list(t1) == t2` coercion test,
 /// and shares this one rather than restating it.
+///
+/// A `NaN` gets [`ScalarKey::Nan`], keyed by `value`'s own address, because
+/// no bit-pattern-based key could be right here: `NaN != NaN` in Python
+/// regardless of bits, confirmed against `deepdiff==9.1.0` — two distinct
+/// `NaN` objects with the *same* bits still fail `difflib`'s `==`-based
+/// match (`[1, nan_a, 2]` vs `[1, 2, nan_b]` reports a `type_changes` at the
+/// `nan`/`2` positions rather than treating the insertion as a clean shift,
+/// which a bit-based key that let `nan_a` match `nan_b` would get wrong).
+/// Each call therefore has to hand back a key that cannot equal *any* other
+/// call's — including another `NaN` read from the exact same bits — and an
+/// address is the only per-call-distinct, already-available `usize` this
+/// function has: `value` is borrowed from a [`Value`] tree that outlives the
+/// whole comparison this key feeds, so the address is stable for exactly as
+/// long as the key needs to be looked up, and (being a fresh allocation per
+/// converted Python object) two different `NaN` occurrences can never share
+/// one. See `tests/golden/README.md`'s "Non-finite floats" section for the
+/// one case this cannot reproduce (the *same* Python `NaN` object compared
+/// or hashed against itself, which real `DeepDiff`/`CPython` sometimes treat
+/// as matching via object identity — a concept this crate's value model
+/// does not carry).
 pub(crate) fn python_scalar_key(value: &Value) -> Option<ScalarKey> {
     Some(match value {
         Value::Null => ScalarKey::Null,
@@ -233,6 +263,9 @@ pub(crate) fn python_scalar_key(value: &Value) -> Option<ScalarKey> {
                 return Some(ScalarKey::Int(i));
             }
             let f = n.as_f64().expect("a serde_json Number is i64, u64, or f64");
+            if f.is_nan() {
+                return Some(ScalarKey::Nan(std::ptr::from_ref(value) as usize));
+            }
             if f.fract() == 0.0 && f.abs() <= MAX_EXACT_F64_INT {
                 #[allow(
                     clippy::cast_possible_truncation,

{deepdiff_rs-0.9.0 → deepdiff_rs-0.9.1}/crates/onix-core/src/lcs_tests.rs

@@ -104,6 +104,67 @@ fn non_integral_floats_compare_by_value() {
     assert!(!python_scalar_eq(&json!(1.5), &json!(2.5)));
 }
 
+// `NaN` cannot arrive via `json!`/`cv` (`serde_json::Number` is finite by
+// construction), so these build the compact `Value` directly rather than
+// through the `serde_json`-literal wrapper the tests above share.
+#[test]
+fn two_distinct_nans_are_never_python_equal() {
+    use crate::value::{Number, Value};
+
+    let a = Value::Number(Number::from_f64(f64::NAN));
+    let b = Value::Number(Number::from_f64(f64::NAN));
+    assert_ne!(
+        super::python_scalar_key(&a),
+        super::python_scalar_key(&b),
+        "two independently-built NaN values must never share a ScalarKey"
+    );
+}
+
+#[test]
+fn the_same_nan_value_reference_yields_the_same_scalar_key() {
+    use crate::value::{Number, Value};
+
+    let a = Value::Number(Number::from_f64(f64::NAN));
+    assert_eq!(
+        super::python_scalar_key(&a),
+        super::python_scalar_key(&a),
+        "hashing/keying the same Value node twice must agree with itself"
+    );
+}
+
+#[test]
+fn nan_and_infinity_never_share_a_scalar_key() {
+    use crate::value::{Number, Value};
+
+    let nan = Value::Number(Number::from_f64(f64::NAN));
+    let inf = Value::Number(Number::from_f64(f64::INFINITY));
+    assert_ne!(
+        super::python_scalar_key(&nan),
+        super::python_scalar_key(&inf)
+    );
+}
+
+#[test]
+fn scalar_key_nan_hashes_and_is_usable_as_a_hashmap_key() {
+    use std::collections::HashMap;
+
+    use crate::value::{Number, Value};
+
+    let a = Value::Number(Number::from_f64(f64::NAN));
+    let b = Value::Number(Number::from_f64(f64::NAN));
+    let key_a = super::python_scalar_key(&a).expect("NaN is a scalar");
+    let key_b = super::python_scalar_key(&b).expect("NaN is a scalar");
+
+    let mut map: HashMap<super::ScalarKey, &str> = HashMap::new();
+    map.insert(key_a.clone(), "a");
+    map.insert(key_b.clone(), "b");
+    // Two distinct NaNs never collapse to one entry, matching Python's own
+    // `nan != nan` (see `super::ScalarKey::Nan`'s own doc).
+    assert_eq!(map.len(), 2);
+    assert_eq!(map.get(&key_a), Some(&"a"));
+    assert_eq!(map.get(&key_b), Some(&"b"));
+}
+
 // --- compute_opcodes -------------------------------------------------
 
 fn vals(items: &[i64]) -> Vec<serde_json::Value> {

{deepdiff_rs-0.9.0 → deepdiff_rs-0.9.1}/crates/onix-core/src/path.rs

@@ -601,6 +601,17 @@ fn escape_non_printable(out: &mut String, c: char) {
 /// is involved. Verified against real Python `repr()` over a million random
 /// bit patterns in the bindings suite.
 pub(crate) fn python_float_repr(value: f64) -> String {
+    if !value.is_finite() {
+        // `{:e}` has no exponent form for these, so the digit-count logic
+        // below (which expects an `e` separator) never applies to them.
+        return if value.is_nan() {
+            "nan".to_string()
+        } else if value.is_sign_positive() {
+            "inf".to_string()
+        } else {
+            "-inf".to_string()
+        };
+    }
     let shortest = format!("{value:e}");
     let significant = shortest
         .split_once('e')
@@ -879,7 +890,7 @@ mod tests {
         ];
         for (input, expected) in cases {
             assert_eq!(
-                set_item_repr(&Value::Number(Number::from_f64(input).expect("finite"))),
+                set_item_repr(&Value::Number(Number::from_f64(input))),
                 expected,
                 "for {input:?}"
             );
@@ -1135,7 +1146,7 @@ mod tests {
         ];
         for (input, expected) in cases {
             assert_eq!(
-                set_item_repr(&Value::Number(Number::from_f64(input).expect("finite"))),
+                set_item_repr(&Value::Number(Number::from_f64(input))),
                 expected,
                 "for {input:?}"
             );

{deepdiff_rs-0.9.0 → deepdiff_rs-0.9.1}/crates/onix-core/src/test_support.rs

@@ -109,6 +109,6 @@ pub(crate) fn cnum(n: &serde_json::Number) -> Number {
     } else if let Some(i) = n.as_i64() {
         Number::from_i64(i)
     } else {
-        Number::from_f64(n.as_f64().expect("serde Number is u64/i64/f64")).expect("finite")
+        Number::from_f64(n.as_f64().expect("serde Number is u64/i64/f64"))
     }
 }