
    G8cen                         d Z ddlZddlZddlmZ ddlZddlZddlm	Z	m
Z
mZ ddlmZ  ej                  e      Z G d d      Z G d d	e      Z G d
 de      Z G d d      Zy)a  
:mod:`~matplotlib.gridspec` contains classes that help to layout multiple
`~.axes.Axes` in a grid-like pattern within a figure.

The `GridSpec` specifies the overall grid structure. Individual cells within
the grid are referenced by `SubplotSpec`\s.

Often, users need not access this module directly, and can use higher-level
methods like `~.pyplot.subplots`, `~.pyplot.subplot_mosaic` and
`~.Figure.subfigures`. See the tutorial
:doc:`/tutorials/intermediate/arranging_axes` for a guide.
    N)Integral)_api_pylab_helpers_tight_layout)Bboxc                       e Zd ZdZddZd Z ed d      Z ed d	      Zd
 Z	ddZ
ddZd Zd Zd Zd Z ej"                  dd      dd       Zed        Zd ZddddddZy)GridSpecBasezm
    A base class of GridSpec that specifies the geometry of the grid
    that a subplot will be placed.
    Nc                     t        |t              r|dk  rt        d|      t        |t              r|dk  rt        d|      ||c| _        | _        | j                  |       | j                  |       y)a  
        Parameters
        ----------
        nrows, ncols : int
            The number of rows and columns of the grid.
        width_ratios : array-like of length *ncols*, optional
            Defines the relative widths of the columns. Each column gets a
            relative width of ``width_ratios[i] / sum(width_ratios)``.
            If not given, all columns will have the same width.
        height_ratios : array-like of length *nrows*, optional
            Defines the relative heights of the rows. Each row gets a
            relative height of ``height_ratios[i] / sum(height_ratios)``.
            If not given, all rows will have the same height.
        r   z/Number of rows must be a positive integer, not z2Number of columns must be a positive integer, not N)
isinstancer   
ValueError_nrows_ncolsset_height_ratiosset_width_ratios)selfnrowsncolsheight_ratioswidth_ratioss        5/usr/lib/python3/dist-packages/matplotlib/gridspec.py__init__zGridSpecBase.__init__!   s     %*eqjA%KM M%*eqjDUINP P#(% T[}-l+    c                 J   t        t        | j                              dk7  rd| j                  nd}t        t        | j                              dk7  rd| j                  nd}dj	                  | j
                  j                  | j                  | j                  ||z         S )N   z, height_ratios= z, width_ratios=z&{clsname}({nrows}, {ncols}{optionals}))clsnamer   r   	optionals)	lenset_row_height_ratios_col_width_ratiosformat	__class____name__r   r   )r   
height_arg	width_args      r   __repr__zGridSpecBase.__repr__:   s    S!8!89:a? /3.E.EGEG 	 C 6 678A= -1,B,BDCE 	7>>NN++++++ 9,	 ?  	r   c                     | j                   S N)r   r   s    r   <lambda>zGridSpecBase.<lambda>F   
    $++ r   zThe number of rows in the grid.)docc                     | j                   S r)   )r   r*   s    r   r+   zGridSpecBase.<lambda>H   r,   r   z"The number of columns in the grid.c                 2    | j                   | j                  fS )zW
        Return a tuple containing the number of rows and columns in the grid.
        )r   r   r*   s    r   get_geometryzGridSpecBase.get_geometryK   s     {{DKK''r   c                      y r)    )r   figures     r   get_subplot_paramszGridSpecBase.get_subplot_paramsQ   s    r   c                 2    |\  }}| |||z   |||z   f   }|S )a[  
        Create and return a `.SubplotSpec` instance.

        Parameters
        ----------
        loc : (int, int)
            The position of the subplot in the grid as
            ``(row_index, column_index)``.
        rowspan, colspan : int, default: 1
            The number of rows and columns the subplot should span in the grid.
        r2   )r   locrowspancolspanloc1loc2subplotspecs          r   new_subplotspeczGridSpecBase.new_subplotspecU   s4     
d4W,d4<.??@r   c                     |dg| j                   z  }|| _        yt        |      | j                   k7  rt        d      || _        y)z
        Set the relative widths of the columns.

        *width_ratios* must be of length *ncols*. Each column gets a relative
        width of ``width_ratios[i] / sum(width_ratios)``.
        Nr   zTExpected the given number of width ratios to match the number of columns of the grid)r   r   r   r!   )r   r   s     r   r   zGridSpecBase.set_width_ratiose   sT     3,L ". $++- G H H!-r   c                     | j                   S )zo
        Return the width ratios.

        This is *None* if no width ratios have been set explicitly.
        )r!   r*   s    r   get_width_ratioszGridSpecBase.get_width_ratioss   s     %%%r   c                     |dg| j                   z  }|| _        yt        |      | j                   k7  rt        d      || _        y)z
        Set the relative heights of the rows.

        *height_ratios* must be of length *nrows*. Each row gets a relative
        height of ``height_ratios[i] / sum(height_ratios)``.
        Nr   zRExpected the given number of height ratios to match the number of rows of the grid)r   r   r   r    )r   r   s     r   r   zGridSpecBase.set_height_ratios{   sT      C$++-M #0 4;;. D E E"/r   c                     | j                   S )zq
        Return the height ratios.

        This is *None* if no height ratios have been set explicitly.
        )r    r*   s    r   get_height_ratioszGridSpecBase.get_height_ratios   s     &&&r   z3.7rawFc                    | j                         \  }}|rd}d}d}d}d}	d}
nY| j                  |      }|j                  }|j                  }|j                  }|j
                  }|j                  }	|j                  }
||z
  }||z
  }|||
|dz
  z  z   z  }|
|z  }||z  t        | j                        z  }| j                  D cg c]  }||z  	 }}dg|g|dz
  z  z   }t        j                  t        j                  ||g      j                        }|||	|dz
  z  z   z  }|	|z  }||z  t        | j                        z  }| j                  D cg c]  }||z  	 }}dg|g|dz
  z  z   }t        j                  t        j                  ||g      j                        }||z
  j                  d      j                   \  }}||z   j                  d      j                   \  }}||||fS c c}w c c}w )a  
        Return the positions of the grid cells in figure coordinates.

        Parameters
        ----------
        fig : `~matplotlib.figure.Figure`
            The figure the grid should be applied to. The subplot parameters
            (margins and spacing between subplots) are taken from *fig*.
        raw : bool, default: False
            If *True*, the subplot parameters of the figure are not taken
            into account. The grid spans the range [0, 1] in both directions
            without margins and there is no space between grid cells. This is
            used for constrained_layout.

        Returns
        -------
        bottoms, tops, lefts, rights : array
            The bottom, top, left, right positions of the grid cells in
            figure coordinates.
        g        g      ?r   r   )   )r0   r4   leftrightbottomtopwspacehspacesumr    npcumsumcolumn_stackflatr!   reshapeT)r   figrC   r   r   rG   rH   rI   rJ   rK   rL   subplot_params	tot_width
tot_heightcell_hsep_hnormrcell_heightssep_heightscell_hscell_wsep_wcell_widths
sep_widthscell_wsfig_topsfig_bottoms	fig_lefts
fig_rightss                                 r   get_grid_positionszGridSpecBase.get_grid_positions   s   , ((*uDEFCFF!44S9N!&&D"((E#**F $$C#**F#**FDL	6\
 uvuQw'778~D$;$; <<*.*A*ABQDBBceWa01))BOO[,,GHMMN efeAg&667~D$:$: ;;)-)?)?@Aq4x@@SUGuQw/0
))BOOZ,EFKKL!$w 7 7 @ B B+!% 8 8 A C C	:Hi;; C As   G$G)c                 $   | j                         D ]p  }t        |d      s|j                         j                         }t        |d      r|j	                         j                         }|j                         ||fk(  sn|c S  t        |||       S )zo
        Check if the figure already has a gridspec with these dimensions,
        or create a new one
        get_subplotspecget_topmost_subplotspecr3   )get_axeshasattrrj   get_gridspecrk   r0   GridSpec)r3   r   r   axgss        r   _check_gridspec_existsz#GridSpecBase._check_gridspec_exists   s     //# 	Br,-'')668289 335BBDB??$6I	 uV44r   c                 *   | j                         \  }}d }t        |t              r4	 |\  }}t	        j
                   |||d       |||d      g||f      \  }}	n ||||z  d      \  }}	t        | ||	      S # t        $ r}t        d      |d}~ww xY w)z,Create and return a `.SubplotSpec` instance.c                     | }t        | t              r,| j                  |      \  }}}||kD  r||dz
  fS t        d      | dk  r| |z   } d| cxk  r|k  r| | fS  |t        d| d| d|       t        d| d|       )Nr   z=GridSpec slice would result in no space allocated for subplotr   zindex z is out of bounds for axis z with size z) is out of bounds for GridSpec with size )r   sliceindices
IndexError)keysizeaxisorig_keystartstop_s          r   
_normalizez,GridSpecBase.__getitem__.<locals>._normalize   s    H#u%!$T!2tQ%< $(?*  "9 : : 7*C?d?8O #%$vhZ 8--1F+dV&E F F %vhZ 8;;?&&B C Cr   zUnrecognized subplot specNr   r   )r0   r   tupler   rN   ravel_multi_indexSubplotSpec)
r   ry   r   r   r   k1k2errnum1num2s
             r   __getitem__zGridSpecBase.__getitem__   s    ((*u	C( c5!GB --Bq):b%+CD JD$ $C=JD$4t,,  G !<=3FGs   A8 8	BBBT)sharexshareysqueeze
subplot_kwc                   | j                   }|t        d      t        |t              r|rdnd}t        |t              r|rdnd}t        |t              rt        j                  d       t        j                  g d||       |i }|j                         }t        j                  | j                  | j                  ft              }t        | j                        D ]]  }t        | j                        D ]C  }d|d	   ||d
f   |d
|f   d}	|	|   |d<   |	|   |d<    |j                  | ||f   fi ||||f<   E _ |dv r#|j                   D ]  }
|
j#                  d        |dv r#|j                   D ]  }
|
j%                  d        |r/|j&                  dk(  r|j)                         S |j+                         S |S )z
        Add all subplots specified by this `GridSpec` to its parent figure.

        See `.Figure.subplots` for detailed documentation.
        NzIGridSpec.subplots() only works for GridSpecs created with a parent figureallnonez]sharex argument to subplots() was an integer.  Did you intend to use subplot() (without 's')?)r   rowcolr   )r   r   )dtype)r   r   r   )r   r   r   r   r   r   )r   r   T)check_patch)r   r   r   )r3   r   r   boolr   r   warn_externalcheck_in_listcopyrN   emptyr   r   objectrangeadd_subplotrQ   _label_outer_xaxis_label_outer_yaxisrz   itemr   )r   r   r   r   r   r3   axarrr   r   shared_withrq   s              r   subplotszGridSpecBase.subplots	  s    > < = = fd#$U&Ffd#$U&F fh'9: 	8"(	9J__&
 $++t{{36B% 	2CT[[) 2'+E$K&+CFmE!S&MK'26':
8$'26':
8$"4&"4"4cN#2&0#2c3h2	2 ^#jj 8%%$%78^#jj 8%%$%78  $)::?5::<GG Lr   )NNr)   )r   r   )F)r$   
__module____qualname____doc__r   r'   propertyr   r   r0   r4   r<   r   r?   r   rB   r   delete_parameterrh   staticmethodrs   r   r   r2   r   r   r	   r	      s    
,2
 -:<E-=?E( .&0' T5%(;< );<z 5 5(#-J "'ud <r   r	   c                   T     e Zd ZdZ	 	 	 	 d fd	Zg dZd Zd	dZd Z	 	 d
dZ	 xZ
S )rp   a  
    A grid layout to place subplots within a figure.

    The location of the grid cells is determined in a similar way to
    `~.figure.SubplotParams` using *left*, *right*, *top*, *bottom*, *wspace*
    and *hspace*.

    Indexing a GridSpec instance returns a `.SubplotSpec`.
    c                     || _         || _        || _        || _        || _        |	| _        || _        t        | !  |||
|       y)a  
        Parameters
        ----------
        nrows, ncols : int
            The number of rows and columns of the grid.

        figure : `.Figure`, optional
            Only used for constrained layout to create a proper layoutgrid.

        left, right, top, bottom : float, optional
            Extent of the subplots as a fraction of figure width or height.
            Left cannot be larger than right, and bottom cannot be larger than
            top. If not given, the values will be inferred from a figure or
            rcParams at draw time. See also `GridSpec.get_subplot_params`.

        wspace : float, optional
            The amount of width reserved for space between subplots,
            expressed as a fraction of the average axis width.
            If not given, the values will be inferred from a figure or
            rcParams when necessary. See also `GridSpec.get_subplot_params`.

        hspace : float, optional
            The amount of height reserved for space between subplots,
            expressed as a fraction of the average axis height.
            If not given, the values will be inferred from a figure or
            rcParams when necessary. See also `GridSpec.get_subplot_params`.

        width_ratios : array-like of length *ncols*, optional
            Defines the relative widths of the columns. Each column gets a
            relative width of ``width_ratios[i] / sum(width_ratios)``.
            If not given, all columns will have the same width.

        height_ratios : array-like of length *nrows*, optional
            Defines the relative heights of the rows. Each row gets a
            relative height of ``height_ratios[i] / sum(height_ratios)``.
            If not given, all rows will have the same height.

        r   r   N)	rG   rI   rH   rJ   rK   rL   r3   superr   )r   r   r   r3   rG   rI   rH   rJ   rK   rL   r   r   r#   s               r   r   zGridSpec.__init__R  sS    T 	
&2'4 	 	6r   )rG   rI   rH   rJ   rK   rL   c                 H   |j                         D ].  \  }}|| j                  v rt        | ||       "t        | d       t        j
                  j                  j                         D ]  }|j                  j                  j                  D ]  }t        |t        j                  j                        s(|j                         j                         }|j!                         | k(  sZ|j#                  |j                         j%                  |j                                 y)a  
        Update the subplot parameters of the grid.

        Parameters that are not explicitly given are not changed. Setting a
        parameter to *None* resets it to :rc:`figure.subplot.*`.

        Parameters
        ----------
        left, right, top, bottom : float or None, optional
            Extent of the subplots as a fraction of figure width or height.
        wspace, hspace : float, optional
            Spacing between the subplots as a fraction of the average subplot
            width / height.
        z is an unknown keywordN)items_AllowedKeyssetattrAttributeErrorr   Gcffigsvaluescanvasr3   axesr   mplSubplotBaserj   rk   ro   _set_positionget_position)r   kwargskv
figmanagerrq   sss          r   updatezGridSpec.update  s     LLN 	CDAqD%%%a#$s*@%ABB		C
 ),,1188: 	JJ ''..33 Jb#(("6"67++-EEGB(D0((..0==biiHJ	J	Jr   c                 b   |N| j                   D ci c]  }|t        j                  d|z       }}t        j                  j                  di |}nt        j
                  |j                        } |j                  di | j                   D ci c]  }|t        | |       c} |S c c}w c c}w )z
        Return the `.SubplotParams` for the GridSpec.

        In order of precedence the values are taken from

        - non-*None* attributes of the GridSpec
        - the provided *figure*
        - :rc:`figure.subplot.*`
        zfigure.subplot.r2   )	r   r   rcParamsr3   SubplotParamsr   subplotparsr   getattr)r   r3   r   kwr   s        r   r4   zGridSpec.get_subplot_params  s     >,,. S\\"3A"566 .B .**228R8K))F$6$67KN4;L;LMaaq!11MN. Ns   B'B,c                 Z    | j                   D cg c]  }t        | |      s| c}S c c}w )z
        Return a list of the names of the subplot parameters explicitly set
        in the GridSpec.

        This is a subset of the attributes of `.SubplotParams`.
        )r   r   )r   r   s     r   locally_modified_subplot_paramsz(GridSpec.locally_modified_subplot_params  s'      ,,Aaa0@AAAs   ((c           
          ||j                         }t        j                  ||j                  t        j                  |j                  |       |||||      }|r | j
                  di | yy)a  
        Adjust subplot parameters to give specified padding.

        Parameters
        ----------
        pad : float
            Padding between the figure edge and the edges of subplots, as a
            fraction of the font-size.
        h_pad, w_pad : float, optional
            Padding (height/width) between edges of adjacent subplots.
            Defaults to *pad*.
        rect : tuple (left, bottom, right, top), default: None
            (left, bottom, right, top) rectangle in normalized figure
            coordinates that the whole subplots area (including labels) will
            fit into. Default (None) is the whole figure.
        N)	grid_spec)padh_padw_padrectr2   )_get_rendererr   get_tight_layout_figurer   get_subplotspec_listr   )r   r3   rendererr   r   r   r   r   s           r   tight_layoutzGridSpec.tight_layout  sl    $ ++-H66FKK..v{{dK#U%dD DKK!&! r   )	NNNNNNNNNr)   )NgHzG?NNN)r$   r   r   r   r   r   r   r4   r   r   __classcell__r#   s   @r   rp   rp   H  sB     -19=%)2646l JLJ8*B -1<@"r   rp   c                   6     e Zd ZdZ	 	 d fd	ZddZd Z xZS )GridSpecFromSubplotSpeczx
    GridSpec whose subplot layout parameters are inherited from the
    location specified by a given SubplotSpec.
    c                     || _         || _        || _        | j                  j                         j                  | _        t
        |   ||||       y)ak  
        Parameters
        ----------
        nrows, ncols : int
            Number of rows and number of columns of the grid.
        subplot_spec : SubplotSpec
            Spec from which the layout parameters are inherited.
        wspace, hspace : float, optional
            See `GridSpec` for more details. If not specified default values
            (from the figure or rcParams) are used.
        height_ratios : array-like of length *nrows*, optional
            See `GridSpecBase` for details.
        width_ratios : array-like of length *ncols*, optional
            See `GridSpecBase` for details.
        r   N)_wspace_hspace_subplot_specro   r3   r   r   )	r   r   r   subplot_specrK   rL   r   r   r#   s	           r   r   z GridSpecFromSubplotSpec.__init__  sS    & )((557>>&2'4 	 	6r   c                    | j                   | j                   n*||j                  j                  nt        j                  d   }| j
                  | j
                  n*||j                  j                  nt        j                  d   }| j                  j                  |      }|j                  \  }}}}t        j                  j                  ||||||      S )z1Return a dictionary of subplot layout parameters.zfigure.subplot.hspacezfigure.subplot.wspace)rG   rH   rI   rJ   rK   rL   )r   r   rL   r   r   r   rK   r   r   extentsr3   r   )	r   r3   rL   rK   figboxrG   rI   rH   rJ   s	            r   r4   z*GridSpecFromSubplotSpec.get_subplot_params   s    "&,,":$,,4:4Fv))00||$;< 	 #',,":$,,4:4Fv))00||$;< 	 ##008#)>> feSzz''T/53/5f ( F 	Fr   c                 6    | j                   j                         S )zY
        Return the topmost `.SubplotSpec` instance associated with the subplot.
        )r   rk   r*   s    r   rk   z/GridSpecFromSubplotSpec.get_topmost_subplotspec  s     !!99;;r   )NNNNr)   )r$   r   r   r   r   r4   rk   r   r   s   @r   r   r     s      &*2666F <r   r   c                       e Zd ZdZddZd Zed        Zed        Z	e	j                  d        Z	d Zd	 Zed
        Zed        Zd Zd Zd Zd Zd Zd Zd Zd Zd Zy)r   a]  
    The location of a subplot in a `GridSpec`.

    .. note::

        Likely, you will never instantiate a `SubplotSpec` yourself. Instead,
        you will typically obtain one from a `GridSpec` using item-access.

    Parameters
    ----------
    gridspec : `~matplotlib.gridspec.GridSpec`
        The GridSpec, which the subplot is referencing.
    num1, num2 : int
        The subplot will occupy the *num1*-th cell of the given
        *gridspec*.  If *num2* is provided, the subplot will span between
        *num1*-th cell and *num2*-th cell **inclusive**.

        The index starts from 0.
    Nc                 .    || _         || _        || _        y r)   )	_gridspecr   r   )r   gridspecr   r   s       r   r   zSubplotSpec.__init__+  s    !		r   c           
          | j                          d| j                  j                   d| j                  j                   d| j                  j                   d| j                  j                   d
S )N[:z, ])ro   r7   r}   r~   r8   r*   s    r   r'   zSubplotSpec.__repr__0  sc    $$&'q<<%%&a(9(9':"<<%%&a(9(9':!= 	>r   c                    t        |      dk(  rS|\  }t        |t              r|S t        |t              st	        d|      	 t        t        t        |            \  }}}n-t        |      dk(  r|\  }}}nt        dt        |       d      t        j                  | ||      }|t        |||       }t        |t              r4t        |      dk(  r&t        d	 |D              st	        d
|       |\  }}n5t        |t              r|dk  s|||z  kD  rt	        d||z   d|      |x}}||dz
  | S # t        $ r t	        d|      dw xY w)z
        Construct a `.SubplotSpec` from a parent `.Figure` and either

        - a `.SubplotSpec` -- returned as is;
        - one or three numbers -- a MATLAB-style subplot specifier.
        r   z>Single argument to subplot must be a three-digit integer, not N   z0subplot() takes 1 or 3 positional arguments but z were givenrl   rF   c              3   <   K   | ]  }t        |t                y wr)   )r   r   ).0ns     r   	<genexpr>z1SubplotSpec._from_subplot_args.<locals>.<genexpr>U  s     <1z!X.<s   z3Subplot specifier tuple must contain integers, not znum must be 1 <= num <= z, not )r   r   r   r   r   mapintstr	TypeErrorrp   rs   r   r   )	r3   argsargrowscolsnumrr   ijs	            r   _from_subplot_argszSubplotSpec._from_subplot_args5  s    t9>DC#{+
X. $$'7,- -7"%c3s8"4dC
 Y!^"OD$N"4yk6 7 7 ,,VT4@:$V4Bc5!c#h!m<<< I#O  DAqc8,a3d? .tDykwGI IKA!A#ay1  7 $$'7,-2677s   D7 7Ec                 J    | j                   | j                  S | j                   S r)   )_num2r   r*   s    r   r   zSubplotSpec.num2d  s     JJ.tyy>DJJ>r   c                     || _         y r)   )r   )r   values     r   r   zSubplotSpec.num2h  s	    
r   c                     | j                   S r)   )r   r*   s    r   ro   zSubplotSpec.get_gridspecl  s    ~~r   c                 x    | j                         j                         \  }}||| j                  | j                  fS )a  
        Return the subplot geometry as tuple ``(n_rows, n_cols, start, stop)``.

        The indices *start* and *stop* define the range of the subplot within
        the `GridSpec`. *stop* is inclusive (i.e. for a single cell
        ``start == stop``).
        )ro   r0   r   r   )r   r   r   s      r   r0   zSubplotSpec.get_geometryo  s6     &&(557
dT499dii//r   c                     | j                         j                  }t        | j                  |z  | j                  |z  dz         S )z6The rows spanned by this subplot, as a `range` object.r   )ro   r   r   r   r   )r   r   s     r   r7   zSubplotSpec.rowspanz  s<     !!#))TYY%'e);a)?@@r   c                     | j                         j                  }t        | j                  |z  | j                  |z  g      \  }}t        ||dz         S )z9The columns spanned by this subplot, as a `range` object.r   )ro   r   sortedr   r   r   )r   r   c1c2s       r   r8   zSubplotSpec.colspan  sP     !!#)) U*DII,=>?BRa  r   c                 4    | j                   j                  dk(  S Nr   )r7   r}   r*   s    r   is_first_rowzSubplotSpec.is_first_row      ||!!Q&&r   c                 d    | j                   j                  | j                         j                  k(  S r)   )r7   r~   ro   r   r*   s    r   is_last_rowzSubplotSpec.is_last_row  &    ||  D$5$5$7$=$===r   c                 4    | j                   j                  dk(  S r  )r8   r}   r*   s    r   is_first_colzSubplotSpec.is_first_col  r	  r   c                 d    | j                   j                  | j                         j                  k(  S r)   )r8   r~   ro   r   r*   s    r   is_last_colzSubplotSpec.is_last_col  r  r   c                    | j                         }|j                         \  }}t        j                  | j                  | j
                  g||f      \  }}|j                  |      \  }}}	}
||   j                         }||   j                         }|	|   j                         }|
|   j                         }t        j                  ||||      S )zJ
        Update the subplot position from ``figure.subplotpars``.
        )ro   r0   rN   unravel_indexr   r   rh   minmaxr   from_extents)r   r3   r   r   r   r   r   re   rd   rf   rg   
fig_bottomfig_topfig_left	fig_rights                  r   r   zSubplotSpec.get_position  s     $$&,,.u%%tyy$))&<uenM
d''/ 	5Xy* !&**,
4.$$&T?&&(t$((*	  :y'JJr   c                 ^    | j                         }t        |d      r|j                         S | S )zX
        Return the topmost `SubplotSpec` instance associated with the subplot.
        rk   )ro   rn   rk   )r   r   s     r   rk   z#SubplotSpec.get_topmost_subplotspec  s1     $$&8673355Kr   c           	          | j                   | j                  | j                  ft        |dt	                     t        |dt	                     t        |dt	                     fk(  S )z}
        Two SubplotSpecs are considered equal if they refer to the same
        position(s) in the same `GridSpec`.
        r   r   r   )r   r   r   r   r   )r   others     r   __eq__zSubplotSpec.__eq__  sS     DII6E;9E6684E668466 	7r   c                 Z    t        | j                  | j                  | j                  f      S r)   )hashr   r   r   r*   s    r   __hash__zSubplotSpec.__hash__  s     T^^TYY		:;;r   c                     t        ||| fi |S )a  
        Create a GridSpec within this subplot.

        The created `.GridSpecFromSubplotSpec` will have this `SubplotSpec` as
        a parent.

        Parameters
        ----------
        nrows : int
            Number of rows in grid.

        ncols : int
            Number of columns in grid.

        Returns
        -------
        `.GridSpecFromSubplotSpec`

        Other Parameters
        ----------------
        **kwargs
            All other parameters are passed to `.GridSpecFromSubplotSpec`.

        See Also
        --------
        matplotlib.pyplot.subplots

        Examples
        --------
        Adding three subplots in the space occupied by a single subplot::

            fig = plt.figure()
            gs0 = fig.add_gridspec(3, 1)
            ax1 = fig.add_subplot(gs0[0])
            ax2 = fig.add_subplot(gs0[1])
            gssub = gs0[2].subgridspec(1, 3)
            for i in range(3):
                fig.add_subplot(gssub[0, i])
        )r   )r   r   r   r   s       r   subgridspeczSubplotSpec.subgridspec  s    P 'ueTDVDDr   r)   )r$   r   r   r   r   r'   r   r   r   r   setterro   r0   r7   r8   r  r  r  r  r   rk   r  r   r"  r2   r   r   r   r     s    &
>
 ) )\ ? ? 
[[ 	0 A A
 ! !'>'>K 	7<(Er   r   )r   r   loggingnumbersr   numpyrN   
matplotlibr   r   r   r   matplotlib.transformsr   	getLoggerr$   _logr	   rp   r   r   r2   r   r   <module>r+     sm         : : &w"j jZ	U"| U"p4<l 4<nNE NEr   