Merge pull request matplotlib#1360 from NelleV/pep8_tight_layout

PEP8 fixes on tight_layout.py

Author: dmcdougall

lib/matplotlib/tight_layout.py

@@ -1,13 +1,12 @@
 """
-This module provides routines to adjust subplot params so that
-subplots are nicely fit in the figure. In doing so, only axis labels,
-tick labels and axes titles are currently considered.
+This module provides routines to adjust subplot params so that subplots are
+nicely fit in the figure. In doing so, only axis labels, tick labels and axes
+titles are currently considered.
 
 Internally, it assumes that the margins (left_margin, etc.) which are
-differences between ax.get_tightbbox and ax.bbox are independent of
-axes position. This may fail if Axes.adjustable is datalim. Also, This
-will fail for some cases (for example, left or right margin is affected by xlabel).
-
+differences between ax.get_tightbbox and ax.bbox are independent of axes
+position. This may fail if Axes.adjustable is datalim. Also, This will fail
+for some cases (for example, left or right margin is affected by xlabel).
 """
 
 import warnings
@@ -19,16 +18,18 @@
 rcParams = matplotlib.rcParams
 
 
-
 def _get_left(tight_bbox, axes_bbox):
     return axes_bbox.xmin - tight_bbox.xmin
 
+
 def _get_right(tight_bbox, axes_bbox):
     return tight_bbox.xmax - axes_bbox.xmax
 
+
 def _get_bottom(tight_bbox, axes_bbox):
     return axes_bbox.ymin - tight_bbox.ymin
 
+
 def _get_top(tight_bbox, axes_bbox):
     return tight_bbox.ymax - axes_bbox.ymax
 
@@ -59,55 +60,64 @@ def auto_adjust_subplotpars(fig, renderer,
       list of subplots that will be used to calcuate optimal subplot_params.
 
     pad : float
-      padding between the figure edge and the edges of subplots, as a fraction of the font-size.
+      padding between the figure edge and the edges of subplots, as a fraction
+      of the font-size.
     h_pad, w_pad : float
       padding (height/width) between edges of adjacent subplots.
         Defaults to `pad_inches`.
 
     rect
       [left, bottom, right, top] in normalized (0, 1) figure coordinates.
     """
-
-
     rows, cols = nrows_ncols
 
-    pad_inches = pad * FontProperties(size=rcParams["font.size"]).get_size_in_points() / 72.
+    pad_inches = pad * FontProperties(
+                    size=rcParams["font.size"]).get_size_in_points() / 72.
 
     if h_pad is not None:
-        vpad_inches = h_pad * FontProperties(size=rcParams["font.size"]).get_size_in_points() / 72.
+        vpad_inches = h_pad * FontProperties(
+                        size=rcParams["font.size"]).get_size_in_points() / 72.
     else:
         vpad_inches = pad_inches
 
     if w_pad is not None:
-        hpad_inches = w_pad * FontProperties(size=rcParams["font.size"]).get_size_in_points() / 72.
+        hpad_inches = w_pad * FontProperties(
+                        size=rcParams["font.size"]).get_size_in_points() / 72.
     else:
         hpad_inches = pad_inches
 
-
     if len(subplot_list) == 0:
         raise RuntimeError("")
 
     if len(num1num2_list) != len(subplot_list):
         raise RuntimeError("")
 
     if rect is None:
-        margin_left, margin_bottom, margin_right, margin_top = None, None, None, None
+        margin_left = None
+        margin_bottom = None
+        margin_right = None
+        margin_top = None
     else:
         margin_left, margin_bottom, _right, _top = rect
-        if _right: margin_right = 1. - _right
-        else: margin_right = None
-        if _top: margin_top = 1. - _top
-        else: margin_top = None
+        if _right:
+            margin_right = 1. - _right
+        else:
+            margin_right = None
+        if _top:
+            margin_top = 1. - _top
+        else:
+            margin_top = None
 
-    vspaces = [[] for i in range((rows+1)*cols)]
-    hspaces = [[] for i in range(rows*(cols+1))]
+    vspaces = [[] for i in range((rows + 1) * cols)]
+    hspaces = [[] for i in range(rows * (cols + 1))]
 
     union = Bbox.union
 
     if ax_bbox_list is None:
         ax_bbox_list = []
         for subplots in subplot_list:
-            ax_bbox = union([ax.get_position(original=True) for ax in subplots])
+            ax_bbox = union([ax.get_position(original=True)
+                             for ax in subplots])
             ax_bbox_list.append(ax_bbox)
 
     for subplots, ax_bbox, (num1, num2) in zip(subplot_list,
@@ -117,76 +127,85 @@ def auto_adjust_subplotpars(fig, renderer,
         #ax_bbox = union([ax.get_position(original=True) for ax in subplots])
 
         tight_bbox_raw = union([ax.get_tightbbox(renderer) for ax in subplots])
-        tight_bbox = TransformedBbox(tight_bbox_raw, fig.transFigure.inverted())
+        tight_bbox = TransformedBbox(tight_bbox_raw,
+                                     fig.transFigure.inverted())
 
         row1, col1 = divmod(num1, cols)
 
-
         if num2 is None:
             # left
-            hspaces[row1 * (cols+1) + col1].append(_get_left(tight_bbox, ax_bbox))
+            hspaces[row1 * (cols + 1) + col1].append(
+                                        _get_left(tight_bbox, ax_bbox))
             # right
-            hspaces[row1 * (cols+1) + (col1+1)].append(_get_right(tight_bbox, ax_bbox))
+            hspaces[row1 * (cols + 1) + (col1 + 1)].append(
+                                        _get_right(tight_bbox, ax_bbox))
             # top
-            vspaces[row1 * cols + col1].append(_get_top(tight_bbox, ax_bbox))
+            vspaces[row1 * cols + col1].append(
+                                        _get_top(tight_bbox, ax_bbox))
             # bottom
-            vspaces[(row1+1) * cols + col1].append(_get_bottom(tight_bbox, ax_bbox))
+            vspaces[(row1 + 1) * cols + col1].append(
+                                        _get_bottom(tight_bbox, ax_bbox))
 
         else:
             row2, col2 = divmod(num2, cols)
 
-            for row_i in range(row1, row2+1):
+            for row_i in range(row1, row2 + 1):
                 # left
-                hspaces[row_i * (cols+1) + col1].append(_get_left(tight_bbox, ax_bbox))
+                hspaces[row_i * (cols + 1) + col1].append(
+                                    _get_left(tight_bbox, ax_bbox))
                 # right
-                hspaces[row_i * (cols+1) + (col2+1)].append(_get_right(tight_bbox, ax_bbox))
-            for col_i in range(col1, col2+1):
+                hspaces[row_i * (cols + 1) + (col2 + 1)].append(
+                                    _get_right(tight_bbox, ax_bbox))
+            for col_i in range(col1, col2 + 1):
                 # top
-                vspaces[row1 * cols + col_i].append(_get_top(tight_bbox, ax_bbox))
+                vspaces[row1 * cols + col_i].append(
+                                    _get_top(tight_bbox, ax_bbox))
                 # bottom
-                vspaces[(row2+1) * cols + col_i].append(_get_bottom(tight_bbox, ax_bbox))
-
+                vspaces[(row2 + 1) * cols + col_i].append(
+                                    _get_bottom(tight_bbox, ax_bbox))
 
     fig_width_inch, fig_height_inch = fig.get_size_inches()
 
     # margins can be negative for axes with aspect applied. And we
     # append + [0] to make minimum margins 0
 
     if not margin_left:
-        margin_left = max([sum(s) for s in hspaces[::cols+1]] + [0])
+        margin_left = max([sum(s) for s in hspaces[::cols + 1]] + [0])
         margin_left += pad_inches / fig_width_inch
 
     if not margin_right:
-        margin_right =  max([sum(s) for s in hspaces[cols::cols+1]] + [0])
+        margin_right = max([sum(s) for s in hspaces[cols::cols + 1]] + [0])
         margin_right += pad_inches / fig_width_inch
 
     if not margin_top:
-        margin_top =  max([sum(s) for s in vspaces[:cols]] + [0])
+        margin_top = max([sum(s) for s in vspaces[:cols]] + [0])
         margin_top += pad_inches / fig_height_inch
 
     if not margin_bottom:
-        margin_bottom =  max([sum(s) for s in vspaces[-cols:]] + [0])
+        margin_bottom = max([sum(s) for s in vspaces[-cols:]] + [0])
         margin_bottom += pad_inches / fig_height_inch
 
-
     kwargs = dict(left=margin_left,
-                  right=1-margin_right,
+                  right=1 - margin_right,
                   bottom=margin_bottom,
-                  top=1-margin_top)
+                  top=1 - margin_top)
 
     if cols > 1:
-        hspace = max([sum(s) for i in range(rows) for s in hspaces[i*(cols+1)+1:(i+1)*(cols+1)-1]])
+        hspace_strip = hspaces[i * (cols + 1) + 1:(i + 1) * (cols + 1) - 1]
+        hspace = max([sum(s) for i in range(rows) for s in hspace_strip])
         hspace += hpad_inches / fig_width_inch
-        h_axes = ((1-margin_right-margin_left) - hspace * (cols - 1))/cols
+        h_axes = ((1 - margin_right - margin_left) -
+                   hspace * (cols - 1)) / cols
 
-        kwargs["wspace"]=hspace/h_axes
+        kwargs["wspace"] = hspace / h_axes
 
     if rows > 1:
-        vspace =  max([sum(s) for s in vspaces[cols:-cols]])
+        vspace = max([sum(s) for s in vspaces[cols:-cols]])
         vspace += vpad_inches / fig_height_inch
-        v_axes = ((1-margin_top-margin_bottom) - vspace * (rows - 1))/rows
+        v_axes = ((1 - margin_top - margin_bottom) -
+                  vspace * (rows - 1)) / rows
 
-        kwargs["hspace"]=vspace/v_axes
+        kwargs["hspace"] = vspace / v_axes
 
     return kwargs
 
@@ -237,7 +256,6 @@ def get_subplotspec_list(axes_list, grid_spec=None):
         else:
             subplotspec = None
 
-
         subplotspec_list.append(subplotspec)
 
     return subplotspec_list
@@ -274,15 +292,14 @@ def get_tight_layout_figure(fig, axes_list, subplotspec_list, renderer,
         labels) will fit into. Default is (0, 0, 1, 1).
     """
 
-
     subplot_list = []
     nrows_list = []
     ncols_list = []
     ax_bbox_list = []
 
-    subplot_dict = {} # multiple axes can share
-                      # same subplot_interface (e.g, axes_grid1). Thus
-                      # we need to join them together.
+    subplot_dict = {}  # multiple axes can share
+                       # same subplot_interface (e.g, axes_grid1). Thus
+                       # we need to join them together.
 
     subplotspec_list2 = []
 
@@ -314,15 +331,16 @@ def get_tight_layout_figure(fig, axes_list, subplotspec_list, renderer,
         if (mod_row != 0) or (mod_col != 0):
             raise RuntimeError("")
 
-        rowNum1, colNum1 =  divmod(num1, cols)
+        rowNum1, colNum1 = divmod(num1, cols)
         if num2 is None:
-            rowNum2, colNum2 =  rowNum1, colNum1
+            rowNum2, colNum2 = rowNum1, colNum1
         else:
-            rowNum2, colNum2 =  divmod(num2, cols)
-
-        num1num2_list.append((rowNum1*div_row*max_ncols + colNum1*div_col,
-                              ((rowNum2+1)*div_row-1)*max_ncols + (colNum2+1)*div_col-1))
+            rowNum2, colNum2 = divmod(num2, cols)
 
+        num1num2_list.append((rowNum1 * div_row * max_ncols +
+                              colNum1 * div_col,
+                              ((rowNum2 + 1) * div_row - 1) * max_ncols +
+                              (colNum2 + 1) * div_col - 1))
 
     kwargs = auto_adjust_subplotpars(fig, renderer,
                                      nrows_ncols=(max_nrows, max_ncols),
@@ -341,10 +359,14 @@ def get_tight_layout_figure(fig, axes_list, subplotspec_list, renderer,
         # with adjusted rect parameters.
 
         left, bottom, right, top = rect
-        if left is not None: left += kwargs["left"]
-        if bottom is not None: bottom += kwargs["bottom"]
-        if right is not None: right -= (1 - kwargs["right"])
-        if top is not None: top -= (1 - kwargs["top"])
+        if left is not None:
+            left += kwargs["left"]
+        if bottom is not None:
+            bottom += kwargs["bottom"]
+        if right is not None:
+            right -= (1 - kwargs["right"])
+        if top is not None:
+            top -= (1 - kwargs["top"])
 
         #if h_pad is None: h_pad = pad
         #if w_pad is None: w_pad = pad