deepdiff-rs 0.9.2__tar.gz → 0.9.3__tar.gz

{deepdiff_rs-0.9.2 → deepdiff_rs-0.9.3}/Cargo.lock

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

{deepdiff_rs-0.9.2 → deepdiff_rs-0.9.3}/Cargo.toml

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

{deepdiff_rs-0.9.2 → deepdiff_rs-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepdiff-rs
-Version: 0.9.2
+Version: 0.9.3
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: MIT License
@@ -148,7 +148,7 @@ A key appearing more than once on either side is reported in `duplicate_keys` (w
 
 Type comparison uses the full logical Arrow type (timestamp unit and timezone, decimal precision and scale, and so on), but physical encodings that carry the same logical type compare equal — a dictionary-encoded string equals a plain string, polars' `Utf8View` equals pyarrow's `Utf8`, the list variants normalize together, and a map compares equal however a library spells it — so the same table read through pyarrow, polars, or DuckDB reports no spurious type changes. The full normalization rules are documented on `normalized_type` (and `map_entries`) in [`crates/onix-arrow/src/schema.rs`](crates/onix-arrow/src/schema.rs); nullability is ignored but reported in each record. Column names must be unique on each side; a repeated name raises `ValueError`. `diff.schema_arrow` is the same result as an Arrow table: it implements `__arrow_c_stream__`, so `polars.DataFrame(diff.schema_arrow)` consumes it with no pyarrow needed, and `diff.schema_arrow.to_pyarrow()` returns a `pyarrow.Table`; `pandas.api.interchange.from_dataframe(diff.schema_arrow)` also works, but pandas' own implementation of that protocol needs pyarrow installed regardless of which path you take.
 
-`pyarrow` is optional: install it with `pip install deepdiff-rs[arrow]`. It is needed only for `to_pyarrow()` and for passing pyarrow objects in — importing `deepdiff_rs` and diffing polars or DuckDB tables need it not at all. Passing an object that implements neither Arrow protocol raises `TypeError`; calling `to_pyarrow()` without pyarrow installed raises `ImportError` naming the extra. `diff.to_json()` gives the whole diff — schema, summary, and `rows_added`/`rows_removed`/`cells_changed`/`duplicate_keys` in full, one JSON object per row — as a single string with no pyarrow, polars, or pandas needed at all; see [Known limitations](#known-limitations) for its row cap.
+`pyarrow` is optional: install it with `pip install deepdiff-rs[arrow]`. It is needed only for `to_pyarrow()` and for passing pyarrow objects in — importing `deepdiff_rs` and diffing polars or DuckDB tables need it not at all. Passing an object that implements neither Arrow protocol raises `TypeError`; calling `to_pyarrow()` without pyarrow installed raises `ImportError` naming the extra; `diff.to_json()` gives the whole diff — schema, summary, and `rows_added`/`rows_removed`/`cells_changed`/`duplicate_keys` in full, one JSON object per row — as a single string with no pyarrow, polars, or pandas needed at all; see [Known limitations](#known-limitations) for its row cap.
 
 ## Performance
 
@@ -241,7 +241,7 @@ perf/              # cross-language benchmark harness and RESULTS.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` (or `dict` key) containing a lone (unpaired) surrogate code point (e.g. `'\udc80'`, legal in Python but not encodable as UTF-8) is compared and reported exactly like any other `str`, matching DeepDiff's plain `==`; `to_json()` renders it with `json.dumps`'s own single-backslash `\uXXXX` escape. The one accepted divergence, always deterministic: hashing one — a `set`/`frozenset` member, or *any* value at all once `ignore_order=True` (`DeepHash` hashes every value there, not just a set's members) — crashes real DeepDiff with an unhandled `UnicodeEncodeError`, where onix hashes by code point and reports normally. 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).
 - `ignore_order` pairing is `O(N^2)` in unpaired elements per side and carries a polynomial cost in both time and memory with input depth; it has no `max_passes`/`max_diffs` cutoff, so bound the size and depth of untrusted input yourself. See [`crates/onix-core/src/ignore_order/mod.rs`](crates/onix-core/src/ignore_order/mod.rs).

{deepdiff_rs-0.9.2 → deepdiff_rs-0.9.3}/README.md

@@ -130,7 +130,7 @@ A key appearing more than once on either side is reported in `duplicate_keys` (w
 
 Type comparison uses the full logical Arrow type (timestamp unit and timezone, decimal precision and scale, and so on), but physical encodings that carry the same logical type compare equal — a dictionary-encoded string equals a plain string, polars' `Utf8View` equals pyarrow's `Utf8`, the list variants normalize together, and a map compares equal however a library spells it — so the same table read through pyarrow, polars, or DuckDB reports no spurious type changes. The full normalization rules are documented on `normalized_type` (and `map_entries`) in [`crates/onix-arrow/src/schema.rs`](crates/onix-arrow/src/schema.rs); nullability is ignored but reported in each record. Column names must be unique on each side; a repeated name raises `ValueError`. `diff.schema_arrow` is the same result as an Arrow table: it implements `__arrow_c_stream__`, so `polars.DataFrame(diff.schema_arrow)` consumes it with no pyarrow needed, and `diff.schema_arrow.to_pyarrow()` returns a `pyarrow.Table`; `pandas.api.interchange.from_dataframe(diff.schema_arrow)` also works, but pandas' own implementation of that protocol needs pyarrow installed regardless of which path you take.
 
-`pyarrow` is optional: install it with `pip install deepdiff-rs[arrow]`. It is needed only for `to_pyarrow()` and for passing pyarrow objects in — importing `deepdiff_rs` and diffing polars or DuckDB tables need it not at all. Passing an object that implements neither Arrow protocol raises `TypeError`; calling `to_pyarrow()` without pyarrow installed raises `ImportError` naming the extra. `diff.to_json()` gives the whole diff — schema, summary, and `rows_added`/`rows_removed`/`cells_changed`/`duplicate_keys` in full, one JSON object per row — as a single string with no pyarrow, polars, or pandas needed at all; see [Known limitations](#known-limitations) for its row cap.
+`pyarrow` is optional: install it with `pip install deepdiff-rs[arrow]`. It is needed only for `to_pyarrow()` and for passing pyarrow objects in — importing `deepdiff_rs` and diffing polars or DuckDB tables need it not at all. Passing an object that implements neither Arrow protocol raises `TypeError`; calling `to_pyarrow()` without pyarrow installed raises `ImportError` naming the extra; `diff.to_json()` gives the whole diff — schema, summary, and `rows_added`/`rows_removed`/`cells_changed`/`duplicate_keys` in full, one JSON object per row — as a single string with no pyarrow, polars, or pandas needed at all; see [Known limitations](#known-limitations) for its row cap.
 
 ## Performance
 
@@ -223,7 +223,7 @@ perf/              # cross-language benchmark harness and RESULTS.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` (or `dict` key) containing a lone (unpaired) surrogate code point (e.g. `'\udc80'`, legal in Python but not encodable as UTF-8) is compared and reported exactly like any other `str`, matching DeepDiff's plain `==`; `to_json()` renders it with `json.dumps`'s own single-backslash `\uXXXX` escape. The one accepted divergence, always deterministic: hashing one — a `set`/`frozenset` member, or *any* value at all once `ignore_order=True` (`DeepHash` hashes every value there, not just a set's members) — crashes real DeepDiff with an unhandled `UnicodeEncodeError`, where onix hashes by code point and reports normally. 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).
 - `ignore_order` pairing is `O(N^2)` in unpaired elements per side and carries a polynomial cost in both time and memory with input depth; it has no `max_passes`/`max_diffs` cutoff, so bound the size and depth of untrusted input yourself. See [`crates/onix-core/src/ignore_order/mod.rs`](crates/onix-core/src/ignore_order/mod.rs).

{deepdiff_rs-0.9.2 → deepdiff_rs-0.9.3}/crates/onix-core/src/diff/dispatch.rs

@@ -222,7 +222,7 @@ pub(crate) fn check_value_depth(
 ) -> Result<(), Error> {
     if deeper_than(value, max_depth.saturating_sub(depth)) {
         return Err(Error::MaxDepthExceeded {
-            path: render_path(path),
+            path: render_path(path).to_string(),
             max_depth,
         });
     }
@@ -266,7 +266,7 @@ pub(crate) fn check_map_depth(
 ) -> Result<(), Error> {
     if map_deeper_than(map, max_depth.saturating_sub(depth)) {
         return Err(Error::MaxDepthExceeded {
-            path: render_path(path),
+            path: render_path(path).to_string(),
             max_depth,
         });
     }
@@ -294,7 +294,7 @@ pub(crate) fn check_traversal_depth(
 ) -> Result<(), Error> {
     if depth > max_depth {
         return Err(Error::MaxDepthExceeded {
-            path: render_path(path),
+            path: render_path(path).to_string(),
             max_depth,
         });
     }

{deepdiff_rs-0.9.2 → deepdiff_rs-0.9.3}/crates/onix-core/src/diff/object.rs

@@ -113,7 +113,7 @@ pub(crate) fn object_diff(
     // own path sits at), not the *parent* dict's `depth`.
     for (key, old_value) in a {
         scoped(path, key_segment(key), |path| -> Result<(), Error> {
-            match key.as_str().and_then(|s| b.get_str(s)) {
+            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());
                 }),
@@ -124,7 +124,7 @@ pub(crate) fn object_diff(
     }
 
     for (key, new_value) in b {
-        if key.as_str().is_none_or(|s| !a.contains_key_str(s)) {
+        if !a.contains_key(key) {
             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());

{deepdiff_rs-0.9.2 → deepdiff_rs-0.9.3}/crates/onix-core/src/diff/scalar.rs

@@ -159,7 +159,7 @@ pub(crate) fn normalized_pair(
     new: DateTime,
 ) -> Result<(DateTime, DateTime), Error> {
     let out_of_range = || Error::DateTimeOutOfRange {
-        path: render_path(path),
+        path: render_path(path).to_string(),
     };
 
     Ok((

{deepdiff_rs-0.9.2 → deepdiff_rs-0.9.3}/crates/onix-core/src/diff/tests.rs

@@ -1235,20 +1235,23 @@ fn threshold_collapse_rejects_a_deep_side_on_a_constrained_stack_instead_of_cras
             };
             let a = CValue::Object(CObject::from_pairs(vec![
                 (
-                    ObjectKey::Str(std::sync::Arc::from("p")),
+                    ObjectKey::Str(crate::value::Key::Utf8(std::sync::Arc::from("p"))),
                     CValue::from(json!(1)),
                 ),
                 (
-                    ObjectKey::Str(std::sync::Arc::from("q")),
+                    ObjectKey::Str(crate::value::Key::Utf8(std::sync::Arc::from("q"))),
                     CValue::from(json!(2)),
                 ),
             ]));
             let b = CValue::Object(CObject::from_pairs(vec![
                 (
-                    ObjectKey::Str(std::sync::Arc::from("r")),
+                    ObjectKey::Str(crate::value::Key::Utf8(std::sync::Arc::from("r"))),
                     CValue::from(json!(3)),
                 ),
-                (ObjectKey::Str(std::sync::Arc::from("deep")), deep),
+                (
+                    ObjectKey::Str(crate::value::Key::Utf8(std::sync::Arc::from("deep"))),
+                    deep,
+                ),
             ]));
 
             let err = super::diff_with_max_depth(&a, &b, 1).unwrap_err();
@@ -1992,7 +1995,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![(
-        ObjectKey::Str(std::sync::Arc::from("a")),
+        ObjectKey::Str(crate::value::Key::Utf8(std::sync::Arc::from("a"))),
         ctup(&[json!(1), json!(2)]),
     )]));
     let report = super::diff(&cv(&Value::Object(a)), &b).unwrap();
@@ -2127,7 +2130,7 @@ fn a_dict_value_that_is_a_too_deep_tuple_errors_instead_of_being_cloned() {
         deep = ctuple(vec![deep]);
     }
     let b = CValue::Object(CObject::from_pairs(vec![(
-        ObjectKey::Str(std::sync::Arc::from("a")),
+        ObjectKey::Str(crate::value::Key::Utf8(std::sync::Arc::from("a"))),
         deep,
     )]));
     let error = super::diff_with_max_depth(&cv(&json!({})), &b, 4).unwrap_err();
@@ -2711,7 +2714,10 @@ fn two_set_subclasses_of_the_same_class_diff_by_membership() {
 
 #[test]
 fn an_object_subclass_versus_the_base_type_is_a_type_change_at_equal_value() {
-    let entries = vec![(ObjectKey::Str(std::sync::Arc::from("a")), cv(&json!(1)))];
+    let entries = vec![(
+        ObjectKey::Str(crate::value::Key::Utf8(std::sync::Arc::from("a"))),
+        cv(&json!(1)),
+    )];
     let base = CValue::Object(CObject::from_pairs(entries.clone()));
     let subclass = CValue::Object(
         CObject::from_pairs(entries).with_type_name(Some(std::sync::Arc::from("MyDict"))),

{deepdiff_rs-0.9.2 → deepdiff_rs-0.9.3}/crates/onix-core/src/ignore_order/distance.rs

@@ -256,9 +256,11 @@ 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()
-        // 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".
+        // A non-`str` key, and a `str` key holding a lone surrogate (never
+        // equal to one of the plain-ASCII names below — see `ObjectKey::
+        // as_str`, `None` for both), can never match the literal exclusion
+        // list, so it is always counted — `Option::is_none_or` reads as
+        // "excluded only when this is a plain `str` key that matches".
         .filter(|(key, _)| key.as_str().is_none_or(|s| !is_length_excluded_key(s)))
         .map(|(_, v)| item_length(v))
         .sum()
@@ -524,7 +526,7 @@ fn coerce_for_type_change(old_value: &Value, new_value: &Value) -> Option<Value>
             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())),
+        Value::Str(_) => coerce_to_python_str(old_value).map(|s| Value::Str(s.into())),
         Value::Null
         | Value::DateTime(_)
         | Value::Date(_)
@@ -561,6 +563,9 @@ fn is_truthy(value: &Value) -> bool {
         }
         Value::Bool(b) => *b,
         Value::Number(n) => n.as_f64().is_some_and(|f| f != 0.0),
+        // Never empty by construction for `Str::Wtf8` (see `Str::is_empty`),
+        // so this is always `true` there — matching `bool("\udc80") ==
+        // True` in real Python.
         Value::Str(s) => !s.is_empty(),
         Value::Array(items) | Value::Tuple(items) => !items.is_empty(),
         Value::Set(items) | Value::FrozenSet(items) => !items.is_empty(),
@@ -587,7 +592,9 @@ fn coerce_to_f64(value: &Value) -> Option<f64> {
         | Value::Object(_) => None,
         Value::Bool(b) => Some(if *b { 1.0 } else { 0.0 }),
         Value::Number(n) => n.as_f64(),
-        Value::Str(s) => s.trim().parse::<f64>().ok(),
+        // A `Str::Wtf8` (a lone surrogate present) is never a valid float
+        // literal, matching `float("\udc80")` raising in real Python.
+        Value::Str(s) => s.as_utf8().and_then(|s| s.trim().parse::<f64>().ok()),
     }
 }
 
@@ -642,7 +649,8 @@ fn coerce_to_i64(value: &Value) -> Option<i64> {
                     .or_else(|| n.as_u64().and_then(|u| i64::try_from(u).ok()))
             }
         }
-        Value::Str(s) => s.trim().parse::<i64>().ok(),
+        // See `coerce_to_f64`'s doc for the `Str::Wtf8` case.
+        Value::Str(s) => s.as_utf8().and_then(|s| s.trim().parse::<i64>().ok()),
     }
 }
 
@@ -690,7 +698,13 @@ fn coerce_to_python_str(value: &Value) -> Option<String> {
                 n.as_u64().map(|u| u.to_string())
             }
         }
-        Value::Str(s) => Some(s.to_string()),
+        // `str(x)` is the identity for a value already a `str`, including
+        // one holding a lone surrogate — but this coercion only ever needs
+        // to build a `String`, which cannot hold one, so a `Str::Wtf8`
+        // falls through to `None` here (an accepted, narrow gap: it only
+        // costs an unnecessary type-change inclusion, never a wrong one —
+        // see this function's own doc).
+        Value::Str(s) => s.as_utf8().map(ToString::to_string),
     }
 }
 
@@ -731,7 +745,7 @@ enum DictKeyIdentity {
 fn dict_key_identity(key: &ObjectKey) -> Option<DictKeyIdentity> {
     match key {
         ObjectKey::Str(s) => Some(DictKeyIdentity::Scalar(crate::lcs::ScalarKey::Str(
-            s.to_string(),
+            s.as_bytes().to_vec(),
         ))),
         ObjectKey::Other(value) => match value.as_ref() {
             Value::Tuple(items) => items
@@ -831,20 +845,27 @@ pub(crate) fn is_below_threshold_to_diff_deeper(a: &Object, b: &Object) -> bool
             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.
+        // 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 union_len = a
             .keys()
-            .filter_map(ObjectKey::as_str)
-            .chain(b.keys().filter_map(ObjectKey::as_str))
+            .map(key_bytes)
+            .chain(b.keys().map(key_bytes))
             .collect::<HashSet<_>>()
             .len();
-        let intersect_len = a
-            .keys()
-            .filter_map(ObjectKey::as_str)
-            .filter(|key| b.contains_key_str(key))
-            .count();
+        let intersect_len = a.keys().filter(|key| b.contains_key(key)).count();
         (union_len, intersect_len)
     };
     #[allow(
@@ -890,13 +911,13 @@ pub(crate) fn count_object_diff_leaves(
     let mut total = 0;
 
     for (key, old_value) in a {
-        total += match key.as_str().and_then(|s| b.get_str(s)) {
+        total += match b.get(key) {
             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 key.as_str().is_none_or(|s| !a.contains_key_str(s)) {
+        if !a.contains_key(key) {
             total += item_length(new_value);
         }
     }

{deepdiff_rs-0.9.2 → deepdiff_rs-0.9.3}/crates/onix-core/src/ignore_order/hash.rs

@@ -195,7 +195,10 @@ pub(crate) enum ItemKey {
     /// 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),
+    /// WTF-8 bytes (see `crate::value::Str`) rather than `String`, so a
+    /// lone surrogate still has a distinct, correct content key instead of
+    /// failing to compile or silently colliding with a different string.
+    Str(Vec<u8>),
     /// A `datetime`, keyed by its instant with a naive value read as UTC —
     /// `DeepHash._prep_datetime` runs `datetime_normalize` before formatting
     /// its digest string, so a naive and an aware value at the same moment
@@ -257,7 +260,8 @@ pub(crate) enum ItemKey {
     /// keyed too — a plain `String` cannot represent a non-`str` dict key
     /// (`ItemKey` already covers every key kind this crate's dicts allow,
     /// scalar or a `tuple` of scalars, via the same recursion [`item_key`]
-    /// runs on a value).
+    /// runs on a value) and, via [`ItemKey::Str`]'s own WTF-8 bytes, a
+    /// `str` key holding a lone surrogate code point too.
     Dict(BTreeMap<ItemKey, ItemKey>),
 }
 
@@ -667,7 +671,7 @@ fn scalar_content_key(value: &Value) -> ItemKey {
         Value::Null => ItemKey::Null,
         Value::Bool(b) => ItemKey::Bool(*b),
         Value::Number(n) => number_key(n),
-        Value::Str(s) => ItemKey::Str(s.to_string()),
+        Value::Str(s) => ItemKey::Str(s.as_bytes().to_vec()),
         Value::DateTime(dt) => ItemKey::DateTime(dt.instant()),
         Value::Date(date) => ItemKey::Date(date.ordinal()),
         Value::Time(time) => ItemKey::Time(time.hash_seconds_of_day()),
@@ -763,7 +767,7 @@ fn keyed(value: &Value, memo: &IgnoreOrderMemo, want_part: bool) -> (ItemKey, Op
     match value {
         Value::Null => (ItemKey::Null, part()),
         Value::Bool(b) => (ItemKey::Bool(*b), part()),
-        Value::Str(s) => (ItemKey::Str(s.to_string()), part()),
+        Value::Str(s) => (ItemKey::Str(s.as_bytes().to_vec()), part()),
         Value::DateTime(value) => (ItemKey::DateTime(value.instant()), part()),
         Value::Date(value) => (ItemKey::Date(value.ordinal()), part()),
         Value::Time(value) => (ItemKey::Time(value.hash_seconds_of_day()), part()),
@@ -833,7 +837,7 @@ fn keyed(value: &Value, memo: &IgnoreOrderMemo, want_part: bool) -> (ItemKey, Op
 /// inline match, for the unkeyed `DistKey` case) instead.
 fn object_key_item_key(key: &crate::value::ObjectKey, memo: &IgnoreOrderMemo) -> ItemKey {
     match key {
-        crate::value::ObjectKey::Str(s) => ItemKey::Str(s.to_string()),
+        crate::value::ObjectKey::Str(s) => ItemKey::Str(s.as_bytes().to_vec()),
         crate::value::ObjectKey::Other(value) => item_key(value, memo),
     }
 }

{deepdiff_rs-0.9.2 → deepdiff_rs-0.9.3}/crates/onix-core/src/ignore_order/tests.rs

@@ -1865,7 +1865,7 @@ fn tuple_and_list_leaf_lengths_follow_python_equality() {
 /// `serde_json` literal cannot express.
 fn cobj_of(key: &str, value: CValue) -> CValue {
     CValue::Object(crate::value::Object::from_pairs(vec![(
-        ObjectKey::Str(std::sync::Arc::from(key)),
+        ObjectKey::Str(crate::value::Key::Utf8(std::sync::Arc::from(key))),
         value,
     )]))
 }
@@ -3166,7 +3166,7 @@ fn arb_cvalue() -> impl Strategy<Value = CValue> {
         any::<bool>().prop_map(CValue::Bool),
         any::<i64>().prop_map(|i| CValue::Number(crate::value::Number::from_i64(i))),
         arb_float,
-        "[a-z]{0,3}".prop_map(|s| CValue::Str(s.into_boxed_str())),
+        "[a-z]{0,3}".prop_map(|s| CValue::Str(s.into())),
         arb_datetime,
         arb_date,
     ];

{deepdiff_rs-0.9.2 → deepdiff_rs-0.9.3}/crates/onix-core/src/lcs.rs

@@ -87,7 +87,9 @@ use crate::value::Value;
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub(crate) enum ScalarKey {
     Null,
-    Str(String),
+    /// WTF-8 bytes (see `crate::value::Str`), so a lone surrogate still
+    /// compares correctly instead of failing to compile or colliding.
+    Str(Vec<u8>),
     Int(i128),
     /// 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`.
@@ -252,7 +254,7 @@ fn scalar_key(value: &Value) -> ScalarKey {
 pub(crate) fn python_scalar_key(value: &Value) -> Option<ScalarKey> {
     Some(match value {
         Value::Null => ScalarKey::Null,
-        Value::Str(s) => ScalarKey::Str(s.to_string()),
+        Value::Str(s) => ScalarKey::Str(s.as_bytes().to_vec()),
         Value::Bool(b) => ScalarKey::Int(i128::from(*b)),
         Value::Number(n) => {
             if let Some(i) = n