Merge pull request matplotlib#25853 from QuLogic/layoutgrid-leaks

Fix LayoutGrid leaks

Author: tacaswell

lib/matplotlib/_constrained_layout.py

@@ -346,13 +346,15 @@ def make_layout_margins(layoutgrids, fig, renderer, *, w_pad=0, h_pad=0,
     """
     for sfig in fig.subfigs:  # recursively make child panel margins
         ss = sfig._subplotspec
+        gs = ss.get_gridspec()
+
         make_layout_margins(layoutgrids, sfig, renderer,
                             w_pad=w_pad, h_pad=h_pad,
                             hspace=hspace, wspace=wspace)
 
         margins = get_margin_from_padding(sfig, w_pad=0, h_pad=0,
                                           hspace=hspace, wspace=wspace)
-        layoutgrids[sfig].parent.edit_outer_margin_mins(margins, ss)
+        layoutgrids[gs].edit_outer_margin_mins(margins, ss)
 
     for ax in fig._localaxes:
         if not ax.get_subplotspec() or not ax.get_in_layout():

lib/matplotlib/_layoutgrid.py

@@ -38,7 +38,6 @@ def __init__(self, parent=None, parent_pos=(0, 0),
                  h_pad=None, w_pad=None, width_ratios=None,
                  height_ratios=None):
         Variable = kiwi.Variable
-        self.parent = parent
         self.parent_pos = parent_pos
         self.parent_inner = parent_inner
         self.name = name + seq_id()
@@ -57,12 +56,10 @@ def __init__(self, parent=None, parent_pos=(0, 0),
         if not isinstance(parent, LayoutGrid):
             # parent can be a rect if not a LayoutGrid
             # allows specifying a rectangle to contain the layout.
-            self.parent = parent
             self.solver = kiwi.Solver()
         else:
-            self.parent = parent
             parent.add_child(self, *parent_pos)
-            self.solver = self.parent.solver
+            self.solver = parent.solver
         # keep track of artist associated w/ this layout.  Can be none
         self.artists = np.empty((nrows, ncols), dtype=object)
         self.children = np.empty((nrows, ncols), dtype=object)
@@ -77,14 +74,8 @@ def __init__(self, parent=None, parent_pos=(0, 0),
 
         sol = self.solver
 
-        # These are redundant, but make life easier if
-        # we define them all.  All that is really
-        # needed is left/right, margin['left'], and margin['right']
-        self.widths = [Variable(f'{sn}widths[{i}]') for i in range(ncols)]
         self.lefts = [Variable(f'{sn}lefts[{i}]') for i in range(ncols)]
         self.rights = [Variable(f'{sn}rights[{i}]') for i in range(ncols)]
-        self.inner_widths = [Variable(f'{sn}inner_widths[{i}]')
-                             for i in range(ncols)]
         for todo in ['left', 'right', 'leftcb', 'rightcb']:
             self.margins[todo] = [Variable(f'{sn}margins[{todo}][{i}]')
                                   for i in range(ncols)]
@@ -95,9 +86,6 @@ def __init__(self, parent=None, parent_pos=(0, 0),
             self.margins[todo] = np.empty((nrows), dtype=object)
             self.margin_vals[todo] = np.zeros(nrows)
 
-        self.heights = [Variable(f'{sn}heights[{i}]') for i in range(nrows)]
-        self.inner_heights = [Variable(f'{sn}inner_heights[{i}]')
-                              for i in range(nrows)]
         self.bottoms = [Variable(f'{sn}bottoms[{i}]') for i in range(nrows)]
         self.tops = [Variable(f'{sn}tops[{i}]') for i in range(nrows)]
         for todo in ['bottom', 'top', 'bottomcb', 'topcb']:
@@ -109,7 +97,7 @@ def __init__(self, parent=None, parent_pos=(0, 0),
         # set these margins to zero by default. They will be edited as
         # children are filled.
         self.reset_margins()
-        self.add_constraints()
+        self.add_constraints(parent)
 
         self.h_pad = h_pad
         self.w_pad = w_pad
@@ -119,14 +107,14 @@ def __repr__(self):
         for i in range(self.nrows):
             for j in range(self.ncols):
                 str += f'{i}, {j}: '\
-                       f'L({self.lefts[j].value():1.3f}, ' \
+                       f'L{self.lefts[j].value():1.3f}, ' \
                        f'B{self.bottoms[i].value():1.3f}, ' \
-                       f'W{self.widths[j].value():1.3f}, ' \
-                       f'H{self.heights[i].value():1.3f}, ' \
-                       f'innerW{self.inner_widths[j].value():1.3f}, ' \
-                       f'innerH{self.inner_heights[i].value():1.3f}, ' \
+                       f'R{self.rights[j].value():1.3f}, ' \
+                       f'T{self.tops[i].value():1.3f}, ' \
                        f'ML{self.margins["left"][j].value():1.3f}, ' \
-                       f'MR{self.margins["right"][j].value():1.3f}, \n'
+                       f'MR{self.margins["right"][j].value():1.3f}, ' \
+                       f'MB{self.margins["bottom"][i].value():1.3f}, ' \
+                       f'MT{self.margins["top"][i].value():1.3f}, \n'
         return str
 
     def reset_margins(self):
@@ -139,11 +127,11 @@ def reset_margins(self):
                      'leftcb', 'rightcb', 'bottomcb', 'topcb']:
             self.edit_margins(todo, 0.0)
 
-    def add_constraints(self):
+    def add_constraints(self, parent):
         # define self-consistent constraints
         self.hard_constraints()
         # define relationship with parent layoutgrid:
-        self.parent_constraints()
+        self.parent_constraints(parent)
         # define relative widths of the grid cells to each other
         # and stack horizontally and vertically.
         self.grid_constraints()
@@ -177,12 +165,11 @@ def add_child(self, child, i=0, j=0):
         # np.ix_ returns the cross product of i and j indices
         self.children[np.ix_(np.atleast_1d(i), np.atleast_1d(j))] = child
 
-    def parent_constraints(self):
+    def parent_constraints(self, parent):
         # constraints that are due to the parent...
         # i.e. the first column's left is equal to the
         # parent's left, the last column right equal to the
         # parent's right...
-        parent = self.parent
         if not isinstance(parent, LayoutGrid):
             # specify a rectangle in figure coordinates
             hc = [self.lefts[0] == parent[0],