"""

def __init__(self, nrows, ncols, height_ratios=None, width_ratios=None):

"""

self._nrows, self._ncols = nrows, ncols

self.set_height_ratios(height_ratios)

self.set_width_ratios(width_ratios)

def __repr__(self):

height_arg = (', height_ratios=%r' % (self._row_height_ratios,)

if self._row_height_ratios is not None else '')

width_arg = (', width_ratios=%r' % (self._col_width_ratios,)

if self._col_width_ratios is not None else '')

return '{clsname}({nrows}, {ncols}{optionals})'.format(

clsname=self.__class__.__name__,

nrows=self._nrows,

ncols=self._ncols,

optionals=height_arg + width_arg,

)

nrows = property(lambda self: self._nrows,

doc="The number of rows in the grid.")

ncols = property(lambda self: self._ncols,

doc="The number of columns in the grid.")

def get_geometry(self):

"""

return self._nrows, self._ncols

def get_subplot_params(self, figure=None):

# Must be implemented in subclasses

pass

def new_subplotspec(self, loc, rowspan=1, colspan=1):

"""

loc1, loc2 = loc

subplotspec = self[loc1:loc1+rowspan, loc2:loc2+colspan]

return subplotspec

def set_width_ratios(self, width_ratios):

"""

if width_ratios is not None and len(width_ratios) != self._ncols:

raise ValueError('Expected the given number of width ratios to '

'match the number of columns of the grid')

self._col_width_ratios = width_ratios

def get_width_ratios(self):

"""

return self._col_width_ratios

def set_height_ratios(self, height_ratios):

"""

if height_ratios is not None and len(height_ratios) != self._nrows:

raise ValueError('Expected the given number of height ratios to '

'match the number of rows of the grid')

self._row_height_ratios = height_ratios

def get_height_ratios(self):

"""

return self._row_height_ratios

def get_grid_positions(self, fig, raw=False):

"""

nrows, ncols = self.get_geometry()

if raw:

left = 0.

right = 1.

bottom = 0.

top = 1.

wspace = 0.

hspace = 0.

else:

subplot_params = self.get_subplot_params(fig)

left = subplot_params.left

right = subplot_params.right

bottom = subplot_params.bottom

top = subplot_params.top

wspace = subplot_params.wspace

hspace = subplot_params.hspace

tot_width = right - left

tot_height = top - bottom

# calculate accumulated heights of columns

cell_h = tot_height / (nrows + hspace*(nrows-1))

sep_h = hspace * cell_h

if self._row_height_ratios is not None:

norm = cell_h * nrows / sum(self._row_height_ratios)

cell_heights = [r * norm for r in self._row_height_ratios]

else:

cell_heights = [cell_h] * nrows

sep_heights = [0] + ([sep_h] * (nrows-1))

cell_hs = np.cumsum(np.column_stack([sep_heights, cell_heights]).flat)

# calculate accumulated widths of rows

cell_w = tot_width / (ncols + wspace*(ncols-1))

sep_w = wspace * cell_w

if self._col_width_ratios is not None:

norm = cell_w * ncols / sum(self._col_width_ratios)

cell_widths = [r * norm for r in self._col_width_ratios]

else:

cell_widths = [cell_w] * ncols

sep_widths = [0] + ([sep_w] * (ncols-1))

cell_ws = np.cumsum(np.column_stack([sep_widths, cell_widths]).flat)

fig_tops, fig_bottoms = (top - cell_hs).reshape((-1, 2)).T

fig_lefts, fig_rights = (left + cell_ws).reshape((-1, 2)).T

return fig_bottoms, fig_tops, fig_lefts, fig_rights

def __getitem__(self, key):

"""Create and return a `.SubplotSpec` instance."""

nrows, ncols = self.get_geometry()

def _normalize(key, size, axis): # Includes last index.

orig_key = key

if isinstance(key, slice):

start, stop, _ = key.indices(size)

if stop > start:

return start, stop - 1

raise IndexError("GridSpec slice would result in no space "

"allocated for subplot")

else:

if key < 0:

key = key + size

if 0 <= key < size:

return key, key

elif axis is not None:

raise IndexError(f"index {orig_key} is out of bounds for "

f"axis {axis} with size {size}")

else: # flat index

raise IndexError(f"index {orig_key} is out of bounds for "

f"GridSpec with size {size}")

if isinstance(key, tuple):

try:

k1, k2 = key

except ValueError as err:

raise ValueError("Unrecognized subplot spec") from err

num1, num2 = np.ravel_multi_index(

[_normalize(k1, nrows, 0), _normalize(k2, ncols, 1)],

(nrows, ncols))

else: # Single key

num1, num2 = _normalize(key, nrows * ncols, None)

return SubplotSpec(self, num1, num2)

def subplots(self, *, sharex=False, sharey=False, squeeze=True,

subplot_kw=None):

"""

figure = self.figure

if figure is None:

raise ValueError("GridSpec.subplots() only works for GridSpecs "

"created with a parent figure")

if isinstance(sharex, bool):

sharex = "all" if sharex else "none"

if isinstance(sharey, bool):

sharey = "all" if sharey else "none"

# This check was added because it is very easy to type

# `subplots(1, 2, 1)` when `subplot(1, 2, 1)` was intended.

# In most cases, no error will ever occur, but mysterious behavior

# will result because what was intended to be the subplot index is

# instead treated as a bool for sharex.

if isinstance(sharex, Integral):

cbook._warn_external(

"sharex argument to subplots() was an integer. Did you "

"intend to use subplot() (without 's')?")

cbook._check_in_list(["all", "row", "col", "none"],

sharex=sharex, sharey=sharey)

if subplot_kw is None:

subplot_kw = {}

# don't mutate kwargs passed by user...

subplot_kw = subplot_kw.copy()

# Create array to hold all axes.

axarr = np.empty((self._nrows, self._ncols), dtype=object)

for row in range(self._nrows):

for col in range(self._ncols):

shared_with = {"none": None, "all": axarr[0, 0],

"row": axarr[row, 0], "col": axarr[0, col]}

subplot_kw["sharex"] = shared_with[sharex]

subplot_kw["sharey"] = shared_with[sharey]

axarr[row, col] = figure.add_subplot(

self[row, col], **subplot_kw)

# turn off redundant tick labeling

if sharex in ["col", "all"]:

# turn off all but the bottom row

for ax in axarr[:-1, :].flat:

ax.xaxis.set_tick_params(which='both',

labelbottom=False, labeltop=False)

ax.xaxis.offsetText.set_visible(False)

if sharey in ["row", "all"]:

# turn off all but the first column

for ax in axarr[:, 1:].flat:

ax.yaxis.set_tick_params(which='both',

labelleft=False, labelright=False)

ax.yaxis.offsetText.set_visible(False)

if squeeze:

# Discarding unneeded dimensions that equal 1. If we only have one

# subplot, just return it instead of a 1-element array.

return axarr.item() if axarr.size == 1 else axarr.squeeze()

else:

# Returned axis array will be always 2-d, even if nrows=ncols=1.

"""

def __init__(self, nrows, ncols, figure=None,

left=None, bottom=None, right=None, top=None,

wspace=None, hspace=None,

width_ratios=None, height_ratios=None):

"""

self.left = left

self.bottom = bottom

self.right = right

self.top = top

self.wspace = wspace

self.hspace = hspace

self.figure = figure

GridSpecBase.__init__(self, nrows, ncols,

width_ratios=width_ratios,

height_ratios=height_ratios)

if self.figure is None or not self.figure.get_constrained_layout():

self._layoutbox = None

else:

self.figure.init_layoutbox()

self._layoutbox = layoutbox.LayoutBox(

parent=self.figure._layoutbox,

name='gridspec' + layoutbox.seq_id(),

artist=self)

# by default the layoutbox for a gridspec will fill a figure.

# but this can change below if the gridspec is created from a

# subplotspec. (GridSpecFromSubplotSpec)

_AllowedKeys = ["left", "bottom", "right", "top", "wspace", "hspace"]

def __getstate__(self):

return {**self.__dict__, "_layoutbox": None}

def update(self, **kwargs):

"""

for k, v in kwargs.items():

if k in self._AllowedKeys:

setattr(self, k, v)

else:

raise AttributeError(f"{k} is an unknown keyword")

for figmanager in _pylab_helpers.Gcf.figs.values():

for ax in figmanager.canvas.figure.axes:

# copied from Figure.subplots_adjust

if not isinstance(ax, mpl.axes.SubplotBase):

# Check if sharing a subplots axis

if isinstance(ax._sharex, mpl.axes.SubplotBase):

if ax._sharex.get_subplotspec().get_gridspec() == self:

ax._sharex.update_params()

ax._set_position(ax._sharex.figbox)

elif isinstance(ax._sharey, mpl.axes.SubplotBase):

if ax._sharey.get_subplotspec().get_gridspec() == self:

ax._sharey.update_params()

ax._set_position(ax._sharey.figbox)

else:

ss = ax.get_subplotspec().get_topmost_subplotspec()

if ss.get_gridspec() == self:

ax.update_params()

ax._set_position(ax.figbox)

def get_subplot_params(self, figure=None):

"""

if figure is None:

kw = {k: rcParams["figure.subplot."+k] for k in self._AllowedKeys}

subplotpars = mpl.figure.SubplotParams(**kw)

else:

subplotpars = copy.copy(figure.subplotpars)

subplotpars.update(**{k: getattr(self, k) for k in self._AllowedKeys})

return subplotpars

def locally_modified_subplot_params(self):

"""

return [k for k in self._AllowedKeys if getattr(self, k)]

def tight_layout(self, figure, renderer=None,

pad=1.08, h_pad=None, w_pad=None, rect=None):

"""

subplotspec_list = tight_layout.get_subplotspec_list(

figure.axes, grid_spec=self)

if None in subplotspec_list:

cbook._warn_external("This figure includes Axes that are not "

"compatible with tight_layout, so results "

"might be incorrect.")

if renderer is None:

renderer = tight_layout.get_renderer(figure)

kwargs = tight_layout.get_tight_layout_figure(

figure, figure.axes, subplotspec_list, renderer,

pad=pad, h_pad=h_pad, w_pad=w_pad, rect=rect)

if kwargs:

"""

def __init__(self, nrows, ncols,

subplot_spec,

wspace=None, hspace=None,

height_ratios=None, width_ratios=None):

"""

self._wspace = wspace

self._hspace = hspace

self._subplot_spec = subplot_spec

self.figure = self._subplot_spec.get_gridspec().figure

GridSpecBase.__init__(self, nrows, ncols,

width_ratios=width_ratios,

height_ratios=height_ratios)

# do the layoutboxes

subspeclb = subplot_spec._layoutbox

if subspeclb is None:

self._layoutbox = None

else:

# OK, this is needed to divide the figure.

self._layoutbox = subspeclb.layout_from_subplotspec(

subplot_spec,

name=subspeclb.name + '.gridspec' + layoutbox.seq_id(),

artist=self)

def get_subplot_params(self, figure=None):

"""Return a dictionary of subplot layout parameters."""

hspace = (self._hspace if self._hspace is not None

else figure.subplotpars.hspace if figure is not None

else rcParams["figure.subplot.hspace"])

wspace = (self._wspace if self._wspace is not None

else figure.subplotpars.wspace if figure is not None

else rcParams["figure.subplot.wspace"])

figbox = self._subplot_spec.get_position(figure)

left, bottom, right, top = figbox.extents

return mpl.figure.SubplotParams(left=left, right=right,

bottom=bottom, top=top,

wspace=wspace, hspace=hspace)

def get_topmost_subplotspec(self):

"""

"""

def __init__(self, gridspec, num1, num2=None):

self._gridspec = gridspec

self.num1 = num1

self.num2 = num2

if gridspec._layoutbox is not None:

glb = gridspec._layoutbox

# So note that here we don't assign any layout yet,

# just make the layoutbox that will contain all items

# associated w/ this axis. This can include other axes like

# a colorbar or a legend.

self._layoutbox = layoutbox.LayoutBox(

parent=glb,

name=glb.name + '.ss' + layoutbox.seq_id(),

artist=self)

else:

self._layoutbox = None

def __repr__(self):

return (f"{self.get_gridspec()}["

f"{self.rowspan.start}:{self.rowspan.stop}, "

f"{self.colspan.start}:{self.colspan.stop}]")

@staticmethod

def _from_subplot_args(figure, args):

"""

if len(args) == 1:

arg, = args

if isinstance(arg, SubplotSpec):

return arg

else:

try:

s = str(int(arg))

rows, cols, num = map(int, s)

except ValueError as err:

raise ValueError("Single argument to subplot must be a "

"3-digit integer") from err

# num - 1 for converting from MATLAB to python indexing

return GridSpec(rows, cols, figure=figure)[num - 1]

elif len(args) == 3:

rows, cols, num = args

rows = int(rows)

cols = int(cols)

if rows <= 0:

raise ValueError(f"Number of rows must be > 0, not {rows}")

if cols <= 0:

raise ValueError(f"Number of columns must be > 0, not {cols}")

if isinstance(num, tuple) and len(num) == 2:

i, j = map(int, num)

return GridSpec(rows, cols, figure=figure)[i-1:j]

else:

if num < 1 or num > rows*cols:

raise ValueError(

f"num must be 1 <= num <= {rows*cols}, not {num}")

# num - 1 for converting from MATLAB to python indexing

return GridSpec(rows, cols, figure=figure)[int(num) - 1]

else:

raise TypeError(f"subplot() takes 1 or 3 positional arguments but "

f"{len(args)} were given")

# num2 is a property only to handle the case where it is None and someone

# mutates num1.

@property

def num2(self):

return self.num1 if self._num2 is None else self._num2

@num2.setter

def num2(self, value):

self._num2 = value

def __getstate__(self):

return {**self.__dict__, "_layoutbox": None}

def get_gridspec(self):

return self._gridspec

def get_geometry(self):

"""

rows, cols = self.get_gridspec().get_geometry()

return rows, cols, self.num1, self.num2

@cbook.deprecated("3.3", alternative="rowspan, colspan")

def get_rows_columns(self):

"""

gridspec = self.get_gridspec()

nrows, ncols = gridspec.get_geometry()

row_start, col_start = divmod(self.num1, ncols)

row_stop, col_stop = divmod(self.num2, ncols)

return nrows, ncols, row_start, row_stop, col_start, col_stop

@property

def rowspan(self):

"""The rows spanned by this subplot, as a `range` object."""

ncols = self.get_gridspec().ncols

return range(self.num1 // ncols, self.num2 // ncols + 1)

@property

def colspan(self):

"""The columns spanned by this subplot, as a `range` object."""

ncols = self.get_gridspec().ncols

return range(self.num1 % ncols, self.num2 % ncols + 1)

def get_position(self, figure, return_all=False):

"""

gridspec = self.get_gridspec()

nrows, ncols = gridspec.get_geometry()

rows, cols = np.unravel_index([self.num1, self.num2], (nrows, ncols))

fig_bottoms, fig_tops, fig_lefts, fig_rights = \

gridspec.get_grid_positions(figure)

fig_bottom = fig_bottoms[rows].min()

fig_top = fig_tops[rows].max()

fig_left = fig_lefts[cols].min()

fig_right = fig_rights[cols].max()

figbox = Bbox.from_extents(fig_left, fig_bottom, fig_right, fig_top)

if return_all:

return figbox, rows[0], cols[0], nrows, ncols

else:

return figbox

def get_topmost_subplotspec(self):

"""

gridspec = self.get_gridspec()

if hasattr(gridspec, "get_topmost_subplotspec"):

return gridspec.get_topmost_subplotspec()

else:

return self

def __eq__(self, other):

"""

# other may not even have the attributes we are checking.

return ((self._gridspec, self.num1, self.num2)

== (getattr(other, "_gridspec", object()),

getattr(other, "num1", object()),

getattr(other, "num2", object())))

def __hash__(self):

return hash((self._gridspec, self.num1, self.num2))

def subgridspec(self, nrows, ncols, **kwargs):

"""