deepdiff-rs 0.4.0__tar.gz → 0.4.1__tar.gz

{deepdiff_rs-0.4.0 → deepdiff_rs-0.4.1}/Cargo.lock

@@ -127,7 +127,7 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "onix-cli"
-version = "0.4.0"
+version = "0.4.1"
 dependencies = [
  "onix-core",
  "serde_json",
@@ -135,7 +135,7 @@ dependencies = [
 
 [[package]]
 name = "onix-core"
-version = "0.4.0"
+version = "0.4.1"
 dependencies = [
  "proptest",
  "serde",
@@ -145,7 +145,7 @@ dependencies = [
 
 [[package]]
 name = "onix-py"
-version = "0.4.0"
+version = "0.4.1"
 dependencies = [
  "onix-core",
  "pyo3",

{deepdiff_rs-0.4.0 → deepdiff_rs-0.4.1}/Cargo.toml

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

{deepdiff_rs-0.4.0 → deepdiff_rs-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepdiff-rs
-Version: 0.4.0
+Version: 0.4.1
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: MIT License
@@ -118,7 +118,7 @@ Pass `--ignore-order` to compare every list by value instead of by position, mir
 - A subclass of a supported type (a `tuple`, `set` or `frozenset` subclass including `namedtuple`, a `datetime`/`date` 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`, `time` and `timedelta` are not supported. The normalized-versus-raw split is documented in [`tests/golden/README.md`](tests/golden/README.md).
 - **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.
-- Two distinct `str` values that differ only in lone surrogates (`'\ud800'` and `'\udc00'`) convert to the same string, so a set holding both loses a member and with it a finding. Tracked as [issue #27](https://github.com/ksco92/onix/issues/27).
+- A `str` containing a lone (unpaired) surrogate code point (e.g. `'\udc80'`, legal in Python but not encodable as UTF-8) raises `ValueError` naming the exact path on either side, before the two values are ever compared — including a pair DeepDiff would call equal and report as no change, since DeepDiff's scalar equality is plain Python `==` and never hits the encoding problem; DeepDiff does report a plain change for a *differing* pair, and crashes with an unhandled `UnicodeEncodeError` if such a string is ever hashed (a `set`/`frozenset` member). See [`tests/golden/README.md`](tests/golden/README.md)'s "Known DeepDiff quirks" section.
 - A `str` inside a `tuple` or `frozenset` set item is rendered with Python's `repr()`, which escapes every non-printable character; onix escapes those below `U+0100` (the complete set in that range) and passes higher non-printable code points through literally, since escaping them would mean carrying a Unicode category table. Exact for all of ASCII and all printable text. See [`crates/onix-core/src/path.rs`](crates/onix-core/src/path.rs).
 - 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).
@@ -128,25 +128,31 @@ Pass `--ignore-order` to compare every list by value instead of by position, mir
 
 Two committed, regenerable reports back the numbers below; every figure here is copied verbatim from them.
 
-The Python bindings against real `deepdiff` on **live Python objects**, the number a real caller pays (source: [`crates/onix-py/benchmarks/bench_bindings.py`](crates/onix-py/benchmarks/bench_bindings.py), macOS 26.5.1, Apple M5 Max, median of 11 isolated subprocess runs per side):
+The Python bindings against real `deepdiff` on **live Python objects**, the number a real caller pays (source: [`crates/onix-py/benchmarks/bench_bindings.py`](crates/onix-py/benchmarks/bench_bindings.py), macOS 26.5.1, Apple M5 Max, median of 11 isolated subprocess runs per side, run on 2026-09-04):
 
 | Shape | deepdiff | deepdiff_rs | Speedup |
 | --- | --- | --- | --- |
-| `ignore_order`, 10k shuffled ints, ~5% mutated (live objects) | 3128.94ms | 82.57ms | **37.89x** |
-|   peak RSS | 228.0 MB | 141.2 MB | **1.61x** |
-|   CPU seconds | 3.128 s | 0.083 s | **37.88x** |
-| Heterogeneous API-payload records, n=20,000 (live objects) | 3466.52ms | 149.18ms | **23.24x** |
-|   peak RSS | 117.5 MB | 148.3 MB | **0.79x** |
-|   CPU seconds | 3.465 s | 0.149 s | **23.24x** |
-| Same `ignore_order` shape, via `diff_json` (JSON-string path) | 3133.45ms | 83.16ms | **37.68x** |
-|   peak RSS | 228.9 MB | 141.7 MB | **1.62x** |
-|   CPU seconds | 3.131 s | 0.083 s | **37.68x** |
-| Same API-payload shape, via `diff_json` (JSON-string path) | 4568.33ms | 86.33ms | **52.92x** |
-|   peak RSS | 139.0 MB | 141.7 MB | **0.98x** |
-|   CPU seconds | 4.566 s | 0.086 s | **52.90x** |
-| Same API-payload shape, both tools reading two JSON files from disk | 4571.28ms | 85.35ms | **53.56x** |
-|   peak RSS | 139.0 MB | 141.8 MB | **0.98x** |
-|   CPU seconds | 4.569 s | 0.085 s | **53.54x** |
+| `ignore_order`, 10k shuffled ints, ~5% mutated (live objects) | 3164.29ms | 89.08ms | **35.52x** |
+|   peak RSS | 228.4 MB | 141.5 MB | **1.61x** |
+|   CPU seconds | 3.162 s | 0.089 s | **35.50x** |
+| Heterogeneous API-payload records, n=20,000 (live objects) | 3451.01ms | 151.84ms | **22.73x** |
+|   peak RSS | 118.1 MB | 147.7 MB | **0.80x** |
+|   CPU seconds | 3.449 s | 0.152 s | **22.73x** |
+| Typed records (datetime/tuple/set fields), n=10,000 (live objects) | 792.96ms | 47.87ms | **16.57x** |
+|   peak RSS | 60.2 MB | 62.1 MB | **0.97x** |
+|   CPU seconds | 0.792 s | 0.048 s | **16.56x** |
+| Same typed-records shape, `ignore_order` (live objects) | 60483.86ms | 1272.04ms | **47.55x** |
+|   peak RSS | 112.1 MB | 1005.6 MB | **0.11x** |
+|   CPU seconds | 60.452 s | 1.271 s | **47.55x** |
+| Same `ignore_order` shape, via `diff_json` (JSON-string path) | 3168.05ms | 86.95ms | **36.44x** |
+|   peak RSS | 228.7 MB | 142.3 MB | **1.61x** |
+|   CPU seconds | 3.166 s | 0.087 s | **36.46x** |
+| Same API-payload shape, via `diff_json` (JSON-string path) | 4568.00ms | 85.37ms | **53.51x** |
+|   peak RSS | 139.5 MB | 140.9 MB | **0.99x** |
+|   CPU seconds | 4.566 s | 0.085 s | **53.50x** |
+| Same API-payload shape, both tools reading two JSON files from disk | 4565.46ms | 89.43ms | **51.05x** |
+|   peak RSS | 139.5 MB | 141.0 MB | **0.99x** |
+|   CPU seconds | 4.564 s | 0.089 s | **51.03x** |
 
 The engine's own diff-only time and peak resident memory against pinned `deepdiff` 9.1.0 (source: [`perf/RESULTS.md`](perf/RESULTS.md), same machine, median over tier-appropriate runs, diff time excluding process startup and JSON parsing on both sides):
 

{deepdiff_rs-0.4.0 → deepdiff_rs-0.4.1}/README.md

@@ -102,7 +102,7 @@ Pass `--ignore-order` to compare every list by value instead of by position, mir
 - A subclass of a supported type (a `tuple`, `set` or `frozenset` subclass including `namedtuple`, a `datetime`/`date` 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`, `time` and `timedelta` are not supported. The normalized-versus-raw split is documented in [`tests/golden/README.md`](tests/golden/README.md).
 - **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.
-- Two distinct `str` values that differ only in lone surrogates (`'\ud800'` and `'\udc00'`) convert to the same string, so a set holding both loses a member and with it a finding. Tracked as [issue #27](https://github.com/ksco92/onix/issues/27).
+- A `str` containing a lone (unpaired) surrogate code point (e.g. `'\udc80'`, legal in Python but not encodable as UTF-8) raises `ValueError` naming the exact path on either side, before the two values are ever compared — including a pair DeepDiff would call equal and report as no change, since DeepDiff's scalar equality is plain Python `==` and never hits the encoding problem; DeepDiff does report a plain change for a *differing* pair, and crashes with an unhandled `UnicodeEncodeError` if such a string is ever hashed (a `set`/`frozenset` member). See [`tests/golden/README.md`](tests/golden/README.md)'s "Known DeepDiff quirks" section.
 - A `str` inside a `tuple` or `frozenset` set item is rendered with Python's `repr()`, which escapes every non-printable character; onix escapes those below `U+0100` (the complete set in that range) and passes higher non-printable code points through literally, since escaping them would mean carrying a Unicode category table. Exact for all of ASCII and all printable text. See [`crates/onix-core/src/path.rs`](crates/onix-core/src/path.rs).
 - 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).
@@ -112,25 +112,31 @@ Pass `--ignore-order` to compare every list by value instead of by position, mir
 
 Two committed, regenerable reports back the numbers below; every figure here is copied verbatim from them.
 
-The Python bindings against real `deepdiff` on **live Python objects**, the number a real caller pays (source: [`crates/onix-py/benchmarks/bench_bindings.py`](crates/onix-py/benchmarks/bench_bindings.py), macOS 26.5.1, Apple M5 Max, median of 11 isolated subprocess runs per side):
+The Python bindings against real `deepdiff` on **live Python objects**, the number a real caller pays (source: [`crates/onix-py/benchmarks/bench_bindings.py`](crates/onix-py/benchmarks/bench_bindings.py), macOS 26.5.1, Apple M5 Max, median of 11 isolated subprocess runs per side, run on 2026-09-04):
 
 | Shape | deepdiff | deepdiff_rs | Speedup |
 | --- | --- | --- | --- |
-| `ignore_order`, 10k shuffled ints, ~5% mutated (live objects) | 3128.94ms | 82.57ms | **37.89x** |
-|   peak RSS | 228.0 MB | 141.2 MB | **1.61x** |
-|   CPU seconds | 3.128 s | 0.083 s | **37.88x** |
-| Heterogeneous API-payload records, n=20,000 (live objects) | 3466.52ms | 149.18ms | **23.24x** |
-|   peak RSS | 117.5 MB | 148.3 MB | **0.79x** |
-|   CPU seconds | 3.465 s | 0.149 s | **23.24x** |
-| Same `ignore_order` shape, via `diff_json` (JSON-string path) | 3133.45ms | 83.16ms | **37.68x** |
-|   peak RSS | 228.9 MB | 141.7 MB | **1.62x** |
-|   CPU seconds | 3.131 s | 0.083 s | **37.68x** |
-| Same API-payload shape, via `diff_json` (JSON-string path) | 4568.33ms | 86.33ms | **52.92x** |
-|   peak RSS | 139.0 MB | 141.7 MB | **0.98x** |
-|   CPU seconds | 4.566 s | 0.086 s | **52.90x** |
-| Same API-payload shape, both tools reading two JSON files from disk | 4571.28ms | 85.35ms | **53.56x** |
-|   peak RSS | 139.0 MB | 141.8 MB | **0.98x** |
-|   CPU seconds | 4.569 s | 0.085 s | **53.54x** |
+| `ignore_order`, 10k shuffled ints, ~5% mutated (live objects) | 3164.29ms | 89.08ms | **35.52x** |
+|   peak RSS | 228.4 MB | 141.5 MB | **1.61x** |
+|   CPU seconds | 3.162 s | 0.089 s | **35.50x** |
+| Heterogeneous API-payload records, n=20,000 (live objects) | 3451.01ms | 151.84ms | **22.73x** |
+|   peak RSS | 118.1 MB | 147.7 MB | **0.80x** |
+|   CPU seconds | 3.449 s | 0.152 s | **22.73x** |
+| Typed records (datetime/tuple/set fields), n=10,000 (live objects) | 792.96ms | 47.87ms | **16.57x** |
+|   peak RSS | 60.2 MB | 62.1 MB | **0.97x** |
+|   CPU seconds | 0.792 s | 0.048 s | **16.56x** |
+| Same typed-records shape, `ignore_order` (live objects) | 60483.86ms | 1272.04ms | **47.55x** |
+|   peak RSS | 112.1 MB | 1005.6 MB | **0.11x** |
+|   CPU seconds | 60.452 s | 1.271 s | **47.55x** |
+| Same `ignore_order` shape, via `diff_json` (JSON-string path) | 3168.05ms | 86.95ms | **36.44x** |
+|   peak RSS | 228.7 MB | 142.3 MB | **1.61x** |
+|   CPU seconds | 3.166 s | 0.087 s | **36.46x** |
+| Same API-payload shape, via `diff_json` (JSON-string path) | 4568.00ms | 85.37ms | **53.51x** |
+|   peak RSS | 139.5 MB | 140.9 MB | **0.99x** |
+|   CPU seconds | 4.566 s | 0.085 s | **53.50x** |
+| Same API-payload shape, both tools reading two JSON files from disk | 4565.46ms | 89.43ms | **51.05x** |
+|   peak RSS | 139.5 MB | 141.0 MB | **0.99x** |
+|   CPU seconds | 4.564 s | 0.089 s | **51.03x** |
 
 The engine's own diff-only time and peak resident memory against pinned `deepdiff` 9.1.0 (source: [`perf/RESULTS.md`](perf/RESULTS.md), same machine, median over tier-appropriate runs, diff time excluding process startup and JSON parsing on both sides):
 

{deepdiff_rs-0.4.0 → deepdiff_rs-0.4.1}/crates/onix-core/src/value.rs

@@ -522,13 +522,13 @@ impl SetItems {
     /// dropping any member equal to an earlier one.
     ///
     /// A real Python `set` cannot hold two equal members, but this
-    /// constructor cannot assume it was handed one: the Python conversion
-    /// boundary is lossy for lone surrogates (`'\ud800'` and `'\udc00'`
-    /// both become `U+FFFD`), and this type is public. Two equal members
-    /// would render to the same path segment and so to the same *structural*
-    /// report path, which [`crate::report::Report`] requires to be unique;
-    /// dropping the later one is what a Python set would have done with the
-    /// pair in the first place.
+    /// constructor cannot assume it was handed one: this type is public, so
+    /// a caller building a [`Value`] directly can still hand it two
+    /// structurally equal members. Two equal members would render to the
+    /// same path segment and so to the same *structural* report path, which
+    /// [`crate::report::Report`] requires to be unique; dropping the later
+    /// one is what a Python set would have done with the pair in the first
+    /// place.
     ///
     /// Equality here is the structural one `canonical_cmp` decides, which
     /// is exactly what "renders to the same path segment" means. It is

{deepdiff_rs-0.4.0 → deepdiff_rs-0.4.1}/crates/onix-py/benchmarks/bench_bindings.py

@@ -56,6 +56,7 @@ import tempfile
 import time
 from collections.abc import Callable
 from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Final
 
@@ -65,6 +66,9 @@ from deepdiff_rs import DeepDiff as OnixDeepDiff
 from deepdiff_rs import diff_json
 
 type JsonValue = dict[str, "JsonValue"] | list["JsonValue"] | str | int | float | bool | None
+# `id`/`name` (int/str), `created_at` (datetime), `coordinate` (a tuple pair),
+# `tags` (a string set) — the fields `_make_typed_record` builds.
+type TypedRecord = dict[str, int | str | datetime | tuple[int, int] | tuple[float, float] | set[str]]
 
 ##############################################
 ##############################################
@@ -78,12 +82,18 @@ type JsonValue = dict[str, "JsonValue"] | list["JsonValue"] | str | int | float
 SEED: Final[int] = 20260901
 IGNORE_ORDER_SIZE: Final[int] = 10_000
 RECORD_COUNT: Final[int] = 20_000
+TYPED_RECORD_COUNT: Final[int] = 10_000
 VALUE_CHANGE_RATE: Final[float] = 0.05
 RUNS: Final[int] = 11
 
 _ORIGINAL_INT_RANGE: Final[tuple[int, int]] = (0, 1_000_000)
 _CHANGED_INT_RANGE: Final[tuple[int, int]] = (10_000_000, 20_000_000)
 
+# A fixed offset, never the process's local zone, so the fixture's aware
+# half is deterministic across machines.
+_TYPED_RECORD_TZ: Final[timezone] = timezone(timedelta(hours=-5))
+_TAG_POOL: Final[tuple[str, ...]] = ("alpha", "beta", "gamma", "delta", "epsilon", "zeta", "eta", "theta")
+
 
 ##############################################
 ##############################################
@@ -92,6 +102,17 @@ _CHANGED_INT_RANGE: Final[tuple[int, int]] = (10_000_000, 20_000_000)
 # Fixture generation (live Python objects)
 
 
+def _mutation_indices(count: int, rng: random.Random) -> list[int]:
+    """
+    Sample the indices to mutate for a `VALUE_CHANGE_RATE` batch.
+
+    :param count: Total element count to sample from.
+    :param rng: Seeded random source.
+    :return: The indices to mutate.
+    """
+    return rng.sample(range(count), int(count * VALUE_CHANGE_RATE))
+
+
 def build_ignore_order_case() -> tuple[JsonValue, JsonValue]:
     """
     Build the `ignore_order_10k` shape: a shuffled, ~5%-mutated int list.
@@ -102,9 +123,8 @@ def build_ignore_order_case() -> tuple[JsonValue, JsonValue]:
     a: list[JsonValue] = [rng.randint(*_ORIGINAL_INT_RANGE) for _ in range(IGNORE_ORDER_SIZE)]
     b = list(a)
     rng.shuffle(b)
-    change_n = int(IGNORE_ORDER_SIZE * VALUE_CHANGE_RATE)
 
-    for index in rng.sample(range(IGNORE_ORDER_SIZE), change_n):
+    for index in _mutation_indices(IGNORE_ORDER_SIZE, rng):
         b[index] = rng.randint(*_CHANGED_INT_RANGE)
 
     return a, b
@@ -184,9 +204,8 @@ def build_api_payloads_case() -> tuple[JsonValue, JsonValue]:
     rng = random.Random(SEED + 1)
     a: list[JsonValue] = [_make_record(i, rng) for i in range(RECORD_COUNT)]
     b = copy.deepcopy(a)
-    change_n = int(RECORD_COUNT * VALUE_CHANGE_RATE)
 
-    for index in rng.sample(range(RECORD_COUNT), change_n):
+    for index in _mutation_indices(RECORD_COUNT, rng):
         record = b[index]
         assert isinstance(record, dict)
         b[index] = _mutate_record(record, rng)
@@ -194,6 +213,96 @@ def build_api_payloads_case() -> tuple[JsonValue, JsonValue]:
     return a, b
 
 
+def _make_typed_record(index: int, rng: random.Random) -> TypedRecord:
+    """
+    Build one record whose fields exercise 0.4.0's typed-conversion path: a
+    datetime (naive or aware), a numeric-pair tuple, and a small string set.
+
+    :param index: The record's position (used for its `id` and to alternate
+        naive/aware).
+    :param rng: Seeded random source.
+    :return: The built record.
+    """
+    coordinate: tuple[int, int] | tuple[float, float]
+
+    if rng.random() < 0.5:
+        coordinate = (round(rng.uniform(-90.0, 90.0), 4), round(rng.uniform(-180.0, 180.0), 4))
+    else:
+        coordinate = (rng.randint(-1000, 1000), rng.randint(-1000, 1000))
+
+    # Drawn into a variable rather than inline in the dict literal below:
+    # dict values evaluate in key order, and `tags` must draw before
+    # `created_at` for this function's RNG consumption to stay positionally
+    # fixed regardless of how the dict literal is ordered or edited.
+    tags = set(rng.sample(_TAG_POOL, rng.randint(1, 4)))
+
+    return {
+        "id": index,
+        "name": f"typed_{index:07d}",
+        "created_at": datetime(
+            2020 + rng.randint(0, 5),
+            rng.randint(1, 12),
+            rng.randint(1, 28),
+            rng.randint(0, 23),
+            rng.randint(0, 59),
+            rng.randint(0, 59),
+            tzinfo=_TYPED_RECORD_TZ if index % 2 == 0 else None,
+        ),
+        "coordinate": coordinate,
+        "tags": tags,
+    }
+
+
+def _mutate_typed_record(record: TypedRecord, rng: random.Random) -> TypedRecord:
+    """
+    Mutate one typed record for a "value changed" entry: shift its datetime
+    and add a tag drawn from the pool. The tag draw is a no-op when the
+    record already holds that tag, so the datetime always changes but only
+    roughly 70% of mutated records also gain a set change.
+
+    :param record: The original record; not mutated in place.
+    :param rng: Seeded random source.
+    :return: The mutated copy.
+    """
+    mutated = dict(record)
+    created_at = record["created_at"]
+    tags = record["tags"]
+    assert isinstance(created_at, datetime)
+    assert isinstance(tags, set)
+    mutated["created_at"] = created_at + timedelta(days=rng.randint(1, 30))
+    mutated["tags"] = tags | {rng.choice(_TAG_POOL)}
+
+    return mutated
+
+
+def build_typed_records_case(*, shuffle: bool = False) -> tuple[list[TypedRecord], list[TypedRecord]]:
+    """
+    Build the `typed_records` shape: `TYPED_RECORD_COUNT` records, each
+    carrying a datetime, a tuple coordinate, and a string-set tags field,
+    ~5% mutated at record granularity.
+
+    `b` is `copy.deepcopy(a)`, for the same identity-sharing reason
+    documented on `build_api_payloads_case`. With `shuffle=True`, `b` is
+    reordered before mutation (matching `build_ignore_order_case`'s
+    shuffle-then-mutate order) for the `ignore_order` variant; the ordered
+    variant leaves `b` in `a`'s order, matching `build_api_payloads_case`.
+
+    :param shuffle: Whether to shuffle `b`'s record order before mutating.
+    :return: The `(a, b)` pair, as live Python lists of dicts.
+    """
+    rng = random.Random(SEED + 2)
+    a = [_make_typed_record(i, rng) for i in range(TYPED_RECORD_COUNT)]
+    b = copy.deepcopy(a)
+
+    if shuffle:
+        rng.shuffle(b)
+
+    for index in _mutation_indices(TYPED_RECORD_COUNT, rng):
+        b[index] = _mutate_typed_record(b[index], rng)
+
+    return a, b
+
+
 ##############################################
 ##############################################
 ##############################################
@@ -214,6 +323,8 @@ def build_api_payloads_case() -> tuple[JsonValue, JsonValue]:
 CASE_LABELS: Final[dict[str, str]] = {
     "ignore_order": "`ignore_order`, 10k shuffled ints, ~5% mutated (live objects)",
     "api_payloads": "Heterogeneous API-payload records, n=20,000 (live objects)",
+    "typed_records": "Typed records (datetime/tuple/set fields), n=10,000 (live objects)",
+    "typed_records_ignore_order": "Same typed-records shape, `ignore_order` (live objects)",
     "ignore_order_json": "Same `ignore_order` shape, via `diff_json` (JSON-string path)",
     "api_payloads_json": "Same API-payload shape, via `diff_json` (JSON-string path)",
     "api_payloads_file": "Same API-payload shape, both tools reading two JSON files from disk",
@@ -269,6 +380,12 @@ def _diff_callable(tool: str, case: str) -> Callable[[], object]:
     if case in ("ignore_order", "ignore_order_json"):
         a, b = build_ignore_order_case()
         ignore_order = True
+    elif case == "typed_records":
+        a, b = build_typed_records_case()
+        ignore_order = False
+    elif case == "typed_records_ignore_order":
+        a, b = build_typed_records_case(shuffle=True)
+        ignore_order = True
     else:
         a, b = build_api_payloads_case()
         ignore_order = False

{deepdiff_rs-0.4.0 → deepdiff_rs-0.4.1}/crates/onix-py/src/convert.rs

@@ -13,7 +13,7 @@
 //! | `bool` | `Bool` | checked before `int` — `bool` is a Python `int` subclass |
 //! | `int` | `Number` | must fit in `i64` or `u64`; see below |
 //! | `float` | `Number` | must be finite; see below |
-//! | `str` | `Str` | |
+//! | `str` | `Str` | must be encodable as UTF-8; see below |
 //! | `dict` (`str` keys only) | `Object` | keys interned across the whole walk |
 //! | `list` | `Array` | |
 //! | `tuple` | `Tuple` | exactly `tuple`; every subclass is rejected, see below |
@@ -29,8 +29,14 @@
 //!   `DeepDiff` supports them natively).
 //! - A `NaN` or infinite `float` raises [`PyValueError`] (JSON has no
 //!   representation for either).
+//! - A `str` containing a lone (unpaired) surrogate code point (e.g.
+//!   `"\udc80"`) raises [`PyValueError`] naming the exact path: it has no
+//!   UTF-8 encoding. See `tests/golden/README.md` for why this diverges from
+//!   real `DeepDiff`.
 //! - A `dict` key that is not a `str` raises [`PyTypeError`] naming the
-//!   key's type and the path to the dict containing it.
+//!   key's type and the path to the dict containing it; a `str` key with a
+//!   lone surrogate raises [`PyValueError`] the same way, naming the dict's
+//!   path (the key itself has no path segment of its own).
 //! - A `tzinfo` whose `utcoffset()` is not a whole number of seconds raises
 //!   [`PyValueError`]: the value model carries an offset in seconds.
 //! - A `set`/`frozenset` member that is not one of the types this MVP allows
@@ -279,7 +285,8 @@ fn classify<'py>(
     }
 
     if let Ok(s) = current.cast::<PyString>() {
-        return Ok(Step::Done(CValue::Str(s.to_string().into_boxed_str())));
+        let s = s.to_cow().map_err(|_| lone_surrogate_error(path, false))?;
+        return Ok(Step::Done(CValue::Str(s.into_owned().into_boxed_str())));
     }
 
     // Exact, and `datetime` before `date`: see the module doc. A `date` cast
@@ -562,7 +569,12 @@ fn next_dict_entry<'py>(
         ))
     })?;
 
-    Ok(Some((key.to_string(), value)))
+    let key = key
+        .to_cow()
+        .map_err(|_| lone_surrogate_error(dict_path, true))?
+        .into_owned();
+
+    Ok(Some((key, value)))
 }
 
 /// Reads a `date`'s (or a `datetime`'s) `year`/`month`/`day` attributes.
@@ -636,6 +648,26 @@ fn out_of_range_error(type_name: &str, path: &[PathSegment]) -> PyErr {
     ))
 }
 
+/// `to_cow`'s own `UnicodeEncodeError` is discarded in favor of this, so the
+/// message names the exact path the way every other conversion error in this
+/// module does; see the module doc and `tests/golden/README.md` for why this
+/// diverges from real `DeepDiff`.
+///
+/// `is_key` distinguishes the two call sites' wording: a dict key that fails
+/// this check has no path segment of its own yet (like a non-`str` key, see
+/// [`next_dict_entry`]), so `path` there is the path to the *dict*, not the
+/// entry, and the message says so explicitly to avoid implying otherwise.
+fn lone_surrogate_error(path: &[PathSegment], is_key: bool) -> PyErr {
+    let subject = if is_key { "dict key" } else { "str" };
+    let path = render_path(path);
+
+    PyValueError::new_err(format!(
+        "{subject} at {path} contains a lone (unpaired) surrogate code point, which has no \
+         UTF-8 representation; onix's internal value model is UTF-8 and cannot represent it, \
+         unlike Python's str"
+    ))
+}
+
 fn int_to_value(i: &Bound<'_, PyInt>) -> PyResult<CValue> {
     if let Ok(v) = i.extract::<i64>() {
         return Ok(CValue::Number(CNumber::from_i64(v)));

{deepdiff_rs-0.4.0 → deepdiff_rs-0.4.1}/crates/onix-py/tests/test_conversions.py

@@ -217,6 +217,70 @@ def test_non_str_dict_key_error_reports_path_to_the_dict() -> None:
         DeepDiff({"a": {1: "x"}}, {"a": {1: "y"}})
 
 
+# lone (unpaired) surrogates: legal in a Python str, not representable as UTF-8; see
+# tests/golden/README.md for the documented divergence from real DeepDiff.
+
+
+def test_lone_surrogate_value_raises_value_error() -> None:
+    """A lone surrogate value raises ValueError instead of silently comparing equal."""
+    with pytest.raises(ValueError, match=r"str at root contains a lone"):
+        DeepDiff("\udc80", "\udc81")
+
+
+def test_distinct_lone_surrogates_both_raise_the_same_way() -> None:
+    """A different lone surrogate pair is refused identically, not silently equated."""
+    with pytest.raises(ValueError, match=r"str at root contains a lone"):
+        DeepDiff("\udc81", "\udc82")
+
+
+def test_identical_lone_surrogate_value_still_raises() -> None:
+    """An identical pair still raises, even though real DeepDiff reports no change for it."""
+    with pytest.raises(ValueError, match=r"str at root contains a lone"):
+        DeepDiff("\udc80", "\udc80")
+
+
+def test_identical_lone_surrogate_dict_key_still_raises() -> None:
+    """The same holds for a dict key equal on both sides: conversion still validates it."""
+    with pytest.raises(ValueError, match=r"dict key at root\['a'\] contains a lone"):
+        DeepDiff({"a": {"\udc80": 1}}, {"a": {"\udc80": 1}})
+
+
+def test_identical_lone_surrogate_set_item_still_raises() -> None:
+    """The same holds for a set member equal on both sides: real DeepDiff would still crash."""
+    with pytest.raises(ValueError, match=r"str at root\[<set member>\] contains a lone"):
+        DeepDiff({"\udc80"}, {"\udc80"})
+
+
+def test_lone_surrogate_nested_in_list_reports_its_path() -> None:
+    """The error names the exact path, like every other conversion error in this module."""
+    with pytest.raises(ValueError, match=r"str at root\['a'\]\[1\] contains a lone"):
+        DeepDiff({"a": [1, "\udc80"]}, {"a": [1, "ok"]})
+
+
+def test_lone_surrogate_dict_key_raises_value_error_naming_the_dict() -> None:
+    """A lone surrogate dict key raises ValueError naming the containing dict's path."""
+    with pytest.raises(ValueError, match=r"dict key at root\['a'\] contains a lone"):
+        DeepDiff({"a": {"\udc80": 1}}, {"a": {"ok": 1}})
+
+
+def test_lone_surrogate_set_item_raises_value_error() -> None:
+    """A lone surrogate set member raises ValueError; real DeepDiff crashes hashing one instead."""
+    with pytest.raises(ValueError, match=r"str at root\[<set member>\] contains a lone"):
+        DeepDiff({"\udc80"}, {"ok"})
+
+
+def test_lone_surrogate_tuple_item_raises_value_error() -> None:
+    """A lone surrogate inside a tuple raises ValueError naming its index."""
+    with pytest.raises(ValueError, match=r"str at root\[0\] contains a lone"):
+        DeepDiff(("\udc80",), ("ok",))
+
+
+def test_non_bmp_character_is_accepted() -> None:
+    """A genuine non-BMP character converts fine: only an unpaired surrogate is refused."""
+    diff = DeepDiff("😀", "😁")
+    assert diff.to_dict()["values_changed"]["root"] == {"new_value": "😁", "old_value": "😀"}
+
+
 # diff_json's own error path (JSON parsing, not Python-object conversion)