seraplot 2.3.81__tar.gz → 2.3.83__tar.gz

{seraplot-2.3.81 → seraplot-2.3.83}/Cargo.lock

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

{seraplot-2.3.81 → seraplot-2.3.83}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "seraplot"
-version = "2.3.81"
+version = "2.3.83"
 edition = "2021"
 authors = ["feur25"]
 description = "Rust data visualization framework - The modern Plotly alternative"
@@ -37,21 +37,13 @@ numpy = { version = "0.21", optional = true }
 criterion = "0.5"
 
 [features]
-default = []
+default = ["python"]
 python = ["dep:pyo3", "dep:numpy", "dep:egui", "dep:eframe", "dep:egui_plot", "dep:reqwest", "dep:tokio"]
 js = ["dep:wasm-bindgen", "dep:js-sys", "dep:getrandom", "dep:egui"]
 ffi = ["dep:egui"]
 all = ["python"]
 pyo3 = ["dep:pyo3"]
 
-[[example]]
-name = "csv_test"
-path = "examples/csv_test.rs"
-
-[[example]]
-name = "csv_viewer"
-path = "examples/csv_viewer.rs"
-
 [profile.release]
 lto = "thin"
 codegen-units = 1

{seraplot-2.3.81 → seraplot-2.3.83}/PKG-INFO

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

{seraplot-2.3.81 → seraplot-2.3.83}/pyproject.toml

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

{seraplot-2.3.81 → seraplot-2.3.83}/src/bindings/commands/charts.rs

@@ -1305,7 +1305,7 @@ pub fn build_grid(input: &str) -> String {
     let charts = a.charts.unwrap_or_default();
     let cols = o.cols.unwrap_or(2).max(1);
     let gap = o.gap.unwrap_or(16);
-    let bg_color = o.background.clone().or_else(get_global_bg).unwrap_or_else(|| "#f0f2f5".to_string());
+    let bg_color = o.background.clone().or_else(get_global_bg).unwrap_or_else(|| "transparent".to_string());
     let bg_color = bg_color.as_str();
     let cell_height = o.cell_height.unwrap_or(520);
     let mut buf = format!(

seraplot-2.3.83/src/bindings/commands/native.rs

@@ -0,0 +1,8 @@
+#[cfg(feature = "js")]
+crate::impl_wasm_bindings!();
+
+#[cfg(feature = "ffi")]
+crate::impl_cffi_bindings!();
+
+#[cfg(feature = "python")]
+crate::impl_python_bindings!();

seraplot-2.3.83/src/bindings/registry_macro.rs

@@ -0,0 +1,529 @@
+#[macro_export]
+macro_rules! for_each_json_chart_fn {
+    ($mac:ident) => {
+        $mac!(build_html_chart,          "buildHtmlChart");
+        $mac!(build_bar_chart,           "buildBarChart");
+        $mac!(build_hbar,                "buildHbar");
+        $mac!(build_line_chart,          "buildLineChart");
+        $mac!(build_dbscan_chart,        "buildDbscanChart");
+        $mac!(build_dbscan_chart_3d,     "buildDbscanChart3d");
+        $mac!(build_kmeans_chart,        "buildKmeansChart");
+        $mac!(build_scatter_chart,       "buildScatterChart");
+        $mac!(build_histogram,           "buildHistogram");
+        $mac!(build_histogram_overlay,   "buildHistogramOverlay");
+        $mac!(build_grouped_bar,         "buildGroupedBar");
+        $mac!(build_stacked_bar,         "buildStackedBar");
+        $mac!(build_heatmap,             "buildHeatmap");
+        $mac!(build_pie_chart,           "buildPieChart");
+        $mac!(build_donut_chart,         "buildDonutChart");
+        $mac!(build_boxplot,             "buildBoxplot");
+        $mac!(build_violin,              "buildViolin");
+        $mac!(build_slope,               "buildSlope");
+        $mac!(build_sunburst,            "buildSunburst");
+        $mac!(build_funnel,              "buildFunnel");
+        $mac!(build_treemap,             "buildTreemap");
+        $mac!(build_multiline_chart,     "buildMultilineChart");
+        $mac!(build_area_chart,          "buildAreaChart");
+        $mac!(build_waterfall,           "buildWaterfall");
+        $mac!(build_bullet,              "buildBullet");
+        $mac!(build_bubble_map,          "buildBubbleMap");
+        $mac!(build_choropleth,          "buildChoropleth");
+        $mac!(build_scatter3d_chart,     "buildScatter3dChart");
+        $mac!(build_bar3d_chart,         "buildBar3dChart");
+        $mac!(build_line3d_chart,        "buildLine3dChart");
+        $mac!(build_radar_chart,         "buildRadarChart");
+        $mac!(build_radar3d_chart,       "buildRadar3dChart");
+        $mac!(build_lollipop_chart,      "buildLollipopChart");
+        $mac!(build_lollipop3d_chart,    "buildLollipop3dChart");
+        $mac!(build_kde_chart,           "buildKdeChart");
+        $mac!(build_kde3d_chart,         "buildKde3dChart");
+        $mac!(build_ridgeline_chart,     "buildRidgelineChart");
+        $mac!(build_ridgeline3d_chart,   "buildRidgeline3dChart");
+        $mac!(build_bubble3d_chart,      "buildBubble3dChart");
+        $mac!(build_pie3d_chart,         "buildPie3dChart");
+        $mac!(build_violin3d_chart,      "buildViolin3dChart");
+        $mac!(build_heatmap3d_chart,     "buildHeatmap3dChart");
+        $mac!(build_candlestick3d_chart, "buildCandlestick3dChart");
+        $mac!(build_dumbbell3d_chart,    "buildDumbbell3dChart");
+        $mac!(build_funnel3d_chart,      "buildFunnel3dChart");
+        $mac!(build_sunburst3d_chart,    "buildSunburst3dChart");
+        $mac!(build_stacked_bar3d_chart, "buildStackedBar3dChart");
+        $mac!(build_globe3d_chart,       "buildGlobe3dChart");
+        $mac!(build_wordcloud,           "buildWordcloud");
+        $mac!(build_candlestick,         "buildCandlestick");
+        $mac!(build_dumbbell,            "buildDumbbell");
+        $mac!(build_bubble,              "buildBubble");
+        $mac!(build_gauge,               "buildGauge");
+        $mac!(build_parallel,            "buildParallel");
+    };
+}
+
+#[macro_export]
+macro_rules! for_each_chart_fn {
+    ($mac:ident) => {
+        crate::for_each_json_chart_fn!($mac);
+        $mac!(build_grid,                "buildGrid");
+        $mac!(build_slideshow,           "buildSlideshow");
+    };
+}
+
+#[macro_export]
+macro_rules! for_each_chart_class {
+    ($mac:ident) => {
+        $mac!(DbscanModel);
+        $mac!(KMeansModel);
+    };
+}
+
+pub const CHART_ALIASES: &[(&str, &str)] = &[
+    ("bar",            "build_bar_chart"),
+    ("bar_chart",      "build_bar_chart"),
+    ("bars",           "build_bar_chart"),
+    ("hbar",           "build_hbar"),
+    ("barh",           "build_hbar"),
+    ("horizontal_bar", "build_hbar"),
+    ("line",           "build_line_chart"),
+    ("line_chart",     "build_line_chart"),
+    ("scatter",        "build_scatter_chart"),
+    ("scatter_chart",  "build_scatter_chart"),
+    ("hist",           "build_histogram"),
+    ("histogram",      "build_histogram"),
+    ("pie",            "build_pie_chart"),
+    ("pie_chart",      "build_pie_chart"),
+    ("donut",          "build_donut_chart"),
+    ("donut_chart",    "build_donut_chart"),
+    ("heatmap",        "build_heatmap"),
+    ("boxplot",        "build_boxplot"),
+    ("box_plot",       "build_boxplot"),
+    ("violin",         "build_violin"),
+    ("radar",          "build_radar_chart"),
+    ("radar_chart",    "build_radar_chart"),
+    ("lollipop",       "build_lollipop_chart"),
+    ("kde",            "build_kde_chart"),
+    ("ridgeline",      "build_ridgeline_chart"),
+    ("bubble",         "build_bubble"),
+    ("candlestick",    "build_candlestick"),
+    ("dumbbell",       "build_dumbbell"),
+    ("funnel",         "build_funnel"),
+    ("waterfall",      "build_waterfall"),
+    ("treemap",        "build_treemap"),
+    ("sunburst",       "build_sunburst"),
+    ("gauge",          "build_gauge"),
+    ("parallel",       "build_parallel"),
+    ("grouped_bar",    "build_grouped_bar"),
+    ("stacked_bar",    "build_stacked_bar"),
+    ("slope",          "build_slope"),
+    ("bullet",         "build_bullet"),
+    ("area",           "build_area_chart"),
+    ("area_chart",     "build_area_chart"),
+    ("multiline",      "build_multiline_chart"),
+    ("bubble_map",     "build_bubble_map"),
+    ("choropleth",     "build_choropleth"),
+    ("wordcloud",      "build_wordcloud"),
+    ("kmeans",         "build_kmeans_chart"),
+    ("kmeans_chart",   "build_kmeans_chart"),
+    ("dbscan",         "build_dbscan_chart"),
+    ("scatter3d",      "build_scatter3d_chart"),
+    ("bar3d",          "build_bar3d_chart"),
+    ("line3d",         "build_line3d_chart"),
+    ("radar3d",        "build_radar3d_chart"),
+    ("lollipop3d",     "build_lollipop3d_chart"),
+    ("kde3d",          "build_kde3d_chart"),
+    ("ridgeline3d",    "build_ridgeline3d_chart"),
+    ("bubble3d",       "build_bubble3d_chart"),
+    ("pie3d",          "build_pie3d_chart"),
+    ("violin3d",       "build_violin3d_chart"),
+    ("heatmap3d",      "build_heatmap3d_chart"),
+    ("candlestick3d",  "build_candlestick3d_chart"),
+    ("dumbbell3d",     "build_dumbbell3d_chart"),
+    ("funnel3d",       "build_funnel3d_chart"),
+    ("sunburst3d",     "build_sunburst3d_chart"),
+    ("stacked_bar3d",  "build_stacked_bar3d_chart"),
+    ("globe3d",        "build_globe3d_chart"),
+    ("dbscan3d",       "build_dbscan_chart_3d"),
+    ("plot",           "plot_chart"),
+    ("grid",           "build_grid"),
+    ("save",           "savefig"),
+    ("save_fig",       "savefig"),
+];
+
+#[macro_export]
+macro_rules! for_each_ml_oneshot_fn {
+    ($mac:ident) => {
+        $mac!(ml_dbscan_fit_predict,             "mlDbscanFitPredict");
+        $mac!(ml_kmeans_fit_predict,             "mlKmeansFitPredict");
+        $mac!(ml_linear_regression,              "mlLinearRegression");
+        $mac!(ml_ridge,                          "mlRidge");
+        $mac!(ml_lasso,                          "mlLasso");
+        $mac!(ml_elastic_net,                    "mlElasticNet");
+        $mac!(ml_logistic_regression,            "mlLogisticRegression");
+        $mac!(ml_decision_tree_classifier,       "mlDecisionTreeClassifier");
+        $mac!(ml_decision_tree_regressor,        "mlDecisionTreeRegressor");
+        $mac!(ml_random_forest_classifier,       "mlRandomForestClassifier");
+        $mac!(ml_random_forest_regressor,        "mlRandomForestRegressor");
+        $mac!(ml_gradient_boosting_classifier,   "mlGradientBoostingClassifier");
+        $mac!(ml_gradient_boosting_regressor,    "mlGradientBoostingRegressor");
+        $mac!(ml_knn_classifier,                 "mlKnnClassifier");
+        $mac!(ml_knn_regressor,                  "mlKnnRegressor");
+    };
+}
+
+#[macro_export]
+macro_rules! for_each_fn {
+    ($mac:ident) => {
+        $crate::for_each_chart_fn!($mac);
+        $mac!(plot_chart,                "plotChart");
+        $mac!(build_hover_json,          "buildHoverJson");
+        $crate::for_each_ml_oneshot_fn!($mac);
+        $mac!(set_theme,                 "setTheme");
+        $mac!(reset_theme,               "resetTheme");
+        $mac!(themes,                    "themes");
+        $mac!(set_global_background,     "setGlobalBackground");
+        $mac!(reset_global_background,   "resetGlobalBackground");
+    };
+}
+
+#[macro_export]
+macro_rules! impl_python_build_grid {
+    () => {
+        #[pyfunction]
+        #[pyo3(signature = (charts, cols=2, gap=16, bg=None, cell_height=520))]
+        pub fn build_grid(
+            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_doc(
+                crate::bindings::commands::charts::build_grid(
+                    &serde_json::json!({"charts": html_strs, "cols": cols, "gap": gap, "background": bg, "cell_height": cell_height}).to_string()
+                ),
+                crate::bindings::commands::docs::DOC_BUILD_GRID,
+            )
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! impl_python_build_slideshow {
+    () => {
+        #[pyfunction]
+        #[pyo3(signature = (charts, interval_ms=2500, title="", width=900, height=520))]
+        pub fn build_slideshow(
+            charts: Vec<pyo3::PyRef<crate::Chart>>,
+            interval_ms: u32,
+            title: &str,
+            width: i32,
+            height: i32,
+        ) -> crate::Chart {
+            let html_strs: Vec<String> = charts.iter().map(|c| c.html.clone()).collect();
+            crate::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,
+            )
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! impl_python_build_hover_json {
+    () => {
+        #[pyfunction]
+        #[pyo3(signature = (labels, images=None, descriptions=None))]
+        pub fn build_hover_json(
+            labels: Vec<String>,
+            images: Option<Vec<Option<String>>>,
+            descriptions: Option<Vec<Vec<(String, String)>>>,
+        ) -> String {
+            let desc_json: Option<Vec<Vec<Vec<String>>>> = descriptions.map(|outer|
+                outer.into_iter().map(|row| row.into_iter().map(|(k, v)| vec![k, v]).collect()).collect()
+            );
+            crate::bindings::commands::charts::build_hover_json(
+                &serde_json::json!({"labels": labels, "images": images, "descriptions": desc_json}).to_string()
+            )
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! impl_wasm_bindings {
+    () => {
+        use wasm_bindgen::prelude::*;
+        macro_rules! impl_wasm {
+            ($fn:ident, $js:literal) => {
+                #[wasm_bindgen(js_name = $js)]
+                pub fn $fn(input: &str) -> String {
+                    crate::bindings::commands::charts::$fn(input)
+                }
+            };
+        }
+        crate::for_each_fn!(impl_wasm);
+    };
+}
+
+#[macro_export]
+macro_rules! impl_cffi_bindings {
+    () => {
+        macro_rules! impl_cffi {
+            ($fn:ident, $_js:literal) => {
+                #[no_mangle]
+                pub unsafe extern "C" fn $fn(input: *const std::os::raw::c_char) -> *mut std::os::raw::c_char {
+                    let s = std::ffi::CStr::from_ptr(input).to_str().unwrap_or("");
+                    std::ffi::CString::new(crate::bindings::commands::charts::$fn(s))
+                        .unwrap_or_default()
+                        .into_raw()
+                }
+            };
+        }
+        crate::for_each_fn!(impl_cffi);
+        #[no_mangle]
+        pub unsafe extern "C" fn seraplot_free(ptr: *mut std::os::raw::c_char) {
+            if !ptr.is_null() { drop(std::ffi::CString::from_raw(ptr)); }
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! impl_python_bindings {
+    () => {
+        use pyo3::prelude::*;
+        use pyo3::types::PyAny;
+
+        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
+        }
+
+        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); }
+                    }
+                }
+            }
+            serde_json::Value::Object(m).to_string()
+        }
+
+        macro_rules! impl_python {
+            ($fn:ident, $_js:literal) => {
+                #[pyfunction]
+                #[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(&py_args_to_json(title, labels, values, kwargs)),
+                        "",
+                    ))
+                }
+            };
+        }
+        crate::for_each_json_chart_fn!(impl_python);
+
+        macro_rules! impl_python_json {
+            ($fn:ident, $_js:literal) => {
+                #[pyfunction]
+                pub fn $fn(input: &str) -> String {
+                    crate::bindings::commands::charts::$fn(input)
+                }
+            };
+        }
+        crate::for_each_ml_oneshot_fn!(impl_python_json);
+
+        #[pyfunction]
+        #[pyo3(name = "set_bg", signature = (html, color=None))]
+        pub fn set_bg_fn(html: &PyAny, color: Option<&str>) -> PyResult<crate::Chart> {
+            let raw: String = if let Ok(chart) = html.extract::<PyRef<crate::Chart>>() {
+                chart.html.clone()
+            } else { html.extract::<String>()? };
+            Ok(crate::Chart::new(crate::html::hover::apply_bg(raw, color)))
+        }
+
+        #[pyfunction]
+        pub fn show_chart_value(chart_json: &str) -> bool { crate::bindings::commands::charts::show_chart_value(chart_json) }
+
+        #[pyfunction]
+        pub fn bench_chart_value(chart_json: &str) -> bool { crate::bindings::commands::charts::bench_chart_value(chart_json) }
+
+        #[pyfunction]
+        pub fn set_chart_kind(kind: u8) -> bool { crate::bindings::commands::charts::set_chart_kind(kind); true }
+
+        #[pyfunction]
+        pub fn set_chart_orientation(vertical: bool) -> bool { crate::bindings::commands::charts::set_chart_orientation(vertical); true }
+
+        #[pyfunction]
+        #[pyo3(signature = (n=2000))]
+        pub fn bench_pure_rust(n: usize) -> (f64, f64, f64, f64) { crate::bindings::commands::charts::bench_pure_rust(n) }
+
+        #[pyclass(module = "seraplot", name = "DBSCAN")]
+        pub struct DbscanModel(crate::bindings::commands::charts::DbscanState);
+
+        #[pymethods]
+        impl DbscanModel {
+            #[new]
+            #[pyo3(signature = (eps=0.5, min_samples=5))]
+            pub fn py_new(eps: f64, min_samples: usize) -> Self {
+                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.0.eps).usize(self.0.min_samples).usize(n).usize(d).finish();
+                let _h = crate::ml::cache::TaskHandle::auto("DBSCAN.fit", fp);
+                self.0.fit(&x);
+                _h.complete(&crate::ml::cache::PartialState::default());
+                Ok(())
+            }
+            #[pyo3(signature = (x))]
+            pub fn fit_predict(&mut self, x: Vec<Vec<f64>>) -> PyResult<Vec<i32>> {
+                self.fit(x)?; Ok(self.0.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 }
+            fn doc(&self) -> &'static str { crate::bindings::commands::docs::DOC_DBSCAN_MODEL }
+            fn __repr__(&self) -> String {
+                format!("DBSCAN(eps={}, min_samples={}) -> {} clusters, {} noise",
+                    self.0.eps, self.0.min_samples, self.0.n_clusters, self.0.n_noise)
+            }
+        }
+
+        #[pyclass(module = "seraplot", name = "KMeans")]
+        pub struct KMeansModel(crate::bindings::commands::charts::KMeansState);
+
+        #[pymethods]
+        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(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) = super::ml::extract_flat(x)?;
+                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);
+                self.0.fit_flat(&flat, n, dims);
+                _h.complete(&crate::ml::cache::PartialState::default());
+                Ok(())
+            }
+            #[pyo3(signature = (x))]
+            pub fn fit_predict(&mut self, x: &PyAny) -> PyResult<Vec<i32>> {
+                self.fit(x)?; Ok(self.0.labels.clone())
+            }
+            #[pyo3(signature = (x))]
+            pub fn transform(&self, x: &PyAny) -> PyResult<Vec<Vec<f64>>> {
+                let (flat, n, dims) = super::ml::extract_flat(x)?;
+                Ok(self.0.transform_flat(&flat, n, dims))
+            }
+            #[pyo3(signature = (x))]
+            pub fn predict(&self, x: &PyAny) -> PyResult<Vec<i32>> {
+                let (flat, n, dims) = super::ml::extract_flat(x)?;
+                Ok(self.0.predict_flat(&flat, n, dims))
+            }
+            #[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 __repr__(&self) -> String {
+                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)
+            }
+        }
+
+        crate::impl_python_build_grid!();
+        crate::impl_python_build_slideshow!();
+        crate::impl_python_build_hover_json!();
+
+        #[pyfunction]
+        #[pyo3(name = "plot", signature = (x, y=None, *, title="", kind="line", color_hex=0x6366F1_u32, width=900_i32, height=480_i32, x_label="", y_label="", gridlines=false, palette=None, background=None, show_points=true))]
+        pub fn plot_chart(
+            py: Python<'_>,
+            x: &PyAny,
+            y: Option<&PyAny>,
+            title: &str,
+            kind: &str,
+            color_hex: u32,
+            width: i32,
+            height: i32,
+            x_label: &str,
+            y_label: &str,
+            gridlines: bool,
+            palette: Option<Vec<u32>>,
+            background: Option<&str>,
+            show_points: bool,
+        ) -> PyResult<crate::Chart> {
+            let (bg, pal, grid) = crate::merge_global_opts(background, palette, gridlines);
+            let pal_opt: Option<Vec<u32>> = if pal.is_empty() { None } else { Some(pal) };
+            if let Ok(cols_obj) = x.getattr("columns") {
+                let cols: Vec<String> = cols_obj.extract()?;
+                if cols.len() >= 2 {
+                    let xv = crate::py_to_f64_vec(py, x.get_item(&cols[0])?)?;
+                    let yv = crate::py_to_f64_vec(py, x.get_item(&cols[1])?)?;
+                    let auto_title = if title.is_empty() { format!("{} vs {}", cols[0], cols[1]) } else { title.to_string() };
+                    return Ok(crate::Chart::new_doc(
+                        crate::bindings::commands::charts::plot_chart(
+                            &serde_json::json!({"x":xv,"y":yv,"kind":"scatter","title":auto_title,"color_hex":color_hex,"width":width,"height":height,"x_label":x_label,"y_label":y_label,"gridlines":grid,"palette":pal_opt,"background":bg}).to_string()
+                        ), "",
+                    ));
+                }
+            }
+            let xv = crate::py_to_f64_vec(py, x)?;
+            let yv: Option<Vec<f64>> = if let Some(yobj) = y { Some(crate::py_to_f64_vec(py, yobj)?) } else { None };
+            Ok(crate::Chart::new_doc(
+                crate::bindings::commands::charts::plot_chart(
+                    &serde_json::json!({"x":xv,"y":yv,"kind":kind,"title":title,"color_hex":color_hex,"show_points":show_points,"width":width,"height":height,"x_label":x_label,"y_label":y_label,"gridlines":grid,"palette":pal_opt,"background":bg}).to_string()
+                ), "",
+            ))
+        }
+
+        #[pyfunction]
+        #[pyo3(signature = (chart, path))]
+        pub fn savefig(chart: &crate::Chart, path: &str) -> PyResult<()> {
+            std::fs::write(path, &chart.html).map_err(|e| pyo3::exceptions::PyIOError::new_err(e.to_string()))
+        }
+    };
+}

{seraplot-2.3.81 → seraplot-2.3.83}/src/html/hover.rs

@@ -112,7 +112,7 @@ pub fn parse_hover_json(json: &str) -> Vec<HoverSlot> {
 pub const HOVER_CSS: &str = "";
 pub const HOVER_JS:  &str = "";
 
-pub const DEFAULT_BG: &str = "#fff";
+pub const DEFAULT_BG: &str = "transparent";
 
 #[inline]
 fn resolve_named_color(c: &str) -> &str {
@@ -139,7 +139,7 @@ pub fn apply_bg(html: String, bg: Option<&str>) -> String {
         Some(c) => c,
     };
     let color = resolve_named_color(raw);
-    let h = html.replacen(".sp-bg{fill:#fff}", &format!(".sp-bg{{fill:{color}}}"), 1);
+    let h = html.replacen(".sp-bg{fill:transparent}", &format!(".sp-bg{{fill:{color}}}"), 1);
     h.replacen("</head>", &format!("<style>html,body{{background:{color}!important}}</style></head>"), 1)
 }
 
@@ -428,7 +428,7 @@ pub fn build_chart_html(title: &str, svg: &str, hover_json: &str) -> String {
     buf.extend_from_slice(html_attr_esc(title).as_bytes());
     buf.extend_from_slice(b"</title>");
     buf.extend_from_slice(CSS.as_bytes());
-    buf.extend_from_slice(b"<style>body{margin:0;background:#fff;display:flex;justify-content:center;padding:0}@keyframes sp-i{from{opacity:0;transform:translateY(8px) scale(.94)}}@keyframes sp-bar{from{opacity:0;transform:scaleY(0)}}@keyframes sp-pop{0%{opacity:0;transform:scale(0)}70%{transform:scale(1.08)}100%{opacity:1;transform:scale(1)}}@keyframes sp-arc{from{opacity:0;transform:scale(.82) rotate(-6deg)}}@keyframes sp-fn{from{opacity:0;transform:scaleX(.7) translateY(8px)}}svg rect[data-idx]{transform-box:fill-box;transform-origin:bottom center;animation:sp-bar .5s cubic-bezier(.22,.61,.36,1) both}svg circle[data-idx]{transform-box:fill-box;transform-origin:center;animation:sp-pop .42s cubic-bezier(.34,1.56,.64,1) both}svg path[data-idx]{transform-box:fill-box;transform-origin:center;animation:sp-arc .48s cubic-bezier(.22,.61,.36,1) both}svg polygon[data-idx]{transform-box:fill-box;transform-origin:center;animation:sp-fn .48s cubic-bezier(.22,.61,.36,1) both}svg line[data-idx]{animation:sp-i .45s cubic-bezier(.22,.61,.36,1) both}svg rect[data-idx]:hover{transform:scaleY(1.03);filter:brightness(1.12) saturate(1.1)}svg circle[data-idx]:hover{transform:scale(1.3);filter:brightness(1.15)}svg path[data-idx]:hover{filter:brightness(1.1) drop-shadow(0 2px 8px rgba(0,0,0,.2))}.sp-bg{fill:#fff}</style></head><body>");
+    buf.extend_from_slice(b"<style>body{margin:0;background:transparent;display:flex;justify-content:center;padding:0}@keyframes sp-i{from{opacity:0;transform:translateY(8px) scale(.94)}}@keyframes sp-bar{from{opacity:0;transform:scaleY(0)}}@keyframes sp-pop{0%{opacity:0;transform:scale(0)}70%{transform:scale(1.08)}100%{opacity:1;transform:scale(1)}}@keyframes sp-arc{from{opacity:0;transform:scale(.82) rotate(-6deg)}}@keyframes sp-fn{from{opacity:0;transform:scaleX(.7) translateY(8px)}}svg rect[data-idx]{transform-box:fill-box;transform-origin:bottom center;animation:sp-bar .5s cubic-bezier(.22,.61,.36,1) both}svg circle[data-idx]{transform-box:fill-box;transform-origin:center;animation:sp-pop .42s cubic-bezier(.34,1.56,.64,1) both}svg path[data-idx]{transform-box:fill-box;transform-origin:center;animation:sp-arc .48s cubic-bezier(.22,.61,.36,1) both}svg polygon[data-idx]{transform-box:fill-box;transform-origin:center;animation:sp-fn .48s cubic-bezier(.22,.61,.36,1) both}svg line[data-idx]{animation:sp-i .45s cubic-bezier(.22,.61,.36,1) both}svg rect[data-idx]:hover{transform:scaleY(1.03);filter:brightness(1.12) saturate(1.1)}svg circle[data-idx]:hover{transform:scale(1.3);filter:brightness(1.15)}svg path[data-idx]:hover{filter:brightness(1.1) drop-shadow(0 2px 8px rgba(0,0,0,.2))}.sp-bg{fill:transparent}</style></head><body>");
     buf.extend_from_slice(b"<div id=\"");
     push_pid(&mut buf, id);
     buf.extend_from_slice(b"\" style=\"position:relative;display:inline-block;border-radius:12px;overflow:hidden;box-shadow:0 2px 8px rgba(0,0,0,.07),0 0 0 1px rgba(0,0,0,.04)\">");
@@ -519,7 +519,7 @@ pub fn html_prefix(buf: &mut Vec<u8>, title: &str, id: u64) {
         ".sp-cls-x{cursor:pointer;color:#94a3b8;margin-left:6px;font-size:13px}",
         ".sp-cls-x:hover{color:#f87171}",
         "</style>",
-        "<style>body{margin:0;background:#fff;display:flex;justify-content:center;padding:0}",
+        "<style>body{margin:0;background:transparent;display:flex;justify-content:center;padding:0}",
         "@keyframes sp-i{from{opacity:0;transform:translateY(8px) scale(.94)}}",
         "@keyframes sp-bar{from{opacity:0;transform:scaleY(0)}}",
         "@keyframes sp-pop{0%{opacity:0;transform:scale(0)}70%{transform:scale(1.08)}100%{opacity:1;transform:scale(1)}}",
@@ -533,7 +533,7 @@ pub fn html_prefix(buf: &mut Vec<u8>, title: &str, id: u64) {
         "svg rect[data-idx]:hover{transform:scaleY(1.03);filter:brightness(1.12) saturate(1.1)}",
         "svg circle[data-idx]:hover{transform:scale(1.3);filter:brightness(1.15)}",
         "svg path[data-idx]:hover{filter:brightness(1.1) drop-shadow(0 2px 8px rgba(0,0,0,.2))}",
-        ".sp-bg{fill:#fff}",
+        ".sp-bg{fill:transparent}",
         "</style></head><body><div id=\"",
     ).as_bytes();
     const TPL3: &[u8] = b"\" style=\"position:relative;display:inline-block;border-radius:12px;overflow:hidden;box-shadow:0 2px 8px rgba(0,0,0,.07),0 0 0 1px rgba(0,0,0,.04)\">";