feat(data-layer): TickAggregator (tick-to-candle) in all 10 languages (#309)

* feat(data-layer): TickAggregator in Node, WASM, Python + C ABI hub

First data-layer feature (F2): roll trade ticks up into fixed-timeframe OHLCV
candles, exposed natively and over the C ABI.

- wickra-data wired as a binding dependency (workspace dep; its wickra-core dep
  is default-features=false so it never forces rayon into the rayon-free WASM
  build — native bindings re-enable parallel through their own dependency).
- Node `TickAggregator(bucket, gapFill?)` -> `push(price, size, ts): Candle[]`;
  WASM the same (array of objects); Python `push(...) -> list[tuple]`.
- C ABI: `WickraCandle` struct + `wickra_tick_aggregator_new/push/free` (push
  writes candles into a caller buffer and returns the count), generated via the
  capi generator's new DATA_LAYER section; cbindgen now parses wickra-data so
  `TickAggregator` is a forward-declared opaque; header vendored to bindings/go.

Verified bit-identical across Node/WASM/Python/C/C++ (o=100 h=101 l=100 c=101
v=3 ts=0 for the shared 3-tick probe). WIP: Go/C#/Java/R generated bindings and
the cross-language golden are still pending.

* feat(data-layer): TickAggregator in Go, C#, Java, R (lossless push/drain)

Complete F2 across all 10 languages: the C-ABI tick aggregator now uses a
two-step push/drain so gap-fill candles are never lost, and the four generated
bindings expose it idiomatically.

- C ABI redesigned: opaque TickAggregator handle (inner aggregator + pending
  buffer); push consumes a tick and returns the closed-candle count, drain copies
  them into a count-sized caller buffer.
- Go: NewTickAggregator + Push(price,size,ts) []Candle; C#: TickAggregator +
  Candle[] Push(...); Java: TickAggregator + Candle[] push(...); R: TickAggregator
  constructor + push() S3 generic returning an (n x 6) numeric matrix.
- Candle output record generated per language from WickraCandle.

Verified bit-identical to the native bindings (o=100 h=101 l=100 c=101 v=3 ts=0)
in Go, C#, Java, and R at runtime; R passes R CMD check (pre-existing doc
warnings only). WIP: cross-language data-layer golden + CHANGELOG still pending.

* test(data-layer): cross-language golden for the tick aggregator + CHANGELOG

gen_golden emits a deterministic tick stream (testdata/golden/data_ticks.csv) and
the reference candle streams with and without gap filling (data_candles.csv,
data_candles_gap.csv). Every binding replays the shared ticks through its
TickAggregator and checks the candles bit-for-bit (fp tolerance) against the Rust
reference:

- Node / WASM / Python / Go / C# / Java / R: a dedicated parity test each.
- C / C++: data_layer_test.c (compiled as both, run as ctest).

The gap-fill fixture closes several candles from a single push, exercising the
lossless push/drain path. Records the feature under CHANGELOG [Unreleased].

* fix(examples): rename the CSV-loader candle to WickraBar

The example CSV helper (wickra_csv.h) defined its own struct WickraCandle, which
now collides with the public C ABI WickraCandle (the tick aggregator output) in
any example that includes both headers (backtest, multi_timeframe, the strategy
examples). The public type owns the name; rename the example loader's bar to
WickraBar. The generated golden_test.c is untouched (its only match was the
unrelated WickraCandleVolumeOutput).

bindings/python/Cargo.toml

@@ -22,5 +22,6 @@ workspace = true
 
 [dependencies]
 wickra-core = { workspace = true }
+wickra-data = { workspace = true }
 pyo3 = { workspace = true }
 numpy = { workspace = true }

bindings/python/python/wickra/__init__.py

@@ -358,6 +358,8 @@ from ._wickra import (
     ThreeLineBreak,
     Equivolume,
     CandleVolume,
+    # Data layer
+    TickAggregator,
     # Market Profile
     CompositeProfile,
     HighLowVolumeNodes,
@@ -902,6 +904,8 @@ __all__ = [
     "ThreeLineBreak",
     "Equivolume",
     "CandleVolume",
+    # Data layer
+    "TickAggregator",
     # Market Profile
     "CompositeProfile",
     "HighLowVolumeNodes",

bindings/python/src/lib.rs

@@ -28285,6 +28285,8 @@ fn _wickra(_py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyProfileShape>()?;
     m.add_class::<PyHighLowVolumeNodes>()?;
     m.add_class::<PyCompositeProfile>()?;
+    // Data layer.
+    m.add_class::<PyTickAggregator>()?;
     // Candlestick patterns.
     m.add_class::<PyDoji>()?;
     m.add_class::<PyHammer>()?;
@@ -28557,3 +28559,60 @@ fn _wickra(_py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyM2Measure>()?;
     Ok(())
 }
+
+// ===== Data layer: tick-to-candle aggregation =====
+
+/// One aggregated candle as `(open, high, low, close, volume, timestamp)`.
+type CandleTuple = (f64, f64, f64, f64, f64, i64);
+
+/// Convert a `wickra-data` error into a Python `ValueError`.
+fn map_data_err(e: wickra_data::Error) -> PyErr {
+    PyValueError::new_err(e.to_string())
+}
+
+/// Roll trade ticks up into fixed-timeframe OHLCV candles.
+#[pyclass(
+    name = "TickAggregator",
+    module = "wickra._wickra",
+    skip_from_py_object
+)]
+#[derive(Clone)]
+struct PyTickAggregator {
+    inner: wickra_data::aggregator::TickAggregator,
+}
+
+#[pymethods]
+impl PyTickAggregator {
+    #[new]
+    #[pyo3(signature = (bucket, gap_fill = false))]
+    fn new(bucket: i64, gap_fill: bool) -> PyResult<Self> {
+        let timeframe = wickra_data::aggregator::Timeframe::new(bucket).map_err(map_data_err)?;
+        let mut inner = wickra_data::aggregator::TickAggregator::new(timeframe);
+        if gap_fill {
+            inner = inner.with_gap_fill(true);
+        }
+        Ok(Self { inner })
+    }
+
+    /// Push one trade tick; returns the candles closed as a result, each a
+    /// `(open, high, low, close, volume, timestamp)` tuple.
+    fn push(&mut self, price: f64, size: f64, timestamp: i64) -> PyResult<Vec<CandleTuple>> {
+        let tick = wc::Tick::new(price, size, timestamp).map_err(map_err)?;
+        Ok(self
+            .inner
+            .push(tick)
+            .map_err(map_data_err)?
+            .into_iter()
+            .map(|c| (c.open, c.high, c.low, c.close, c.volume, c.timestamp))
+            .collect())
+    }
+
+    #[getter]
+    fn fills_gaps(&self) -> bool {
+        self.inner.fills_gaps()
+    }
+
+    fn __repr__(&self) -> String {
+        format!("TickAggregator(fills_gaps={})", self.inner.fills_gaps())
+    }
+}

bindings/python/tests/test_data_layer.py

@@ -0,0 +1,44 @@
+"""Cross-language data-layer parity for the Python binding: replay the shared
+golden tick stream through the TickAggregator and check the candles against the
+Rust-generated fixtures, with and without gap filling. Fixtures are produced by
+``cargo run -p wickra-examples --bin gen_golden``.
+"""
+import csv
+import os
+
+import pytest
+import wickra as ta
+
+HERE = os.path.dirname(__file__)
+GOLDEN = os.path.normpath(os.path.join(HERE, "..", "..", "..", "testdata", "golden"))
+
+
+def _read(name):
+    with open(os.path.join(GOLDEN, name + ".csv"), newline="") as f:
+        rows = list(csv.reader(f))
+    return [[float(x) for x in r] for r in rows[1:] if r]
+
+
+TICKS = _read("data_ticks")
+
+
+def _run(gap_fill):
+    agg = ta.TickAggregator(1000, gap_fill=gap_fill)
+    out = []
+    for price, size, ts in TICKS:
+        out.extend(agg.push(price, size, int(ts)))
+    return out
+
+
+@pytest.mark.parametrize(
+    "gap_fill,fixture",
+    [(False, "data_candles"), (True, "data_candles_gap")],
+)
+def test_tick_aggregator_matches_golden(gap_fill, fixture):
+    got = _run(gap_fill)
+    want = _read(fixture)
+    assert len(got) == len(want)
+    for i, (g, w) in enumerate(zip(got, want)):
+        for j in range(6):
+            tol = 1e-9 * max(1.0, abs(w[j]))
+            assert abs(g[j] - w[j]) <= tol, f"row {i} col {j}: {g[j]} vs {w[j]}"