Portable method to generate matplotlib interactive figures in Windows, Linux, Spyder, command line

Question

I'm looking for a a method to generate interactive figures that works in Windows and Linux, commandline or Spyder. For example, the following script:

import matplotlib.pyplot as plt
fig, ax = plt.subplots(1, 1, tight_layout=True)
#plt.ion() # doesn't seem to do much
ax.plot([0,1,2],[0,3,2])
fig.show()
#plt.show(block=False) # similar behavior as fig.show()
#plt.pause(1)
input('Press enter to quit.')

Behavior for different environments:

• Linux command line: plot window shows up and is responsive while the script waits for user input. The window stays even if the program continues running (not in this short example), although the zoom buttons don't work anymore. This is desired behavior.

• Windows command line: an empty nonresponsive plot window shows up, which disappears when the program ends. Adding plt.pause() results in an interactive plot, but it is only responsive for the specified number of seconds.

• Linux/Windows Spyder with iPython, configured for automatic plots: figures show up and are responsive, but only after the script finishes.

• Linux/Windows Spyder, configured for inline plots: plots show up after the script finishes, but with warnings due to the tight_layout=True parameter: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect. and matplotlib is currently using a non-GUI backend. (Note that I need tight_layout because otherwise often axis labels are clipped or figures with multiple subplots have bad margins.)

• Linux/Windows Spyder, inline plots: with plt.plot(...); plt.show() (rather than the fig.plot(...); fig.show() object-oriented way), the inline plots show up during program execution.

How can I write code that generates interactive plots during program execution (possibly while waiting for a keypress) that will run correctly from the Windows command line, Linux command line, and Spyder?

Edit: plt.show() instead of fig.show() will result in a plot being shown correctly, but outside IPython, it blocks execution of the script until I click the close button of the figure window. This is rather cumbersome when there are multiple figures or when the calculation is not yet finished. And plt.show(block=False) has the same behavior as fig.show().

I'm using an noncustomized Anaconda 5.1 environment with Python 3.6.4, matplotlib 2.1.2, spyder 3.2.6. In Spyder: Tools > Preferences > IPython > Backend, set to 'inline' or 'automatic' (and restarting kernel after changing this setting.)

Answer 1

It seems the following is what you're after:

import matplotlib.pyplot as plt

fig, ax = plt.subplots(1, 1, tight_layout=True)

plt.ion()
ax.plot([0,1,2],[0,3,2])

plt.show()
plt.pause(0.1)

input('Press enter to quit.')
plt.close()

In general, a python program is evaluated linearly. This contradicts the desire to have a blocking command line (input) but a non-blocking GUI.
What happens in the above is that a GUI is created, but without any propper event-loop started. Therefore the code can continue to be executed even after the GUI being shown. The drawback of this is clearly that without event-loop, you cannot interact with the GUI.

In case a plotting window needs to be shown and some user input is required, or further code is to be executed after showing the fully interactive figure, one can run such code within the GUI event loop.

import matplotlib.pyplot as plt

def run_after(callback, pause=10, figure=None):
    figure = figure or plt.gcf()
    timer = figure.canvas.new_timer(interval=pause)
    timer.single_shot = True
    timer.add_callback(callback)
    timer.start()
    return timer


fig, ax = plt.subplots(1, 1, tight_layout=True)
ax.plot([0,1,2],[0,3,2])

# This function contains the code to be executed within the GUI event loop
def mycallback():
    import tkinter
    from tkinter import simpledialog
    root = tkinter.Tk()
    root.withdraw()
    w = simpledialog.askinteger("Title", "How many numbers do you want to print")

    for i in range(w):
        print(i)


cb = run_after(mycallback)

plt.show()

Answer 2

Here is an approach that sort of works, but not very well for all environments:

import matplotlib.pyplot as plt
import sys
import matplotlib

def plt_show_interactive():
    """Show plot windows, with interaction if possible; prompt to continue.""" 
    in_ipython = ('get_ipython' in globals())
    inline_backend = ('inline' in matplotlib.get_backend())
    in_linux = (sys.platform == 'linux')

    if inline_backend:
        plt.show()
    elif not in_linux and in_ipython:
        print("Press Ctrl-C to continue.")
        try:    
            while True:
                plt.pause(0.5)
        except KeyboardInterrupt:
            print("Continuing.")
    elif in_linux and not in_ipython:
        # Command line: plots are interactive during wait for input.
        plt.show(block=False)
        input("Press ENTER to continue.")
    elif in_linux and in_ipython:
        # Loop with plt.pause(1) causes repeated focus stealing.
        plt.pause(1)
        print("Sorry, plots are not interactive until program has finished.")
    elif not in_linux and not in_ipython:
        # Ctrl-C is handled differently here.
        plt.pause(1)
        input("Sorry, not interactive. Press ENTER to continue.")


def prompt_if_not_ipython(verb="end"):
    """Ask user to press ENTER if not we're not inside IPython."""
    if ('get_ipython' not in globals()):
        input("Press ENTER to %s." % verb)


fig, ax = plt.subplots(1, 1, tight_layout=True)
ax.plot([0,1,2],[0,3,2])

plt_show_interactive()
prompt_if_not_ipython()