| Server IP : 35.80.110.71 / Your IP : 216.73.216.221 Web Server : Apache/2.4.58 (Ubuntu) System : Linux ip-172-31-21-44 6.17.0-1019-aws #19~24.04.1-Ubuntu SMP Tue Jun 23 18:53:06 UTC 2026 x86_64 User : ubuntu ( 1000) PHP Version : 8.3.31 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /lib/python3/dist-packages/matplotlib/__pycache__/ |
Upload File : |
�
G8�c�) � � � d Z ddlmZ ddlZddlmZ ddlmZm Z G d� d� Z
G d� d e
� Z G d
� d e
� Z G d � d
e
� Z
y)a1
Classes to layout elements in a `.Figure`.
Figures have a ``layout_engine`` property that holds a subclass of
`~.LayoutEngine` defined here (or *None* for no layout). At draw time
``figure.get_layout_engine().execute()`` is called, the goal of which is
usually to rearrange Axes on the figure to produce a pleasing layout. This is
like a ``draw`` callback but with two differences. First, when printing we
disable the layout engine for the final draw. Second, it is useful to know the
layout engine while the figure is being created. In particular, colorbars are
made differently with different layout engines (for historical reasons).
Matplotlib supplies two layout engines, `.TightLayoutEngine` and
`.ConstrainedLayoutEngine`. Third parties can create their own layout engine
by subclassing `.LayoutEngine`.
� )� nullcontextN)�do_constrained_layout)�get_subplotspec_list�get_tight_layout_figurec �\ � � e Zd ZdZdZdZ� fd�Zd� Zed� � Z ed� � Z
d� Z d� Z � xZ
S ) � LayoutEnginea�
Base class for Matplotlib layout engines.
A layout engine can be passed to a figure at instantiation or at any time
with `~.figure.Figure.set_layout_engine`. Once attached to a figure, the
layout engine ``execute`` function is called at draw time by
`~.figure.Figure.draw`, providing a special draw-time hook.
.. note::
However, note that layout engines affect the creation of colorbars, so
`~.figure.Figure.set_layout_engine` should be called before any
colorbars are created.
Currently, there are two properties of `LayoutEngine` classes that are
consulted while manipulating the figure:
- ``engine.colorbar_gridspec`` tells `.Figure.colorbar` whether to make the
axes using the gridspec method (see `.colorbar.make_axes_gridspec`) or
not (see `.colorbar.make_axes`);
- ``engine.adjust_compatible`` stops `.Figure.subplots_adjust` from being
run if it is not compatible with the layout engine.
To implement a custom `LayoutEngine`:
1. override ``_adjust_compatible`` and ``_colorbar_gridspec``
2. override `LayoutEngine.set` to update *self._params*
3. override `LayoutEngine.execute` with your implementation
Nc �2 �� t �| � di |�� i | _ y �N� )�super�__init__�_params)�self�kwargs� __class__s ��:/usr/lib/python3/dist-packages/matplotlib/layout_engine.pyr
zLayoutEngine.__init__> s �� �
���"�6�"��� � c � � t ��N��NotImplementedError)r r s r �setzLayoutEngine.setB s � �!�!r c �> � | j �t �| j S )zc
Return a boolean if the layout engine creates colorbars using a
gridspec.
)�_colorbar_gridspecr �r s r �colorbar_gridspecz LayoutEngine.colorbar_gridspecE �" � � � "� "� *�%� %��&�&�&r c �> � | j �t �| j S )zn
Return a boolean if the layout engine is compatible with
`~.Figure.subplots_adjust`.
)�_adjust_compatibler r s r �adjust_compatiblez LayoutEngine.adjust_compatibleO r r c �, � t | j � S )zF
Return copy of the parameters for the layout engine.
)�dictr r s r �getzLayoutEngine.getY s � � �D�L�L�!�!r c � � t �)zB
Execute the layout on the figure given by *fig*.
r �r �figs r �executezLayoutEngine.execute_ s
� �
"�!r )�__name__�
__module__� __qualname__�__doc__r r r
r �propertyr r r# r' �
__classcell__�r s @r r r sR �� � �> �� ���"� �'� �'� �'� �'�"� "r r c �( � � e Zd ZdZ� fd�Zd� Z� xZS )�PlaceHolderLayoutEnginea�
This layout engine does not adjust the figure layout at all.
The purpose of this `.LayoutEngine` is to act as a placeholder when the
user removes a layout engine to ensure an incompatible `.LayoutEngine` can
not be set later.
Parameters
----------
adjust_compatible, colorbar_gridspec : bool
Allow the PlaceHolderLayoutEngine to mirror the behavior of whatever
layout engine it is replacing.
c �@ �� || _ || _ t �| � di |�� y r
)r r r r
)r r r r r s �r r
z PlaceHolderLayoutEngine.__init__v s# �� �"3�� �"3�� �
���"�6�"r c � � y r r r% s r r' z PlaceHolderLayoutEngine.execute{ s � �r )r( r) r* r+ r
r' r- r. s @r r0 r0 g s �� �
� #�
r r0 c �N � � e Zd ZdZdZdZddddd�� fd�
Zd� Zddddd �d
�Z� xZ S ) �TightLayoutEnginez�
Implements the ``tight_layout`` geometry management. See
:doc:`/tutorials/intermediate/tight_layout_guide` for details.
TgH�z�G�?N�r r � r6 ��pad�h_pad�w_pad�rectc �z �� t �| � di |�� dD ] }d| j |< � | j ||||�� y)a'
Initialize tight_layout engine.
Parameters
----------
pad : float, 1.08
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*.
rect : tuple (left, bottom, right, top), default: (0, 0, 1, 1).
rectangle in normalized figure coordinates that the subplots
(including labels) will fit into.
r7 Nr )r r
r r )r r8 r9 r: r; r �tdr s �r r
zTightLayoutEngine.__init__� sH �� �" ���"�6�"�3� $�B� #�D�L�L�� � $�
���S��U���>r c �4 � | j }|j � } t |dt � � 5 t ||j
t
|j
� ||d |d |d |d �� }ddd� r |j di |�� yy# 1 sw Y � xY w) ad
Execute tight_layout.
This decides the subplot parameters given the padding that
will allow the axes labels to not be covered by other labels
and axes.
Parameters
----------
fig : `.Figure` to perform layout on.
See also: `.figure.Figure.tight_layout` and `.pyplot.tight_layout`.
�_draw_disabledr8 r9 r: r; r7 Nr )r �
_get_renderer�getattrr r �axesr �subplots_adjust)r r& �info�rendererr s r r' zTightLayoutEngine.execute� s� � � �|�|���$�$�&��
=�W�X� /��
=�
?� #�,��S�X�X� 3�C�H�H� =�x���K�t�G�}�D��M��&�\�#�F� #�
� �C� � � )�&� )� � #� #�s �=B�B)r8 r: r9 r; c � � | j j D ]* }t � | ��t � | | j |< �, y r �r �__kwdefaults__�localsr )r r8 r: r9 r; r= s r r zTightLayoutEngine.set� s; � ��(�(�)�)� 0�B��x��|�'�#)�8�B�<�� � �R� � 0r �
r( r) r* r+ r r r
r' r r- r. s @r r4 r4 s? �� �� �� �� "�$�d�"�?�.*�0 �T��D� 0� 0r r4 c �T � � e Zd ZdZdZdZddddddd�� fd�
Zd� Zdddddd�d �Z� xZ S )
�ConstrainedLayoutEnginez�
Implements the ``constrained_layout`` geometry management. See
:doc:`/tutorials/intermediate/constrainedlayout_guide` for details.
FNr5 )r9 r: �hspace�wspacer; �compressc � �� t �| � di |�� | j t j d t j d t j d t j d d�� | j |||||�� || _ y) a�
Initialize ``constrained_layout`` settings.
Parameters
----------
h_pad, w_pad : float
Padding around the axes elements in figure-normalized units.
Default to :rc:`figure.constrained_layout.h_pad` and
:rc:`figure.constrained_layout.w_pad`.
hspace, wspace : float
Fraction of the figure to dedicate to space between the
axes. These are evenly spread between the gaps between the axes.
A value of 0.2 for a three-column layout would have a space
of 0.1 of the figure width between each column.
If h/wspace < h/w_pad, then the pads are used instead.
Default to :rc:`figure.constrained_layout.hspace` and
:rc:`figure.constrained_layout.wspace`.
rect : tuple of 4 floats
Rectangle in figure coordinates to perform constrained layout in
(left, bottom, width, height), each from 0-1.
compress : bool
Whether to shift Axes so that white space in between them is
removed. This is useful for simple grids of fixed-aspect Axes (e.g.
a grid of images). See :ref:`compressed_layout`.
z figure.constrained_layout.w_padz figure.constrained_layout.h_padz figure.constrained_layout.wspacez figure.constrained_layout.hspacer5 )r: r9 rN rM r; Nr )r r
r �mpl�rcParams� _compress) r r9 r: rM rN r; rO r r s �r r
z ConstrainedLayoutEngine.__init__� s� �� �8 ���"�6�"� ���s�|�|�$E�F��|�|�$E�F�� � �%G�H�� � �%G�H�"� � $�
���u�E�&��� � �!��r c � � |j � \ }}| j d |z }| j d |z }t |||| j d | j d | j d | j �� S )z�
Perform constrained_layout and move and resize axes accordingly.
Parameters
----------
fig : `.Figure` to perform layout on.
r: r9 rN rM r; )r: r9 rN rM r; rO )�get_size_inchesr r rS )r r& �width�heightr: r9 s r r' z ConstrainedLayoutEngine.execute� sz � � �+�+�-�
��v�� � �W�%��-��� � �W�%��.��$�S��U�,0�L�L��,B�,0�L�L��,B�*.�,�,�v�*>�.2�n�n� >� >r )r9 r: rM rN r; c � � | j j D ]* }t � | ��t � | | j |< �, y)a�
Set the pads for constrained_layout.
Parameters
----------
h_pad, w_pad : float
Padding around the axes elements in figure-normalized units.
Default to :rc:`figure.constrained_layout.h_pad` and
:rc:`figure.constrained_layout.w_pad`.
hspace, wspace : float
Fraction of the figure to dedicate to space between the
axes. These are evenly spread between the gaps between the axes.
A value of 0.2 for a three-column layout would have a space
of 0.1 of the figure width between each column.
If h/wspace < h/w_pad, then the pads are used instead.
Default to :rc:`figure.constrained_layout.hspace` and
:rc:`figure.constrained_layout.wspace`.
rect : tuple of 4 floats
Rectangle in figure coordinates to perform constrained layout in
(left, bottom, width, height), each from 0-1.
NrG )r r9 r: rM rN r; r= s r r zConstrainedLayoutEngine.set s= � �. �(�(�)�)� 0�B��x��|�'�#)�8�B�<�� � �R� � 0r rJ r. s @r rL rL � sH �� ��
�� �� $�D� �T� � �&"�P>�& �t���4�0� 0r rL )r+ �
contextlibr �
matplotlibrQ � matplotlib._constrained_layoutr �matplotlib._tight_layoutr r r r0 r4 rL r r r �<module>r] sN ���" #� � @�?�I"� I"�X�l� �0:0� � :0�z]0�l� ]0r