FIX: Toolbar savefig respects rcparams (#615)

* Feature: Respect savefig rcParams in Download button

Fixes #138, #234, #339

The Download button now respects ALL matplotlib savefig.* rcParams
instead of always saving as PNG with hardcoded settings.

Implementation:
- Override Toolbar.save_figure() to call canvas._send_save_buffer()
- Add Canvas._send_save_buffer() that calls figure.savefig() without
  hardcoded parameters (respects all rcParams)
- Send buffer + format metadata to frontend via ipywidgets comm
- Update frontend handle_save() to accept buffers from backend
- Support multiple formats with correct MIME types:
  PNG, PDF, SVG, EPS, JPEG, TIFF, PS, TIF
- Set correct file extensions based on format
- Maintain backward compatibility with canvas.toDataURL() fallback

Respects these rcParams:
- savefig.format (png, pdf, svg, jpg, eps, etc.)
- savefig.dpi (resolution)
- savefig.transparent (transparent backgrounds)
- savefig.facecolor (custom background colors)
- All other savefig.* parameters

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* Test: Add comprehensive tests for rcParams support

Manual test notebook (tests/manual_test_rcparams_save.ipynb):
- Tests all savefig.* rcParams (format, transparent, facecolor, dpi)
- Tests multiple formats: PNG, PDF, SVG, JPEG
- Includes verification checklist
- Documents expected behavior for each test case

Python unit tests (tests/test_download.py):
- Test _send_save_buffer respects savefig.format (PNG, PDF, SVG)
- Test download() method calls _send_save_buffer
- Test Toolbar.save_figure() calls _send_save_buffer
- Test respects savefig.dpi and savefig.transparent rcParams
- Test warns on unsupported format (e.g., webp)
- Add 'tests' to pytest testpaths in pyproject.toml

Addresses issues #138, #234, #339

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* Feature: Add fig.canvas.download() for programmatic downloads

- Add public download() method to Canvas class
- Allows triggering downloads from Python code without clicking button
- Respects all savefig rcParams like the toolbar button
- Includes comprehensive docstring with examples
- Add test file demonstrating programmatic usage

Use cases:
- Batch downloading multiple figures
- Automated workflows
- Custom save logic in notebooks

Example:
    fig, ax = plt.subplots()
    ax.plot([1, 2, 3])
    fig.canvas.download()  # Triggers browser download

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* Fix: Check format before savefig for matplotlib 3.5 compatibility

matplotlib 3.5 may reject invalid formats before we can check them,
so we need to validate the format from rcParams BEFORE calling savefig()
to ensure our warning is properly emitted.

Fixes test_send_save_buffer_warns_on_unsupported_format on matplotlib 3.5.

* Support all matplotlib formats in Download button

Remove artificial format restrictions - if matplotlib can generate it,
we support downloading it. Use known MIME types where available, or
fall back to application/octet-stream for unknown formats. The filename
extension ensures proper OS handling regardless.

This enables formats like PGF (LaTeX graphics), SVG compressed (svgz),
and raw RGBA formats to download correctly.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* Refactor: Use pytest parametrize for format tests

Use pytest.mark.parametrize to reduce code duplication in format tests.
Remove PGF test as LaTeX backend is not available in CI environment.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* remove junk file

---------

Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: ianhi

ipympl/backend_nbagg.py

@@ -128,6 +128,10 @@ def __init__(self, canvas, *args, **kwargs):
 
         self.on_msg(self.canvas._handle_message)
 
+    def save_figure(self, *args):
+        """Override to use rcParams-aware save."""
+        self.canvas._send_save_buffer()
+
     def export(self):
         buf = io.BytesIO()
         self.canvas.figure.savefig(buf, format='png', dpi='figure')
@@ -327,6 +331,52 @@ def send_binary(self, data):
         # Actually send the data
         self.send({'data': '{"type": "binary"}'}, buffers=[data])
 
+    def download(self):
+        """
+        Trigger a download of the figure respecting savefig rcParams.
+
+        This is a programmatic way to trigger the same download that happens
+        when the user clicks the Download button in the toolbar.
+
+        The figure will be saved using all applicable savefig.* rcParams
+        including format, dpi, transparent, facecolor, etc.
+
+        Examples
+        --------
+        >>> fig, ax = plt.subplots()
+        >>> ax.plot([1, 2, 3], [1, 4, 2])
+        >>> fig.canvas.download()  # Downloads with current rcParams
+
+        >>> # Download as PDF
+        >>> plt.rcParams['savefig.format'] = 'pdf'
+        >>> fig.canvas.download()
+
+        >>> # Download with custom DPI
+        >>> plt.rcParams['savefig.dpi'] = 300
+        >>> fig.canvas.download()
+        """
+        self._send_save_buffer()
+
+    def _send_save_buffer(self):
+        """Generate figure buffer respecting savefig rcParams and send to frontend."""
+        buf = io.BytesIO()
+
+        # Call savefig WITHOUT any parameters - fully respects all rcParams
+        self.figure.savefig(buf)
+
+        # Get the format that was used
+        fmt = rcParams.get('savefig.format', 'png')
+
+        # Get the buffer data
+        data = buf.getvalue()
+
+        # Send to frontend with format metadata
+        msg_data = {
+            "type": "save",
+            "format": fmt
+        }
+        self.send({'data': json.dumps(msg_data)}, buffers=[data])
+
     def new_timer(self, *args, **kwargs):
         return TimerTornado(*args, **kwargs)
 

pyproject.toml

@@ -120,6 +120,7 @@ source = "code"
 
 [tool.pytest.ini_options]
 testpaths = [
+    "tests",
     "docs/examples",
 ]
 norecursedirs = [

src/mpl_widget.ts

@@ -148,13 +148,67 @@ export class MPLCanvasModel extends DOMWidgetModel {
         }
     }
 
-    handle_save() {
+    handle_save(msg?: any, buffers?: (ArrayBuffer | ArrayBufferView)[]) {
+        let blob_url: string;
+        let filename: string;
+        let should_revoke = false;
+
+        // If called with buffers, use the backend-generated buffer
+        if (buffers && buffers.length > 0) {
+            const url_creator = window.URL || window.webkitURL;
+
+            // Get format from message (already parsed by on_comm_message)
+            const format = msg.format || 'png';
+
+            // Map format to MIME type - use known types where available
+            const mimeTypes: { [key: string]: string } = {
+                'png': 'image/png',
+                'jpg': 'image/jpeg',
+                'jpeg': 'image/jpeg',
+                'pdf': 'application/pdf',
+                'svg': 'image/svg+xml',
+                'svgz': 'image/svg+xml',
+                'eps': 'application/postscript',
+                'ps': 'application/postscript',
+                'tif': 'image/tiff',
+                'tiff': 'image/tiff',
+                'pgf': 'application/x-latex',
+                'raw': 'application/octet-stream',
+                'rgba': 'application/octet-stream'
+            };
+
+            // Use known MIME type or generic fallback
+            const mimeType = mimeTypes[format] || 'application/octet-stream';
+
+            // Convert buffer to Uint8Array
+            const buffer = new Uint8Array(
+                ArrayBuffer.isView(buffers[0]) ? buffers[0].buffer : buffers[0]
+            );
+
+            // Create blob with MIME type
+            const blob = new Blob([buffer], { type: mimeType });
+            blob_url = url_creator.createObjectURL(blob);
+            filename = this.get('_figure_label') + '.' + format;
+            should_revoke = true;
+        } else {
+            // Fallback to old behavior (use canvas toDataURL)
+            blob_url = this.offscreen_canvas.toDataURL();
+            filename = this.get('_figure_label') + '.png';
+        }
+
+        // Trigger download
         const save = document.createElement('a');
-        save.href = this.offscreen_canvas.toDataURL();
-        save.download = this.get('_figure_label') + '.png';
+        save.href = blob_url;
+        save.download = filename;
         document.body.appendChild(save);
         save.click();
         document.body.removeChild(save);
+
+        // Clean up blob URL if needed
+        if (should_revoke) {
+            const url_creator = window.URL || window.webkitURL;
+            url_creator.revokeObjectURL(blob_url);
+        }
     }
 
     handle_resize(msg: { [index: string]: any }) {

tests/manual_test_rcparams_save.ipynb

@@ -0,0 +1,149 @@
+"""Tests for download functionality respecting rcParams."""
+
+import io
+import json
+from unittest.mock import MagicMock, patch
+
+import matplotlib
+import matplotlib.pyplot as plt
+import pytest
+
+
+@pytest.mark.parametrize(
+    "format_name,signature_check",
+    [
+        ("png", lambda buf: len(buf) > 0 and buf[:8] == b'\x89PNG\r\n\x1a\n'),
+        ("pdf", lambda buf: buf[:4] == b'%PDF'),
+        ("svg", lambda buf: b'<?xml' in buf or b'<svg' in buf),
+    ]
+)
+def test_send_save_buffer_respects_format(format_name, signature_check):
+    """Test that _send_save_buffer respects savefig.format rcParam."""
+    matplotlib.use('module://ipympl.backend_nbagg')
+
+    plt.rcParams['savefig.format'] = format_name
+    fig, ax = plt.subplots()
+    ax.plot([1, 2, 3], [1, 4, 2])
+
+    canvas = fig.canvas
+    canvas.send = MagicMock()
+
+    canvas._send_save_buffer()
+
+    # Verify send was called
+    assert canvas.send.called
+    call_args = canvas.send.call_args
+
+    # Check message format
+    msg_data = json.loads(call_args[0][0]['data'])
+    assert msg_data['type'] == 'save'
+    assert msg_data['format'] == format_name
+
+    # Check buffer signature
+    buffers = call_args[1]['buffers']
+    assert len(buffers) == 1
+    assert signature_check(buffers[0])
+
+    plt.close(fig)
+
+
+def test_download_method_calls_send_save_buffer():
+    """Test that download() method calls _send_save_buffer()."""
+    matplotlib.use('module://ipympl.backend_nbagg')
+
+    fig, ax = plt.subplots()
+    ax.plot([1, 2, 3], [1, 4, 2])
+
+    canvas = fig.canvas
+
+    # Mock _send_save_buffer
+    with patch.object(canvas, '_send_save_buffer') as mock_send:
+        canvas.download()
+        mock_send.assert_called_once()
+
+    plt.close(fig)
+
+
+def test_toolbar_save_figure_calls_send_save_buffer():
+    """Test that Toolbar.save_figure() calls canvas._send_save_buffer()."""
+    matplotlib.use('module://ipympl.backend_nbagg')
+
+    fig, ax = plt.subplots()
+    ax.plot([1, 2, 3], [1, 4, 2])
+
+    canvas = fig.canvas
+    toolbar = canvas.toolbar
+
+    # Mock _send_save_buffer
+    with patch.object(canvas, '_send_save_buffer') as mock_send:
+        toolbar.save_figure()
+        mock_send.assert_called_once()
+
+    plt.close(fig)
+
+
+def test_send_save_buffer_respects_dpi():
+    """Test that _send_save_buffer respects savefig.dpi rcParam."""
+    matplotlib.use('module://ipympl.backend_nbagg')
+
+    # Test with high DPI
+    plt.rcParams['savefig.format'] = 'png'
+    plt.rcParams['savefig.dpi'] = 300
+
+    fig, ax = plt.subplots(figsize=(2, 2))
+    ax.plot([1, 2, 3], [1, 4, 2])
+
+    canvas = fig.canvas
+    canvas.send = MagicMock()
+
+    canvas._send_save_buffer()
+
+    # Get buffer size with high DPI
+    call_args = canvas.send.call_args
+    high_dpi_size = len(call_args[1]['buffers'][0])
+
+    plt.close(fig)
+
+    # Test with low DPI
+    plt.rcParams['savefig.dpi'] = 50
+
+    fig2, ax2 = plt.subplots(figsize=(2, 2))
+    ax2.plot([1, 2, 3], [1, 4, 2])
+
+    canvas2 = fig2.canvas
+    canvas2.send = MagicMock()
+
+    canvas2._send_save_buffer()
+
+    # Get buffer size with low DPI
+    call_args2 = canvas2.send.call_args
+    low_dpi_size = len(call_args2[1]['buffers'][0])
+
+    plt.close(fig2)
+
+    # High DPI should produce larger file
+    assert high_dpi_size > low_dpi_size
+
+
+def test_send_save_buffer_respects_transparent():
+    """Test that _send_save_buffer respects savefig.transparent rcParam."""
+    matplotlib.use('module://ipympl.backend_nbagg')
+
+    plt.rcParams['savefig.format'] = 'png'
+    plt.rcParams['savefig.transparent'] = True
+
+    fig, ax = plt.subplots()
+    fig.patch.set_facecolor('red')
+    ax.plot([1, 2, 3], [1, 4, 2])
+
+    canvas = fig.canvas
+    canvas.send = MagicMock()
+
+    canvas._send_save_buffer()
+
+    # Verify buffer was created (checking actual transparency would require PIL)
+    call_args = canvas.send.call_args
+    buffers = call_args[1]['buffers']
+    assert len(buffers[0]) > 0
+
+    plt.close(fig)