mscolnick
commented
2 months ago We do some fancy-ish things in marimo/_output/mpl.py
which is called twice:
- https://github.com/marimo-team/marimo/blob/b4256c9f283cde8879d5ccd71ff39bb29c0e2b87/marimo/_output/formatters/matplotlib_formatters.py#L25
- https://github.com/marimo-team/marimo/blob/b4256c9f283cde8879d5ccd71ff39bb29c0e2b87/marimo/_runtime/runtime.py#L964
I wonder if this is only run in edit mode (and not as a script) that you are seeing this issue. and possible we need to clear the plots in run mode. @akshayka any thoughts?
dmadisetti
akshayka
Describe the bug
I noticed when I did the qmd export for quarto that plots don't properly work:
plt.gcaobject rather than its snapshot at run.This doesn't affect the reactive notebook since the plot object is rendered to HTML, essentially creating a snapshot, and then the next cell is executed. However, in script mode the output is just a pointer to the current global state
Suggestion: I think deep copies can be expensive, so maybe an optional deep copy?
Environment
3.12-dev (I haven't pulled in a few days but I don't think you've made any changed that would affect this)
Code to reproduce
Relevant export test:
for completion the [plots.py](http://plots.py) tutorial
```python # Copyright 2024 Marimo. All rights reserved. import marimo __generated_with = "0.1.69" app = marimo.App() @app.cell(hide_code=True) def __(mo): mo.md("# Plotting") return @app.cell(hide_code=True) def __(check_dependencies): check_dependencies() return @app.cell(hide_code=True) def __(mo): mo.md( """ marimo supports several popular plotting libraries, including matplotlib, plotly, seaborn, and altair. This tutorial gives examples using matplotlib; other libraries are used similarly. """ ) return @app.cell(hide_code=True) def __(mo): mo.md("## Matplotlib") return @app.cell(hide_code=True) def __(mo): mo.md( """ To show a plot, include it in the last expression of a cell (just like any other output). ```python3 # create the plot in the last line of the cell import matplotlib.pyplot as plt plt.plot([1, 2]) ``` """ ) return @app.cell def __(plt): plt.plot([1, 2]) return @app.cell(hide_code=True) def __(mo): mo.md( """ ```python3 # create a plot plt.plot([1, 2]) # ... do some work ... # make plt.gca() the last line of the cell plt.gca() ``` """ ) return @app.cell def __(plt): plt.plot([1, 2]) # ... do some work ... # make plt.gca() the last line of the cell plt.gca() return @app.cell(hide_code=True) def __(mo, plt_show_explainer): mo.accordion(plt_show_explainer) return @app.cell(hide_code=True) def __(mo): mo.md( """ **A new figure every cell.** Every cell starts with an empty figure for the imperative `pyplot` API. """ ) return @app.cell def __(np): x = np.linspace(start=-4, stop=4, num=100, dtype=float) return x, @app.cell def __(plt, x): plt.plot(x, x) plt.plot(x, x**2) plt.gca() return @app.cell def __(plt, x): plt.plot(x, x**3) return @app.cell(hide_code=True) def __(mo): mo.md( """ To build a figure over multiple cells, use the object-oriented API and create your own axis: """ ) return @app.cell def __(plt, x): _, axis = plt.subplots() axis.plot(x, x) axis.plot(x, x**2) axis return axis, @app.cell def __(axis, x): axis.plot(x, x**3) axis return @app.cell(hide_code=True) def __(mo): mo.md( """ ### Draw plots interactively Draw plots interactively by parametrizing them with UI elements. """ ) return @app.cell def __(mo): exponent = mo.ui.slider(1, 5, value=1, step=1, label='exponent') mo.md( f""" **Visualizing powers.** {exponent} """ ) return exponent, @app.cell def __(exponent, mo, plt, x): import functools @functools.cache def _plot(exponent): plt.plot(x, x**exponent) return plt.gca() _tex = ( f"$$f(x) = x^{exponent.value}$$" if exponent.value > 1 else "$$f(x) = x$$" ) mo.md( f""" {_tex} {mo.as_html(_plot(exponent.value))} """ ) return functools, @app.cell(hide_code=True) def __(mo): mo.md("## Other libraries") return @app.cell(hide_code=True) def __(mo): mo.md( """ marimo also supports these other plotting libraries: - Plotly - Seaborn - Altair Just output their figure objects as the last expression of a cell, or embed them in markdown with `mo.as_html`. If you would like another library to be integrated into marimo, please get in touch. """ ) return @app.cell(hide_code=True) def __(missing_packages, mo): module_not_found_explainer = mo.md( """ ## Oops! It looks like you're missing a package that this tutorial requires. Close marimo, install **`numpy`** and **`matplotlib`**, then open this tutorial once more. If you use `pip`, run ``` pip install numpy matplotlib ``` at your command line. """ ).callout(kind='warn') def check_dependencies(): if missing_packages: return module_not_found_explainer return check_dependencies, module_not_found_explainer @app.cell(hide_code=True) def __(): plt_show_explainer = { "Using `plt.show()`": """ You can use `plt.show()` or `figure.show()` to display plots in the console area of a cell. Keep in mind that console outputs are not shown in the app view. """ } return plt_show_explainer, @app.cell def __(): try: import matplotlib import matplotlib.pyplot as plt import numpy as np missing_packages = False except ModuleNotFoundError: missing_packages = True if not missing_packages: matplotlib.rcParams['figure.figsize'] = (6, 2.4) return matplotlib, missing_packages, np, plt @app.cell def __(): import marimo as mo return mo, import matplotlib.pyplot as plt if __name__ == "__main__": objs, _ = app.run() for i, o in enumerate(objs): # Unpack the Line2d cases if isinstance(o, list): o, = o # Quick hack for testing if "matplotlib" in str(type(o)): o.get_figure().savefig(f"{i}.png") ``` produces: 11.png 12.png 14.png 15.png 5.png 7.png where 5 and 7 are the same, and the rest are the same This isn't the same behavior as in the export, but similar, and still incorrect      