seraplot 2.3.73__tar.gz → 2.3.74__tar.gz

{seraplot-2.3.73 → seraplot-2.3.74}/Cargo.lock

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

{seraplot-2.3.73 → seraplot-2.3.74}/Cargo.toml

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

{seraplot-2.3.73 → seraplot-2.3.74}/PKG-INFO

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

{seraplot-2.3.73 → seraplot-2.3.74}/pyproject.toml

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

{seraplot-2.3.73 → seraplot-2.3.74}/src/bindings/commands/charts.rs

@@ -32,7 +32,7 @@ fn get_global_grid() -> bool {
 }
 
 #[derive(Deserialize, Default)]
-pub struct CoreOpts {
+pub struct ChartOpts {
     pub width: Option<i32>,
     pub height: Option<i32>,
     pub x_label: Option<String>,
@@ -98,7 +98,7 @@ pub struct CoreOpts {
     pub descriptions: Option<Vec<Vec<Vec<String>>>>,
 }
 
-impl CoreOpts {
+impl ChartOpts {
     pub fn w(&self, default: i32) -> i32 { self.width.unwrap_or(default) }
     pub fn h(&self, default: i32) -> i32 { self.height.unwrap_or(default) }
     pub fn xl(&self) -> String { self.x_label.clone().unwrap_or_default() }
@@ -124,7 +124,7 @@ impl CoreOpts {
 }
 
 #[derive(Deserialize, Default)]
-pub struct CoreArgs {
+pub struct ChartArgs {
     pub labels: Option<Vec<String>>,
     pub values: Option<Vec<f64>>,
     pub x: Option<Vec<f64>>,
@@ -156,35 +156,35 @@ pub struct CoreArgs {
     pub data: Option<Vec<Vec<f64>>>,
 }
 
-pub fn parse_opts(opts: &str) -> CoreOpts {
+pub fn parse_opts(opts: &str) -> ChartOpts {
     serde_json::from_str(opts).unwrap_or_default()
 }
 
-pub fn parse_args(args: &str) -> CoreArgs {
+pub fn parse_args(args: &str) -> ChartArgs {
     serde_json::from_str(args).unwrap_or_default()
 }
 
-fn parse_all(input: &str) -> (String, CoreArgs, CoreOpts) {
+fn parse_all(input: &str) -> (String, ChartArgs, ChartOpts) {
     #[derive(Deserialize, Default)]
     struct All {
         #[serde(default)]
         title: String,
         #[serde(flatten)]
-        args: CoreArgs,
+        args: ChartArgs,
         #[serde(flatten)]
-        opts: CoreOpts,
+        opts: ChartOpts,
     }
     let all: All = serde_json::from_str(input).unwrap_or_default();
     (all.title, all.args, all.opts)
 }
 
-pub fn apply(html: String, o: &CoreOpts) -> String {
+pub fn apply(html: String, o: &ChartOpts) -> String {
     let bg_str = o.bg_str().or_else(get_global_bg);
     let bg = bg_str.as_deref();
     crate::html::hover::apply_opts(html, bg, !o.no_x(), !o.no_y())
 }
 
-pub fn apply_bg3d(html: String, o: &CoreOpts) -> String {
+pub fn apply_bg3d(html: String, o: &ChartOpts) -> String {
     let bg_str = o.bg_str().or_else(get_global_bg);
     if let Some(bg) = bg_str.as_deref() {
         crate::html::hover::apply_bg(html, Some(bg))
@@ -1297,13 +1297,17 @@ pub fn build_slideshow(input: &str) -> String {
         format!("<div style=\"color:#1e293b;font-family:system-ui;font-size:22px;font-weight:700;text-align:center;margin-bottom:16px\">{}</div>", show_title)
     };
     let n = charts.len();
-    let json_array = format!("[{}]", charts.iter()
-        .map(|s| serde_json::to_string(s).unwrap_or_else(|_| "\"\"".to_string()))
-        .collect::<Vec<_>>().join(","));
+    let mut frames_html = String::new();
+    for (i, html) in charts.iter().enumerate() {
+        let esc = html.replace('&', "&amp;").replace('"', "&quot;");
+        let vis = if i == 0 { "" } else { "display:none;" };
+        frames_html.push_str(&format!(
+            "<iframe id=\"sp-s-{i}\" style=\"{vis}width:{width}px;height:{height}px;border:none;border-radius:12px;overflow:hidden;box-shadow:0 2px 12px rgba(0,0,0,.1)\" srcdoc=\"{esc}\"></iframe>"
+        ));
+    }
     format!(
         "<!DOCTYPE html><html><head><meta charset=\"utf-8\"><style>\
         body{{margin:0;padding:24px;background:#f0f2f5;display:flex;flex-direction:column;align-items:center;font-family:system-ui}}\
-        .sp-frm{{border-radius:12px;overflow:hidden;box-shadow:0 2px 12px rgba(0,0,0,.1);background:#fff}}\
         .sp-ctrl{{display:flex;gap:10px;margin-top:14px;align-items:center}}\
         .sp-btn{{cursor:pointer;background:#6366f1;color:#fff;border:none;border-radius:8px;padding:7px 20px;font-size:14px;font-weight:600}}\
         .sp-btn:hover{{background:#4f46e5}}\
@@ -1312,20 +1316,19 @@ pub fn build_slideshow(input: &str) -> String {
         .sp-bar{{height:100%;background:#6366f1;border-radius:2px;width:0%}}\
         </style></head><body>\
         {title_html}\
-        <div class=\"sp-frm\" id=\"sp-frm\" style=\"width:{width}px;height:{height}px\"></div>\
+        {frames_html}\
         <div class=\"sp-ctrl\">\
         <button class=\"sp-btn\" id=\"sp-p\">&#9664;</button>\
         <div class=\"sp-ctr\" id=\"sp-c\">1 / {n}</div>\
         <button class=\"sp-btn\" id=\"sp-n\">&#9654;</button>\
         </div>\
         <div class=\"sp-prog\"><div class=\"sp-bar\" id=\"sp-b\"></div></div>\
-        <script type=\"application/json\" id=\"sp-d\">{json_array}</script>\
         <script>\
-        const frames=JSON.parse(document.getElementById('sp-d').textContent);\
+        const slides=document.querySelectorAll('[id^=\"sp-s-\"]');\
         let idx=0,timer;\
-        function show(i){{idx=((i%frames.length)+frames.length)%frames.length;\
-          document.getElementById('sp-frm').innerHTML=frames[idx];\
-          document.getElementById('sp-c').textContent=(idx+1)+' / '+frames.length;\
+        function show(i){{idx=((i%slides.length)+slides.length)%slides.length;\
+          slides.forEach((s,j)=>{{s.style.display=j===idx?'':'none';}});\
+          document.getElementById('sp-c').textContent=(idx+1)+' / '+slides.length;\
           const b=document.getElementById('sp-b');\
           b.style.transition='none';b.style.width='0%';\
           setTimeout(()=>{{b.style.transition='width {ivms}ms linear';b.style.width='100%';}},20);}}\
@@ -1445,4 +1448,68 @@ pub fn themes(_: &str) -> String {
     "[\"dark\",\"light\",\"scientific\",\"apple\",\"notion\",\"minimal\",\"neon\"]".to_string()
 }
 
+pub struct DbscanState {
+    pub eps: f64,
+    pub min_samples: usize,
+    pub labels: Vec<i32>,
+    pub n_clusters: usize,
+    pub n_noise: usize,
+}
+
+impl DbscanState {
+    pub fn new(eps: f64, min_samples: usize) -> Self {
+        Self { eps, min_samples, labels: Vec::new(), n_clusters: 0, n_noise: 0 }
+    }
+    pub fn fit(&mut self, x: &[Vec<f64>]) {
+        let (labels, n_clusters) = crate::plot::default::scatter::dbscan_core_nd(x, self.eps, self.min_samples);
+        self.n_noise = labels.iter().filter(|&&l| l < 0).count();
+        self.labels = labels;
+        self.n_clusters = n_clusters;
+    }
+}
+
+pub struct KMeansState {
+    pub k: usize,
+    pub max_iter: usize,
+    pub tol: f64,
+    pub mini_batch: bool,
+    pub batch_size: usize,
+    pub n_init: usize,
+    pub labels: Vec<i32>,
+    pub centroids: Vec<Vec<f64>>,
+    pub inertia: f64,
+    pub n_iter: usize,
+}
 
+impl KMeansState {
+    pub fn new(k: usize, max_iter: usize, tol: f64, mini_batch: bool, batch_size: usize, n_init: usize) -> Self {
+        Self { k, max_iter, tol, mini_batch, batch_size, n_init, labels: Vec::new(), centroids: Vec::new(), inertia: 0.0, n_iter: 0 }
+    }
+    pub fn fit_flat(&mut self, flat: &[f64], n: usize, dims: usize) {
+        if self.mini_batch {
+            let (labels, flat_c, inertia) = crate::plot::default::minibatch_kmeans_core_flat(flat, n, dims, self.k, self.max_iter, self.batch_size);
+            self.labels = labels;
+            self.centroids = (0..self.k.min(n)).map(|ki| flat_c[ki*dims..(ki+1)*dims].to_vec()).collect();
+            self.inertia = inertia;
+        } else {
+            let (labels, flat_c, inertia) = crate::plot::default::kmeans_core_flat_ninit(flat, n, dims, self.k, self.max_iter, self.tol, self.n_init);
+            self.labels = labels;
+            self.centroids = (0..self.k.min(n)).map(|ki| flat_c[ki*dims..(ki+1)*dims].to_vec()).collect();
+            self.inertia = inertia;
+        }
+        self.n_iter = self.max_iter;
+    }
+    pub fn predict_flat(&self, flat: &[f64], n: usize, dims: usize) -> Vec<i32> {
+        (0..n).map(|i| {
+            self.centroids.iter().enumerate()
+                .map(|(ki, c)| (ki, crate::plot::default::kmeans::sq_dist_flat(&flat[i*dims..(i+1)*dims], c)))
+                .min_by(|a, b| a.1.partial_cmp(&b.1).unwrap())
+                .map(|(ki, _)| ki as i32).unwrap_or(0)
+        }).collect()
+    }
+    pub fn transform_flat(&self, flat: &[f64], n: usize, dims: usize) -> Vec<Vec<f64>> {
+        (0..n).map(|i| {
+            self.centroids.iter().map(|c| crate::plot::default::kmeans::sq_dist_flat(&flat[i*dims..(i+1)*dims], c).sqrt()).collect()
+        }).collect()
+    }
+}

{seraplot-2.3.73 → seraplot-2.3.74}/src/bindings/commands/native.rs

@@ -1,4 +1,4 @@
-#[cfg(feature = "js")]
+#[cfg(feature = "js")]
 use wasm_bindgen::prelude::*;
 
 #[cfg(feature = "js")]
@@ -55,35 +55,65 @@ fn chart_auto(name: &str, title: &str, n: usize) -> crate::ml::cache::TaskHandle
 }
 
 #[cfg(feature = "python")]
-fn kwargs_to_json(kwargs: Option<&pyo3::types::PyDict>) -> String {
-    fn v(val: &PyAny) -> serde_json::Value {
-        if val.is_none() { return serde_json::Value::Null; }
-        if let Ok(b) = val.extract::<bool>() { return serde_json::Value::Bool(b); }
-        if let Ok(i) = val.extract::<i64>() { return serde_json::json!(i); }
-        if let Ok(f) = val.extract::<f64>() { return serde_json::json!(f); }
-        if let Ok(s) = val.extract::<String>() { return serde_json::Value::String(s); }
-        if let Ok(list) = val.extract::<Vec<Vec<f64>>>() { return serde_json::json!(list); }
-        if let Ok(list) = val.extract::<Vec<f64>>() { return serde_json::json!(list); }
-        if let Ok(list) = val.extract::<Vec<String>>() { return serde_json::json!(list); }
-        if let Ok(list) = val.extract::<Vec<i64>>() { return serde_json::json!(list); }
-        serde_json::Value::Null
+fn py_any_val(val: &PyAny) -> serde_json::Value {
+    if val.is_none() { return serde_json::Value::Null; }
+    if let Ok(b) = val.extract::<bool>() { return serde_json::Value::Bool(b); }
+    if let Ok(i) = val.extract::<i64>() { return serde_json::json!(i); }
+    if let Ok(f) = val.extract::<f64>() { return serde_json::json!(f); }
+    if let Ok(s) = val.extract::<String>() { return serde_json::Value::String(s); }
+    if let Ok(list) = val.extract::<Vec<Vec<f64>>>() { return serde_json::json!(list); }
+    if let Ok(list) = val.extract::<Vec<f64>>() { return serde_json::json!(list); }
+    if let Ok(list) = val.extract::<Vec<String>>() { return serde_json::json!(list); }
+    if let Ok(list) = val.extract::<Vec<i64>>() { return serde_json::json!(list); }
+    serde_json::Value::Null
+}
+
+#[cfg(feature = "python")]
+fn py_args_to_json(
+    title: &str,
+    labels: Option<&pyo3::types::PyAny>,
+    values: Option<&pyo3::types::PyAny>,
+    kwargs: Option<&pyo3::types::PyDict>,
+) -> String {
+    let mut m = serde_json::Map::new();
+    if !title.is_empty() { m.insert("title".into(), serde_json::json!(title)); }
+    if let Some(v) = labels {
+        let jv = py_any_val(v);
+        if jv != serde_json::Value::Null { m.insert("labels".into(), jv); }
+    }
+    if let Some(v) = values {
+        if let Ok(vv) = v.extract::<Vec<Vec<f64>>>() {
+            m.insert("series".into(), serde_json::json!(vv));
+        } else {
+            let jv = py_any_val(v);
+            if jv != serde_json::Value::Null { m.insert("values".into(), jv); }
+        }
+    }
+    if let Some(d) = kwargs {
+        for (key, val) in d.iter() {
+            if let Ok(ks) = key.str() {
+                let ks = ks.to_string_lossy().to_string();
+                let v = py_any_val(val);
+                if v != serde_json::Value::Null { m.insert(ks, v); }
+            }
+        }
     }
-    let Some(d) = kwargs else { return "{}".to_string() };
-    serde_json::Value::Object(
-        d.iter()
-            .filter_map(|(k, val)| Some((k.str().ok()?.to_string_lossy().to_string(), v(val))))
-            .collect(),
-    ).to_string()
+    serde_json::Value::Object(m).to_string()
 }
 
 #[cfg(feature = "python")]
 macro_rules! impl_python {
     ($fn:ident, $_js:literal) => {
         #[pyfunction]
-        #[pyo3(signature = (**kwargs))]
-        pub fn $fn(kwargs: Option<&pyo3::types::PyDict>) -> PyResult<crate::Chart> {
+        #[pyo3(signature = (title="", labels=None, values=None, **kwargs))]
+        pub fn $fn(
+            title: &str,
+            labels: Option<&pyo3::types::PyAny>,
+            values: Option<&pyo3::types::PyAny>,
+            kwargs: Option<&pyo3::types::PyDict>,
+        ) -> PyResult<crate::Chart> {
             Ok(crate::Chart::new_doc(
-                crate::bindings::commands::charts::$fn(&kwargs_to_json(kwargs)),
+                crate::bindings::commands::charts::$fn(&py_args_to_json(title, labels, values, kwargs)),
                 "",
             ))
         }
@@ -179,13 +209,7 @@ pub fn bench_pure_rust(n: usize) -> (f64, f64, f64, f64) {
 
 #[cfg(feature = "python")]
 #[pyclass(module = "seraplot", name = "DBSCAN")]
-pub struct DbscanModel {
-    eps: f64,
-    min_samples: usize,
-    labels_: Vec<i32>,
-    n_clusters_: usize,
-    n_noise_: usize,
-}
+pub struct DbscanModel(crate::bindings::commands::charts::DbscanState);
 
 #[cfg(feature = "python")]
 #[pymethods]
@@ -193,19 +217,16 @@ impl DbscanModel {
     #[new]
     #[pyo3(signature = (eps=0.5, min_samples=5))]
     pub fn py_new(eps: f64, min_samples: usize) -> Self {
-        DbscanModel { eps, min_samples, labels_: Vec::new(), n_clusters_: 0, n_noise_: 0 }
+        DbscanModel(crate::bindings::commands::charts::DbscanState::new(eps, min_samples))
     }
 
     #[pyo3(signature = (x))]
     pub fn fit(&mut self, x: Vec<Vec<f64>>) -> PyResult<()> {
         let n = x.len();
         let d = x.first().map_or(0, |r| r.len());
-        let fp = crate::ml::cache::Fp::new("DBSCAN.fit").f64(self.eps).usize(self.min_samples).usize(n).usize(d).finish();
+        let fp = crate::ml::cache::Fp::new("DBSCAN.fit").f64(self.0.eps).usize(self.0.min_samples).usize(n).usize(d).finish();
         let _h = crate::ml::cache::TaskHandle::auto("DBSCAN.fit", fp);
-        let (labels, n_clusters) = crate::plot::default::scatter::dbscan_core_nd(&x, self.eps, self.min_samples);
-        self.n_noise_ = labels.iter().filter(|&&l| l < 0).count();
-        self.labels_ = labels;
-        self.n_clusters_ = n_clusters;
+        self.0.fit(&x);
         _h.complete(&crate::ml::cache::PartialState::default());
         Ok(())
     }
@@ -213,33 +234,20 @@ impl DbscanModel {
     #[pyo3(signature = (x))]
     pub fn fit_predict(&mut self, x: Vec<Vec<f64>>) -> PyResult<Vec<i32>> {
         self.fit(x)?;
-        Ok(self.labels_.clone())
+        Ok(self.0.labels.clone())
     }
 
-    #[getter]
-    pub fn labels_(&self) -> Vec<i32> { self.labels_.clone() }
+    #[getter] pub fn labels_(&self) -> Vec<i32> { self.0.labels.clone() }
+    #[getter] pub fn n_clusters_(&self) -> usize { self.0.n_clusters }
+    #[getter] pub fn n_noise_(&self) -> usize { self.0.n_noise }
+    #[getter] pub fn eps(&self) -> f64 { self.0.eps }
+    #[getter] pub fn min_samples(&self) -> usize { self.0.min_samples }
 
-    #[getter]
-    pub fn n_clusters_(&self) -> usize { self.n_clusters_ }
-
-    #[getter]
-    pub fn n_noise_(&self) -> usize { self.n_noise_ }
-
-    #[getter]
-    pub fn eps(&self) -> f64 { self.eps }
-
-    #[getter]
-    pub fn min_samples(&self) -> usize { self.min_samples }
-
-    fn doc(&self) -> &'static str {
-        crate::bindings::commands::docs::DOC_DBSCAN_MODEL
-    }
+    fn doc(&self) -> &'static str { crate::bindings::commands::docs::DOC_DBSCAN_MODEL }
 
     fn __repr__(&self) -> String {
-        format!(
-            "DBSCAN(eps={}, min_samples={}) -> {} clusters, {} noise",
-            self.eps, self.min_samples, self.n_clusters_, self.n_noise_
-        )
+        format!("DBSCAN(eps={}, min_samples={}) -> {} clusters, {} noise",
+            self.0.eps, self.0.min_samples, self.0.n_clusters, self.0.n_noise)
     }
 }
 
@@ -278,18 +286,7 @@ fn extract_flat(x: &PyAny) -> PyResult<(Vec<f64>, usize, usize)> {
 
 #[cfg(feature = "python")]
 #[pyclass(module = "seraplot", name = "KMeans")]
-pub struct KMeansModel {
-    k: usize,
-    max_iter: usize,
-    tol: f64,
-    mini_batch: bool,
-    batch_size: usize,
-    n_init: usize,
-    labels_: Vec<i32>,
-    centroids_: Vec<Vec<f64>>,
-    inertia_: f64,
-    n_iter_: usize,
-}
+pub struct KMeansModel(crate::bindings::commands::charts::KMeansState);
 
 #[cfg(feature = "python")]
 #[pymethods]
@@ -297,27 +294,15 @@ impl KMeansModel {
     #[new]
     #[pyo3(signature = (k=3, max_iter=300, tol=1e-4, mini_batch=false, batch_size=1000, n_init=10))]
     pub fn py_new(k: usize, max_iter: usize, tol: f64, mini_batch: bool, batch_size: usize, n_init: usize) -> Self {
-        KMeansModel { k, max_iter, tol, mini_batch, batch_size, n_init, labels_: Vec::new(), centroids_: Vec::new(), inertia_: 0.0, n_iter_: 0 }
+        KMeansModel(crate::bindings::commands::charts::KMeansState::new(k, max_iter, tol, mini_batch, batch_size, n_init))
     }
 
     #[pyo3(signature = (x))]
     pub fn fit(&mut self, x: &PyAny) -> PyResult<()> {
         let (flat, n, dims) = extract_flat(x)?;
-        let fp = crate::ml::cache::Fp::new("KMeans.fit").usize(self.k).usize(self.max_iter).bval(self.mini_batch).data(&flat, n, dims).finish();
+        let fp = crate::ml::cache::Fp::new("KMeans.fit").usize(self.0.k).usize(self.0.max_iter).bval(self.0.mini_batch).data(&flat, n, dims).finish();
         let _h = crate::ml::cache::TaskHandle::auto("KMeans.fit", fp);
-        if self.mini_batch {
-            let (labels, flat_c, inertia) = crate::plot::default::minibatch_kmeans_core_flat(&flat, n, dims, self.k, self.max_iter, self.batch_size);
-            self.labels_ = labels;
-            self.centroids_ = (0..self.k.min(n)).map(|ki| flat_c[ki*dims..(ki+1)*dims].to_vec()).collect();
-            self.inertia_ = inertia;
-            self.n_iter_ = self.max_iter;
-        } else {
-            let (labels, flat_c, inertia) = crate::plot::default::kmeans_core_flat_ninit(&flat, n, dims, self.k, self.max_iter, self.tol, self.n_init);
-            self.labels_ = labels;
-            self.centroids_ = (0..self.k.min(n)).map(|ki| flat_c[ki*dims..(ki+1)*dims].to_vec()).collect();
-            self.inertia_ = inertia;
-            self.n_iter_ = self.max_iter;
-        }
+        self.0.fit_flat(&flat, n, dims);
         _h.complete(&crate::ml::cache::PartialState::default());
         Ok(())
     }
@@ -325,41 +310,33 @@ impl KMeansModel {
     #[pyo3(signature = (x))]
     pub fn fit_predict(&mut self, x: &PyAny) -> PyResult<Vec<i32>> {
         self.fit(x)?;
-        Ok(self.labels_.clone())
+        Ok(self.0.labels.clone())
     }
 
     #[pyo3(signature = (x))]
     pub fn transform(&self, x: &PyAny) -> PyResult<Vec<Vec<f64>>> {
         let (flat, n, dims) = extract_flat(x)?;
-        Ok((0..n).map(|i| {
-            self.centroids_.iter().map(|c| crate::plot::default::kmeans::sq_dist_flat(&flat[i*dims..(i+1)*dims], c).sqrt()).collect()
-        }).collect())
+        Ok(self.0.transform_flat(&flat, n, dims))
     }
 
     #[pyo3(signature = (x))]
     pub fn predict(&self, x: &PyAny) -> PyResult<Vec<i32>> {
         let (flat, n, dims) = extract_flat(x)?;
-        Ok((0..n).map(|i| {
-            self.centroids_.iter().enumerate()
-                .map(|(ki, c)| (ki, crate::plot::default::kmeans::sq_dist_flat(&flat[i*dims..(i+1)*dims], c)))
-                .min_by(|a, b| a.1.partial_cmp(&b.1).unwrap())
-                .map(|(ki, _)| ki as i32).unwrap_or(0)
-        }).collect())
+        Ok(self.0.predict_flat(&flat, n, dims))
     }
 
-    #[getter] pub fn labels_(&self) -> Vec<i32> { self.labels_.clone() }
-    #[getter] pub fn centroids_(&self) -> Vec<Vec<f64>> { self.centroids_.clone() }
-    #[getter] pub fn inertia_(&self) -> f64 { self.inertia_ }
-    #[getter] pub fn n_iter_(&self) -> usize { self.n_iter_ }
-    #[getter] pub fn n_clusters(&self) -> usize { self.centroids_.len() }
-    #[getter] pub fn k(&self) -> usize { self.k }
+    #[getter] pub fn labels_(&self) -> Vec<i32> { self.0.labels.clone() }
+    #[getter] pub fn centroids_(&self) -> Vec<Vec<f64>> { self.0.centroids.clone() }
+    #[getter] pub fn inertia_(&self) -> f64 { self.0.inertia }
+    #[getter] pub fn n_iter_(&self) -> usize { self.0.n_iter }
+    #[getter] pub fn n_clusters(&self) -> usize { self.0.centroids.len() }
+    #[getter] pub fn k(&self) -> usize { self.0.k }
 
-    fn doc(&self) -> &'static str {
-        crate::bindings::commands::docs::DOC_KMEANS_MODEL
-    }
+    fn doc(&self) -> &'static str { crate::bindings::commands::docs::DOC_KMEANS_MODEL }
 
     fn __repr__(&self) -> String {
-        format!("KMeans(k={}, max_iter={}, n_init={}, mini_batch={}) -> inertia={:.2}", self.k, self.max_iter, self.n_init, self.mini_batch, self.inertia_)
+        format!("KMeans(k={}, max_iter={}, n_init={}, mini_batch={}) -> inertia={:.2}",
+            self.0.k, self.0.max_iter, self.0.n_init, self.0.mini_batch, self.0.inertia)
     }
 }
 
@@ -374,27 +351,14 @@ pub fn build_grid(
     cell_height: i32,
 ) -> Chart {
     let _h = chart_auto("build_grid", "", 0);
-    let bg_color = bg
-        .map(|s| s.to_string())
-        .or_else(crate::get_global_background)
-        .unwrap_or_else(|| "#f0f2f5".to_string());
-    let cols = cols.max(1);
-    let mut buf = format!(
-        "<!DOCTYPE html><html><head><meta charset=\"utf-8\"><style>\
-        *{{box-sizing:border-box}}body{{margin:0;padding:{gap}px;background:{bg_color}}}\
-        .spg{{display:grid;grid-template-columns:repeat({cols},1fr);gap:{gap}px}}\
-        .spg-c iframe{{width:100%;height:{cell_height}px;border:none;display:block;\
-        border-radius:12px;overflow:hidden;box-shadow:0 2px 8px rgba(0,0,0,.07)}}\
-        </style></head><body><div class=\"spg\">"
-    );
-    for c in charts.iter() {
-        let esc = c.html.replace('&', "&amp;").replace('"', "&quot;");
-        buf.push_str("<div class=\"spg-c\"><iframe srcdoc=\"");
-        buf.push_str(&esc);
-        buf.push_str("\"></iframe></div>");
-    }
-    buf.push_str("</div></body></html>");
-    Chart::new_doc(buf, crate::bindings::commands::docs::DOC_BUILD_GRID)
+    let bg_color = bg.map(|s| s.to_string()).or_else(crate::get_global_background).unwrap_or_else(|| "#f0f2f5".to_string());
+    let html_strs: Vec<String> = charts.iter().map(|c| c.html.clone()).collect();
+    Chart::new_doc(
+        crate::bindings::commands::charts::build_grid(
+            &serde_json::json!({"charts": html_strs, "cols": cols, "gap": gap, "background": bg_color, "cell_height": cell_height}).to_string()
+        ),
+        crate::bindings::commands::docs::DOC_BUILD_GRID,
+    )
 }
 
 #[cfg(feature = "python")]
@@ -408,58 +372,13 @@ pub fn build_slideshow(
     height: i32,
 ) -> Chart {
     let _h = chart_auto("build_slideshow", "", 0);
-    if charts.is_empty() { return Chart::new_doc(String::new(), crate::bindings::commands::docs::DOC_BUILD_SLIDESHOW); }
-    let svgs: Vec<String> = charts.iter().map(|c| {
-        let h = &c.html;
-        let start = h.find("<svg").unwrap_or(0);
-        let end = h.rfind("</svg>").map(|i| i + 6).unwrap_or(h.len());
-        if start < end { h[start..end].to_string() }
-        else { "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"100\" height=\"100\"></svg>".to_string() }
-    }).collect();
-    let json_array = format!("[{}]", svgs.iter()
-        .map(|s| serde_json::to_string(s).unwrap_or_else(|_| "\"\"".to_string()))
-        .collect::<Vec<_>>().join(","));
-    let n = charts.len();
-    let ivms = interval_ms;
-    let title_html = if title.is_empty() { String::new() } else {
-        format!("<div style=\"color:#1e293b;font-family:system-ui;font-size:22px;font-weight:700;text-align:center;margin-bottom:16px\">{}</div>", title)
-    };
-    Chart::new_doc(format!(
-        "<!DOCTYPE html><html><head><meta charset=\"utf-8\"><style>\
-        body{{margin:0;padding:24px;background:#f0f2f5;display:flex;flex-direction:column;align-items:center;font-family:system-ui}}\
-        .sp-frm{{border-radius:12px;overflow:hidden;box-shadow:0 2px 12px rgba(0,0,0,.1);background:#fff}}\
-        .sp-frm svg{{width:{width}px;height:{height}px;display:block}}\
-        .sp-ctrl{{display:flex;gap:10px;margin-top:14px;align-items:center}}\
-        .sp-btn{{cursor:pointer;background:#6366f1;color:#fff;border:none;border-radius:8px;padding:7px 20px;font-size:14px;font-weight:600}}\
-        .sp-btn:hover{{background:#4f46e5}}\
-        .sp-ctr{{color:#64748b;font-size:13px;min-width:64px;text-align:center}}\
-        .sp-prog{{width:{width}px;height:4px;background:#e2e8f0;border-radius:2px;margin-top:10px;overflow:hidden}}\
-        .sp-bar{{height:100%;background:#6366f1;border-radius:2px;width:0%}}\
-        </style></head><body>\
-        {title_html}\
-        <div class=\"sp-frm\" id=\"sp-frm\"></div>\
-        <div class=\"sp-ctrl\">\
-        <button class=\"sp-btn\" id=\"sp-p\">&#9664;</button>\
-        <div class=\"sp-ctr\" id=\"sp-c\">1 / {n}</div>\
-        <button class=\"sp-btn\" id=\"sp-n\">&#9654;</button>\
-        </div>\
-        <div class=\"sp-prog\"><div class=\"sp-bar\" id=\"sp-b\"></div></div>\
-        <script type=\"application/json\" id=\"sp-d\">{json_array}</script>\
-        <script>\
-        const frames=JSON.parse(document.getElementById('sp-d').textContent);\
-        let idx=0,timer;\
-        function show(i){{idx=((i%frames.length)+frames.length)%frames.length;\
-          document.getElementById('sp-frm').innerHTML=frames[idx];\
-          document.getElementById('sp-c').textContent=(idx+1)+' / '+frames.length;\
-          const b=document.getElementById('sp-b');\
-          b.style.transition='none';b.style.width='0%';\
-          setTimeout(()=>{{b.style.transition='width {ivms}ms linear';b.style.width='100%';}},20);}}\
-        function play(){{clearInterval(timer);timer=setInterval(()=>{{show(idx+1);}},{ivms});}}\
-        show(0);play();\
-        document.getElementById('sp-p').onclick=()=>{{clearInterval(timer);show(idx-1);play();}};\
-        document.getElementById('sp-n').onclick=()=>{{clearInterval(timer);show(idx+1);play();}};\
-        </script></body></html>"
-    ), crate::bindings::commands::docs::DOC_BUILD_SLIDESHOW)
+    let html_strs: Vec<String> = charts.iter().map(|c| c.html.clone()).collect();
+    Chart::new_doc(
+        crate::bindings::commands::charts::build_slideshow(
+            &serde_json::json!({"charts": html_strs, "interval_ms": interval_ms, "title": title, "width": width, "height": height}).to_string()
+        ),
+        crate::bindings::commands::docs::DOC_BUILD_SLIDESHOW,
+    )
 }
 
 #[cfg(feature = "python")]