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>

Author: ianhi

ipympl/backend_nbagg.py

@@ -359,24 +359,14 @@ def download(self):
 
     def _send_save_buffer(self):
         """Generate figure buffer respecting savefig rcParams and send to frontend."""
-        # Get the format before calling savefig to properly warn about unsupported formats
-        fmt = rcParams.get('savefig.format', 'png')
-
-        # Validate format is supported by the frontend
-        supported_formats = {'png', 'jpg', 'jpeg', 'pdf', 'svg', 'eps', 'ps', 'tif', 'tiff'}
-        if fmt not in supported_formats:
-            warn(
-                f"Download format '{fmt}' is not supported by the ipympl frontend, "
-                f"falling back to PNG. Supported formats: {', '.join(sorted(supported_formats))}",
-                UserWarning,
-                stacklevel=3
-            )
-
         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()
 

src/mpl_widget.ts

@@ -160,38 +160,36 @@ export class MPLCanvasModel extends DOMWidgetModel {
             // Get format from message (already parsed by on_comm_message)
             const format = msg.format || 'png';
 
-            // Map format to MIME type
+            // 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'
+                'tiff': 'image/tiff',
+                'pgf': 'application/x-latex',
+                'raw': 'application/octet-stream',
+                'rgba': 'application/octet-stream'
             };
 
-            const mimeType = mimeTypes[format];
-
-            // If format is unknown, fall back to canvas toDataURL method
-            if (!mimeType) {
-                console.warn(`Unknown save format '${format}', falling back to PNG`);
-                blob_url = this.offscreen_canvas.toDataURL();
-                filename = this.get('_figure_label') + '.png';
-            } else {
-                // Convert buffer to Uint8Array
-                const buffer = new Uint8Array(
-                    ArrayBuffer.isView(buffers[0]) ? buffers[0].buffer : buffers[0]
-                );
+            // Use known MIME type or generic fallback
+            const mimeType = mimeTypes[format] || 'application/octet-stream';
 
-                // Create blob with correct MIME type
-                const blob = new Blob([buffer], { type: mimeType });
-                blob_url = url_creator.createObjectURL(blob);
-                filename = this.get('_figure_label') + '.' + format;
-                should_revoke = true;
-            }
+            // 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();

tests/test_download.py

@@ -191,24 +191,28 @@ def test_send_save_buffer_respects_transparent():
     plt.close(fig)
 
 
-def test_send_save_buffer_warns_on_unsupported_format():
-    """Test that _send_save_buffer warns about unsupported formats."""
+def test_send_save_buffer_with_pgf_format():
+    """Test that _send_save_buffer works with PGF format."""
     matplotlib.use('module://ipympl.backend_nbagg')
 
-    # Test with an unsupported format
-    plt.rcParams['savefig.format'] = 'webp'
+    # Test with PGF format (LaTeX graphics format)
+    plt.rcParams['savefig.format'] = 'pgf'
 
     fig, ax = plt.subplots()
     ax.plot([1, 2, 3], [1, 4, 2])
 
     canvas = fig.canvas
     canvas.send = MagicMock()
 
-    # Should issue a warning
-    with pytest.warns(UserWarning, match="Download format 'webp' is not supported"):
-        canvas._send_save_buffer()
+    # Should work without warnings
+    canvas._send_save_buffer()
 
-    # Should still send the buffer (frontend will fall back to PNG)
+    # Should send the buffer with format='pgf'
     assert canvas.send.called
+    call_args = canvas.send.call_args
+    assert 'data' in call_args[0][0]
+    import json
+    msg_data = json.loads(call_args[0][0]['data'])
+    assert msg_data['format'] == 'pgf'
 
     plt.close(fig)