deepdiff-rs 0.7.0__tar.gz → 0.7.1__tar.gz

{deepdiff_rs-0.7.0 → deepdiff_rs-0.7.1}/Cargo.lock

@@ -629,7 +629,7 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "onix-arrow"
-version = "0.7.0"
+version = "0.7.1"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -646,7 +646,7 @@ dependencies = [
 
 [[package]]
 name = "onix-cli"
-version = "0.7.0"
+version = "0.7.1"
 dependencies = [
  "onix-core",
  "serde_json",
@@ -654,17 +654,18 @@ dependencies = [
 
 [[package]]
 name = "onix-core"
-version = "0.7.0"
+version = "0.7.1"
 dependencies = [
  "proptest",
  "serde",
  "serde_json",
  "stats_alloc",
+ "unicode-general-category",
 ]
 
 [[package]]
 name = "onix-py"
-version = "0.7.0"
+version = "0.7.1"
 dependencies = [
  "arrow-array",
  "arrow-ipc",
@@ -1112,6 +1113,12 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
 
+[[package]]
+name = "unicode-general-category"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b993bddc193ae5bd0d623b49ec06ac3e9312875fdae725a975c51db1cc1677f"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"

{deepdiff_rs-0.7.0 → deepdiff_rs-0.7.1}/Cargo.toml

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

{deepdiff_rs-0.7.0 → deepdiff_rs-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepdiff-rs
-Version: 0.7.0
+Version: 0.7.1
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: MIT License
@@ -160,7 +160,7 @@ Type comparison uses the full logical Arrow type (timestamp unit and timezone, d
 - **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.
 - 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).
+- 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).
 - A `values_changed` between two multi-line strings runs a `difflib`-style `O(N*M)` line diff on the default path with no opt-out, worst when changes are spread evenly through the text (about 35 s for a heavily edited 1 MB string and growing quadratically, so a few megabytes is minutes), so bound the size of untrusted strings yourself. See [`crates/onix-core/src/unified_diff.rs`](crates/onix-core/src/unified_diff.rs).

{deepdiff_rs-0.7.0 → deepdiff_rs-0.7.1}/README.md

@@ -142,7 +142,7 @@ Type comparison uses the full logical Arrow type (timestamp unit and timezone, d
 - **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.
 - 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).
+- 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).
 - A `values_changed` between two multi-line strings runs a `difflib`-style `O(N*M)` line diff on the default path with no opt-out, worst when changes are spread evenly through the text (about 35 s for a heavily edited 1 MB string and growing quadratically, so a few megabytes is minutes), so bound the size of untrusted strings yourself. See [`crates/onix-core/src/unified_diff.rs`](crates/onix-core/src/unified_diff.rs).

{deepdiff_rs-0.7.0 → deepdiff_rs-0.7.1}/crates/onix-core/Cargo.toml

@@ -12,6 +12,7 @@ workspace = true
 [dependencies]
 serde = "1"
 serde_json = "1"
+unicode-general-category = "1.1"
 
 [dev-dependencies]
 proptest = "1"

{deepdiff_rs-0.7.0 → deepdiff_rs-0.7.1}/crates/onix-core/src/path.rs

@@ -10,6 +10,8 @@
 
 use std::fmt::Write as _;
 
+use unicode_general_category::{GeneralCategory, get_general_category};
+
 use crate::datetime::{SECONDS_PER_DAY, div_rem_euclid};
 use crate::value::{Number, Value};
 
@@ -209,20 +211,6 @@ pub fn set_item_repr(item: &Value) -> String {
 /// [`Value`]'s own stack-safety posture: nothing bounds how deep a value a
 /// caller may render, and a natively recursive renderer would be an
 /// unguarded overflow sink on adversarially nested input.
-///
-/// # Divergence from Python: non-printable non-ASCII characters
-///
-/// Python's `repr()` escapes any character it considers non-printable (the
-/// Unicode `Cc`/`Cf`/`Cs`/`Co`/`Cn`/`Zl`/`Zp` categories, plus `Zs` other
-/// than a plain space) as `\xXX`/`\uXXXX`/`\UXXXXXXXX`. This port escapes
-/// exactly those below `U+0100` (every ASCII control, `U+007F`–`U+00A0`,
-/// and the soft hyphen `U+00AD` — the complete non-printable set in that
-/// range) and passes everything above through literally, which is what
-/// Python does for all *printable* text. Reproducing the rest would mean
-/// carrying a Unicode category table for characters (zero-width joiners,
-/// unassigned code points) that no realistic diff input holds; this is an
-/// accepted, narrow, documented limitation, in the same class as
-/// `crate::lcs`'s `2^53` numeric bound.
 #[must_use]
 pub fn python_repr(value: &Value) -> String {
     let mut out = String::new();
@@ -387,8 +375,8 @@ fn push_sequence<'a>(
 
 /// Python's `repr()` for a `str`: single quotes unless the string contains a
 /// single quote and no double quote (then double quotes), with `\`, the
-/// wrapping quote and the non-printable characters escaped — see
-/// [`python_repr`]'s doc for the one documented gap above `U+00FF`.
+/// wrapping quote and every non-printable code point escaped as `\xXX`,
+/// `\uXXXX` or `\UXXXXXXXX` per [`escape_non_printable`].
 fn python_repr_str(s: &str) -> String {
     let quote = if s.contains('\'') && !s.contains('"') {
         '"'
@@ -408,10 +396,7 @@ fn python_repr_str(s: &str) -> String {
                 out.push('\\');
                 out.push(c);
             }
-            c if is_escaped_below_u100(c) => {
-                // Writing into a `String` is infallible.
-                let _ = write!(out, "\\x{:02x}", u32::from(c));
-            }
+            c if is_non_printable(c) => escape_non_printable(&mut out, c),
             c => out.push(c),
         }
     }
@@ -437,10 +422,43 @@ fn number_repr(n: &Number) -> String {
         .to_string()
 }
 
-/// The complete set of code points below `U+0100` Python's `repr()` escapes
-/// as `\xXX`: the C0 controls, `DEL` through `NBSP`, and the soft hyphen.
-fn is_escaped_below_u100(c: char) -> bool {
-    c < '\u{20}' || ('\u{7f}'..='\u{a0}').contains(&c) || c == '\u{ad}'
+/// Whether `c` is one of the code points Python's `repr()` escapes: every
+/// character in Unicode general categories `Cc`, `Cf`, `Cs`, `Co`, `Cn`,
+/// `Zl`, `Zp` or `Zs`, except the plain space (`U+0020`), which is `Zs` but
+/// stays printable. This is `CPython`'s own rule
+/// (`Tools/unicode/makeunicodedata.py`'s `PRINTABLE_MASK`, read from the
+/// `unicode-general-category` table pinned to Unicode 16.0.0 — the same
+/// version Python 3.14's `unicodedata` module ships).
+fn is_non_printable(c: char) -> bool {
+    if c == ' ' {
+        return false;
+    }
+    matches!(
+        get_general_category(c),
+        GeneralCategory::Control
+            | GeneralCategory::Format
+            | GeneralCategory::Surrogate
+            | GeneralCategory::PrivateUse
+            | GeneralCategory::Unassigned
+            | GeneralCategory::LineSeparator
+            | GeneralCategory::ParagraphSeparator
+            | GeneralCategory::SpaceSeparator
+    )
+}
+
+/// Appends `c`'s `repr()` escape to `out`: `\xXX` below `U+0100`, `\uXXXX`
+/// up to `U+FFFF`, `\UXXXXXXXX` above — the same three widths
+/// `Objects/unicodeobject.c`'s `unicode_repr` picks by.
+fn escape_non_printable(out: &mut String, c: char) {
+    let code_point = u32::from(c);
+    // Writing into a `String` is infallible.
+    let _ = if code_point < 0x100 {
+        write!(out, "\\x{code_point:02x}")
+    } else if code_point < 0x1_0000 {
+        write!(out, "\\u{code_point:04x}")
+    } else {
+        write!(out, "\\U{code_point:08x}")
+    };
 }
 
 /// Python's `repr()` for a `float`, which is `float_repr_style="short"`: the
@@ -525,7 +543,9 @@ fn python_float_repr(value: f64) -> String {
 
 #[cfg(test)]
 mod tests {
-    use super::{PathSegment, python_repr, quote_key, render_path, set_item_repr};
+    use super::{
+        PathSegment, escape_non_printable, python_repr, quote_key, render_path, set_item_repr,
+    };
     use crate::test_support::{cdate, cdt_at};
     use crate::value::{Builder, Number, SetItems, Value};
 
@@ -813,6 +833,86 @@ mod tests {
         }
     }
 
+    /// Every expectation here is real Python `repr()` output, verified
+    /// against `CPython` 3.14 (Unicode 16.0.0).
+    #[test]
+    fn python_repr_str_escapes_non_printable_code_points_above_u0100() {
+        let cases = [
+            // U+00FF: printable Latin-1, the code point right after the old
+            // below-U+0100 ceiling — left bare, not escaped.
+            ("a\u{ff}b", "'a\u{ff}b'"),
+            // U+200B: Cf (zero width space) — \uXXXX width.
+            ("a\u{200b}b", r"'a\u200bb'"),
+            // U+2028: Zl (line separator) — \uXXXX width.
+            ("a\u{2028}b", r"'a\u2028b'"),
+            // U+E000: Co (private use) — \uXXXX width.
+            ("a\u{e000}b", r"'a\ue000b'"),
+            // U+0378: Cn (unassigned in Unicode 16.0.0) — \uXXXX width.
+            ("a\u{378}b", r"'a\u0378b'"),
+            // U+FFFF: Cn (a BMP noncharacter) — the top of the \uXXXX width.
+            ("a\u{ffff}b", r"'a\uffffb'"),
+            // U+10000: Lo, printable astral text — left bare.
+            ("a\u{10000}b", "'a\u{10000}b'"),
+            // U+1F600: So, a printable astral emoji — left bare.
+            ("a\u{1f600}b", "'a\u{1f600}b'"),
+            // U+F0000: Co (a supplementary private-use plane) — \UXXXXXXXX
+            // width, the one the old port could not reach at all.
+            ("a\u{f0000}b", r"'a\U000f0000b'"),
+            // U+10FFFF: Cn, the last valid Unicode scalar value.
+            ("a\u{10ffff}b", r"'a\U0010ffffb'"),
+        ];
+        for (input, expected) in cases {
+            let item = Value::Tuple(Box::new([Value::Str(input.into())]));
+            assert_eq!(
+                python_repr(&item),
+                format!("({expected},)"),
+                "for {input:?}"
+            );
+        }
+    }
+
+    /// The plain space (`U+0020`) is `Zs` like every other escaped space
+    /// separator, but Python's own rule carves it out as printable — the
+    /// one exception `is_non_printable` must apply.
+    #[test]
+    fn python_repr_str_does_not_escape_plain_space() {
+        let item = Value::Tuple(Box::new([Value::Str("a b".into())]));
+        assert_eq!(python_repr(&item), "('a b',)");
+    }
+
+    /// Exercises `escape_non_printable` directly, at the two code points
+    /// each escape width's `<` comparison must reject vs. accept: `U+00FF`
+    /// stays `\xXX`, `U+0100` switches to `\uXXXX`; `U+FFFF` stays `\uXXXX`,
+    /// `U+10000` switches to `\UXXXXXXXX`.
+    #[test]
+    fn escape_non_printable_widths_switch_exactly_at_their_boundaries() {
+        let cases = [
+            (0xff, "\\xff"),
+            (0x100, "\\u0100"),
+            (0xffff, "\\uffff"),
+            (0x1_0000, "\\U00010000"),
+        ];
+        for (code_point, expected) in cases {
+            let mut out = String::new();
+            escape_non_printable(
+                &mut out,
+                char::from_u32(code_point).expect("valid code point"),
+            );
+            assert_eq!(out, expected, "for U+{code_point:04X}");
+        }
+    }
+
+    /// Fails `make check` if a `unicode-general-category` bump ever changes
+    /// the table `is_non_printable` reads, so a Unicode-version drift is
+    /// caught here rather than only by the Python bindings' own
+    /// interpreter-version-gated differential test (`test_sets.py`'s
+    /// `test_bmp_printability_table_matches_the_running_interpreter_on_3_14`),
+    /// which needs a Python 3.14 interpreter to run at all.
+    #[test]
+    fn unicode_general_category_stays_pinned_to_16_0_0() {
+        assert_eq!(unicode_general_category::UNICODE_VERSION, (16, 0, 0));
+    }
+
     /// Python's `repr()` for a calendar value — the form a container holding
     /// one shows, and the form issue #21 will need once a calendar value may
     /// be a set member. Every expectation here is real Python `repr()`

deepdiff_rs-0.7.1/crates/onix-py/.python-version

@@ -0,0 +1 @@
+3.14

{deepdiff_rs-0.7.0 → deepdiff_rs-0.7.1}/crates/onix-py/tests/test_sets.py

@@ -18,6 +18,8 @@ import json
 import math
 import random
 import struct
+import sys
+import unicodedata
 from typing import Final
 
 import pytest
@@ -30,6 +32,26 @@ from deepdiff_rs import DeepDiff, diff_json
 FLOAT_CASE_COUNT: Final[int] = 1_000_000
 FLOAT_BATCH_SIZE: Final[int] = 5_000
 
+# How many BMP code points are rendered per diff call in the str-repr
+# differential below (one call per batch keeps the full sweep fast).
+BMP_BATCH_SIZE: Final[int] = 2_000
+
+# Beyond-BMP sample: one code point per category needing the `\UXXXXXXXX`
+# escape width, plus three printable ones left bare.
+SUPPLEMENTARY_SAMPLE: Final[list[int]] = [
+    0x10000,  # Lo, printable
+    0x1F600,  # So, printable (emoji)
+    0x30000,  # Lo, printable
+    0xE01EF,  # Mn, printable (combining, astral)
+    0xE0001,  # Cf, non-printable
+    0xF0000,  # Co, non-printable (private-use plane)
+    0x10FFFD,  # Co, non-printable (private-use plane)
+    0x2FFFE,  # Cn, non-printable (unassigned noncharacter)
+    0x3FFFD,  # Cn, non-printable (unassigned)
+    0x40000,  # Cn, non-printable (unassigned)
+    0x10FFFF,  # Cn, non-printable (last valid code point)
+]
+
 
 def test_set_items_are_reported_as_added_and_removed_paths() -> None:
     """The two set categories are lists of path strings, sorted by onix."""
@@ -204,6 +226,61 @@ def test_float_set_item_paths_match_python_repr_over_a_million_bit_patterns() ->
     )
 
 
+def _rendered_tuple_str_path(s: str) -> str:
+    """
+    Render one `(s,)` tuple set item's path.
+
+    :param s: A single-character string.
+    :return: The rendered ``set_item_removed`` entry.
+    """
+    entries = DeepDiff({(s,)}, {("sentinel",)}).to_dict()["set_item_removed"]
+    assert len(entries) == 1, entries
+    return entries[0]
+
+
+def _assert_batch_matches_python_repr(code_points: list[int]) -> None:
+    """
+    Diff one batch of one-element `(chr(cp),)` tuple set items against real Python `repr()`.
+
+    :param code_points: The batch to check, distinct code points.
+    """
+    strings = [chr(cp) for cp in code_points]
+    items = {(s,) for s in strings}
+    rendered = set(DeepDiff(items, {("sentinel",)}).to_dict()["set_item_removed"])
+    expected = {f"root[{(s,)!r}]" for s in strings}
+    if rendered == expected:
+        return
+
+    for cp in code_points:
+        s = chr(cp)
+        want = f"root[{(s,)!r}]"
+        actual = _rendered_tuple_str_path(s)
+        assert actual == want, f"U+{cp:04X} rendered differently: expected {want!r}, got {actual!r}"
+    pytest.fail("batch-level mismatch, but no single code point in it diverged")
+
+
+def test_bmp_printability_table_matches_the_running_interpreter_on_3_14() -> None:
+    """Pins the assumption the sweep below relies on: 3.14 must ship Unicode 16.0.0."""
+    if sys.version_info[:2] != (3, 14):
+        pytest.skip("only meaningful on the crate's pinned reference interpreter, 3.14")
+    assert unicodedata.unidata_version == "16.0.0"
+
+
+def test_str_inside_tuple_matches_python_repr_over_the_full_bmp() -> None:
+    """Every BMP code point escapes exactly like Python `repr()`, against Unicode 16.0.0."""
+    if unicodedata.unidata_version != "16.0.0":
+        pytest.skip("valid only against Unicode 16.0.0 (Python 3.14); see tests/golden/README.md")
+
+    code_points = [cp for cp in range(0x10000) if not 0xD800 <= cp <= 0xDFFF]
+    for start in range(0, len(code_points), BMP_BATCH_SIZE):
+        _assert_batch_matches_python_repr(code_points[start : start + BMP_BATCH_SIZE])
+
+
+def test_str_inside_tuple_matches_python_repr_beyond_the_bmp() -> None:
+    """The `\\UXXXXXXXX` escape width, and printable astral text left bare."""
+    _assert_batch_matches_python_repr(SUPPLEMENTARY_SAMPLE)
+
+
 def test_a_set_holding_an_unhashable_subclass_is_refused() -> None:
     """A list subclass that defines __hash__ can be a set member; onix refuses it by path."""
 

{deepdiff_rs-0.7.0 → deepdiff_rs-0.7.1}/pyproject.toml

@@ -39,11 +39,9 @@ Repository = "https://github.com/ksco92/onix"
 #
 # `deepdiff==9.1.0` itself requires Python >=3.10, tighter than this
 # package's own `requires-python` (>=3.9) — the marker below keeps `uv
-# sync`'s universal (all-supported-versions) resolution satisfiable. There
-# is no interpreter pin for the test venv itself (unlike the PEP-723
-# scripts under ../../scripts/ and ../../perf/, which do pin an exact
-# version): `uv sync` resolves whatever Python >=3.10 it finds/manages, and
-# the abi3 wheel this crate builds works identically across all of them.
+# sync`'s universal (all-supported-versions) resolution satisfiable. The
+# test venv itself IS pinned, via this directory's `.python-version`:
+# Pinned to 3.14, Unicode 16.0.0; see tests/golden/README.md, Pinned versions.
 # polars and duckdb are here (test group) only, never as runtime deps: the
 # Arrow table-diff tests feed the same data through pyarrow, polars, and
 # DuckDB and assert identical results, which needs all three installed to run