rebased

I don't claim to fully understand what's going on here. However, all axes created in the session use the same globalGrouper. In contrast, each set of axes that are created from one unpickling have a separateGrouper instance.

I'm not sure that this really creates a problem, but it's an asymmetry that I wouldn't have expected.

The observation is correct, but not a problem... until we decide to allow post-hoc modifications of the sharedness state.
Proper solution would be to implement merging of groupers, or just get rid of the grouper structure and simply store a list of axes that a given axes is shared with and walk the tree when needed (which is also O(n) unless you store way too many vertices).

See also#9923.

until we decide to allow post-hoc modifications of the sharedness state

Does that mean that the usual

ax1.get_shared_x_axes().join(ax1, ax2)

isn't allowed? By whom?
In any case I think it would be useful not having the reestablish the sharing after unpickling. On the other hand, I'm not sure how often that really happens in the wild and looping though all axes and callingjoin isn't that hard either.

Well, I didn't know that API even existed (I think it qualifies as an API leak, but it's a nifty one...), so you have a point.
In practice, though, that just means that the current implementation doesn't support post-hoc sharing of axises in manner in the way you suggested when using unpickled axes (because they end up using different groupers). But I think that's a relatively rarer case that just pickling and unpickling already shared axes...

I don't think it depends on whether the axes had been shared previously.

In case of previously shared axes, you'd do

import matplotlib.pyplot as pltimport picklefig, axes = plt.subplots(ncols=3, sharey="row")axes[0].plot([0,1],[0,1])axes[1].plot([0,1],[1,2])axes[2].plot([0,1],[2,3])pickle.dump(fig, file('fig1.pkl', 'wb'))  plt.close("all")fig2 = pickle.load(file('fig1.pkl','rb'))ax_master = fig2.axes[0]for ax in fig2.axes:    if ax is not ax_master:        ax_master.get_shared_y_axes().join(ax_master, ax)    plt.show()

In case of previously unshared axes you can do the same:

import matplotlib.pyplot as pltimport picklefig, axes = plt.subplots(ncols=3)axes[0].plot([0,1],[0,1])axes[1].plot([0,1],[1,2])axes[2].plot([0,1],[2,3])pickle.dump(fig, file('fig1.pkl', 'wb'))  plt.close("all")fig2 = pickle.load(file('fig1.pkl','rb'))ax_master = fig2.axes[0]for ax in fig2.axes:    if ax is not ax_master:        ax_master.get_shared_y_axes().join(ax_master, ax)    ax.autoscale()    plt.show()

My point is that with this implementation, you can't reload two separately pickled axes and then share them, and I think that's a reasonable tradeoff in exchange of being able to correctly pickle and unpickle previously shared axes.

I'm afraid that someone will stumble upon this limitation again.
On the other hand, it feels like a proper solution with merging Groupers should be possible with just a few extra lines of code. I wouldn't hold this PR up from a release, but we should aim at full pickling support.

So theGrouper object has a (weak)ref to every axes that is involved in any sharing does this mean that every pickle will includeall currently shared axes, they will all be restored on unpickle, and then any non-used ones will be immediately gc'd (or do they stick around)?

I agree the detail that some Axes objects will use the global group and other axes (sets) will use their own private Grouper seems like a major gotcha bug.

Suspect the fix will be to, in addition to this change, to prune the pickeled Grouper to just be things shared by current set of interest and then on restore to inject them selves back into the shared grouper.

Moved this to 3.1

Replaced by#11544.