cleanup

Signed-off-by: Andrei Gherghescu <[email protected]>

Author: andrei-ng

docs/book/src/fundamentals/static_image_export.md

@@ -91,6 +91,9 @@ plot1.write_image_with_exporter(&mut exporter, "plot1", ImageFormat::PNG, 800, 6
     .expect("Failed to export plot1");
 plot2.write_image_with_exporter(&mut exporter, "plot2", ImageFormat::JPEG, 800, 600, 1.0)
     .expect("Failed to export plot2");
+
+// Always close the exporter to ensure proper release of WebDriver resources
+exporter.close();
 ```
 
 ## Supported Formats
@@ -129,8 +132,13 @@ let base64_data = plot.to_base64_with_exporter(&mut exporter, ImageFormat::PNG,
 // Get SVG data (vector format, scalable)
 let svg_data = plot.to_svg_with_exporter(&mut exporter, 400, 300, 1.0)
     .expect("Failed to export plot");
+
+// Always close the exporter to ensure proper release of WebDriver resources
+exporter.close();
 ```
 
+Always call `close()` on the exporter to ensure proper release of WebDriver resources. Due to the nature of WebDriver implementation, close has to be called as resources cannot be automatically dropped or released.
+
 ## Advanced Configuration
 
 ### Custom WebDriver Configuration
@@ -150,6 +158,10 @@ let mut exporter = StaticExporterBuilder::default()
     ])
     .build()
     .expect("Failed to create StaticExporter");
+
+// Always close the exporter to ensure proper release of WebDriver resources
+exporter.close();
+
 ```
 
 ### Parallel Usage
@@ -172,6 +184,9 @@ let mut exporter = StaticExporterBuilder::default()
     .webdriver_port(get_unique_port())
     .build()
     .expect("Failed to build StaticExporter");
+
+// Always close the exporter to ensure proper release of WebDriver resources
+exporter.close();
 ```
 
 ## Logging Support
@@ -190,6 +205,9 @@ env_logger::init();
 let mut exporter = StaticExporterBuilder::default()
     .build()
     .expect("Failed to create StaticExporter");
+
+// Always close the exporter to ensure proper release of WebDriver resources
+exporter.close();
 ```
 
 ## Performance Considerations

examples/customization/consistent_static_format_export/src/main.rs

@@ -162,6 +162,9 @@ fn line_and_scatter_plot(
     info!("  - {file_name}.pdf");
     info!("  - {file_name}.svg");
     info!("  - {file_name}.png");
+
+    // Always close the exporter to ensure proper release of WebDriver resources
+    exporter.close();
 }
 
 fn read_from_file(file_path: &str) -> Vec<Vec<f64>> {

examples/static_export/src/main.rs

@@ -28,7 +28,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         1.0,
     )?;
     plot3.write_image("./output/plot3_legacy_api", ImageFormat::SVG, 800, 600, 1.0)?;
-    plot1.write_image("./output/plot3_legacy_api", ImageFormat::PDF, 800, 600, 1.0)?;
+
+    plot1.write_image("./output/plot1_legacy_api", ImageFormat::PDF, 800, 600, 1.0)?;
 
     // Create a single StaticExporter to reuse across all plots
     // This is more efficient than creating a new exporter for each plot which
@@ -108,5 +109,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .expect("Failed to create custom StaticExporter");
     */
 
+    // Always close the exporter to ensure proper release of WebDriver resources
+    exporter.close();
+
     Ok(())
 }

plotly/Cargo.toml

@@ -52,7 +52,7 @@ dyn-clone = "1"
 erased-serde = "0.4"
 image = { version = "0.25", optional = true }
 plotly_derive = { version = "0.13", path = "../plotly_derive" }
-plotly_static = { version = "0.0", path = "../plotly_static", optional = true }
+plotly_static = { version = "0.1", path = "../plotly_static", optional = true }
 plotly_kaleido = { version = "0.13", path = "../plotly_kaleido", optional = true }
 ndarray = { version = "0.16", optional = true }
 once_cell = "1"

plotly/src/layout/rangebreaks.rs

@@ -4,7 +4,7 @@ use serde::Serialize;
 use crate::private::NumOrString;
 
 /// Struct representing a rangebreak for Plotly axes.
-/// See: https://plotly.com/python/reference/layout/xaxis/#layout-xaxis-rangebreaks
+/// See: <https://plotly.com/python/reference/layout/xaxis/#layout-xaxis-rangebreaks>
 #[derive(Debug, Clone, Serialize, PartialEq, FieldSetter)]
 pub struct RangeBreak {
     /// Sets the lower and upper bounds for this range break, e.g. ["sat",

plotly/src/layout/scene.rs

@@ -357,7 +357,7 @@ impl Rotation {
 pub struct Projection {
     #[serde(rename = "type")]
     projection_type: Option<ProjectionType>,
-    /// Sets the rotation of the map projection. See https://plotly.com/python/reference/layout/geo/#layout-geo-projection-rotation
+    // Sets the rotation of the map projection. See https://plotly.com/python/reference/layout/geo/#layout-geo-projection-rotation
     #[serde(rename = "rotation")]
     rotation: Option<Rotation>,
 }

plotly/src/lib.rs

@@ -6,7 +6,7 @@
 //!
 //! The `kaleido` and `kaleido_download` features are deprecated since version
 //! 0.13.0 and will be removed in version 0.14.0. Please migrate to the
-//! `plotly_static` and `plotly_static_download` features instead.
+//! `plotly_static` and `static_export_*` features instead.
 #![recursion_limit = "256"] // lets us use a large serde_json::json! macro for testing crate::layout::Axis
 extern crate askama;
 extern crate rand;

plotly/src/plot.rs

@@ -532,7 +532,10 @@ impl Plot {
         let mut exporter = plotly_static::StaticExporterBuilder::default()
             .build()
             .map_err(|e| format!("Failed to create StaticExporter: {e}"))?;
-        self.write_image_with_exporter(&mut exporter, filename, format, width, height, scale)
+        let result =
+            self.write_image_with_exporter(&mut exporter, filename, format, width, height, scale);
+        exporter.close();
+        result
     }
 
     /// Convert the `Plot` to a static image and return the image as a `base64`
@@ -560,7 +563,9 @@ impl Plot {
         let mut exporter = plotly_static::StaticExporterBuilder::default()
             .build()
             .map_err(|e| format!("Failed to create StaticExporter: {e}"))?;
-        self.to_base64_with_exporter(&mut exporter, format, width, height, scale)
+        let result = self.to_base64_with_exporter(&mut exporter, format, width, height, scale);
+        exporter.close();
+        result
     }
 
     /// Convert the `Plot` to SVG and return it as a String using plotly_static.
@@ -583,7 +588,9 @@ impl Plot {
         let mut exporter = plotly_static::StaticExporterBuilder::default()
             .build()
             .map_err(|e| format!("Failed to create StaticExporter: {e}"))?;
-        self.to_svg_with_exporter(&mut exporter, width, height, scale)
+        let result = self.to_svg_with_exporter(&mut exporter, width, height, scale);
+        exporter.close();
+        result
     }
 
     /// Convert the `Plot` to a static image of the given image format and save
@@ -752,6 +759,99 @@ impl Plot {
         )
     }
 
+    /// Convert the `Plot` to a static image and save at the given location
+    /// using a provided AsyncStaticExporter.
+    ///
+    /// Similar to the sync version in [`Self::write_image_with_exporter`], but
+    /// meant for async contexts.
+    ///
+    /// This method allows you to reuse a AsyncStaticExporter instance across
+    /// multiple plots, which is more efficient than creating a new one for
+    /// each operation.
+    ///
+    /// For more details see the [plotly_static documentation](https://docs.rs/plotly_static/).
+    #[cfg(feature = "plotly_static")]
+    pub async fn write_image_async<P: AsRef<Path>>(
+        &self,
+        exporter: &mut plotly_static::AsyncStaticExporter,
+        filename: P,
+        format: ImageFormat,
+        width: usize,
+        height: usize,
+        scale: f64,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        exporter
+            .write_fig(
+                filename.as_ref(),
+                &serde_json::to_value(self)?,
+                format,
+                width,
+                height,
+                scale,
+            )
+            .await
+    }
+
+    /// Convert the `Plot` to a static image and return the image as a `base64`
+    /// String using a provided AsyncStaticExporter. Supported formats are
+    /// [ImageFormat::JPEG], [ImageFormat::PNG] and [ImageFormat::WEBP].
+    ///
+    /// Similar to the sync version in [`Self::to_base64_with_exporter`], but
+    /// meant for async contexts.
+    ///
+    /// For more details see the [plotly_static documentation](https://docs.rs/plotly_static/).
+    #[cfg(feature = "plotly_static")]
+    pub async fn to_base64_async(
+        &self,
+        exporter: &mut plotly_static::AsyncStaticExporter,
+        format: ImageFormat,
+        width: usize,
+        height: usize,
+        scale: f64,
+    ) -> Result<String, Box<dyn std::error::Error>> {
+        match format {
+            ImageFormat::JPEG | ImageFormat::PNG | ImageFormat::WEBP => {
+                exporter.write_to_string(
+                    &serde_json::to_value(self)?,
+                    format,
+                    width,
+                    height,
+                    scale,
+                )
+                .await
+            }
+            _ => {
+                Err(format!("Cannot generate base64 string for ImageFormat:{format}. Allowed formats are JPEG, PNG, WEBP").into())
+            }
+        }
+    }
+
+    /// Convert the `Plot` to SVG and return it as a String using a provided
+    /// AsyncStaticExporter.
+    ///
+    /// Similar to the sync version in [`Self::to_svg_with_exporter`], but
+    /// meant for async contexts.
+    ///
+    /// For more details see the [plotly_static documentation](https://docs.rs/plotly_static/).
+    #[cfg(feature = "plotly_static")]
+    pub async fn to_svg_async(
+        &self,
+        exporter: &mut plotly_static::AsyncStaticExporter,
+        width: usize,
+        height: usize,
+        scale: f64,
+    ) -> Result<String, Box<dyn std::error::Error>> {
+        exporter
+            .write_to_string(
+                &serde_json::to_value(self)?,
+                ImageFormat::SVG,
+                width,
+                height,
+                scale,
+            )
+            .await
+    }
+
     fn render(&self) -> String {
         let tmpl = PlotTemplate {
             plot: self,
@@ -900,7 +1000,6 @@ impl PartialEq for Plot {
 #[cfg(test)]
 mod tests {
     use std::path::PathBuf;
-    use std::sync::atomic::{AtomicU32, Ordering};
 
     #[cfg(feature = "kaleido")]
     use plotly_kaleido::ImageFormat;
@@ -1068,7 +1167,8 @@ mod tests {
     // Helper to generate unique ports for parallel tests
     #[cfg(feature = "plotly_static")]
     fn get_unique_port() -> u32 {
-        static PORT_COUNTER: AtomicU32 = AtomicU32::new(5544);
+        use std::sync::atomic::{AtomicU32, Ordering};
+        static PORT_COUNTER: AtomicU32 = AtomicU32::new(5144);
         PORT_COUNTER.fetch_add(1, Ordering::SeqCst)
     }
 

plotly_static/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "plotly_static"
-version = "0.0.4"
+version = "0.1.0"
 description = "Export Plotly graphs to static images using WebDriver"
 authors = ["Andrei Gherghescu [email protected]"]
 license = "MIT"

plotly_static/README.md

@@ -56,7 +56,7 @@ Add to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-plotly_static = { version = "0.0.4", features = ["chromedriver", "webdriver_download"] }
+plotly_static = { version = "0.1", features = ["chromedriver", "webdriver_download"] }
 serde_json = "1.0"
 ```