Matplotlib upgrade

[zombie-einstein]

Hey @sash-a, thought I'd grab a look at #253.

Changes here update Matplotlib version and then makes changes to pass type checking, so it builds and passes tests.

But ...

The new API now requires that the animation update function returns a list of artists that have been updated, these are objects returned from plotting calls like a plot object, or text box (see the table here). The state/data of these objects can be updated without redrawing the whole thing.

I've done this rubiks cube environment:

# Create the first frame of the plot and return a list of drawn image artists
images = self._draw(ax, states[0])

def make_frame(state: State) -> Sequence[Artist]:
    # Update the data in each image from the state
    for i, image in enumerate(images):
        image.set_data(state.cube[i])
    # Return the updated images
    return images

# Create the animation object.
self._animation = matplotlib.animation.FuncAnimation(
    fig,
    make_frame,
    frames=states,
    interval=interval,
)

Doing this for all environments is easier for some than others given how they've been written, it means passing all the relevant artists to the animate function when the plot is created, and then correctly updating them inside the update function.

I think the animations will still work as is, as they still generally update the axes by reference inside the animation function, it's just less efficient then the new API that just updates the relevant artists.

[sash-a]

Wow this is an awesome addition, thanks @zombie-einstein!

Which environments are still remaining?

Also I think the way you've done it with make_frame looks good, but I have no experience with the new API

[zombie-einstein]

Which environments are still remaining?

Apart from rubix cube they all need a look at, with varying degrees of complexity. I think the general pattern needs to be something like a draw function that draws the first frame (and also draws the individual frames via the render method), and returns any actors that will be updated during the animation, then use this to initialise the first frame and update actors inside the update-func.

Some also currently have actors that are created dynamically during plotting I've been trying to work out the best pattern for, in some cases it seems it would be more efficient to initialise all the actors ahead of time, and update their states as needed. E.g. for the sudoko environment initialise all the text actors and update the text during animation (rather than create them on the fly).

So there's a decent chunk of work to refactor all the plots. One option could be merge something like this PR, which will updated the requirement and passes linting/tests, and still create plots (just less efficiently), and then incrementally update the individual viewers in separate PRs to make best use of the new API.

[sash-a]

Hi @zombie-einstein sorry for leaving this hanging, I needed a bit of time off 😂

I'll have a deeper look at it this week and give some a proper opinion 😄

[zombie-einstein]

Hi @zombie-einstein sorry for leaving this hanging, I needed a bit of time off 😂

I'll have a deeper look at it this week and give some a proper opinion 😄

Sure no worries, let me know if you've any follow up questions on the API update.

[sash-a]

I like the pattern, although seems like tetris is a special case?

One thing that I think would be nice to standardise is the name of the main draw function, many are called _add_foo or _draw_xyz. I think a good name would be _draw_state or _draw_frame?

As a function signature maybe:

def _draw_state(state: State, artist: Artist) -> Artist

Just going to check that everything is rendering properly

[sash-a]

Ok I've run all of them and they look good to me except for:

• graph colouring
• knapsack
• MMST
• sodoku
• TSP

Knapsack seems to just be because the knapsack image isn't added to the manifest which is an easy fix, the others seem to have deeper issues. I tested with the following notebook (we can add this to the examples folder for easy testing in the future)

[zombie-einstein]

One thing that I think would be nice to standardise is the name of the main draw function, many are called _add_foo or _draw_xyz. I think a good name would be _draw_state or _draw_frame?

As a function signature maybe:

def _draw_state(state: State, artist: Artist) -> Artist

Yeah think this would be ideal, I think it should be something like a 'draw_frame(...) -> Sequence[Artist]` that draws the full frame/image and can be called to draw a single frame/image and returns any artists that can be updated (I think in principle this could be any data structure of artists).

[zombie-einstein]

Ok I've run all of them and they look good to me except for:

* graph colouring

* knapsack

* MMST

* sodoku

* TSP

Knapsack seems to just be because the knapsack image isn't added to the manifest which is an easy fix, the others seem to have deeper issues. I tested with the following notebook (we can add this to the examples folder for easy testing in the future)

Yeah good shout, it was kind of painful to check all these manually.