seraplot 2.3.83__tar.gz → 2.3.84__tar.gz

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

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

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

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

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

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

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

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

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

@@ -1490,6 +1490,99 @@ pub fn themes(_: &str) -> String {
     "[\"dark\",\"light\",\"scientific\",\"apple\",\"notion\",\"minimal\",\"neon\"]".to_string()
 }
 
+pub fn export_svg(input: &str) -> String {
+    #[derive(serde::Deserialize)]
+    struct In { html: String }
+    let v: In = match serde_json::from_str(input) { Ok(v) => v, Err(_) => return String::new() };
+    let h = v.html;
+    let start = match h.find("<svg") { Some(i) => i, None => return String::new() };
+    let end = match h[start..].find("</svg>") { Some(i) => start + i + 6, None => return String::new() };
+    h[start..end].to_string()
+}
+
+pub fn export_data_url(input: &str) -> String {
+    use base64::Engine;
+    let svg = export_svg(input);
+    if svg.is_empty() { return String::new(); }
+    let b64 = base64::engine::general_purpose::STANDARD.encode(svg.as_bytes());
+    format!("data:image/svg+xml;base64,{b64}")
+}
+
+pub fn export_html_file(input: &str) -> String {
+    #[derive(serde::Deserialize)]
+    struct In { html: String, path: String }
+    let v: In = match serde_json::from_str(input) { Ok(v) => v, Err(_) => return "{\"ok\":false}".to_string() };
+    match std::fs::write(&v.path, v.html) {
+        Ok(_) => format!("{{\"ok\":true,\"path\":{}}}", serde_json::to_string(&v.path).unwrap_or_else(|_| "\"\"".into())),
+        Err(e) => format!("{{\"ok\":false,\"error\":{}}}", serde_json::to_string(&e.to_string()).unwrap_or_else(|_| "\"\"".into())),
+    }
+}
+
+pub fn chart_append(input: &str) -> String {
+    #[derive(serde::Deserialize)]
+    struct In { kind: String, x: Option<Vec<f64>>, y: Option<Vec<f64>>, title: Option<String>, max_points: Option<usize>, color_hex: Option<u32>, width: Option<i32>, height: Option<i32>, prev_x: Option<Vec<f64>>, prev_y: Option<Vec<f64>> }
+    let v: In = match serde_json::from_str(input) { Ok(v) => v, Err(_) => return String::new() };
+    let mut xs = v.prev_x.unwrap_or_default();
+    let mut ys = v.prev_y.unwrap_or_default();
+    if let Some(nx) = v.x { xs.extend(nx); }
+    if let Some(ny) = v.y { ys.extend(ny); }
+    if let Some(m) = v.max_points {
+        if xs.len() > m { let cut = xs.len() - m; xs.drain(..cut); }
+        if ys.len() > m { let cut = ys.len() - m; ys.drain(..cut); }
+    }
+    let title = v.title.unwrap_or_default();
+    let color = v.color_hex.unwrap_or(0x6366F1);
+    let w = v.width.unwrap_or(900);
+    let h = v.height.unwrap_or(420);
+    let payload = serde_json::json!({"title":title,"x":xs,"y":ys,"color_hex":color,"width":w,"height":h,"show_points":true});
+    let html = match v.kind.as_str() {
+        "scatter" => build_scatter_chart(&payload.to_string()),
+        _ => build_line_chart(&serde_json::json!({"title":title,"labels":xs.iter().map(|v|v.to_string()).collect::<Vec<_>>(),"values":ys,"color_hex":color,"width":w,"height":h,"show_points":true}).to_string()),
+    };
+    serde_json::json!({"html":html,"x":xs,"y":ys}).to_string()
+}
+
+pub fn ml_save_model(input: &str) -> String {
+    #[derive(serde::Deserialize)]
+    struct In { kind: String, state: serde_json::Value, path: Option<String> }
+    let v: In = match serde_json::from_str(input) { Ok(v) => v, Err(_) => return "{\"ok\":false}".to_string() };
+    let envelope = serde_json::json!({"seraplot_model_v":1,"kind":v.kind,"state":v.state});
+    let s = envelope.to_string();
+    if let Some(p) = v.path {
+        if let Err(e) = std::fs::write(&p, &s) {
+            return format!("{{\"ok\":false,\"error\":{}}}", serde_json::to_string(&e.to_string()).unwrap_or_else(|_| "\"\"".into()));
+        }
+        return format!("{{\"ok\":true,\"path\":{},\"size\":{}}}", serde_json::to_string(&p).unwrap_or_else(|_| "\"\"".into()), s.len());
+    }
+    serde_json::json!({"ok":true,"data":s}).to_string()
+}
+
+pub fn ml_load_model(input: &str) -> String {
+    #[derive(serde::Deserialize)]
+    struct In { path: Option<String>, data: Option<String> }
+    let v: In = match serde_json::from_str(input) { Ok(v) => v, Err(_) => return "{\"ok\":false}".to_string() };
+    let raw = if let Some(p) = v.path {
+        match std::fs::read_to_string(&p) { Ok(s) => s, Err(e) => return format!("{{\"ok\":false,\"error\":{}}}", serde_json::to_string(&e.to_string()).unwrap_or_else(|_| "\"\"".into())) }
+    } else if let Some(d) = v.data { d } else { return "{\"ok\":false,\"error\":\"need path or data\"}".to_string() };
+    match serde_json::from_str::<serde_json::Value>(&raw) {
+        Ok(j) => serde_json::json!({"ok":true,"model":j}).to_string(),
+        Err(e) => format!("{{\"ok\":false,\"error\":{}}}", serde_json::to_string(&e.to_string()).unwrap_or_else(|_| "\"\"".into())),
+    }
+}
+
+pub fn chart_info(input: &str) -> String {
+    #[derive(serde::Deserialize)]
+    struct In { html: String }
+    let v: In = match serde_json::from_str(input) { Ok(v) => v, Err(_) => return "{}".to_string() };
+    let h = v.html;
+    let len = h.len();
+    let n_paths = h.matches("<path").count();
+    let n_rects = h.matches("<rect").count();
+    let n_circles = h.matches("<circle").count();
+    let has_svg = h.contains("<svg");
+    serde_json::json!({"size":len,"paths":n_paths,"rects":n_rects,"circles":n_circles,"has_svg":has_svg}).to_string()
+}
+
 pub fn bench_chart_value(s: &str) -> bool {
     serde_json::from_str::<serde_json::Value>(s).is_ok()
 }

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

@@ -34,6 +34,11 @@ pub fn register_submodules(py: Python<'_>, m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(build_hover_json, m)?)?;
     m.add_function(wrap_pyfunction!(plot_chart, m)?)?;
     m.add_function(wrap_pyfunction!(savefig, m)?)?;
+    m.add_function(wrap_pyfunction!(export_svg, m)?)?;
+    m.add_function(wrap_pyfunction!(export_data_url, m)?)?;
+    m.add_function(wrap_pyfunction!(export_png, m)?)?;
+    m.add_function(wrap_pyfunction!(chart_info, m)?)?;
+    m.add_class::<LiveStream>()?;
 
     for (alias, canonical) in crate::bindings::registry_macro::CHART_ALIASES {
         if let Ok(func) = m.getattr(*canonical) {

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

@@ -180,6 +180,13 @@ macro_rules! for_each_fn {
         $mac!(themes,                    "themes");
         $mac!(set_global_background,     "setGlobalBackground");
         $mac!(reset_global_background,   "resetGlobalBackground");
+        $mac!(export_svg,                "exportSvg");
+        $mac!(export_data_url,           "exportDataUrl");
+        $mac!(export_html_file,          "exportHtmlFile");
+        $mac!(chart_append,              "chartAppend");
+        $mac!(ml_save_model,             "mlSaveModel");
+        $mac!(ml_load_model,             "mlLoadModel");
+        $mac!(chart_info,                "chartInfo");
     };
 }
 
@@ -525,5 +532,92 @@ macro_rules! impl_python_bindings {
         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()))
         }
+
+        #[pyfunction]
+        pub fn export_svg(chart: &crate::Chart) -> String {
+            crate::bindings::commands::charts::export_svg(
+                &serde_json::json!({"html": chart.html}).to_string()
+            )
+        }
+
+        #[pyfunction]
+        pub fn export_data_url(chart: &crate::Chart) -> String {
+            crate::bindings::commands::charts::export_data_url(
+                &serde_json::json!({"html": chart.html}).to_string()
+            )
+        }
+
+        #[pyfunction]
+        #[pyo3(signature = (chart, path))]
+        pub fn export_png(chart: &crate::Chart, path: &str) -> PyResult<()> {
+            let svg = crate::bindings::commands::charts::export_svg(
+                &serde_json::json!({"html": chart.html}).to_string()
+            );
+            if svg.is_empty() {
+                return Err(pyo3::exceptions::PyValueError::new_err("no <svg> in chart html"));
+            }
+            let p = std::path::Path::new(path);
+            let target = if matches!(p.extension().and_then(|e| e.to_str()), Some("svg")) {
+                path.to_string()
+            } else {
+                let mut q = std::path::PathBuf::from(path);
+                q.set_extension("svg");
+                q.to_string_lossy().to_string()
+            };
+            std::fs::write(&target, svg).map_err(|e| pyo3::exceptions::PyIOError::new_err(e.to_string()))
+        }
+
+        #[pyfunction]
+        pub fn chart_info(chart: &crate::Chart) -> String {
+            crate::bindings::commands::charts::chart_info(
+                &serde_json::json!({"html": chart.html}).to_string()
+            )
+        }
+
+        #[pyclass(module = "seraplot", name = "LiveStream")]
+        pub struct LiveStream {
+            kind: String,
+            xs: Vec<f64>,
+            ys: Vec<f64>,
+            title: String,
+            max_points: usize,
+            color_hex: u32,
+            width: i32,
+            height: i32,
+        }
+
+        #[pymethods]
+        impl LiveStream {
+            #[new]
+            #[pyo3(signature = (kind="line", title="", max_points=500, color_hex=0x6366F1_u32, width=900, height=420))]
+            pub fn py_new(kind: &str, title: &str, max_points: usize, color_hex: u32, width: i32, height: i32) -> Self {
+                Self { kind: kind.to_string(), xs: Vec::new(), ys: Vec::new(), title: title.to_string(), max_points, color_hex, width, height }
+            }
+            #[pyo3(signature = (x, y))]
+            pub fn push(&mut self, x: f64, y: f64) {
+                self.xs.push(x); self.ys.push(y);
+                if self.xs.len() > self.max_points { let cut = self.xs.len() - self.max_points; self.xs.drain(..cut); }
+                if self.ys.len() > self.max_points { let cut = self.ys.len() - self.max_points; self.ys.drain(..cut); }
+            }
+            #[pyo3(signature = (xs, ys))]
+            pub fn extend(&mut self, xs: Vec<f64>, ys: Vec<f64>) {
+                self.xs.extend(xs); self.ys.extend(ys);
+                if self.xs.len() > self.max_points { let cut = self.xs.len() - self.max_points; self.xs.drain(..cut); }
+                if self.ys.len() > self.max_points { let cut = self.ys.len() - self.max_points; self.ys.drain(..cut); }
+            }
+            pub fn render(&self) -> crate::Chart {
+                let payload = serde_json::json!({
+                    "kind": self.kind, "title": self.title, "color_hex": self.color_hex,
+                    "width": self.width, "height": self.height,
+                    "prev_x": self.xs, "prev_y": self.ys
+                });
+                let out = crate::bindings::commands::charts::chart_append(&payload.to_string());
+                let v: serde_json::Value = serde_json::from_str(&out).unwrap_or(serde_json::Value::Null);
+                let html = v.get("html").and_then(|h| h.as_str()).unwrap_or("").to_string();
+                crate::Chart::new(html)
+            }
+            pub fn clear(&mut self) { self.xs.clear(); self.ys.clear(); }
+            #[getter] pub fn n(&self) -> usize { self.xs.len() }
+        }
     };
 }