jsonatapy 2.2.1__tar.gz → 2.2.2__tar.gz

{jsonatapy-2.2.1 → jsonatapy-2.2.2}/.gitignore

@@ -63,6 +63,11 @@ benchmarks/javascript/package-lock.json
 # Test artifacts
 # tests/jsonata-js/ - Now a git submodule, don't ignore
 
+# Claude Code local settings (personal per-developer permissions/config,
+# not meant to be shared across the team)
+.claude/settings.local.json
+.claude/worktrees/
+
 # Temporary files
 *.tmp
 *.bak

{jsonatapy-2.2.1 → jsonatapy-2.2.2}/CHANGELOG.md

@@ -19,6 +19,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Security
 
+## [2.2.2] - 2026-07-09
+
+### Added
+- Documented `JsonataData`, `evaluate_with_data`, and `evaluate_data_to_json` in `docs/api.md`
+  (previously absent from the API reference entirely, despite being the "3-15x faster"
+  pre-converted-data path highlighted in the README's Performance section). Added a cross-link
+  from `docs/rust-crate.md` to the full auto-generated API reference on docs.rs. (#65)
+
+### Changed
+- Updated Rust dependencies to the latest versions compatible with existing (unpinned) semver
+  requirements: `simd-json` 0.17.0 → 0.17.2 plus 6 transitive patch bumps. No security advisories
+  found before or after (`cargo deny check`). (#65)
+
+### Deprecated
+
+### Removed
+
+### Fixed
+- SIMD-accelerated JSON parsing (`simd-json` feature, on by default) was consistently *slower*
+  than the plain `serde_json` fallback for most payload sizes (up to 29% slower at 180KB), the
+  opposite of its intent — caused by allocating fresh internal scratch buffers on every single
+  parse call. Fixed by reusing a thread-local scratch buffer across calls; SIMD parsing now beats
+  `serde_json` consistently (up to +22% faster) instead of losing at 3 of 4 tested sizes.
+  Also corrected the README's "(optional feature)" wording for SIMD, which implied opt-in when
+  it's actually enabled by default, including in published wheels. (#65)
+
+### Security
+
 ## [2.2.1] - 2026-07-08
 
 > Same code as [2.1.7](#217---2026-07-08) below, renumbered. This project's release versions

{jsonatapy-2.2.1 → jsonatapy-2.2.2}/Cargo.lock

@@ -103,9 +103,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.2.65"
+version = "1.2.66"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e228eec9be7c17ccb640b59b36a5cd805ea2a564a4c5e162c2f659fea30d3b96"
+checksum = "f5d6cac793997bd970000024b2934968efe83b382de4fdcf4fcb46b6ee4ad996"
 dependencies = [
  "find-msvc-tools",
  "shlex",
@@ -245,9 +245,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.6"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+checksum = "5181e0de7b61eb03a81e347d6dd8797bae9da5146707b51077e2d71a54ec0ceb"
 dependencies = [
  "crossbeam-epoch",
  "crossbeam-utils",
@@ -264,9 +264,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.21"
+version = "0.8.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17"
 
 [[package]]
 name = "crunchy"
@@ -483,7 +483,7 @@ dependencies = [
 
 [[package]]
 name = "jsonata-core"
-version = "2.2.1"
+version = "2.2.2"
 dependencies = [
  "base64",
  "chrono",
@@ -522,9 +522,9 @@ checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
 
 [[package]]
 name = "memchr"
-version = "2.8.2"
+version = "2.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
 
 [[package]]
 name = "num-traits"
@@ -882,9 +882,9 @@ dependencies = [
 
 [[package]]
 name = "rustversion"
-version = "1.0.22"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
 
 [[package]]
 name = "rusty-fork"
@@ -965,9 +965,9 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "simd-json"
-version = "0.17.0"
+version = "0.17.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4255126f310d2ba20048db6321c81ab376f6a6735608bf11f0785c41f01f64e3"
+checksum = "6f75934ad5ee9e78b79ce7731b822debcb3e5fa6c5aabe57410084715897d1ee"
 dependencies = [
  "halfbrown",
  "ref-cast",
@@ -1276,18 +1276,18 @@ checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
 
 [[package]]
 name = "zerocopy"
-version = "0.8.52"
+version = "0.8.54"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce1022995ff5ff5d841ad7d994facc23098cd40152f2c1d11cd607c6f530653f"
+checksum = "b7cbbc0a705a0fd05cc3676525980d2bf5a9bc4adac6d6475209a7887cf59d19"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.52"
+version = "0.8.54"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ae7f38b72ec2a254e2b87ef277cf2cd4fb97cbebf944faa6f33354da0867930"
+checksum = "e2e817b7b52d0c7358d3246da9d69935ebb18116b2b102b4230dac079b4862f5"
 dependencies = [
  "proc-macro2",
  "quote",

{jsonatapy-2.2.1 → jsonatapy-2.2.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsonata-core"
-version = "2.2.1"
+version = "2.2.2"
 edition = "2021"
 authors = ["txjmb <txjmb@users.noreply.github.com>"]
 description = "High-performance Rust implementation of JSONata query and transformation language"

{jsonatapy-2.2.1 → jsonatapy-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jsonatapy
-Version: 2.2.1
+Version: 2.2.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -180,7 +180,7 @@ benchmark methodology.
 - **Pure Rust core** — no JavaScript runtime, no Node.js dependency
 - **Optional Python bindings** — PyO3/maturin, zero-copy where possible
 - **Cross-platform** — Linux, macOS (Intel & ARM), Windows; Python 3.10–3.14
-- **SIMD-accelerated JSON parsing** — via `simd-json` (optional feature)
+- **SIMD-accelerated JSON parsing** — via `simd-json`, enabled by default (disable with `--no-default-features`)
 
 ---
 

{jsonatapy-2.2.1 → jsonatapy-2.2.2}/README.md

@@ -135,7 +135,7 @@ benchmark methodology.
 - **Pure Rust core** — no JavaScript runtime, no Node.js dependency
 - **Optional Python bindings** — PyO3/maturin, zero-copy where possible
 - **Cross-platform** — Linux, macOS (Intel & ARM), Windows; Python 3.10–3.14
-- **SIMD-accelerated JSON parsing** — via `simd-json` (optional feature)
+- **SIMD-accelerated JSON parsing** — via `simd-json`, enabled by default (disable with `--no-default-features`)
 
 ---
 

jsonatapy-2.2.2/examples/simd_json_bench.rs

@@ -0,0 +1,126 @@
+//! One-off benchmark: how much does the `simd` feature speed up JSON parsing?
+//!
+//! Run with the feature on (default) vs off, e.g.:
+//!   cargo run --release --example simd_json_bench
+//!   cargo run --release --example simd_json_bench --no-default-features
+//!
+//! Not part of the permanent benchmark suite - a throwaway comparison.
+
+use jsonata_core::value::JValue;
+use std::time::Instant;
+
+fn ecommerce_json(n: usize) -> String {
+    let products: Vec<String> = (0..n)
+        .map(|i| {
+            format!(
+                r#"{{"id":{i},"name":"Product {i}","category":"{cat}","price":{price},"inStock":{stock},"rating":{rating},"reviews":{reviews},"tags":["tag1","tag2","tag3"],"vendor":{{"name":"Vendor {v}","rating":4.2}}}}"#,
+                i = i,
+                cat = ["Electronics", "Clothing", "Books", "Home"][i % 4],
+                price = 10.0 + i as f64 * 5.5,
+                stock = i % 3 != 0,
+                rating = 3.0 + (i % 3) as f64 * 0.5,
+                reviews = i * 2,
+                v = i % 10,
+            )
+        })
+        .collect();
+    format!(r#"{{"products":[{}]}}"#, products.join(","))
+}
+
+const REPEAT_TRIALS: usize = 5;
+
+fn bench_parse(label: &str, json: &str, iterations: usize) {
+    // warmup (shared across all trials)
+    for _ in 0..(iterations / 10).max(10) {
+        let _ = JValue::from_json_str(json).unwrap();
+    }
+
+    // Take the min across REPEAT_TRIALS independent trials - single-sample
+    // wall-clock timing is noisy enough to be meaningless on its own (see
+    // this project's own benchmarks/python/benchmark.py for why).
+    let mut best_ms: Option<f64> = None;
+    let mut all_ms = Vec::with_capacity(REPEAT_TRIALS);
+    for _ in 0..REPEAT_TRIALS {
+        let start = Instant::now();
+        for _ in 0..iterations {
+            let _ = JValue::from_json_str(json).unwrap();
+        }
+        let ms = start.elapsed().as_secs_f64() * 1000.0;
+        all_ms.push(ms);
+        best_ms = Some(best_ms.map_or(ms, |b: f64| b.min(ms)));
+    }
+    let best_ms = best_ms.unwrap();
+    let per_iter = best_ms / iterations as f64;
+    println!(
+        "{label:<28} {bytes:>8} bytes  {iterations:>6} iters  min={min:>8.2}ms  all={all:?}  {per:>10.5} ms/iter",
+        label = label,
+        bytes = json.len(),
+        iterations = iterations,
+        min = best_ms,
+        all = all_ms.iter().map(|v| format!("{v:.1}")).collect::<Vec<_>>(),
+        per = per_iter,
+    );
+}
+
+#[cfg(feature = "simd")]
+fn bench_parse_reused_buffer(label: &str, json: &str, iterations: usize) {
+    use simd_json::Buffers;
+
+    let mut buffers = Buffers::new(json.len() + 64);
+    let mut bytes = json.as_bytes().to_vec();
+
+    // warmup
+    for _ in 0..(iterations / 10).max(10) {
+        let _: JValue =
+            simd_json::serde::from_slice_with_buffers(&mut bytes, &mut buffers).unwrap();
+    }
+
+    let mut best_ms: Option<f64> = None;
+    let mut all_ms = Vec::with_capacity(REPEAT_TRIALS);
+    for _ in 0..REPEAT_TRIALS {
+        let start = Instant::now();
+        for _ in 0..iterations {
+            bytes.clear();
+            bytes.extend_from_slice(json.as_bytes());
+            let _: JValue =
+                simd_json::serde::from_slice_with_buffers(&mut bytes, &mut buffers).unwrap();
+        }
+        let ms = start.elapsed().as_secs_f64() * 1000.0;
+        all_ms.push(ms);
+        best_ms = Some(best_ms.map_or(ms, |b: f64| b.min(ms)));
+    }
+    let best_ms = best_ms.unwrap();
+    let per_iter = best_ms / iterations as f64;
+    println!(
+        "{label:<28} {bytes:>8} bytes  {iterations:>6} iters  min={min:>8.2}ms  all={all:?}  {per:>10.5} ms/iter",
+        label = label,
+        bytes = json.len(),
+        iterations = iterations,
+        min = best_ms,
+        all = all_ms.iter().map(|v| format!("{v:.1}")).collect::<Vec<_>>(),
+        per = per_iter,
+    );
+}
+
+fn main() {
+    let feature = if cfg!(feature = "simd") {
+        "simd-json"
+    } else {
+        "serde_json (simd off)"
+    };
+    println!("=== JSON parsing benchmark - active parser: {feature} ===\n");
+
+    bench_parse("tiny (1 product)", &ecommerce_json(1), 200_000);
+    bench_parse("small (10 products)", &ecommerce_json(10), 50_000);
+    bench_parse("medium (100 products)", &ecommerce_json(100), 5_000);
+    bench_parse("large (1000 products)", &ecommerce_json(1000), 500);
+
+    #[cfg(feature = "simd")]
+    {
+        println!("\n=== HYPOTHESIS TEST: simd-json with a REUSED Buffers scratch ===\n");
+        bench_parse_reused_buffer("tiny (1 product)", &ecommerce_json(1), 200_000);
+        bench_parse_reused_buffer("small (10 products)", &ecommerce_json(10), 50_000);
+        bench_parse_reused_buffer("medium (100 products)", &ecommerce_json(100), 5_000);
+        bench_parse_reused_buffer("large (1000 products)", &ecommerce_json(1000), 500);
+    }
+}

{jsonatapy-2.2.1 → jsonatapy-2.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "jsonatapy"
-version = "2.2.1"
+version = "2.2.2"
 description = "High-performance Python/Rust implementation of JSONata query and transformation language"
 authors = [
     {name = "txjmb", email = "txjmb@users.noreply.github.com"}

{jsonatapy-2.2.1 → jsonatapy-2.2.2}/src/value.rs

@@ -572,14 +572,33 @@ impl JValue {
 
     /// Parse a JSON string into a JValue (single-pass, no intermediate serde_json::Value).
     ///
-    /// When the `simd` feature is enabled, uses simd-json for 2-4x faster parsing
-    /// on CPUs with SIMD support (SSE4.2/AVX2/NEON). Falls back to serde_json otherwise.
+    /// When the `simd` feature is enabled, uses simd-json for faster parsing on CPUs
+    /// with SIMD support (SSE4.2/AVX2/NEON). Falls back to serde_json otherwise.
+    ///
+    /// `simd_json::serde::from_slice` allocates fresh internal scratch buffers
+    /// (`Buffers::new`) on every call, sized proportionally to the input - measured
+    /// as the dominant cost, large enough to make the "simd" path consistently
+    /// SLOWER than plain serde_json (worse as input grows: -26% at 189 bytes,
+    /// -29% at 180KB). Reusing those buffers across calls via
+    /// `from_slice_with_buffers` (thread-local, since JValue's Rc-based design is
+    /// already single-threaded per instance) eliminates that reallocation and
+    /// brings simd-json back to consistently faster than serde_json (+5% to +22%
+    /// across the same size range, measured with benches/examples/simd_json_bench.rs).
     pub fn from_json_str(s: &str) -> Result<JValue, serde_json::Error> {
         #[cfg(feature = "simd")]
         {
-            // simd-json requires a mutable byte slice with padding
-            let mut bytes = s.as_bytes().to_vec();
-            if let Ok(value) = simd_json::serde::from_slice::<JValue>(&mut bytes) {
+            thread_local! {
+                static SCRATCH: std::cell::RefCell<(Vec<u8>, simd_json::Buffers)> =
+                    std::cell::RefCell::new((Vec::new(), simd_json::Buffers::new(0)));
+            }
+
+            let result = SCRATCH.with(|scratch| {
+                let (bytes, buffers) = &mut *scratch.borrow_mut();
+                bytes.clear();
+                bytes.extend_from_slice(s.as_bytes());
+                simd_json::serde::from_slice_with_buffers::<JValue>(bytes, buffers)
+            });
+            if let Ok(value) = result {
                 return Ok(value);
             }
             // Fall back to serde_json if simd-json fails (e.g., unsupported CPU)