Hi, I'm unsure as well how to do a scripted notebook test as well. However, to start you could post your test code that can be pasted into a reviewers notebook.

There is nbval, but it only works for static notebooks. There is a UAT notebook in this repo for live testing of the notebook backend.

@mbewley Thanks for taking this on! If you have any questions (code or process) please do not hesitate to ask! You will probably get faster answers asking publically (here or on https://gitter.im/matplotlib/matplotlib ) but if there is anything you do not feel comfortable asking publicly email me.

Here's the minimal example that works inside a notebook... just click on the generated 49 MP image, and it will rapidly toggle a little red/green box in the top left.

%matplotlib notebook
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import time


IMSIZE = 7000
RED = (1,0,0,1)
GREEN = (0,1,0,1)

class ExampleToggle:
    
    def __init__(self):
        plt.ioff()
        self.fig = plt.figure()
        self.ax = self.fig.add_subplot(111)
        self.canvas = self.ax.figure.canvas

        self.im = np.random.randint(0, 255, [IMSIZE,IMSIZE, 3]).astype('uint8')
        self.tmp_colour = RED
        self.rect = mpatches.Rectangle([0, 0], 200, 200, edgecolor='yellow', facecolor=self.tmp_colour, linewidth=0.5, animated=True)
        self.ax.add_patch(self.rect)
        
        plt.show()
        self.canvas.mpl_connect('button_press_event', self.clicked)
        
        self.ax.imshow(self.im)
        self.canvas.draw()
        self.background = self.canvas.copy_from_bbox(self.ax.bbox)    

    def clicked(self, event):
        if self.tmp_colour == RED:
            self.tmp_colour = GREEN
        elif self.tmp_colour == GREEN:
            self.tmp_colour = RED
        self.rect.set_facecolor(self.tmp_colour)
        self.canvas.restore_region(self.background)
        self.ax.draw_artist(self.rect)
        self.canvas.blit(self.ax.bbox)
et = ExampleToggle()

Looks like a sensible change (untested). To be clear, the blitting you are adding is on the server side - you aren't getting any blitting through the javascript and into the notebook. That's fine (and a hard problem to solve), but we should be careful not to call it full-blown blitting in the nbagg backend.

I was asked to do the pull request - first time contributor to matplotlib

Wow! Really impressive stuff - there is a lot of connective tissue you've had to get your head around, and you've done a great job of it as far as I can see! Keep up the awesome work - looking forward to seeing your future mpl contributions 👍

Ha, the "connective tissue" was all blink1073 - I just managed to copy/paste correctly (and do a neat minimal example). Yes, the server side blitting works perfectly on local host for fast access. It also works quite quickly on EC2 (tested at work where we have a pretty fast connection), but chews up monstrous amounts of bandwidth - so maybe should come with some sort of warning?

Hey guys, is there anything we need to do to make sure this gets into 2.2? (it was slated for 2.1, but got bumped).

I labelled it release critical so that we're sure to take a look at it before the next feature release.

Thanks!

power cycled to re-trigger CI.

Do you see the issues with #4290 with this patch?

Can you copy (or re-write) the UAT in #4290 ?

Or put your example in the UAT notebook.

Hmm, I didn't see those issues. I've now:

• Rebased on the latest merge in matplotlib, and checked it works in my use case.
• Copied in the UAT notebook from ENH : Nbagg blit #4290 to the same location in my pull request (only change is letting jupyter upgrade the notebook format).
• Ran the notebook. Tests seem to work fine, but exhibit the same flickering issue as your previous ones.

Anything else I need to do?

That's odd - careful not to get pull requests mixed up - I got a bit confused at first. This one on blitting we're currently trying to get in is #9240, the old one on blitting from a couple of years ago is just the numbers rearranged - #4290.

Hey, any feedback on the updates?

Can you update the UAT notebook as part of this PR?

Any theories on the flickering?

What did you want updated on the UAT notebook? I added it into the repo and checked it ran - the tests all still seemed sensible.
In terms of the flickering, I don't know the matplotlib codebase well at all, but it seems to be a pixel width on the right and bottom edges of the axis (when you have xticks/yticks set to none). Is there some inconsistency between the area that gets saved/restored as the background image, and the border/tickmarks of an axis?

@mbewley just for the changes to be check-in as part of this PR so that the next person to work on this can run them.

Ah, sorry, thought I'd done that - forgot to push. Will do...

oops, looks like you accidentally rebased in a bunch of other commits...

Hmm, I was trying to update to the latest head on master, as it was getting pretty old. What's the best way to fix it?

To rebase, I always squash my own commits

git rebase -i HEAD~X  # where X is the last commit *not* made by me

Then I rebase with master:

git fetch upstream master
git rebase upstream/master

See:
https://matplotlib.org/devel/gitwash/index.html

When I've gotten in the state that you are in, I copy the files I edited somewhere else and then in my branch:

git reset --hard upstream/master

and then re-add the changes.

Ok, I thought I followed this: https://matplotlib.org/devel/gitwash/development_workflow.html#development-workflow ("Rebasing on Trunk"), but must've stuffed it up. Will fix and push again.

While investigating this I ran into #13971, which may be related - essentially any mouse click on the figure will result in a draw, which might interfere with the use of blit locally. I think it would be worth solving #13971 first just in case.

ping @mbewley - sometimes takes a while to get things through matplotlib - hopefully the process hasn't scared you off!

This still does not deal with the double-buffering correctly. For example in

%matplotlib notebook
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

fig, ax = plt.subplots()
xdata, ydata = [], []
ln, = plt.plot([], [], 'ro')

def init():
    ax.set_xlim(0, 2*np.pi)
    ax.set_ylim(-1, 1)
    return ln,

def update(frame):
    xdata.append(frame)
    ydata.append(np.sin(frame))
    ln.set_data(xdata, ydata)
    return ln,

ani = FuncAnimation(fig, update, frames=np.linspace(0, 2*np.pi, 128),
                    init_func=init, blit=True)
plt.show()

every other frame has the incorrect tick labels. I think instead of using two render objects, we need a double-buffered renderer sub-class.

I'll closed as abandoned; thanks for the PR, and feel free to re-open if you want to come back to this!

I'll closed as abandoned; thanks for the PR, and feel free to re-open if you want to come back to this!

For any future finders of this PR: This was subsumed and then superceded by #19059