deepdiff-rs 0.8.1__tar.gz → 0.8.2__tar.gz

{deepdiff_rs-0.8.1 → deepdiff_rs-0.8.2}/Cargo.lock

@@ -629,7 +629,7 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "onix-arrow"
-version = "0.8.1"
+version = "0.8.2"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -646,7 +646,7 @@ dependencies = [
 
 [[package]]
 name = "onix-cli"
-version = "0.8.1"
+version = "0.8.2"
 dependencies = [
  "onix-core",
  "serde_json",
@@ -654,7 +654,7 @@ dependencies = [
 
 [[package]]
 name = "onix-core"
-version = "0.8.1"
+version = "0.8.2"
 dependencies = [
  "proptest",
  "serde",
@@ -665,7 +665,7 @@ dependencies = [
 
 [[package]]
 name = "onix-py"
-version = "0.8.1"
+version = "0.8.2"
 dependencies = [
  "arrow-array",
  "arrow-ipc",

{deepdiff_rs-0.8.1 → deepdiff_rs-0.8.2}/Cargo.toml

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

{deepdiff_rs-0.8.1 → deepdiff_rs-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepdiff-rs
-Version: 0.8.1
+Version: 0.8.2
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: MIT License
@@ -203,7 +203,7 @@ Both reports carry their full methodology, fairness rules, and the reproduce com
 
 **Python API.** The public surface is `DeepDiff`, `diff_json`, `diff_tables` (returning a `TableDiff`), `MaxDepthError`, and `MAX_DEPTH_CEILING`.
 
-- `DeepDiff(t1, t2, ignore_order=False, max_depth=None)`: diffs two live Python objects of supported value types — `None`, `bool`, `int`, `float`, `str`, `dict` (with `str` keys), `list`, `tuple`, `set`, `frozenset`, `datetime.datetime`, `datetime.date`, `datetime.time`, and `datetime.timedelta` (see [Known limitations](#known-limitations) for the exact restrictions and exclusions); `.to_json()` returns the DeepDiff-compatible JSON string, `.to_dict()` the same report as a dict — with Python types preserved, so a value the diff found in a `tuple`, `set` or `frozenset` comes back as one and a `datetime`/`date`/`time`/`timedelta` comes back as a real one of those — and the instance is falsy when there is no difference. The `set_item_added`/`set_item_removed` categories are lists of path strings, each ending in the item itself (`root['a'][2]`, `root['x']`, `root[(1, 2)]`).
+- `DeepDiff(t1, t2, ignore_order=False, max_depth=None)`: diffs two live Python objects of supported value types — `None`, `bool`, `int`, `float`, `str`, `dict`, `list`, `tuple`, `set`, `frozenset`, `datetime.datetime`, `datetime.date`, `datetime.time`, and `datetime.timedelta` (see [Known limitations](#known-limitations) for the exact restrictions and exclusions, including which types a `dict` key may be); `.to_json()` returns the DeepDiff-compatible JSON string, `.to_dict()` the same report as a dict — with Python types preserved, so a value the diff found in a `tuple`, `set` or `frozenset` comes back as one and a `datetime`/`date`/`time`/`timedelta` comes back as a real one of those — and the instance is falsy when there is no difference. The `set_item_added`/`set_item_removed` categories are lists of path strings, each ending in the item itself (`root['a'][2]`, `root['x']`, `root[(1, 2)]`).
 - `diff_json(a, b, ignore_order=False, max_depth=None) -> str`: diffs two JSON strings entirely in Rust and returns the report as a JSON string.
 - `MaxDepthError` (a `ValueError` subclass) is raised when input exceeds `max_depth`; `MAX_DEPTH_CEILING` (20,000) is the hard upper bound on `max_depth`.
 - `diff_tables(left, right, key=[...]) -> TableDiff`: diffs two Arrow tables (see [Diffing tables](#diffing-tables)). `TableDiff.schema` is the list of changed columns, `.schema_arrow` the same as an Arrow table, `.summary()` the schema and row change counts, `.to_json()` the schema diff as JSON; `.rows_added()`, `.rows_removed()`, `.cells_changed()`, and `.duplicate_keys()` return Arrow tables.
@@ -238,7 +238,7 @@ 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` (with `str` keys), `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. `int`s must fit in `i64`/`u64`, `float`s must be finite, and anything else — a non-`str` dict key, a custom object, an arbitrary-precision `int`, or a non-finite `float` — raises `TypeError`/`ValueError` naming the exact path it was found at. 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`, `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).
 - 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.

{deepdiff_rs-0.8.1 → deepdiff_rs-0.8.2}/README.md

@@ -185,7 +185,7 @@ Both reports carry their full methodology, fairness rules, and the reproduce com
 
 **Python API.** The public surface is `DeepDiff`, `diff_json`, `diff_tables` (returning a `TableDiff`), `MaxDepthError`, and `MAX_DEPTH_CEILING`.
 
-- `DeepDiff(t1, t2, ignore_order=False, max_depth=None)`: diffs two live Python objects of supported value types — `None`, `bool`, `int`, `float`, `str`, `dict` (with `str` keys), `list`, `tuple`, `set`, `frozenset`, `datetime.datetime`, `datetime.date`, `datetime.time`, and `datetime.timedelta` (see [Known limitations](#known-limitations) for the exact restrictions and exclusions); `.to_json()` returns the DeepDiff-compatible JSON string, `.to_dict()` the same report as a dict — with Python types preserved, so a value the diff found in a `tuple`, `set` or `frozenset` comes back as one and a `datetime`/`date`/`time`/`timedelta` comes back as a real one of those — and the instance is falsy when there is no difference. The `set_item_added`/`set_item_removed` categories are lists of path strings, each ending in the item itself (`root['a'][2]`, `root['x']`, `root[(1, 2)]`).
+- `DeepDiff(t1, t2, ignore_order=False, max_depth=None)`: diffs two live Python objects of supported value types — `None`, `bool`, `int`, `float`, `str`, `dict`, `list`, `tuple`, `set`, `frozenset`, `datetime.datetime`, `datetime.date`, `datetime.time`, and `datetime.timedelta` (see [Known limitations](#known-limitations) for the exact restrictions and exclusions, including which types a `dict` key may be); `.to_json()` returns the DeepDiff-compatible JSON string, `.to_dict()` the same report as a dict — with Python types preserved, so a value the diff found in a `tuple`, `set` or `frozenset` comes back as one and a `datetime`/`date`/`time`/`timedelta` comes back as a real one of those — and the instance is falsy when there is no difference. The `set_item_added`/`set_item_removed` categories are lists of path strings, each ending in the item itself (`root['a'][2]`, `root['x']`, `root[(1, 2)]`).
 - `diff_json(a, b, ignore_order=False, max_depth=None) -> str`: diffs two JSON strings entirely in Rust and returns the report as a JSON string.
 - `MaxDepthError` (a `ValueError` subclass) is raised when input exceeds `max_depth`; `MAX_DEPTH_CEILING` (20,000) is the hard upper bound on `max_depth`.
 - `diff_tables(left, right, key=[...]) -> TableDiff`: diffs two Arrow tables (see [Diffing tables](#diffing-tables)). `TableDiff.schema` is the list of changed columns, `.schema_arrow` the same as an Arrow table, `.summary()` the schema and row change counts, `.to_json()` the schema diff as JSON; `.rows_added()`, `.rows_removed()`, `.cells_changed()`, and `.duplicate_keys()` return Arrow tables.
@@ -220,7 +220,7 @@ 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` (with `str` keys), `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. `int`s must fit in `i64`/`u64`, `float`s must be finite, and anything else — a non-`str` dict key, a custom object, an arbitrary-precision `int`, or a non-finite `float` — raises `TypeError`/`ValueError` naming the exact path it was found at. 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`, `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).
 - 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.

{deepdiff_rs-0.8.1 → deepdiff_rs-0.8.2}/crates/onix-core/src/diff/object.rs

@@ -6,7 +6,7 @@ use crate::value::{Object, Value};
 
 use crate::error::Error;
 use crate::ignore_order::IgnoreOrderMemo;
-use crate::path::PathSegment;
+use crate::path::{PathSegment, object_key_path_segment as key_segment};
 use crate::report::{Report, ValuesChangedEntry};
 
 use super::{DiffOptions, check_map_depth, check_value_depth, diff_at, scoped};
@@ -95,6 +95,14 @@ pub(crate) fn object_diff(
         return Ok(report);
     }
 
+    // A non-`str` key needs python-equality matching (`object_diff_mixed`'s
+    // own doc has the rule); dispatched to a separate function, kept off
+    // this function's own frame, to protect the default `max_depth`
+    // budget on the hot `object_diff` <-> `diff_at` recursion.
+    if a.has_non_str_keys() || b.has_non_str_keys() {
+        return object_diff_mixed(path, a, b, depth, opts, memo);
+    }
+
     let mut report = Report::new();
 
     // Stepping into a key — whether it recurses (shared key) or is a leaf
@@ -104,26 +112,20 @@ pub(crate) fn object_diff(
     // `check_value_depth` call needs that same `depth + 1` (the depth its
     // own path sits at), not the *parent* dict's `depth`.
     for (key, old_value) in a {
-        scoped(
-            path,
-            PathSegment::Key(key.to_string()),
-            |path| -> Result<(), Error> {
-                match b.get(key) {
-                    None => {
-                        check_value_depth(path, old_value, depth + 1, opts.max_depth).map(|()| {
-                            report.insert_dictionary_item_removed(path.clone(), old_value.clone());
-                        })
-                    }
-                    Some(new_value) => diff_at(path, old_value, new_value, depth + 1, opts, memo)
-                        .map(|sub_report| report.merge(sub_report)),
-                }
-            },
-        )?;
+        scoped(path, key_segment(key), |path| -> Result<(), Error> {
+            match key.as_str().and_then(|s| b.get_str(s)) {
+                None => check_value_depth(path, old_value, depth + 1, opts.max_depth).map(|()| {
+                    report.insert_dictionary_item_removed(path.clone(), old_value.clone());
+                }),
+                Some(new_value) => diff_at(path, old_value, new_value, depth + 1, opts, memo)
+                    .map(|sub_report| report.merge(sub_report)),
+            }
+        })?;
     }
 
     for (key, new_value) in b {
-        if !a.contains_key(key) {
-            scoped(path, PathSegment::Key(key.to_string()), |path| {
+        if key.as_str().is_none_or(|s| !a.contains_key_str(s)) {
+            scoped(path, key_segment(key), |path| {
                 check_value_depth(path, new_value, depth + 1, opts.max_depth).map(|()| {
                     report.insert_dictionary_item_added(path.clone(), new_value.clone());
                 })
@@ -133,3 +135,51 @@ pub(crate) fn object_diff(
 
     Ok(report)
 }
+
+/// [`object_diff`]'s walk for the (rare) case where `a` or `b` has a
+/// non-`str` key — kept out of `object_diff`'s own body; see the call
+/// site's doc for why.
+///
+/// A non-`str` key matches across `a` and `b` by Python `==`, not this
+/// crate's own structural `ObjectKey` equality, via
+/// [`crate::ignore_order::match_dict_keys`] — see that function's doc for
+/// the exact rule and `tests/golden/README.md`'s "A dict key matches across
+/// two dicts by Python `==`" section for the confirmed example
+/// (`{1: "a"}` vs `{1.0: "a2"}` reports `root[1.0]`, `b`'s key form).
+///
+/// The `threshold_to_diff_deeper` collapse and the depth-counting
+/// convention are exactly [`object_diff`]'s own — see that function's doc.
+fn object_diff_mixed(
+    path: &mut Vec<PathSegment>,
+    a: &Object,
+    b: &Object,
+    depth: usize,
+    opts: &DiffOptions,
+    memo: &IgnoreOrderMemo,
+) -> Result<Report, Error> {
+    let mut report = Report::new();
+    let matched = crate::ignore_order::match_dict_keys(a, b);
+
+    for (key, old_value, new_value) in matched.shared {
+        scoped(path, key_segment(key), |path| {
+            diff_at(path, old_value, new_value, depth + 1, opts, memo)
+                .map(|sub_report| report.merge(sub_report))
+        })?;
+    }
+    for (key, old_value) in matched.only_a {
+        scoped(path, key_segment(key), |path| {
+            check_value_depth(path, old_value, depth + 1, opts.max_depth).map(|()| {
+                report.insert_dictionary_item_removed(path.clone(), old_value.clone());
+            })
+        })?;
+    }
+    for (key, new_value) in matched.only_b {
+        scoped(path, key_segment(key), |path| {
+            check_value_depth(path, new_value, depth + 1, opts.max_depth).map(|()| {
+                report.insert_dictionary_item_added(path.clone(), new_value.clone());
+            })
+        })?;
+    }
+
+    Ok(report)
+}

{deepdiff_rs-0.8.1 → deepdiff_rs-0.8.2}/crates/onix-core/src/diff/tests.rs

@@ -3,7 +3,7 @@ use crate::error::Error;
 use crate::path::PathSegment;
 use crate::report::Report;
 use crate::test_support::{cdate, cdt, cdt_at, cfrozen, cnum, cobj, cset, ctup, cv};
-use crate::value::{Object as CObject, SetItems, Value as CValue};
+use crate::value::{Object as CObject, ObjectKey, SetItems, Value as CValue};
 use serde_json::{Map, Number, Value, json};
 
 // Thin wrappers routing each `serde_json`-literal-based test through the real
@@ -1234,12 +1234,21 @@ fn threshold_collapse_rejects_a_deep_side_on_a_constrained_stack_instead_of_cras
                 value
             };
             let a = CValue::Object(CObject::from_pairs(vec![
-                (std::sync::Arc::from("p"), CValue::from(json!(1))),
-                (std::sync::Arc::from("q"), CValue::from(json!(2))),
+                (
+                    ObjectKey::Str(std::sync::Arc::from("p")),
+                    CValue::from(json!(1)),
+                ),
+                (
+                    ObjectKey::Str(std::sync::Arc::from("q")),
+                    CValue::from(json!(2)),
+                ),
             ]));
             let b = CValue::Object(CObject::from_pairs(vec![
-                (std::sync::Arc::from("r"), CValue::from(json!(3))),
-                (std::sync::Arc::from("deep"), deep),
+                (
+                    ObjectKey::Str(std::sync::Arc::from("r")),
+                    CValue::from(json!(3)),
+                ),
+                (ObjectKey::Str(std::sync::Arc::from("deep")), deep),
             ]));
 
             let err = super::diff_with_max_depth(&a, &b, 1).unwrap_err();
@@ -1289,6 +1298,71 @@ fn structure_exactly_at_configured_max_depth_diffs_successfully() {
     );
 }
 
+/// `object_diff_mixed`'s shared-key recursion steps `depth` by exactly one.
+#[test]
+fn mixed_dict_shared_key_recursion_steps_depth_by_one_not_by_multiplication() {
+    let a = CValue::Object(CObject::from_pairs(vec![(
+        ObjectKey::Other(Box::new(CValue::from(json!(1)))),
+        cv(&json!("a")),
+    )]));
+    let b = CValue::Object(CObject::from_pairs(vec![(
+        ObjectKey::Other(Box::new(CValue::from(json!(1)))),
+        cv(&json!("b")),
+    )]));
+
+    let err = super::diff_with_max_depth(&a, &b, 0).unwrap_err();
+
+    assert_eq!(
+        err,
+        Error::MaxDepthExceeded {
+            path: "root[1]".to_string(),
+            max_depth: 0,
+        }
+    );
+}
+
+/// `object_diff_mixed`'s removed-key (`only_a`) sink checks the removed
+/// value against its own path depth plus one, not the parent's.
+#[test]
+fn mixed_dict_removed_key_value_is_checked_against_its_own_plus_one_depth() {
+    let a = CValue::Object(CObject::from_pairs(vec![(
+        ObjectKey::Other(Box::new(CValue::from(json!(5)))),
+        cv(&nested_array(10, json!(1))), // one past the correct budget of 9
+    )]));
+    let b = CValue::Object(CObject::from_pairs(vec![]));
+
+    let err = super::diff_with_max_depth(&a, &b, 10).unwrap_err();
+
+    assert_eq!(
+        err,
+        Error::MaxDepthExceeded {
+            path: "root[5]".to_string(),
+            max_depth: 10,
+        }
+    );
+}
+
+/// [`mixed_dict_removed_key_value_is_checked_against_its_own_plus_one_depth`]'s
+/// twin for `object_diff_mixed`'s added-key (`only_b`) sink.
+#[test]
+fn mixed_dict_added_key_value_is_checked_against_its_own_plus_one_depth() {
+    let a = CValue::Object(CObject::from_pairs(vec![]));
+    let b = CValue::Object(CObject::from_pairs(vec![(
+        ObjectKey::Other(Box::new(CValue::from(json!(5)))),
+        cv(&nested_array(10, json!(1))), // one past the correct budget of 9
+    )]));
+
+    let err = super::diff_with_max_depth(&a, &b, 10).unwrap_err();
+
+    assert_eq!(
+        err,
+        Error::MaxDepthExceeded {
+            path: "root[5]".to_string(),
+            max_depth: 10,
+        }
+    );
+}
+
 #[test]
 fn structure_one_level_past_configured_max_depth_errors() {
     let a = nested_dict(4, json!("a"));
@@ -1918,7 +1992,7 @@ fn list_vs_tuple_nested_in_a_dict_is_a_type_change() {
     let mut a = Map::new();
     a.insert("a".to_string(), json!([1, 2]));
     let b = CValue::Object(CObject::from_pairs(vec![(
-        std::sync::Arc::from("a"),
+        ObjectKey::Str(std::sync::Arc::from("a")),
         ctup(&[json!(1), json!(2)]),
     )]));
     let report = super::diff(&cv(&Value::Object(a)), &b).unwrap();
@@ -2052,7 +2126,10 @@ fn a_dict_value_that_is_a_too_deep_tuple_errors_instead_of_being_cloned() {
     for _ in 0..5 {
         deep = CValue::Tuple(vec![deep].into_boxed_slice());
     }
-    let b = CValue::Object(CObject::from_pairs(vec![(std::sync::Arc::from("a"), deep)]));
+    let b = CValue::Object(CObject::from_pairs(vec![(
+        ObjectKey::Str(std::sync::Arc::from("a")),
+        deep,
+    )]));
     let error = super::diff_with_max_depth(&cv(&json!({})), &b, 4).unwrap_err();
     assert!(matches!(error, Error::MaxDepthExceeded { .. }));
 }

{deepdiff_rs-0.8.1 → deepdiff_rs-0.8.2}/crates/onix-core/src/ignore_order/distance.rs

@@ -5,7 +5,7 @@
 //! (`super::hash`) at all — every function here operates directly on the
 //! crate's compact [`Value`].
 
-use crate::value::{Number, Object, Value};
+use crate::value::{Number, Object, ObjectKey, Value};
 
 use crate::diff::DiffOptions;
 
@@ -256,7 +256,10 @@ pub(crate) fn item_length(value: &Value) -> usize {
 /// "new value" is a whole map, not a [`Value`]) can share it directly.
 fn item_length_of_map(map: &Object) -> usize {
     map.iter()
-        .filter(|(key, _)| !is_length_excluded_key(key))
+        // A non-`str` key can never match the literal exclusion list below,
+        // so it is always counted — `Option::is_none_or` reads as "excluded
+        // only when this is a `str` key that matches".
+        .filter(|(key, _)| key.as_str().is_none_or(|s| !is_length_excluded_key(s)))
         .map(|(_, v)| item_length(v))
         .sum()
 }
@@ -425,13 +428,21 @@ fn python_eq(a: &Value, b: &Value) -> bool {
         (Value::Set(x) | Value::FrozenSet(x), Value::Set(y) | Value::FrozenSet(y)) => {
             unordered_python_eq(x, y)
         }
+        // A non-`str` key needs `match_dict_keys`'s python-equality
+        // matching (see its doc); dispatched to a separate function, kept
+        // off this frame for the reason `crate::diff::object::object_diff`'s
+        // own dispatch documents.
         (Value::Object(x), Value::Object(y)) => {
-            x.len() == y.len()
-                && x.iter()
-                    .zip(y.iter())
-                    .all(|((x_key, x_value), (y_key, y_value))| {
-                        x_key == y_key && python_eq(x_value, y_value)
-                    })
+            if x.has_non_str_keys() || y.has_non_str_keys() {
+                dict_python_eq_mixed(x, y)
+            } else {
+                x.len() == y.len()
+                    && x.iter()
+                        .zip(y.iter())
+                        .all(|((x_key, x_value), (y_key, y_value))| {
+                            x_key == y_key && python_eq(x_value, y_value)
+                        })
+            }
         }
         _ => match (
             crate::lcs::python_scalar_key(a),
@@ -445,6 +456,20 @@ fn python_eq(a: &Value, b: &Value) -> bool {
     }
 }
 
+/// [`python_eq`]'s dict case for the (rare) pair where `a` or `b` has a
+/// non-`str` key — python-equality key matching via [`match_dict_keys`],
+/// kept out of [`python_eq`]'s own body for the reason its call site
+/// documents.
+fn dict_python_eq_mixed(a: &Object, b: &Object) -> bool {
+    let matched = match_dict_keys(a, b);
+    matched.only_a.is_empty()
+        && matched.only_b.is_empty()
+        && matched
+            .shared
+            .iter()
+            .all(|(_, a_value, b_value)| python_eq(a_value, b_value))
+}
+
 /// Element-wise [`python_eq`] over two sequences of the same length — what
 /// `list(x) == y` compares once `list()` has copied `x`'s items in order.
 fn sequences_python_eq(a: &[Value], b: &[Value]) -> bool {
@@ -693,13 +718,133 @@ fn coerce_to_python_str(value: &Value) -> Option<String> {
 /// producing a completely different pairing decision).
 pub(crate) const THRESHOLD_TO_DIFF_DEEPER: f64 = 0.33;
 
+/// A dict key's Python-equality identity — see [`match_dict_keys`]'s doc
+/// for the matching rule this backs and what a `None` result means.
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
+enum DictKeyIdentity {
+    Scalar(crate::lcs::ScalarKey),
+    Tuple(Vec<crate::lcs::ScalarKey>),
+}
+
+fn dict_key_identity(key: &ObjectKey) -> Option<DictKeyIdentity> {
+    match key {
+        ObjectKey::Str(s) => Some(DictKeyIdentity::Scalar(crate::lcs::ScalarKey::Str(
+            s.to_string(),
+        ))),
+        ObjectKey::Other(value) => match value.as_ref() {
+            Value::Tuple(items) => items
+                .iter()
+                .map(crate::lcs::python_scalar_key)
+                .collect::<Option<Vec<_>>>()
+                .map(DictKeyIdentity::Tuple),
+            other => crate::lcs::python_scalar_key(other).map(DictKeyIdentity::Scalar),
+        },
+    }
+}
+
+/// The result of matching two [`Object`]s' keys by [`DictKeyIdentity`] — see
+/// [`match_dict_keys`].
+pub(crate) struct DictKeyMatch<'a> {
+    /// A key present (by identity) on both sides: `b`'s own key (the one
+    /// `DeepDiff` renders and recurses with — see `crate::diff::object`'s
+    /// doc), `a`'s value, then `b`'s value.
+    pub(crate) shared: Vec<(&'a ObjectKey, &'a Value, &'a Value)>,
+    /// A key present only in `a`.
+    pub(crate) only_a: Vec<(&'a ObjectKey, &'a Value)>,
+    /// A key present only in `b`.
+    pub(crate) only_b: Vec<(&'a ObjectKey, &'a Value)>,
+}
+
+/// Matches `a`'s and `b`'s keys by [`DictKeyIdentity`] rather than
+/// [`Object::get`]/[`Object::contains_key`]'s structural [`ObjectKey`]
+/// equality — the rule every dict-vs-dict comparison in this crate needs
+/// once either side has a non-`str` key: `DeepDiff`'s own `dict`'s `==`
+/// (`_diff_dict`'s `SetOrdered` key intersection) collapses `1`, `1.0` and
+/// `True` into one key and compares a `tuple` key element-wise, confirmed
+/// against real `deepdiff==9.1.0`: `{1: "a"}` vs `{1.0: "a"}` is `{}`, not
+/// a removed+added pair. A key `dict_key_identity` cannot classify
+/// (unreachable from `onix-py`'s conversion, which restricts a dict key to
+/// `None`/`bool`/`int`/`float`/`str`/`datetime`/`date`/a `tuple` of those)
+/// is always reported as added/removed instead of matched.
+/// `crate::diff::object_diff`, [`count_object_diff_leaves`] and
+/// [`is_below_threshold_to_diff_deeper`] each call this once
+/// [`Object::has_non_str_keys`] says either side needs it, so an ordinary
+/// all-`str` object — the overwhelming common case — never builds the
+/// `BTreeMap` this does.
+///
+/// `O((n + m) log(n + m))`: one lookup map built from `b`'s keys, probed
+/// once per `a` key — the same complexity class `Object::get`'s binary
+/// search already gave the `str`-only path (`n` lookups at `O(log n)`
+/// each), not a quadratic case a non-`str` key newly introduces.
+pub(crate) fn match_dict_keys<'a>(a: &'a Object, b: &'a Object) -> DictKeyMatch<'a> {
+    let mut b_by_identity: std::collections::BTreeMap<DictKeyIdentity, usize> =
+        std::collections::BTreeMap::new();
+    let b_entries: Vec<(&ObjectKey, &Value)> = b.iter().collect();
+    for (index, (key, _)) in b_entries.iter().enumerate() {
+        if let Some(identity) = dict_key_identity(key) {
+            b_by_identity.insert(identity, index);
+        }
+    }
+
+    let mut matched_b: std::collections::BTreeSet<usize> = std::collections::BTreeSet::new();
+    let mut shared = Vec::new();
+    let mut only_a = Vec::new();
+
+    for (key, a_value) in a {
+        let found =
+            dict_key_identity(key).and_then(|identity| b_by_identity.get(&identity).copied());
+        match found {
+            Some(index) => {
+                matched_b.insert(index);
+                let (b_key, b_value) = b_entries[index];
+                shared.push((b_key, a_value, b_value));
+            }
+            None => only_a.push((key, a_value)),
+        }
+    }
+
+    let only_b = b_entries
+        .into_iter()
+        .enumerate()
+        .filter(|(index, _)| !matched_b.contains(index))
+        .map(|(_, entry)| entry)
+        .collect();
+
+    DictKeyMatch {
+        shared,
+        only_a,
+        only_b,
+    }
+}
+
 /// The shared `threshold_to_diff_deeper` ratio check backing both
 /// [`count_object_diff_leaves`] (the count-only distance mirror) and
 /// `crate::diff::object_diff`'s own unconditional collapse — see
 /// [`THRESHOLD_TO_DIFF_DEEPER`]'s own doc for why both exist.
 pub(crate) fn is_below_threshold_to_diff_deeper(a: &Object, b: &Object) -> bool {
-    let union_len = a.keys().chain(b.keys()).collect::<HashSet<_>>().len();
-    let intersect_len = a.keys().filter(|key| b.contains_key(key)).count();
+    let (union_len, intersect_len) = if a.has_non_str_keys() || b.has_non_str_keys() {
+        let matched = match_dict_keys(a, b);
+        (
+            matched.shared.len() + matched.only_a.len() + matched.only_b.len(),
+            matched.shared.len(),
+        )
+    } else {
+        // Unchanged from before `ObjectKey` existed: every key here is a
+        // `Str`, so structural and python-equality matching coincide, and
+        // `as_str` never filters anything out.
+        let union_len = a
+            .keys()
+            .filter_map(ObjectKey::as_str)
+            .chain(b.keys().filter_map(ObjectKey::as_str))
+            .collect::<HashSet<_>>()
+            .len();
+        let intersect_len = a
+            .keys()
+            .filter_map(ObjectKey::as_str)
+            .filter(|key| b.contains_key_str(key))
+            .count();
+        (union_len, intersect_len)
+    };
     #[allow(
         clippy::cast_precision_loss,
         reason = "key counts are small, far under f64's exact-integer range"
@@ -734,16 +879,22 @@ pub(crate) fn count_object_diff_leaves(
         return item_length_of_map(b);
     }
 
+    // Dispatched to a separate function, kept off this frame for the
+    // reason `crate::diff::object::object_diff`'s own dispatch documents.
+    if a.has_non_str_keys() || b.has_non_str_keys() {
+        return count_object_diff_leaves_mixed(a, b, depth, opts, memo);
+    }
+
     let mut total = 0;
 
     for (key, old_value) in a {
-        total += match b.get(key) {
+        total += match key.as_str().and_then(|s| b.get_str(s)) {
             None => item_length(old_value),
             Some(new_value) => count_diff_leaves(old_value, new_value, depth + 1, opts, memo),
         };
     }
     for (key, new_value) in b {
-        if !a.contains_key(key) {
+        if key.as_str().is_none_or(|s| !a.contains_key_str(s)) {
             total += item_length(new_value);
         }
     }
@@ -751,6 +902,34 @@ pub(crate) fn count_object_diff_leaves(
     total
 }
 
+/// [`count_object_diff_leaves`]'s walk for the (rare) case where `a` or `b`
+/// has a non-`str` key — matches keys the same way
+/// `crate::diff::object::object_diff_mixed` does (python-equality, via
+/// [`match_dict_keys`]); kept out of [`count_object_diff_leaves`]'s own
+/// body for the reason its call site documents.
+fn count_object_diff_leaves_mixed(
+    a: &Object,
+    b: &Object,
+    depth: usize,
+    opts: &DiffOptions,
+    memo: &IgnoreOrderMemo,
+) -> usize {
+    let matched = match_dict_keys(a, b);
+    let mut total = 0;
+
+    for (_, old_value, new_value) in &matched.shared {
+        total += count_diff_leaves(old_value, new_value, depth + 1, opts, memo);
+    }
+    for (_, old_value) in &matched.only_a {
+        total += item_length(old_value);
+    }
+    for (_, new_value) in &matched.only_b {
+        total += item_length(new_value);
+    }
+
+    total
+}
+
 /// [`count_diff_leaves`]'s set case: `DeepDiff`'s delta view of a set diff
 /// is `{"set_item_added": {<path>: {<items>}}, "set_item_removed": ...}`,
 /// and `_get_item_length` sums the [`item_length`] of every added and every

{deepdiff_rs-0.8.1 → deepdiff_rs-0.8.2}/crates/onix-core/src/ignore_order/fxhash.rs

@@ -42,8 +42,12 @@ pub(crate) type HashSet<T> = std::collections::HashSet<T, BuildHasherDefault<FxH
 /// attacker-controlled member content *and* reached for every set/frozenset
 /// comparison, **including with the default `ignore_order=false`**, so an
 /// `FxHash` table there would be a crafted-collision `DoS` on the ordinary
-/// path; a `BTreeMap` has no hash to attack (`O(log n)` worst case, always). See
-/// that module's "Set-member digests" section. Every remaining `FxHash` table
+/// path; a `BTreeMap` has no hash to attack (`O(log n)` worst case, always,
+/// though each of those comparisons is a full walk of the probed key —
+/// `member_content`'s `MemberContent::UnhashableDict` key is itself keyed by
+/// each dict key's own `ItemKey` tree, not a flat string, since a dict key
+/// may be a `tuple`). See that module's "Set-member digests" section. Every
+/// remaining `FxHash` table
 /// in this module — `HashedList`, `AddedCandidates`,
 /// the pairing/`used` sets, and the distance memo — is reached **only** under
 /// `ignore_order=true`, the pairing hot path already bounded by the `O(N²)`