deepdiff-rs 0.13.0__tar.gz → 0.13.1__tar.gz

{deepdiff_rs-0.13.0 → deepdiff_rs-0.13.1}/Cargo.lock

@@ -629,7 +629,7 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "onix-arrow"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -648,7 +648,7 @@ dependencies = [
 
 [[package]]
 name = "onix-cli"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "onix-core",
  "serde_json",
@@ -656,7 +656,7 @@ dependencies = [
 
 [[package]]
 name = "onix-core"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "num-bigint",
  "num-traits",
@@ -669,7 +669,7 @@ dependencies = [
 
 [[package]]
 name = "onix-py"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "arrow-array",
  "arrow-schema",

{deepdiff_rs-0.13.0 → deepdiff_rs-0.13.1}/Cargo.toml

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

{deepdiff_rs-0.13.0 → deepdiff_rs-0.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepdiff-rs
-Version: 0.13.0
+Version: 0.13.1
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: MIT License
@@ -136,7 +136,7 @@ Pass `--ignore-order` to compare every list by value instead of by position, mir
 
 `diff_tables` compares two tables the way `DeepDiff` compares two objects. It takes any object implementing the [Arrow PyCapsule interface](https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html) — a pyarrow `Table` or `RecordBatch`, a polars `DataFrame`, a DuckDB relation — and imports it with no Python round trip. The two tables are matched on a required, non-empty set of key columns (the table's primary key).
 
-It reports the **schema** diff (which columns were added, removed, or changed type), the keyed **row** diff (which rows were added, removed, or changed, and which keys are duplicated), and the per-cell diff (`cells_changed`): one row per changed cell, carrying the key columns, `column`, `old_value`/`new_value`, and `change` (`became_null`/`became_non_null`, `type_changed`, or `value_changed`), ordered by the canonical string rendering of the key columns (nulls first), then left-schema column order — the exact rendering and change-classification rules are in the module doc of [`crates/onix-arrow/src/row_diff.rs`](crates/onix-arrow/src/row_diff.rs). Rows are matched by the key columns; `rows_added`, `rows_removed`, `cells_changed`, and `duplicate_keys` return Arrow tables, and `summary()` counts each outcome.
+It reports the **schema** diff (which columns were added, removed, or changed type), the keyed **row** diff (which rows were added, removed, or changed, and which keys are duplicated), and the per-cell diff (`cells_changed`): one row per changed cell, carrying the key columns, `column`, `old_value`/`new_value`, and `change` (`became_null`/`became_non_null`, `type_changed`, or `value_changed`), ordered by the canonical string rendering of the key columns (nulls first), then left-schema column order — the exact rendering and change-classification rules are in [`docs/design/row-diff.md`](docs/design/row-diff.md)'s "Per-cell changes" section. Rows are matched by the key columns; `rows_added`, `rows_removed`, `cells_changed`, and `duplicate_keys` return Arrow tables, and `summary()` counts each outcome.
 
 ```python
 import pyarrow as pa
@@ -243,7 +243,7 @@ crates/onix-core   # the diff engine (library, no I/O)
 crates/onix-cli    # the `onix` binary (thin CLI over the core)
 crates/onix-arrow  # Arrow table diffing (schema diff and keyed row diff)
 crates/onix-py     # PyO3 bindings, published as `deepdiff-rs`
-docs/design/       # algorithm/invariant reference pages (list-diff, ignore-order, value-model, depth-budget)
+docs/design/       # algorithm/invariant reference pages (list-diff, ignore-order, value-model, depth-budget, row-diff)
 scripts/           # gen_goldens.py: regenerates tests/golden/ from real DeepDiff
 tests/golden       # DeepDiff-generated expected outputs (the compatibility corpus)
 perf/              # cross-language benchmark harness and RESULTS.md

{deepdiff_rs-0.13.0 → deepdiff_rs-0.13.1}/README.md

@@ -118,7 +118,7 @@ Pass `--ignore-order` to compare every list by value instead of by position, mir
 
 `diff_tables` compares two tables the way `DeepDiff` compares two objects. It takes any object implementing the [Arrow PyCapsule interface](https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html) — a pyarrow `Table` or `RecordBatch`, a polars `DataFrame`, a DuckDB relation — and imports it with no Python round trip. The two tables are matched on a required, non-empty set of key columns (the table's primary key).
 
-It reports the **schema** diff (which columns were added, removed, or changed type), the keyed **row** diff (which rows were added, removed, or changed, and which keys are duplicated), and the per-cell diff (`cells_changed`): one row per changed cell, carrying the key columns, `column`, `old_value`/`new_value`, and `change` (`became_null`/`became_non_null`, `type_changed`, or `value_changed`), ordered by the canonical string rendering of the key columns (nulls first), then left-schema column order — the exact rendering and change-classification rules are in the module doc of [`crates/onix-arrow/src/row_diff.rs`](crates/onix-arrow/src/row_diff.rs). Rows are matched by the key columns; `rows_added`, `rows_removed`, `cells_changed`, and `duplicate_keys` return Arrow tables, and `summary()` counts each outcome.
+It reports the **schema** diff (which columns were added, removed, or changed type), the keyed **row** diff (which rows were added, removed, or changed, and which keys are duplicated), and the per-cell diff (`cells_changed`): one row per changed cell, carrying the key columns, `column`, `old_value`/`new_value`, and `change` (`became_null`/`became_non_null`, `type_changed`, or `value_changed`), ordered by the canonical string rendering of the key columns (nulls first), then left-schema column order — the exact rendering and change-classification rules are in [`docs/design/row-diff.md`](docs/design/row-diff.md)'s "Per-cell changes" section. Rows are matched by the key columns; `rows_added`, `rows_removed`, `cells_changed`, and `duplicate_keys` return Arrow tables, and `summary()` counts each outcome.
 
 ```python
 import pyarrow as pa
@@ -225,7 +225,7 @@ crates/onix-core   # the diff engine (library, no I/O)
 crates/onix-cli    # the `onix` binary (thin CLI over the core)
 crates/onix-arrow  # Arrow table diffing (schema diff and keyed row diff)
 crates/onix-py     # PyO3 bindings, published as `deepdiff-rs`
-docs/design/       # algorithm/invariant reference pages (list-diff, ignore-order, value-model, depth-budget)
+docs/design/       # algorithm/invariant reference pages (list-diff, ignore-order, value-model, depth-budget, row-diff)
 scripts/           # gen_goldens.py: regenerates tests/golden/ from real DeepDiff
 tests/golden       # DeepDiff-generated expected outputs (the compatibility corpus)
 perf/              # cross-language benchmark harness and RESULTS.md

{deepdiff_rs-0.13.0 → deepdiff_rs-0.13.1}/crates/onix-arrow/examples/row_diff_profile.rs

@@ -1,6 +1,5 @@
-//! Per-pass wall-time and peak-RSS profile of one keyed row diff, the committed
-//! harness every row-diff performance change posts a before/after table from.
-//! Builds only with the `profile` feature, which the release wheel never enables.
+//! Per-pass wall-time and peak-RSS profile of one keyed row diff. Builds only
+//! with the `profile` feature, which the release wheel never enables.
 //!
 //! Each invocation runs a discarded warm-up diff, a timed uninstrumented diff
 //! (the `uninstrumented wall` line), and an instrumented diff whose passes make

{deepdiff_rs-0.13.0 → deepdiff_rs-0.13.1}/crates/onix-arrow/src/lib.rs

@@ -9,8 +9,9 @@
 //! tables use [`MemoryInput`]; a one-shot stream spools to a temporary file
 //! and implements [`TableInput`] over it, as the Python bindings do.
 //!
-//! See `src/row_diff.rs` for the row-matching and value-comparison rules, and
-//! `src/schema.rs` for the column type-normalization rules.
+//! See `src/row_diff.rs` for the row-matching passes, `docs/design/row-diff.md`
+//! for the algorithm, hashing, and value-comparison rules, and `src/schema.rs`
+//! for the column type-normalization rules.
 //!
 //! # Example
 //!
@@ -77,8 +78,9 @@ pub use schema::{ChangeKind, SchemaChange, diff_schemas};
 pub use table_diff::{TableDiff, TableDiffSummary};
 
 /// The maximum column-type nesting depth [`diff_tables`] will compare; deeper is refused
-/// with [`TableDiffError::MaxDepthExceeded`], turning a native-stack overflow (recursive
-/// comparison, `Display`, `Clone`/`Drop`) into an error before it can run.
+/// with [`TableDiffError::MaxDepthExceeded`], bounding the native-stack recursion in
+/// comparison, `Display`, `Clone`, and the drop of values onix builds from accepted
+/// input — not a caller's own drop of a `DataType` it built past this depth.
 /// Per-level cost is measured by `crates/onix-arrow/examples/type_stack_cost.rs`.
 pub const MAX_NESTING_DEPTH: usize = 128;
 

{deepdiff_rs-0.13.0 → deepdiff_rs-0.13.1}/crates/onix-arrow/src/row_diff.rs

@@ -1,152 +1,12 @@
-//! Keyed row diff: which rows were added, removed, or changed between two
-//! tables, matched by a required primary key, in memory proportional to the
-//! row count rather than the data size.
+//! Keyed row diff: which rows were added, removed, or changed between two tables, matched
+//! by a required primary key, in memory proportional to the row count rather than the data
+//! size. See `docs/design/row-diff.md` for the algorithm, hashing, and value-semantics detail.
 //!
-//! # Algorithm
-//!
-//! Three passes, so the full decoded tables never sit in memory at once:
-//!
-//! 1. **Hash pass.** Each side is opened and streamed batch by batch. Every row
-//!    yields a keyed 128-bit hash of its key columns and a keyed 128-bit hash of
-//!    its non-key columns (the value semantics are in [`hash_cell`]). The pairs
-//!    are collected into one `(key_hash, row_hash)` vector per side — 32 bytes
-//!    per row, the only per-row state that grows with the input — while the
-//!    batches themselves are dropped as they are consumed. Set arithmetic on the
-//!    two sorted vectors then classifies every key: only on the left (removed),
-//!    only on the right (added), on both with different row hashes (changed), on
-//!    both with equal row hashes (unchanged, never materialized), or appearing
-//!    more than once on either side (a duplicate key, excluded from the other
-//!    three and reported with its per-side counts).
-//! 2. **Materialize pass.** Each side is read again (a [`TableInput`] is
-//!    re-openable) and filtered to the rows whose keys landed in the added /
-//!    removed sets, plus one row per duplicate key for the duplicate-key report.
-//!    Only the differing rows are ever built into an output batch, and a kept
-//!    selection copies any buffer it shares with its decoded input batch (see
-//!    [`unshared`]).
-//! 3. **Cell pass.** The rows whose key is in the *changed* set are paired by
-//!    key hash and every common non-key column is compared cell by cell, one
-//!    output record per differing cell (see [`diff_cells`]).
-//!
-//! Single-threaded, every pass re-reads both sides and the cell pass holds both
-//! sides' changed rows at once. The parallel path reads the right side once: the
-//! left is hashed and indexed first ([`KeyIndex`]), so the right's hash pass
-//! tallies each row against the left key it matches instead of keeping its
-//! hashes ([`classify_indexed`]), keeps its added candidates, and spills its
-//! changed value rows by key-hash partition to anonymous temporary IPC files
-//! ([`RightFuse`]); one re-read of the left then materializes it and spills its
-//! changed rows ([`reread_left`]), and the cell pass compares and renders one
-//! partition at a time across the workers ([`diff_cells_streaming`]), holding one
-//! partition plus the output.
-//!
-//! # Parallelism
-//!
-//! By default the diff runs across `TableDiffOptions::threads` workers (the
-//! machine's available parallelism, capped at [`crate::MAX_THREADS`]): the hash
-//! passes hash each batch on a worker and append its rows straight into shared
-//! per-key-hash partition buffers, the classify step merge-joins each partition
-//! on its own worker, the left re-read classifies and routes each batch on a
-//! worker while the order-dependent filtering runs in batch order, and the cell
-//! pass renders each partition across the workers. The partition count is
-//! capped independently of the worker count (see [`partition_count`] and
-//! [`MAX_PARTITIONS`]). Every partitioning is by key hash and every reduction is
-//! order-independent or reordered back to batch order, so the output is
-//! byte-identical at any thread count; `threads == 1` runs the single-threaded
-//! path. The choice is made by peeking up to [`MIN_PARALLEL_ROWS`] rows or
-//! [`MAX_PEEK_BYTES`] of each side (whichever comes first) before spawning: a
-//! diff whose sides both fit under that bound runs single-threaded, and the peek
-//! reads the left side first so a large left never also buffers the right.
-//!
-//! Per-row state: 32 bytes a row per side single-threaded; in parallel, 32 on
-//! the left plus an 8-byte tally and under a byte of bucket directory, and a
-//! 32-byte map entry (first-row position and count) per right key absent from
-//! the left. Beyond that: in-flight batches (workers times batch size), buffer
-//! slack, the size gate's peek (at most [`MAX_PEEK_BYTES`] plus one producer
-//! batch per side), and every distinct duplicated key's values. In parallel, a
-//! key the left lacks keeps its first right row at full width until the key
-//! repeats, and each right batch holding such a row keeps a candidate record of
-//! those rows' key columns (shared with the rows until compaction copies them).
-//! The first right row of a key the left holds once with another row hash is
-//! spilled unless its batch repeats the key. A selection kept past its scan
-//! keeps its whole input batch resident, per side, if it keeps over half of it;
-//! a smaller one copies its buffers out, but byte-view data buffers reach the
-//! output whole, so its view data stays. The duplicate-key report always copies
-//! its key columns out. The cell pass holds a spill of every common value
-//! column of every changed row, both sides (resident where written temp pages
-//! count), and about twice the `cells_changed` output, not bounded by the
-//! changed *cell* count. The README's Known-limitations bullet has the figures.
-//!
-//! # Hashing
-//!
-//! Row identity is a single keyed 128-bit SipHash-1-3 ([`siphasher`]), keyed
-//! from 16 bytes of OS randomness ([`getrandom`]) drawn once per diff. Both
-//! sides of one diff share the key, so their hashes are comparable; a different
-//! diff draws a fresh key. Because the key is secret and random per run, the
-//! row-matching table cannot be forced into collisions by chosen input, and no
-//! unkeyed content hash table is used on this default (no-flag) path. Two
-//! distinct keys colliding to the same 128-bit hash — the only way this can
-//! misclassify — has probability on the order of `n² / 2¹²⁸`, negligible for
-//! any real table.
-//!
-//! # Value semantics
-//!
-//! Cell hashing largely matches how onix's core compares scalars: integers and
-//! integral floats within `±2⁵³` fold to one integer form (so `1`, `1.0`,
-//! `-0.0`, and a dictionary-encoded `1` all hash equal), other floats hash by
-//! their bit pattern, decimals (128- and 256-bit) hash by their exact value with
-//! trailing zeros removed (so `1.00` equals `1.0000`), timestamps hash by their
-//! UTC instant in nanoseconds (so the same instant at microsecond and
-//! millisecond precision hashes equal), times and durations likewise normalize
-//! to nanoseconds (so the same clock time or elapsed span at different units
-//! hashes equal), and a null is a distinct value that equals only another null —
-//! the `IS DISTINCT FROM` semantics the `DuckDB` oracle uses. One rule is this
-//! crate's own, not `onix-core`'s (which refuses NaN at conversion): every NaN
-//! folds to one canonical NaN, so no NaN-payload difference is a change, because
-//! the renderer cannot show two NaN payloads apart.
-//!
-//! # Per-cell changes
-//!
-//! [`diff_cells`] reports, for every changed row, which cells differ, as one
-//! output row per differing cell: the key columns, then `column`, `old_value`,
-//! `new_value`, and `change` (see [`diff_cells`] for the exact output order).
-//! A cell is reported changed **if and only if its [`hash_cell`] contribution
-//! differs** between the two matched rows — the same helper the row hash is
-//! built from, so the cell list and the row-changed decision can never drift.
-//! Each reported cell is labelled:
-//!
-//! - `became_null`/`became_non_null` when exactly one side is null;
-//! - `type_changed` when both are non-null and the two sides' types are not
-//!   losslessly comparable — their [`value_domain`]s differ (a number becoming a
-//!   string, a timestamp becoming a date), both are timestamps but one is
-//!   zone-aware and the other naive (different meaning at the same instant), or
-//!   both are intervals of different variants (which are not one span);
-//! - `value_changed` otherwise: the same value domain, differing in value over
-//!   the hash's lossless normalization. This covers a lossless type change —
-//!   `Int32`→`Int64`, a float width change, a time/duration unit change, a
-//!   decimal scale change — whose equal values hash equal and so are *not*
-//!   reported at all, and are `value_changed` only when the value genuinely
-//!   differs.
-//!
-//! A column present on only one side is a schema change and never a cell change.
-//! `old_value`/`new_value` are a canonical string rendering
-//! ([`arrow_cast::display`]), null for a null cell, produced so that a
-//! `value_changed` record can never carry two equal renderings: numbers of
-//! differing width render at the wider type (an `f32` `0.1` shows as
-//! `0.10000000149011612` against an `f64` `0.1`), a timestamp renders as its UTC
-//! instant with its zone appended when aware (so an aware and a naive timestamp
-//! of the same instant differ), a decimal renders at its native scale, a string
-//! verbatim (decimals and strings match the `DuckDB` oracle), a duration
-//! renders as an ISO 8601 `PT<seconds>S` string computed from its value — never
-//! through the Arrow formatter, whose second/millisecond duration formatter can
-//! emit a `<invalid>` sentinel while still succeeding — and a cross-variant
-//! interval renders with its variant appended, so two variants whose human
-//! form would otherwise coincide stay distinct (see [`prepare_render`]). As a
-//! construction guard, a `value_changed` record whose two renderings are
-//! nonetheless equal is a
-//! [`TableDiffError::EqualRenderings`], not a silent row. There is no typed
-//! old/new
-//! column: a long-format table mixes every compared column's type in one column,
-//! so a single typed column cannot represent them and the string rendering is
-//! the uniform form.
+//! - **Hash pass** — hashes every row's key and non-key columns; classifies keys by presence
+//!   and hash equality across the two sides.
+//! - **Materialize pass** — re-reads each side, keeping only added/removed rows and one row
+//!   per duplicate key.
+//! - **Cell pass** — pairs changed rows by key hash and reports each differing cell.
 //!
 //! # Which column types are hashed, refused, or skipped
 //!
@@ -172,11 +32,6 @@
 //!   non-key column (`List` and its variants, `FixedSizeList`, `Struct`, `Map`,
 //!   `Union`), which is out of scope for the row diff. A nested *key* column is
 //!   refused.
-//!
-//! [`hash_cell`] itself is non-recursive; the two recursive walks here —
-//! [`is_hashable`] and [`value_domain`], each over a dictionary value type — are
-//! bounded by the [`crate::MAX_NESTING_DEPTH`] depth check
-//! [`crate::diff_schemas`] runs before any row is read.
 
 use std::collections::{BTreeMap, HashMap, HashSet};
 use std::fs::File;
@@ -664,7 +519,8 @@ fn decimal_value(array: &ArrayRef, row: usize) -> Option<(i256, i8)> {
 
 /// Hashes one cell into `hasher`, tagged by kind so unlike kinds never collide.
 /// A null writes only [`TAG_NULL`]; every other kind writes its tag then a
-/// canonical form of the value (see the module docs' value semantics).
+/// canonical form of the value (see `docs/design/row-diff.md`'s "Value
+/// semantics" section).
 fn hash_cell(
     hasher: &mut CellHasher,
     array: &ArrayRef,
@@ -2629,11 +2485,12 @@ struct ColumnInputs<'a> {
 }
 
 /// Compares one column across the paired changed rows and appends a record for
-/// every differing cell. The change kind and rendering follow the module docs'
-/// per-cell rules: a value domain or timestamp-awareness mismatch is a type
-/// change, a differing value over the hash's lossless normalization is a value
-/// change, and each side renders in the common comparison form so a
-/// `value_changed` record never carries equal renderings.
+/// every differing cell. The change kind and rendering follow
+/// `docs/design/row-diff.md`'s "Per-cell changes" section: a value domain or
+/// timestamp-awareness mismatch is a type change, a differing value over the
+/// hash's lossless normalization is a value change, and each side renders in
+/// the common comparison form so a `value_changed` record never carries equal
+/// renderings.
 fn emit_column_records(
     column: &ColumnInputs<'_>,
     records: &mut Vec<CellRecord>,
@@ -4203,8 +4060,8 @@ impl CellColumns {
     }
 }
 
-/// Diffs the rows of two tables matched by `key`. See the module docs for the
-/// algorithm and value semantics.
+/// Diffs the rows of two tables matched by `key`. See `docs/design/row-diff.md`
+/// for the algorithm and value semantics.
 pub(crate) fn diff_rows(
     left: &impl TableInput,
     right: &impl TableInput,

{deepdiff_rs-0.13.0 → deepdiff_rs-0.13.1}/crates/onix-core/src/diff/options.rs

@@ -103,10 +103,10 @@ pub fn diff(a: &Value, b: &Value) -> Result<Report, Error> {
 /// assert!(report.is_empty());
 /// ```
 pub fn diff_with_options(a: &Value, b: &Value, opts: &DiffOptions) -> Result<Report, Error> {
-    // The distance memo is created here, per diff invocation, and dropped
-    // when this returns — no cross-call state. It only ever caches
-    // `ignore_order` container-pair distances (see `crate::ignore_order`'s
-    // `memo` module); for an ordered diff it is threaded but never consulted.
+    // The memo is created here, per diff invocation, and dropped when this
+    // returns — no cross-call state. An ordered diff consults it only through
+    // set comparison (set-member and tuple digests); `ignore_order` also
+    // caches container-pair distances in it.
     diff_with_options_memo(a, b, opts, &crate::ignore_order::IgnoreOrderMemo::new())
 }
 

{deepdiff_rs-0.13.0 → deepdiff_rs-0.13.1}/crates/onix-core/src/ignore_order/distance.rs

@@ -11,8 +11,6 @@ use crate::diff::DiffOptions;
 
 use super::IgnoreOrderMemo;
 
-use super::fxhash::HashSet;
-
 /// A total-ordering wrapper for the non-negative, always-finite distances
 /// [`rough_distance`] computes, so they can key a [`BTreeMap`](std::collections::BTreeMap) (ascending
 /// iteration, for [`compute_pairs`](super::pairing::compute_pairs)'s greedy loop) and group candidates by
@@ -872,7 +870,9 @@ pub(crate) fn match_dict_keys<'a>(a: &'a Object, b: &'a Object) -> DictKeyMatch<
 /// 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.
+/// [`THRESHOLD_TO_DIFF_DEEPER`]'s own doc for why both exist. All-`str` keys
+/// are counted by a merge of the two ascending key sequences: one key
+/// comparison per step, no hashing.
 pub(crate) fn is_below_threshold_to_diff_deeper(a: &Object, b: &Object) -> bool {
     let (union_len, intersect_len) = if a.has_non_str_keys() || b.has_non_str_keys() {
         let matched = match_dict_keys(a, b);
@@ -881,28 +881,24 @@ pub(crate) fn is_below_threshold_to_diff_deeper(a: &Object, b: &Object) -> bool
             matched.shared.len(),
         )
     } else {
-        // Every key here is an `ObjectKey::Str`, so structural and
-        // python-equality matching coincide. Counted by WTF-8 bytes, not
-        // `ObjectKey::as_str` (which is `None` for a lone-surrogate key —
-        // `ObjectKey` has no `Hash` impl at all, see its own doc, so this
-        // is also the only way to put one in a `HashSet` here), so a
-        // surrogate key is counted correctly instead of silently dropped.
-        fn key_bytes(key: &ObjectKey) -> &[u8] {
-            match key {
-                ObjectKey::Str(s) => s.as_bytes(),
-                ObjectKey::Other(_) => {
-                    unreachable!("has_non_str_keys() is false on both sides in this branch")
+        let (mut a_keys, mut b_keys) = (a.keys().peekable(), b.keys().peekable());
+        let mut intersect_len = 0;
+        while let (Some(a_key), Some(b_key)) = (a_keys.peek(), b_keys.peek()) {
+            match a_key.cmp(b_key) {
+                std::cmp::Ordering::Less => {
+                    a_keys.next();
+                }
+                std::cmp::Ordering::Greater => {
+                    b_keys.next();
+                }
+                std::cmp::Ordering::Equal => {
+                    intersect_len += 1;
+                    a_keys.next();
+                    b_keys.next();
                 }
             }
         }
-        let union_len = a
-            .keys()
-            .map(key_bytes)
-            .chain(b.keys().map(key_bytes))
-            .collect::<HashSet<_>>()
-            .len();
-        let intersect_len = a.keys().filter(|key| b.contains_key(key)).count();
-        (union_len, intersect_len)
+        (a.len() + b.len() - intersect_len, intersect_len)
     };
     #[allow(
         clippy::cast_precision_loss,

deepdiff_rs-0.13.1/crates/onix-core/src/ignore_order/fxhash.rs

@@ -0,0 +1,115 @@
+//! `FxHash`: a small, fast, non-cryptographic hasher for this module's `HashMap`/`HashSet`s.
+//! See [`FxHasher`]'s doc for the accepted `DoS` trade-off and which tables carry it.
+
+use std::hash::BuildHasherDefault;
+
+/// This module's [`HashMap`](std::collections::HashMap), keyed with [`FxHasher`].
+pub(crate) type HashMap<K, V> = std::collections::HashMap<K, V, BuildHasherDefault<FxHasher>>;
+/// The [`HashMap`] equivalent for [`std::collections::HashSet`].
+pub(crate) type HashSet<T> = std::collections::HashSet<T, BuildHasherDefault<FxHasher>>;
+
+/// The `FxHash` algorithm (the one `rustc` itself uses for compiler-hot-path hash maps),
+/// implemented from scratch.
+///
+/// # `DoS` trade-off (this hasher is *not* collision-resistant)
+///
+/// `FxHash` uses a fixed, public seed ([`FX_SEED`]) and an invertible step: a crafted
+/// collision degrades an `FxHash` map or set from `O(1)` to `O(n)` per operation, pushing
+/// [`HashedList::build`](super::hash::HashedList::build) from `O(n)` to `O(n²)` on an
+/// all-colliding list, on top of the module's `O(N²)` pairing.
+/// [`HashedList`](super::hash::HashedList), `AddedCandidates`, the pairing/`used` sets and
+/// its result maps (`most_in_common_pairs`, `pairs`), `consumed_removed`, and the distance
+/// memo are `FxHash`-keyed and reached only under `ignore_order=true`: an accepted,
+/// documented `DoS` trade-off — `SipHash` there cost a measured per-call penalty on the
+/// pairing hot path (PR #4). No default-path table is `FxHash`-keyed:
+/// [`IgnoreOrderMemo`](super::memo::IgnoreOrderMemo)'s `tuple_ids`, which set comparison
+/// reaches through `set_member_digest` -> `tuple_keyed` -> `tuple_digest` for a tuple dict
+/// key inside a set member, is a `BTreeMap` (below), and
+/// [`is_below_threshold_to_diff_deeper`](super::distance::is_below_threshold_to_diff_deeper),
+/// called by `object_diff` for every unequal dict pair, counts dict-key overlap by a sorted
+/// merge, with no table. Bound untrusted input against the module's `O(N²)` pairing
+/// regardless of hasher.
+///
+/// Every `FxHash`-keyed type carrying a float ([`ItemKey`](super::hash::ItemKey),
+/// [`ScalarKey`](crate::lcs::ScalarKey), and the distance memo's
+/// [`DistKey`](super::hash::DistKey) via `number_key`) mixes its bits first
+/// ([`mix_float_bits`](crate::lcs::mix_float_bits)), so integral and half-integer floats —
+/// whose raw bit patterns share many trailing zeros — do not collide by accident. Every `NaN`
+/// additionally folds onto one fixed key, matching `DeepHash`'s `str()`-based digest: this
+/// changes which values these tables treat as the same item, not their per-lookup cost.
+///
+/// `node_table`, `member_content` and `tuple_ids` in `IgnoreOrderMemo` are `BTreeMap`s instead,
+/// since they are keyed by attacker-controlled member content and reached on the default path
+/// too, with no `Hash` derive: `O(log n)` worst case, always, though each comparison still
+/// walks the whole probed key — `member_content`'s `MemberContent::UnhashableDict` key is
+/// itself keyed by each dict key's own `ItemKey` tree, not a flat string.
+///
+/// An integer beyond `i128` (`ItemKey::BigInt`) hashes and compares by its magnitude digits,
+/// `O(digits)` not `O(1)` per lookup — inside a hashable tuple it reaches the same cost via
+/// `ScalarKey::Big` and `tuple_ids`, through `PyHashPart::Scalar` — a cost the `ignore_order`
+/// element-count cap does not bound: one huge integer costs its own digit length regardless
+/// of element count. A custom object's `ItemKey::Object` costs `ItemKey::Dict`'s full walk
+/// plus one class-name comparison, and two distinct classes sharing a `__name__` share its
+/// bucket; `ItemKey::Opaque` costs one identity string comparison.
+#[derive(Default)]
+pub(crate) struct FxHasher {
+    pub(crate) hash: u64,
+}
+
+/// `FxHash`'s seed constant (golden-ratio-derived odd constant).
+pub(crate) const FX_SEED: u64 = 0x51_7c_c1_b7_27_22_0a_95;
+
+impl FxHasher {
+    /// Folds one word into the hash: rotate, xor, multiply — `FxHash`'s mixing step.
+    pub(crate) fn add_to_hash(&mut self, word: u64) {
+        self.hash = (self.hash.rotate_left(5) ^ word).wrapping_mul(FX_SEED);
+    }
+}
+
+impl std::hash::Hasher for FxHasher {
+    fn write(&mut self, mut bytes: &[u8]) {
+        while let Some(chunk) = bytes.get(..8) {
+            let word = u64::from_ne_bytes(chunk.try_into().expect("chunk is exactly 8 bytes"));
+            self.add_to_hash(word);
+            bytes = &bytes[8..];
+        }
+        for &byte in bytes {
+            self.add_to_hash(u64::from(byte));
+        }
+    }
+
+    fn write_u8(&mut self, i: u8) {
+        self.add_to_hash(u64::from(i));
+    }
+
+    fn write_u16(&mut self, i: u16) {
+        self.add_to_hash(u64::from(i));
+    }
+
+    fn write_u32(&mut self, i: u32) {
+        self.add_to_hash(u64::from(i));
+    }
+
+    fn write_u64(&mut self, i: u64) {
+        self.add_to_hash(i);
+    }
+
+    fn write_u128(&mut self, i: u128) {
+        #[allow(
+            clippy::cast_possible_truncation,
+            reason = "hash mixing only, truncation does not affect correctness, only distribution"
+        )]
+        {
+            self.add_to_hash(i as u64);
+            self.add_to_hash((i >> 64) as u64);
+        }
+    }
+
+    fn write_usize(&mut self, i: usize) {
+        self.add_to_hash(i as u64);
+    }
+
+    fn finish(&self) -> u64 {
+        self.hash
+    }
+}

{deepdiff_rs-0.13.0 → deepdiff_rs-0.13.1}/crates/onix-core/src/ignore_order/hash.rs

@@ -329,7 +329,7 @@ impl std::hash::Hash for ItemKey {
 /// Referring to a nested tuple by id rather than by its whole identity is
 /// what keeps this `O(arity)` per node: `((((1,),),),)` is four one-element
 /// identities, not four identities of size 1, 2, 3 and 4.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub(crate) enum PyHashPart {
     Scalar(ScalarKey),
     Tuple(TupleId),
@@ -345,12 +345,12 @@ pub(crate) enum PyHashPart {
 /// ([`python_scalar_key`], which makes `1`, `1.0` and `True` one key), and a
 /// list or dict is unhashable, which also makes any tuple containing one
 /// unhashable.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub(crate) struct PyHashKey(Box<[PyHashPart]>);
 
 /// A hashable tuple identity's place in the run's interning table — see
 /// [`super::IgnoreOrderMemo::tuple_digest`].
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub(crate) struct TupleId(usize);
 
 impl TupleId {

{deepdiff_rs-0.13.0 → deepdiff_rs-0.13.1}/crates/onix-core/src/ignore_order/memo.rs

@@ -24,14 +24,17 @@ type DistanceKey = (DistKey, DistKey);
 /// "Distance memo" section: pairwise container distances, tuple
 /// digests, and set-member digests, scoped to one diff run. `DistKey`
 /// keys hash and compare by a full-tree walk; `MemberContent` keys
-/// compare by one (it has no `Hash`). A big-integer leaf costs
+/// compare by one (it has no `Hash`); a `PyHashKey` lookup makes `O(log n)`
+/// comparisons, each `O(the probed key's element bytes)`, a nested tuple
+/// comparing as one id. A big-integer leaf costs
 /// `O(digits)` per lookup; `super::fxhash`'s doc enumerates each key's cost.
 pub(crate) struct IgnoreOrderMemo<'r> {
     cache: RefCell<HashMap<DistanceKey, f64>>,
     /// Interns each hashable-tuple identity to its digest, shared
     /// across the run — see `docs/design/ignore-order.md`'s "Distance
-    /// memo" section.
-    tuple_ids: RefCell<HashMap<PyHashKey, TupleId>>,
+    /// memo" section. A `BTreeMap`, reached on the default path through a
+    /// set member's tuple dict keys; its key type carries no `Hash` derive.
+    tuple_ids: RefCell<BTreeMap<PyHashKey, TupleId>>,
     /// The digest assigned to each interned identity, indexed by
     /// [`TupleId::index`].
     tuple_digests: RefCell<Vec<ItemKey>>,
@@ -60,7 +63,7 @@ impl<'r> IgnoreOrderMemo<'r> {
     pub(crate) fn new() -> Self {
         Self {
             cache: RefCell::new(HashMap::default()),
-            tuple_ids: RefCell::new(HashMap::default()),
+            tuple_ids: RefCell::new(BTreeMap::new()),
             tuple_digests: RefCell::new(Vec::new()),
             node_table: RefCell::new(BTreeMap::new()),
             member_content: RefCell::new(BTreeMap::new()),
@@ -78,7 +81,7 @@ impl<'r> IgnoreOrderMemo<'r> {
     pub(crate) fn disabled() -> Self {
         Self {
             cache: RefCell::new(HashMap::default()),
-            tuple_ids: RefCell::new(HashMap::default()),
+            tuple_ids: RefCell::new(BTreeMap::new()),
             tuple_digests: RefCell::new(Vec::new()),
             node_table: RefCell::new(BTreeMap::new()),
             member_content: RefCell::new(BTreeMap::new()),