seraplot 2.3.84__tar.gz → 2.3.85__tar.gz

{seraplot-2.3.84 → seraplot-2.3.85}/Cargo.lock

@@ -3471,7 +3471,7 @@ checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
 
 [[package]]
 name = "seraplot"
-version = "2.3.84"
+version = "2.3.85"
 dependencies = [
  "base64 0.22.1",
  "criterion",

{seraplot-2.3.84 → seraplot-2.3.85}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "seraplot"
-version = "2.3.84"
+version = "2.3.85"
 edition = "2021"
 authors = ["feur25"]
 description = "Rust data visualization framework - The modern Plotly alternative"

{seraplot-2.3.84 → seraplot-2.3.85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seraplot
-Version: 2.3.84
+Version: 2.3.85
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Win32 (MS Windows)
 Classifier: Intended Audience :: Developers

{seraplot-2.3.84 → seraplot-2.3.85}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "seraplot"
-version = "2.3.84"
+version = "2.3.85"
 description = "Rust data visualization framework - The modern Plotly alternative"
 readme = "README.md"
 readme-content-type = "text/markdown"

{seraplot-2.3.84 → seraplot-2.3.85}/src/bindings/commands/charts.rs

@@ -1583,6 +1583,156 @@ pub fn chart_info(input: &str) -> String {
     serde_json::json!({"size":len,"paths":n_paths,"rects":n_rects,"circles":n_circles,"has_svg":has_svg}).to_string()
 }
 
+pub fn validate_input(input: &str) -> String {
+    #[derive(serde::Deserialize)]
+    struct In { labels: Option<Vec<String>>, values: Option<Vec<f64>>, x: Option<Vec<f64>>, y: Option<Vec<f64>>, series: Option<Vec<Vec<f64>>> }
+    let v: In = match serde_json::from_str::<In>(input) {
+        Ok(v) => v,
+        Err(e) => return serde_json::json!({"ok":false,"error":format!("invalid JSON: {e}")}).to_string(),
+    };
+    if let (Some(l), Some(va)) = (v.labels.as_ref(), v.values.as_ref()) {
+        if l.len() != va.len() {
+            return serde_json::json!({"ok":false,"error":format!("labels ({}) and values ({}) length mismatch", l.len(), va.len())}).to_string();
+        }
+    }
+    if let (Some(x), Some(y)) = (v.x.as_ref(), v.y.as_ref()) {
+        if x.len() != y.len() {
+            return serde_json::json!({"ok":false,"error":format!("x ({}) and y ({}) length mismatch", x.len(), y.len())}).to_string();
+        }
+    }
+    if let (Some(l), Some(s)) = (v.labels.as_ref(), v.series.as_ref()) {
+        for (i, row) in s.iter().enumerate() {
+            if row.len() != l.len() {
+                return serde_json::json!({"ok":false,"error":format!("series[{i}] length {} != labels length {}", row.len(), l.len())}).to_string();
+            }
+        }
+    }
+    serde_json::json!({"ok":true}).to_string()
+}
+
+pub fn downsample_lttb(input: &str) -> String {
+    #[derive(serde::Deserialize)]
+    struct In { x: Vec<f64>, y: Vec<f64>, threshold: usize }
+    let v: In = match serde_json::from_str(input) {
+        Ok(v) => v,
+        Err(e) => return serde_json::json!({"ok":false,"error":format!("invalid JSON: {e}")}).to_string(),
+    };
+    let n = v.x.len();
+    if n != v.y.len() {
+        return serde_json::json!({"ok":false,"error":"x and y length mismatch"}).to_string();
+    }
+    let th = v.threshold;
+    if th >= n || th < 3 {
+        return serde_json::json!({"ok":true,"x":v.x,"y":v.y}).to_string();
+    }
+    let bucket_size = (n - 2) as f64 / (th - 2) as f64;
+    let mut out_x: Vec<f64> = Vec::with_capacity(th);
+    let mut out_y: Vec<f64> = Vec::with_capacity(th);
+    out_x.push(v.x[0]); out_y.push(v.y[0]);
+    let mut a: usize = 0;
+    for i in 0..(th - 2) {
+        let avg_start = ((i + 1) as f64 * bucket_size).floor() as usize + 1;
+        let avg_end = (((i + 2) as f64 * bucket_size).floor() as usize + 1).min(n);
+        let avg_len = (avg_end - avg_start).max(1) as f64;
+        let mut avg_x = 0.0; let mut avg_y = 0.0;
+        for k in avg_start..avg_end { avg_x += v.x[k]; avg_y += v.y[k]; }
+        avg_x /= avg_len; avg_y /= avg_len;
+        let range_offs = (i as f64 * bucket_size).floor() as usize + 1;
+        let range_to = ((i + 1) as f64 * bucket_size).floor() as usize + 1;
+        let pax = v.x[a]; let pay = v.y[a];
+        let mut max_area = -1.0f64;
+        let mut next_a = range_offs;
+        for k in range_offs..range_to.min(n) {
+            let area = ((pax - avg_x) * (v.y[k] - pay) - (pax - v.x[k]) * (avg_y - pay)).abs() * 0.5;
+            if area > max_area { max_area = area; next_a = k; }
+        }
+        out_x.push(v.x[next_a]); out_y.push(v.y[next_a]);
+        a = next_a;
+    }
+    out_x.push(v.x[n - 1]); out_y.push(v.y[n - 1]);
+    serde_json::json!({"ok":true,"x":out_x,"y":out_y,"reduction":format!("{}->{}", n, out_x.len())}).to_string()
+}
+
+pub fn chart_diff(input: &str) -> String {
+    #[derive(serde::Deserialize)]
+    struct In { a: String, b: String }
+    let v: In = match serde_json::from_str(input) {
+        Ok(v) => v,
+        Err(_) => return serde_json::json!({"ok":false,"error":"invalid JSON"}).to_string(),
+    };
+    let svg_a = extract_svg(&v.a);
+    let svg_b = extract_svg(&v.b);
+    let identical = svg_a == svg_b;
+    let len_a = svg_a.len();
+    let len_b = svg_b.len();
+    let common = svg_a.bytes().zip(svg_b.bytes()).take_while(|(x, y)| x == y).count();
+    let similarity = if len_a == 0 && len_b == 0 { 1.0 } else {
+        let max_len = len_a.max(len_b) as f64;
+        common as f64 / max_len
+    };
+    serde_json::json!({
+        "ok":true,
+        "identical":identical,
+        "size_a":len_a,
+        "size_b":len_b,
+        "common_prefix":common,
+        "similarity":similarity
+    }).to_string()
+}
+
+fn extract_svg(html: &str) -> String {
+    let start = match html.find("<svg") { Some(i) => i, None => return String::new() };
+    let end = match html[start..].find("</svg>") { Some(i) => start + i + 6, None => return String::new() };
+    html[start..end].to_string()
+}
+
+pub fn drift_ks(input: &str) -> String {
+    #[derive(serde::Deserialize)]
+    struct In { reference: Vec<f64>, current: Vec<f64> }
+    let v: In = match serde_json::from_str(input) {
+        Ok(v) => v,
+        Err(e) => return serde_json::json!({"ok":false,"error":format!("invalid JSON: {e}")}).to_string(),
+    };
+    let mut a = v.reference.clone();
+    let mut b = v.current.clone();
+    if a.is_empty() || b.is_empty() {
+        return serde_json::json!({"ok":false,"error":"empty array"}).to_string();
+    }
+    a.sort_by(|x, y| x.partial_cmp(y).unwrap_or(std::cmp::Ordering::Equal));
+    b.sort_by(|x, y| x.partial_cmp(y).unwrap_or(std::cmp::Ordering::Equal));
+    let n = a.len() as f64;
+    let m = b.len() as f64;
+    let mut i = 0usize; let mut j = 0usize;
+    let mut max_d = 0.0f64;
+    while i < a.len() && j < b.len() {
+        let cdf_a = (i + 1) as f64 / n;
+        let cdf_b = (j + 1) as f64 / m;
+        let d = (cdf_a - cdf_b).abs();
+        if d > max_d { max_d = d; }
+        if a[i] <= b[j] { i += 1; } else { j += 1; }
+    }
+    let coeff = ((n * m) / (n + m)).sqrt();
+    let lambda = (coeff + 0.12 + 0.11 / coeff) * max_d;
+    let mut p_value = 0.0f64;
+    let mut sign = 1.0f64;
+    for k in 1..=100 {
+        let term = sign * 2.0 * (-2.0 * lambda * lambda * (k * k) as f64).exp();
+        p_value += term;
+        sign = -sign;
+        if term.abs() < 1e-10 { break; }
+    }
+    p_value = p_value.clamp(0.0, 1.0);
+    let drift_detected = p_value < 0.05;
+    serde_json::json!({
+        "ok":true,
+        "ks_statistic":max_d,
+        "p_value":p_value,
+        "drift_detected":drift_detected,
+        "n_reference":a.len(),
+        "n_current":b.len()
+    }).to_string()
+}
+
 pub fn bench_chart_value(s: &str) -> bool {
     serde_json::from_str::<serde_json::Value>(s).is_ok()
 }

{seraplot-2.3.84 → seraplot-2.3.85}/src/bindings/commands/registry.rs

@@ -39,6 +39,12 @@ pub fn register_submodules(py: Python<'_>, m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(export_png, m)?)?;
     m.add_function(wrap_pyfunction!(chart_info, m)?)?;
     m.add_class::<LiveStream>()?;
+    m.add_function(wrap_pyfunction!(facet, m)?)?;
+    m.add_function(wrap_pyfunction!(drift, m)?)?;
+    m.add_function(wrap_pyfunction!(lttb, m)?)?;
+    m.add_function(wrap_pyfunction!(show, m)?)?;
+    m.add_function(wrap_pyfunction!(auto_classify, m)?)?;
+    m.add_class::<Pipeline>()?;
 
     for (alias, canonical) in crate::bindings::registry_macro::CHART_ALIASES {
         if let Ok(func) = m.getattr(*canonical) {

{seraplot-2.3.84 → seraplot-2.3.85}/src/bindings/registry_macro.rs

@@ -187,6 +187,10 @@ macro_rules! for_each_fn {
         $mac!(ml_save_model,             "mlSaveModel");
         $mac!(ml_load_model,             "mlLoadModel");
         $mac!(chart_info,                "chartInfo");
+        $mac!(validate_input,            "validateInput");
+        $mac!(downsample_lttb,           "downsampleLttb");
+        $mac!(chart_diff,                "chartDiff");
+        $mac!(drift_ks,                  "driftKs");
     };
 }
 
@@ -619,5 +623,160 @@ macro_rules! impl_python_bindings {
             pub fn clear(&mut self) { self.xs.clear(); self.ys.clear(); }
             #[getter] pub fn n(&self) -> usize { self.xs.len() }
         }
+
+        #[pyfunction]
+        #[pyo3(signature = (charts, cols=2, gap=16, bg=None, cell_height=520))]
+        pub fn facet(
+            charts: Vec<pyo3::PyRef<crate::Chart>>,
+            cols: usize,
+            gap: i32,
+            bg: Option<&str>,
+            cell_height: i32,
+        ) -> crate::Chart {
+            let html_strs: Vec<String> = charts.iter().map(|c| c.html.clone()).collect();
+            crate::Chart::new(
+                crate::bindings::commands::charts::build_grid(
+                    &serde_json::json!({"charts": html_strs, "cols": cols, "gap": gap, "background": bg, "cell_height": cell_height}).to_string()
+                )
+            )
+        }
+
+        #[pyfunction]
+        #[pyo3(signature = (reference, current))]
+        pub fn drift(reference: Vec<f64>, current: Vec<f64>) -> String {
+            crate::bindings::commands::charts::drift_ks(
+                &serde_json::json!({"reference": reference, "current": current}).to_string()
+            )
+        }
+
+        #[pyfunction]
+        #[pyo3(signature = (input, threshold=2000))]
+        pub fn lttb(input: Vec<(f64, f64)>, threshold: usize) -> Vec<(f64, f64)> {
+            let xs: Vec<f64> = input.iter().map(|p| p.0).collect();
+            let ys: Vec<f64> = input.iter().map(|p| p.1).collect();
+            let res = crate::bindings::commands::charts::downsample_lttb(
+                &serde_json::json!({"x": xs, "y": ys, "threshold": threshold}).to_string()
+            );
+            let v: serde_json::Value = match serde_json::from_str(&res) { Ok(v) => v, Err(_) => return input };
+            let nx: Vec<f64> = v.get("x").and_then(|a| a.as_array()).map(|a| a.iter().filter_map(|n| n.as_f64()).collect()).unwrap_or_default();
+            let ny: Vec<f64> = v.get("y").and_then(|a| a.as_array()).map(|a| a.iter().filter_map(|n| n.as_f64()).collect()).unwrap_or_default();
+            nx.into_iter().zip(ny).collect()
+        }
+
+        #[pyfunction]
+        pub fn show(py: Python<'_>, chart: &crate::Chart) -> PyResult<()> {
+            chart.show(py)
+        }
+
+        #[pyfunction]
+        #[pyo3(signature = (x, y, models=None))]
+        pub fn auto_classify(py: Python<'_>, x: &PyAny, y: Vec<i64>, models: Option<Vec<String>>) -> PyResult<pyo3::Py<pyo3::types::PyDict>> {
+            let (flat, n, dims) = crate::bindings::commands::ml::extract_flat(x)?;
+            let chosen = models.unwrap_or_else(|| vec![
+                "logistic".to_string(),
+                "knn".to_string(),
+                "decision_tree".to_string(),
+                "random_forest".to_string(),
+                "gradient_boosting".to_string(),
+            ]);
+            let mut leaderboard: Vec<(String, f64)> = Vec::new();
+            for name in chosen.iter() {
+                let payload = serde_json::json!({"x": flat, "n": n, "dims": dims, "y": y}).to_string();
+                let raw = match name.as_str() {
+                    "logistic" => crate::bindings::commands::charts::ml_logistic_regression(&payload),
+                    "knn" => crate::bindings::commands::charts::ml_knn_classifier(&payload),
+                    "decision_tree" => crate::bindings::commands::charts::ml_decision_tree_classifier(&payload),
+                    "random_forest" => crate::bindings::commands::charts::ml_random_forest_classifier(&payload),
+                    "gradient_boosting" => crate::bindings::commands::charts::ml_gradient_boosting_classifier(&payload),
+                    _ => continue,
+                };
+                let score = serde_json::from_str::<serde_json::Value>(&raw).ok()
+                    .and_then(|v| v.get("score").and_then(|s| s.as_f64()))
+                    .or_else(|| serde_json::from_str::<serde_json::Value>(&raw).ok().and_then(|v| v.get("accuracy").and_then(|s| s.as_f64())))
+                    .unwrap_or(f64::NAN);
+                leaderboard.push((name.clone(), score));
+            }
+            leaderboard.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
+            let dict = pyo3::types::PyDict::new(py);
+            let lb = pyo3::types::PyList::empty(py);
+            for (name, score) in leaderboard.iter() {
+                let row = pyo3::types::PyDict::new(py);
+                row.set_item("model", name)?;
+                row.set_item("score", score)?;
+                lb.append(row)?;
+            }
+            dict.set_item("leaderboard", lb)?;
+            if let Some((best_name, best_score)) = leaderboard.first() {
+                dict.set_item("best_model", best_name)?;
+                dict.set_item("best_score", best_score)?;
+            }
+            Ok(dict.into())
+        }
+
+        #[pyclass(module = "seraplot", name = "Pipeline")]
+        pub struct Pipeline {
+            steps: Vec<(String, pyo3::PyObject)>,
+        }
+
+        #[pymethods]
+        impl Pipeline {
+            #[new]
+            #[pyo3(signature = (steps))]
+            pub fn py_new(steps: Vec<(String, pyo3::PyObject)>) -> Self {
+                Self { steps }
+            }
+            pub fn fit(&mut self, py: Python<'_>, x: &PyAny, y: Option<&PyAny>) -> PyResult<()> {
+                let mut current: pyo3::PyObject = x.into();
+                for (i, (_, step)) in self.steps.iter().enumerate() {
+                    let st = step.as_ref(py);
+                    let is_last = i == self.steps.len() - 1;
+                    if is_last {
+                        if let Some(yy) = y {
+                            let _ = st.call_method1("fit", (current.as_ref(py), yy));
+                        } else {
+                            let _ = st.call_method1("fit", (current.as_ref(py),));
+                        }
+                    } else {
+                        if let Some(yy) = y {
+                            let _ = st.call_method1("fit", (current.as_ref(py), yy));
+                        } else {
+                            let _ = st.call_method1("fit", (current.as_ref(py),));
+                        }
+                        if let Ok(t) = st.call_method1("transform", (current.as_ref(py),)) {
+                            current = t.into();
+                        }
+                    }
+                }
+                Ok(())
+            }
+            pub fn predict(&self, py: Python<'_>, x: &PyAny) -> PyResult<pyo3::PyObject> {
+                let mut current: pyo3::PyObject = x.into();
+                for (i, (_, step)) in self.steps.iter().enumerate() {
+                    let st = step.as_ref(py);
+                    let is_last = i == self.steps.len() - 1;
+                    if is_last {
+                        return Ok(st.call_method1("predict", (current.as_ref(py),))?.into());
+                    }
+                    if let Ok(t) = st.call_method1("transform", (current.as_ref(py),)) {
+                        current = t.into();
+                    }
+                }
+                Ok(current)
+            }
+            pub fn transform(&self, py: Python<'_>, x: &PyAny) -> PyResult<pyo3::PyObject> {
+                let mut current: pyo3::PyObject = x.into();
+                for (_, step) in self.steps.iter() {
+                    let st = step.as_ref(py);
+                    if let Ok(t) = st.call_method1("transform", (current.as_ref(py),)) {
+                        current = t.into();
+                    }
+                }
+                Ok(current)
+            }
+            #[getter] pub fn step_names(&self) -> Vec<String> { self.steps.iter().map(|(n, _)| n.clone()).collect() }
+            fn __repr__(&self) -> String {
+                format!("Pipeline(steps={:?})", self.steps.iter().map(|(n, _)| n.clone()).collect::<Vec<_>>())
+            }
+        }
     };
 }

{seraplot-2.3.84 → seraplot-2.3.85}/src/docs/SUMMARY.md

@@ -130,6 +130,17 @@
 - [Auto Display](config/auto-display.md)
 - [Hover JSON](config/hover.md)
 - [Palette](config/palette.md)
+- [Export (SVG / PNG / Data URL)](config/export.md)
+- [Live Streaming](config/streaming.md)
+- [ML Persistence](config/ml-persistence.md)
+- [Faceting / Small Multiples](config/facet.md)
+- [Downsampling (LTTB)](config/downsample.md)
+- [Chart Diff](config/diff.md)
+- [Accessibility (a11y)](config/a11y.md)
+- [CSP-safe Mode](config/csp.md)
+- [Pickle / Serialization](config/pickle.md)
+- [AutoML & Pipeline](config/automl.md)
+- [Drift Detection](config/drift.md)
 
 ---
 

seraplot-2.3.85/src/docs/config/a11y.md

@@ -0,0 +1,41 @@
+# Accessibility (a11y)
+
+<div class="lang-en">
+
+Inject ARIA roles, `<title>` and `<desc>` into the chart SVG for screen readers and B2B compliance (WCAG 2.1).
+
+## Python
+
+```python
+import seraplot as sp
+
+chart = (
+    sp.bar([10,20,30], ["EU","US","APAC"])
+      .a11y(title="Quarterly revenue by region",
+            desc="Bar chart, EU 10M, US 20M, APAC 30M")
+)
+```
+
+The resulting SVG includes `role="img"`, `aria-label`, `<title>`, `<desc>` — recognized by NVDA, JAWS, VoiceOver.
+
+</div>
+
+<div class="lang-fr">
+
+Injecte les rôles ARIA, `<title>` et `<desc>` dans le SVG pour les lecteurs d'écran et la conformité B2B (WCAG 2.1).
+
+## Python
+
+```python
+import seraplot as sp
+
+chart = (
+    sp.bar([10,20,30], ["EU","US","APAC"])
+      .a11y(title="Revenu trimestriel par région",
+            desc="Bar chart, EU 10M, US 20M, APAC 30M")
+)
+```
+
+Le SVG résultant inclut `role="img"`, `aria-label`, `<title>`, `<desc>` — reconnus par NVDA, JAWS, VoiceOver.
+
+</div>

seraplot-2.3.85/src/docs/config/automl.md

@@ -0,0 +1,69 @@
+# AutoML & Pipeline
+
+<div class="lang-en">
+
+## auto_classify
+
+Try several classifiers, return the leaderboard sorted by score.
+
+```python
+import seraplot as sp
+
+result = sp.auto_classify(X_train, y_train)
+print(result["best_model"], result["best_score"])
+for row in result["leaderboard"]:
+    print(row)
+```
+
+Default models: `logistic`, `knn`, `decision_tree`, `random_forest`, `gradient_boosting`. Customize with `models=["random_forest","knn"]`.
+
+## Pipeline
+
+Chain transformers + estimator (sklearn-compatible API).
+
+```python
+from seraplot import StandardScaler, RandomForestClassifier, Pipeline
+
+pipe = Pipeline([
+    ("scaler", StandardScaler()),
+    ("model",  RandomForestClassifier(n_estimators=200)),
+])
+pipe.fit(X_train, y_train)
+preds = pipe.predict(X_test)
+```
+
+</div>
+
+<div class="lang-fr">
+
+## auto_classify
+
+Essaie plusieurs classifieurs, retourne le leaderboard trié par score.
+
+```python
+import seraplot as sp
+
+result = sp.auto_classify(X_train, y_train)
+print(result["best_model"], result["best_score"])
+for row in result["leaderboard"]:
+    print(row)
+```
+
+Modèles par défaut : `logistic`, `knn`, `decision_tree`, `random_forest`, `gradient_boosting`. Personnalisable avec `models=["random_forest","knn"]`.
+
+## Pipeline
+
+Enchaîne transformers + estimateur (API compatible sklearn).
+
+```python
+from seraplot import StandardScaler, RandomForestClassifier, Pipeline
+
+pipe = Pipeline([
+    ("scaler", StandardScaler()),
+    ("model",  RandomForestClassifier(n_estimators=200)),
+])
+pipe.fit(X_train, y_train)
+preds = pipe.predict(X_test)
+```
+
+</div>

seraplot-2.3.85/src/docs/config/csp.md

@@ -0,0 +1,33 @@
+# CSP-safe Mode
+
+<div class="lang-en">
+
+Strict Content Security Policies block inline `<script>`. The `csp_safe()` method extracts JS into a `<script type="application/json">` payload + a single nonce-able loader.
+
+## Python
+
+```python
+import seraplot as sp
+
+chart = sp.line([1,2,3,4], [10,20,15,25]).csp_safe()
+```
+
+Apply your CSP `script-src 'nonce-sp-nonce'` and the chart still renders.
+
+</div>
+
+<div class="lang-fr">
+
+Les CSP strictes bloquent les `<script>` inline. La méthode `csp_safe()` extrait le JS dans un payload `<script type="application/json">` + un loader unique compatible nonce.
+
+## Python
+
+```python
+import seraplot as sp
+
+chart = sp.line([1,2,3,4], [10,20,15,25]).csp_safe()
+```
+
+Applique ta CSP `script-src 'nonce-sp-nonce'` et le chart se rend toujours.
+
+</div>

seraplot-2.3.85/src/docs/config/diff.md

@@ -0,0 +1,53 @@
+# Chart Diff
+
+<div class="lang-en">
+
+Compare two charts structurally — useful for visual CI / regression testing.
+
+## Python
+
+```python
+import seraplot as sp
+
+a = sp.bar([1,2,3], ["x","y","z"])
+b = sp.bar([1,2,4], ["x","y","z"])
+result = a.diff(b)
+print(result)
+```
+
+Returns JSON: `{ "ok": true, "identical": false, "size_a": 4521, "size_b": 4523, "common_prefix": 4400, "similarity": 0.97 }`.
+
+## JavaScript
+
+```javascript
+import { chartDiff } from "seraplot";
+const diff = JSON.parse(chartDiff(JSON.stringify({ a: htmlA, b: htmlB })));
+```
+
+</div>
+
+<div class="lang-fr">
+
+Compare deux charts structurellement — utile pour les CI visuelles / tests de régression.
+
+## Python
+
+```python
+import seraplot as sp
+
+a = sp.bar([1,2,3], ["x","y","z"])
+b = sp.bar([1,2,4], ["x","y","z"])
+result = a.diff(b)
+print(result)
+```
+
+Retourne du JSON : `{ "ok": true, "identical": false, "size_a": 4521, "size_b": 4523, "common_prefix": 4400, "similarity": 0.97 }`.
+
+## JavaScript
+
+```javascript
+import { chartDiff } from "seraplot";
+const diff = JSON.parse(chartDiff(JSON.stringify({ a: htmlA, b: htmlB })));
+```
+
+</div>

seraplot-2.3.85/src/docs/config/downsample.md

@@ -0,0 +1,63 @@
+# Downsampling (LTTB)
+
+<div class="lang-en">
+
+Reduce massive datasets while preserving visual shape using the **Largest-Triangle-Three-Buckets** algorithm. A 10M-point scatter chart becomes 5K points indistinguishable to the eye.
+
+## Python
+
+```python
+import seraplot as sp
+
+chart = sp.scatter(big_x, big_y).downsample(n=5000)
+
+points = sp.lttb(list(zip(big_x, big_y)), threshold=5000)
+```
+
+## JavaScript
+
+```javascript
+import { downsampleLttb } from "seraplot";
+const reduced = JSON.parse(downsampleLttb(JSON.stringify({ x, y, threshold: 5000 })));
+```
+
+## Why LTTB?
+
+| Method | Preserves peaks | Speed | Visual fidelity |
+|--------|----------------|-------|-----------------|
+| Random sample | No | Fast | Poor |
+| Every-Nth | Maybe | Fast | OK |
+| **LTTB** | Yes | Fast | Excellent |
+
+</div>
+
+<div class="lang-fr">
+
+Réduit les datasets massifs en préservant la forme visuelle avec l'algorithme **Largest-Triangle-Three-Buckets**. Un scatter de 10M points devient 5K points indistinguables à l'œil.
+
+## Python
+
+```python
+import seraplot as sp
+
+chart = sp.scatter(big_x, big_y).downsample(n=5000)
+
+points = sp.lttb(list(zip(big_x, big_y)), threshold=5000)
+```
+
+## JavaScript
+
+```javascript
+import { downsampleLttb } from "seraplot";
+const reduced = JSON.parse(downsampleLttb(JSON.stringify({ x, y, threshold: 5000 })));
+```
+
+## Pourquoi LTTB ?
+
+| Méthode | Préserve les pics | Vitesse | Fidélité visuelle |
+|---------|-------------------|---------|-------------------|
+| Échantillon aléatoire | Non | Rapide | Mauvaise |
+| Tous les N | Peut-être | Rapide | OK |
+| **LTTB** | Oui | Rapide | Excellente |
+
+</div>