a
    DBìjd ã                   @  s`  U d Z ddlmZ ddlmZmZmZmZ ddlm	Z	 ddl
mZ ddlmZ ddlmZ ddlmZ dd	lZdd	lZdd
lmZ ddlmZmZmZmZmZ dd	lZddlmZm Z  ddl!m"Z" ddl#m$Z$ ddl%m&Z&m'Z'm(Z( ddl)m*Z* ddl+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1 ddl2m3Z3m4Z4m5Z5 ddl6m7Z7m8Z8 ddl9m:Z:m;Z;m<Z<m=Z= ddl>m?Z? ddl@mAZA dd	lBmC  mDZE ddlFmGZGmHZHmIZImJZJ ddlKmLZL ddlMmNZN ddlOmPZP ddlQmRZRmSZS ddlTmUZU e�rddlVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZb ddlcmdZdmeZe dZfd egd!< d"Zhd#Zid egd$< G d%d&„ d&ƒZjd'd(œd)d*„Zkd'd(œd+d,„ZlG d-d.„ d.ƒZmG d/d0„ d0ƒZnd–d1d2d3d3d4œd5d6„Zoe	d—d2d3d7d8œd9d:„ƒZpd˜d?d@dAd1dBdCd1d1dDdBd@dEdFœdGdH„ZqG dIdJ„ dJƒZrG dKdL„ dLerƒZsG dMdN„ dNerƒZtG dOdP„ dPerƒZuG dQdR„ dRerƒZvdSdEdTœdUdV„ZwdSdWdXœdYdZ„Zxd™d\d1d1d]œd^d_„Zydšd\d1d3d1d`œdadb„Zzd›dcd1d3dddeœdfdg„Z{G dhdi„ dieuƒZ|G djdk„ dkerƒZ}dœdmdndcdddoœdpdq„Z~d�dEd1dBdrdEdsœdtdu„Zdžd?d1dEdvœdwdx„Z€d1d1dyœdzd{„Z�dŸd|d1dEd}œd~d„Z‚d€dcd�œd‚dƒ„ZƒG d„d…„ d…ƒZ„d dWdcd‡dˆœd‰dŠ„Z…d¡dŒd�dŽd�œd�d‘„Z†d’dEd‡d“œd”d•„Z‡d	S )¢z€
Internal module for formatting output data in csv, html, xml,
and latex files. This module also applies to display formatting.
é    )Úannotations)Ú	GeneratorÚHashableÚMappingÚSequence)Úcontextmanager)Ú
QUOTE_NONE)ÚDecimal)Úpartial)ÚStringION)Úget_terminal_size)ÚTYPE_CHECKINGÚAnyÚCallableÚFinalÚcast)Ú
get_optionÚ
set_option)Úlib)ÚNA)ÚNaTÚ	TimedeltaÚ	Timestamp)ÚNaTType)Úis_complex_dtypeÚis_floatÚ
is_integerÚis_list_likeÚis_numeric_dtypeÚ	is_scalar)ÚCategoricalDtypeÚDatetimeTZDtypeÚExtensionDtype)ÚisnaÚnotna)ÚCategoricalÚDatetimeArrayÚExtensionArrayÚTimedeltaArray)ÚStringDtype)ÚPandasObject)ÚIndexÚ
MultiIndexÚPeriodIndexÚensure_index)ÚDatetimeIndex)ÚTimedeltaIndex)Úconcat)Úcheck_parent_directoryÚstringify_path)Úprinting)Ú	ArrayLikeÚAxesÚColspaceArgTypeÚColspaceTypeÚCompressionOptionsÚFilePathÚFloatFormatTypeÚFormattersTypeÚ
IndexLabelÚSequenceNotStrÚStorageOptionsÚWriteBuffer)Ú	DataFrameÚSeriesaŽ	  
        Parameters
        ----------
        buf : str, Path or StringIO-like, optional, default None
            Buffer to write to. If None, the output is returned as a string.
        columns : array-like, optional, default None
            The subset of columns to write. Writes all columns by default.
        col_space : %(col_space_type)s, optional
            %(col_space)s.
        header : %(header_type)s, optional
            %(header)s.
        index : bool, optional, default True
            Whether to print index (row) labels.
        na_rep : str, optional, default 'NaN'
            String representation of ``NaN`` to use.
        formatters : list, tuple or dict of one-param. functions, optional
            Formatter functions to apply to columns' elements by position or
            name.
            The result of each function must be a unicode string.
            List/tuple must be of length equal to the number of columns.
        float_format : one-parameter function, optional, default None
            Formatter function to apply to columns' elements if they are
            floats. This function must return a unicode string and will be
            applied only to the non-``NaN`` elements, with ``NaN`` being
            handled by ``na_rep``.
        sparsify : bool, optional, default True
            Set to False for a DataFrame with a hierarchical index to print
            every multiindex key at each row.
        index_names : bool, optional, default True
            Prints the names of the indexes.
        justify : str, default None
            How to justify the column labels. If None uses the option from
            the print configuration (controlled by set_option), 'right' out
            of the box. Valid values are

            * left
            * right
            * center
            * justify
            * justify-all
            * start
            * end
            * inherit
            * match-parent
            * initial
            * unset.
        max_rows : int, optional
            Maximum number of rows to display in the console.
        max_cols : int, optional
            Maximum number of columns to display in the console.
        show_dimensions : bool, default False
            Display DataFrame dimensions (number of rows by number of columns).
        decimal : str, default '.'
            Character recognized as decimal separator, e.g. ',' in Europe.
    r   Úcommon_docstring)ÚleftÚrightÚcenterÚjustifyzjustify-allÚstartÚendÚinheritzmatch-parentÚinitialZunsetz™
        Returns
        -------
        str or None
            If buf is None, returns the result as a string. Otherwise returns
            None.
    Úreturn_docstringc                   @  s€   e Zd ZdZddddddddddœ	ddd	d	d
d	dd	ddddœdd„Zddœdd„Zd
dœdd„Zddœdd„Zd
dœdd„ZdS )ÚSeriesFormatterz\
    Implement the main logic of Series.to_string, which underlies
    Series.__repr__.
    TÚNaNFN)	ÚlengthÚheaderÚindexÚna_repÚnameÚfloat_formatÚdtypeÚmax_rowsÚmin_rowsrB   ú
bool | strÚboolÚstrú
str | Noneú
int | NoneÚNone)ÚseriesrO   rP   rQ   rR   rS   rT   rU   rV   rW   Úreturnc       	         C  sj   || _ tƒ | _|| _|| _|| _|| _|| _|	| _|
| _	|d u rHt
dƒ}|| _|| _t ¡ | _|  ¡  d S )Núdisplay.float_format)r^   r   ÚbufrS   rR   rP   rO   rQ   rV   rW   r   rT   rU   r4   Úget_adjustmentÚadjÚ_chk_truncate)Úselfr^   rO   rP   rQ   rR   rS   rT   rU   rV   rW   © rf   úW/mnt/bigstor/www/usecases/.venv/lib/python3.9/site-packages/pandas/io/formats/format.pyÚ__init__Ã   s    
zSeriesFormatter.__init__©r_   c                 C  s¨   |  | j }| j}|o t| jƒ|k}| j}|r’tt|ƒ}|rDt||ƒ}|dkr`|}|jd |… }n*|d }t|jd |… |j| d … fƒ}|| _	nd | _	|| _
|| _d S )Né   é   )rW   rV   Úlenr^   r   ÚintÚminÚilocr1   Ú
tr_row_numÚ	tr_seriesÚis_truncated_vertically)re   rW   rV   rr   r^   Úrow_numrf   rf   rg   rd   ã   s$    

"zSeriesFormatter._chk_truncatec                 C  s4  | j j}d}| j j}t|tttfƒr>|jd ur>|d|j› �7 }| jdurx|d urx|r\|d7 }t	j
|dd�}|d|› �7 }| jdu s’| jd	kr²| jr²|rž|d7 }|d
t| j ƒ› �7 }| jdurú| jd urút| jjdd ƒ}|rú|ræ|d7 }|dt	 
|¡› �7 }t| jjtƒ�r,| jj ¡ }|�r$|d7 }||7 }t|ƒS )NÚ zFreq: Fz, ©ú	úÚ
)Úescape_charszName: TÚtruncatezLength: rS   zdtype: rx   )r^   rS   rQ   Ú
isinstancer/   r-   r0   ÚfreqZfreqstrr4   Úpprint_thingrO   rr   rl   rU   Úgetattrrq   r    Ú_valuesZ_get_repr_footerrZ   )re   rS   ÚfooterrQ   Zseries_nameZ
dtype_nameZ
level_inforf   rf   rg   Ú_get_footerþ   sB    ÿþ
ÿÿzSeriesFormatter._get_footerú	list[str]c                 C  s   t | jjd | j| j| jd�S )N)rT   rR   Úleading_space)Úformat_arrayrq   r   rT   rR   rQ   ©re   rf   rf   rg   Ú_get_formatted_values(  s    ûz%SeriesFormatter._get_formatted_valuesc                 C  s~  | j }|  ¡ }t|ƒdkr2t| jƒj› d|› d�S |j}t|ƒ}t|t	ƒrz|j
dd d�}t ¡ }|jdg|¢R Ž  d¡}n|jdd�}|  ¡ }| j�rd}| j}	tt|	ƒ}	| j ||	d	  ¡}
|
d
krÌd}nd}| jj|g|
dd�d }| |	| |¡ | |	d	 d¡ | j�r2| jjd
g|d	d … |g¢R Ž }n| j d
|¡}| j�r^|�r^|d d | }|�rp|d| 7 }td |¡ƒS )Nr   z([], ú)T)Úinclude_namesÚsparsifyrk   rx   ©Úinclude_namerj   é   ú...z..rF   ©Úmodert   )rq   r�   rl   Útyper^   Ú__name__rQ   Ú
_has_namesr{   r,   Ú_format_multir4   rb   ÚadjoinÚsplitÚ_format_flatr†   rr   rp   r   rm   rc   rG   ÚinsertrP   rZ   Újoin)re   r^   r€   rQ   Zhave_headerÚ	fmt_indexrc   Ú
fmt_valuesZn_header_rowsrs   ÚwidthZdot_strÚresultrf   rf   rg   Ú	to_string1  s>    

"zSeriesFormatter.to_string)	r‘   Ú
__module__Ú__qualname__Ú__doc__rh   rd   r�   r†   r�   rf   rf   rf   rg   rM   ½   s   	ô& *	rM   zdict[str, Any]ri   c                  C  sL   ddl m}  tdƒr"|  ¡ \}}nd}tdƒtdƒtdƒtdƒtd	ƒ|d
œS )aõ  Get the parameters used to repr(dataFrame) calls using DataFrame.to_string.

    Supplying these parameters to DataFrame.to_string is equivalent to calling
    ``repr(DataFrame)``. This is useful if you want to adjust the repr output.

    .. versionadded:: 1.4.0

    Example
    -------
    >>> import pandas as pd
    >>>
    >>> df = pd.DataFrame([[1, 2], [3, 4]])
    >>> repr_params = pd.io.formats.format.get_dataframe_repr_params()
    >>> repr(df) == df.to_string(**repr_params)
    True
    r   )Úconsolezdisplay.expand_frame_reprNúdisplay.max_rowsúdisplay.min_rowszdisplay.max_columnsúdisplay.max_colwidthúdisplay.show_dimensions)rV   rW   Úmax_colsZmax_colwidthÚshow_dimensionsÚ
line_width)Úpandas.io.formatsr¡   r   Zget_console_size)r¡   r¨   Ú_rf   rf   rg   Úget_dataframe_repr_params_  s    úr«   c                  C  sJ   t ƒ \} }tdƒ}|dkr|n|}|dkr.|ntdƒ}dd||tdƒdœS )aé  Get the parameters used to repr(Series) calls using Series.to_string.

    Supplying these parameters to Series.to_string is equivalent to calling
    ``repr(series)``. This is useful if you want to adjust the series repr output.

    .. versionadded:: 1.4.0

    Example
    -------
    >>> import pandas as pd
    >>>
    >>> ser = pd.Series([1, 2, 3, 4])
    >>> repr_params = pd.io.formats.format.get_series_repr_params()
    >>> repr(ser) == ser.to_string(**repr_params)
    True
    r¢   r   r£   Tr¥   )rS   rU   rW   rV   rO   )r   r   )r›   ÚheightZmax_rows_optrV   rW   rf   rf   rg   Úget_series_repr_params€  s    
ûr­   c                   @  sX  e Zd ZdZerendZeee 7 Zdjdd	d
dddddddddddddddddœdd„Zddœdd„Zeddœdd„ƒZ	eddœdd„ƒZ
eddœd d!„ƒZeddœd"d#„ƒZeddœd$d%„ƒZeddœd&d'„ƒZeddœd(d)„ƒZeddœd*d+„ƒZeddœd,d-„ƒZed.dœd/d0„ƒZddd1œd2d3„Zdd4d5œd6d7„Zddd8œd9d:„Zd	d;d<œd=d>„Zd
d?d@œdAdB„ZddœdCdD„ZddœdEdF„ZdddGœdHdI„ZddœdJdK„ZddœdLdM„ZddœdNdO„Zd.dœdPdQ„ZddœdRdS„ZddœdTdU„Z ddœdVdW„Z!ddœdXdY„Z"d.dZd[œd\d]„Z#d^d_d[œd`da„Z$dddbœdcdd„Z%ddZdbœdedf„Z&dgdœdhdi„Z'dS )kÚDataFrameFormatterz‡
    Class for processing dataframe formatting options and data.

    Used by DataFrame.to_string, which backs DataFrame.__repr__.
    rt   NTrN   FÚ.rA   zAxes | NonezColspaceArgType | Nonezbool | SequenceNotStr[str]rY   rZ   zFormattersType | Noner[   úFloatFormatType | Noneúbool | Noner\   rX   r]   )ÚframeÚcolumnsÚ	col_spacerP   rQ   rR   Ú
formattersrG   rT   r‰   Úindex_namesrV   rW   r¦   r§   ÚdecimalÚ	bold_rowsÚescaper_   c                 C  s¼   || _ |  |¡| _|  |¡| _|| _|| _|| _|  |¡| _	|  
|¡| _|	| _|  |
¡| _|| _|| _|| _|| _|| _|| _|| _|| _|  ¡ | _|  ¡ | _| j | _|  ¡  t ¡ | _d S ©N) r²   Ú_initialize_columnsr³   Ú_initialize_colspacer´   rP   rQ   rR   Ú_initialize_formattersrµ   Ú_initialize_justifyrG   rT   Ú_initialize_sparsifyr‰   Úshow_index_namesr·   r¸   r¹   rV   rW   r¦   r§   Ú_calc_max_cols_fittedÚmax_cols_fittedÚ_calc_max_rows_fittedÚmax_rows_fittedÚtr_framerz   r4   rb   rc   )re   r²   r³   r´   rP   rQ   rR   rµ   rG   rT   r‰   r¶   rV   rW   r¦   r§   r·   r¸   r¹   rf   rf   rg   rh   ©  s.    

zDataFrameFormatter.__init__zlist[list[str]]ri   c                 C  s*   |   ¡ }| jr&|  | j¡}| d|¡ |S )zP
        Render a DataFrame to a list of columns (as lists of strings).
        r   )Ú_get_strcols_without_indexrQ   Ú_get_formatted_indexrÅ   r—   )re   ÚstrcolsZ	str_indexrf   rf   rg   Úget_strcolsØ  s
    zDataFrameFormatter.get_strcolsc                 C  s   | j du p| j dko| jS )NTrz   )r§   Úis_truncatedr…   rf   rf   rg   Úshould_show_dimensionsä  s    
ÿz)DataFrameFormatter.should_show_dimensionsc                 C  s   t | jp| jƒS rº   )rY   Úis_truncated_horizontallyrr   r…   rf   rf   rg   rÊ   ê  s    zDataFrameFormatter.is_truncatedc                 C  s   t | jot| jƒ| jkƒS rº   )rY   rÂ   rl   r³   r…   rf   rf   rg   rÌ   î  s    z,DataFrameFormatter.is_truncated_horizontallyc                 C  s   t | jot| jƒ| jkƒS rº   )rY   rÄ   rl   r²   r…   rf   rf   rg   rr   ò  s    z*DataFrameFormatter.is_truncated_verticallyc                 C  s    dt | jƒ› dt | jjƒ› d�S )Nz

[z rows x z	 columns])rl   r²   r³   r…   rf   rf   rg   Údimensions_infoö  s    z"DataFrameFormatter.dimensions_infoc                 C  s   t | jjƒS rº   )r’   r²   rQ   r…   rf   rf   rg   Úhas_index_namesú  s    z"DataFrameFormatter.has_index_namesc                 C  s   t | jjƒS rº   )r’   r²   r³   r…   rf   rf   rg   Úhas_column_namesþ  s    z#DataFrameFormatter.has_column_namesc                 C  s   t | j| j| jfƒS rº   )ÚallrÎ   rQ   rÀ   r…   rf   rf   rg   Úshow_row_idx_names  s    z%DataFrameFormatter.show_row_idx_namesc                 C  s   t | j| j| jfƒS rº   )rÐ   rÏ   rÀ   rP   r…   rf   rf   rg   Úshow_col_idx_names  s    z%DataFrameFormatter.show_col_idx_namesrm   c                 C  s   t | jpt| jƒt| jƒƒS rº   )rn   rV   rl   r²   r…   rf   rf   rg   Úmax_rows_displayed
  s    z%DataFrameFormatter.max_rows_displayed)r‰   r_   c                 C  s   |d u rt dƒS |S )Nzdisplay.multi_sparse©r   )re   r‰   rf   rf   rg   r¿     s    z'DataFrameFormatter._initialize_sparsifyr<   )rµ   r_   c                 C  sT   |d u ri S t | jjƒt |ƒks*t|tƒr.|S tdt |ƒ› dt | jjƒ› d�ƒ‚d S )NzFormatters length(ú+) should match DataFrame number of columns(r‡   )rl   r²   r³   r{   ÚdictÚ
ValueError)re   rµ   rf   rf   rg   r½     s    
ÿÿz)DataFrameFormatter._initialize_formatters)rG   r_   c                 C  s   |d u rt dƒS |S d S )Nzdisplay.colheader_justifyrÔ   )re   rG   rf   rf   rg   r¾      s    z&DataFrameFormatter._initialize_justifyr+   )r³   r_   c                 C  s,   |d ur t |ƒ}| j| | _|S | jjS d S rº   )r.   r²   r³   )re   r³   Úcolsrf   rf   rg   r»   &  s
    z&DataFrameFormatter._initialize_columnsr8   )r´   r_   c                   sÎ   ˆ d u ri }n¼t ˆ ttfƒrBdˆ i}| ‡ fdd„| jjD ƒ¡ nˆt ˆ tƒr‚ˆ  ¡ D ]&}|| jjvrT|dkrTtd|› �ƒ‚qTˆ }nHt	| jjƒt	ˆ ƒkr¸tdt	ˆ ƒ› dt	| jjƒ› d�ƒ‚t
t| jjˆ ƒƒ}|S )Nrt   c                   s   i | ]
}|ˆ “qS rf   rf   )Ú.0Úcolumn©r´   rf   rg   Ú
<dictcomp>5  ó    z;DataFrameFormatter._initialize_colspace.<locals>.<dictcomp>z,Col_space is defined for an unknown column: zCol_space length(rÕ   r‡   )r{   rm   rZ   Úupdater²   r³   r   Úkeysr×   rl   rÖ   Úzip)re   r´   rœ   rÚ   rf   rÛ   rg   r¼   .  s(    
ÿ
ÿÿz'DataFrameFormatter._initialize_colspacec                 C  s0   |   ¡ s| jS tƒ \}}|  |¡r&|S | jS dS )z%Number of columns fitting the screen.N)Ú_is_in_terminalr¦   r   Ú_is_screen_narrow)re   r›   rª   rf   rf   rg   rÁ   F  s    

z(DataFrameFormatter._calc_max_cols_fittedc                 C  sP   |   ¡ r@tƒ \}}| jdkr(||  ¡  S |  |¡r8|}qF| j}n| j}|  |¡S )z,Number of rows with data fitting the screen.r   )rá   r   rV   Ú_get_number_of_auxiliary_rowsÚ_is_screen_shortÚ_adjust_max_rows)re   rª   r¬   rV   rf   rf   rg   rÃ   Q  s    


z(DataFrameFormatter._calc_max_rows_fitted)rV   r_   c                 C  s(   |r$t | jƒ|kr$| jr$t| j|ƒ}|S )zºAdjust max_rows using display logic.

        See description here:
        https://pandas.pydata.org/docs/dev/user_guide/options.html#frequently-used-options

        GH #37359
        )rl   r²   rW   rn   )re   rV   rf   rf   rg   rå   d  s    z#DataFrameFormatter._adjust_max_rowsc                 C  s   t | jdkp| jdkƒS )z/Check if the output is to be shown in terminal.r   )rY   r¦   rV   r…   rf   rf   rg   rá   r  s    z"DataFrameFormatter._is_in_terminalc                 C  s   t | jdkot| jjƒ|kƒS ©Nr   )rY   r¦   rl   r²   r³   )re   Ú	max_widthrf   rf   rg   râ   v  s    z$DataFrameFormatter._is_screen_narrowc                 C  s   t | jdkot| jƒ|kƒS ræ   )rY   rV   rl   r²   )re   Ú
max_heightrf   rf   rg   rä   y  s    z#DataFrameFormatter._is_screen_shortc                 C  s:   d}d}|| }| j r(|t| j ¡ ƒ7 }| jr6|d7 }|S )z?Get number of rows occupied by prompt, dots and dimension info.rj   )r§   rl   rÍ   Ú
splitlinesrP   )re   Zdot_rowZ
prompt_rowZnum_rowsrf   rf   rg   rã   |  s    z0DataFrameFormatter._get_number_of_auxiliary_rowsc                 C  s    | j r|  ¡  | jr|  ¡  dS )zY
        Check whether the frame should be truncated. If so, slice the frame up.
        N)rÌ   Ú_truncate_horizontallyrr   Ú_truncate_verticallyr…   rf   rf   rg   rz   Š  s    zDataFrameFormatter.truncatec                 C  sÊ   | j dusJ ‚| j d }|dkrš| jjdd…d|…f }| jjdd…| d…f }t||fdd�| _t| jttfƒrÀg | jd|… ¢| j| d… ¢| _n&tt	| j
ƒ}| jjdd…d|…f | _|| _dS )z´Remove columns, which are not to be displayed and adjust formatters.

        Attributes affected:
            - tr_frame
            - formatters
            - tr_col_num
        Nrk   rj   ©Zaxis)rÂ   rÅ   ro   r1   r{   rµ   ÚlistÚtupler   rm   r¦   Z
tr_col_num)re   Zcol_numrD   rE   rf   rf   rg   rê   ”  s    
ÿþz)DataFrameFormatter._truncate_horizontallyc                 C  sŠ   | j dusJ ‚| j d }|dkrZt| jƒ}t t |¡t || |¡g¡}| jj| | _n&tt| j	ƒ}| jjd|…dd…f | _|| _
dS )z‚Remove rows, which are not to be displayed.

        Attributes affected:
            - tr_frame
            - tr_row_num
        Nrk   rj   )rÄ   rl   rÅ   ÚnpZhstackZarangero   r   rm   rV   rp   )re   rs   Ú_lenZ_slicerf   rf   rg   rë   ®  s    

 z'DataFrameFormatter._truncate_verticallyc           
   	     s˜  g }t ˆ jƒsbˆ jsbtˆ jƒD ]>\}}ˆ  |¡}t|ˆ jtˆ j 	|d¡ƒˆ j
d�}| |¡ q|S t ˆ jƒrÆttt ˆ jƒˆ _tˆ jƒtˆ jƒkr´tdtˆ jƒ› dtˆ jƒ› d�ƒ‚dd„ ˆ jD ƒ}nˆ  ˆ j¡}ˆ jrì|D ]}| d¡ qÜtˆ jƒD ]œ\}}|| }ttˆ j 	|d¡ƒg‡ fd	d
„|D ƒ¢R Ž }ˆ  |¡}t|ˆ j|ˆ j
d�}tg ‡ fdd
„|D ƒ¢|‘R Ž }	ˆ j
j||	ˆ jd�}| || ¡ qö|S )Nr   )ÚstringsrG   Úminimumrc   zWriting z cols but got z aliasesc                 S  s   g | ]
}|g‘qS rf   rf   )rÙ   Úlabelrf   rf   rg   Ú
<listcomp>×  rÝ   zADataFrameFormatter._get_strcols_without_index.<locals>.<listcomp>rt   c                 3  s   | ]}ˆ j  |¡V  qd S rº   ©rc   rl   ©rÙ   Úxr…   rf   rg   Ú	<genexpr>â  rÝ   z@DataFrameFormatter._get_strcols_without_index.<locals>.<genexpr>)rò   rc   c                 3  s   | ]}ˆ j  |¡V  qd S rº   rõ   rö   r…   rf   rg   rø   é  rÝ   rŽ   )r   rP   Ú	enumeraterÅ   Ú
format_colÚ_make_fixed_widthrG   rm   r´   Úgetrc   Úappendr   rí   rZ   rl   r³   r×   Ú_get_formatted_column_labelsrÑ   Úmax)
re   rÈ   ÚiÚcrš   Ústr_columnsr÷   ZcheaderZheader_colwidthÚmax_lenrf   r…   rg   rÆ   À  sP    
ü
ÿÿÿÿ
ÿ z-DataFrameFormatter._get_strcols_without_indexr‚   )r   r_   c              	   C  sL   | j }|  |¡}t|jd d …|f j|| j| j| j |j	| ¡| j
| jd�S )N)rT   rR   Úspacer·   rƒ   )rÅ   Ú_get_formatterr„   ro   r   rT   rR   r´   rü   r³   r·   rQ   )re   r   r²   Ú	formatterrf   rf   rg   rú   ï  s    
ùzDataFrameFormatter.format_colú	str | intúCallable | Nonec                 C  s`   t | jttfƒr2t|ƒr,tt|ƒ}| j| S d S n*t|ƒrN|| jvrN| j| }| j |d ¡S d S rº   )	r{   rµ   rí   rî   r   r   rm   r³   rü   )re   r   rf   rf   rg   r  ü  s    


z!DataFrameFormatter._get_formatter)r²   r_   c                   s   ddl m} |j}t|tƒr¼|jddd�}tt|Ž ƒ}ˆjj	j
}tdd„ |jD ƒƒ‰tt|tt|ƒƒƒ‰ ‡ ‡‡fdd„‰tt‡fd	d„|D ƒŽ ƒ}ˆjr¨t|ƒr¨||ƒ}d
d„ t|Ž D ƒ}n@|jdd�}ˆjj	}tt|tt|ƒƒƒ‰ ‡ ‡fdd„t|ƒD ƒ}|S )Nr   )Úsparsify_labelsF)r‰   rˆ   c                 s  s   | ]}|j V  qd S rº   )Zis_floating)rÙ   Úlevelrf   rf   rg   rø     rÝ   zBDataFrameFormatter._get_formatted_column_labels.<locals>.<genexpr>c                   s"   |ˆj vrˆ |  rˆsd| S |S )Nú )rµ   )r÷   Úy)Úneed_leadspÚrestrict_formattingre   rf   rg   Úspace_format  s    ÿþýzEDataFrameFormatter._get_formatted_column_labels.<locals>.space_formatc                 3  s"   | ]‰ ‡‡ fd d„ˆ D ƒV  qdS )c                   s   g | ]}ˆ ˆ|ƒ‘qS rf   rf   )rÙ   r  )r  r÷   rf   rg   rô      rÝ   zMDataFrameFormatter._get_formatted_column_labels.<locals>.<genexpr>.<listcomp>Nrf   )rÙ   )r  ©r÷   rg   rø      rÝ   c                 S  s   g | ]}t |ƒ‘qS rf   )rí   rö   rf   rf   rg   rô   %  rÝ   zCDataFrameFormatter._get_formatted_column_labels.<locals>.<listcomp>rŠ   c                   s0   g | ](\}}ˆ  |¡s&ˆ | r&d | n|g‘qS )r  )r  )rÙ   r   r÷   )r  re   rf   rg   rô   *  s   ÿ)Zpandas.core.indexes.multir	  r³   r{   r,   r“   rí   rà   r²   Údtypesr   ÚanyÚlevelsrÖ   Úmapr   r‰   rl   r–   rù   )re   r²   r	  r³   Zfmt_columnsr  Zstr_columns_tupler  rf   )r  r  re   r  rg   rþ     s,    

	ÿþz/DataFrameFormatter._get_formatted_column_labelsc                   sÆ   dd„ ˆj  ¡ D ƒ‰ |j}|j}ˆ d¡}t|tƒrJ|jˆjˆj	|d�}n|j
ˆj	|d�g}‡ ‡fdd„|D ƒ}ˆjjdg|¢R Ž  d	¡}ˆjr¤d
d„ ˆ ¡ D ƒ}ndg|j }ˆjr¾|| S |S d S )Nc                 S  s   i | ]\}}|t t|ƒ“qS rf   )r   rm   )rÙ   ÚkÚvrf   rf   rg   rÜ   4  rÝ   z;DataFrameFormatter._get_formatted_index.<locals>.<dictcomp>Ú	__index__)r‰   rˆ   r  )r‹   r  c              
     s.   g | ]&}t tt|ƒd ˆ  dd¡ˆjd�ƒ‘qS )rD   rt   r   )rG   rò   rc   )rî   rû   rí   rü   rc   rö   ©r´   re   rf   rg   rô   D  s   ûÿÿz;DataFrameFormatter._get_formatted_index.<locals>.<listcomp>rj   rx   c                 S  s   g | ]}t |ƒ‘qS rf   ©rZ   rö   rf   rf   rg   rô   Q  rÝ   rt   )r´   ÚitemsrQ   r³   r  r{   r,   r“   r‰   rÑ   r–   rc   r”   r•   rÒ   Ú_get_column_name_listZnlevelsrP   )re   r²   rQ   r³   Úfmtr™   ZadjoinedZ
col_headerrf   r  rg   rÇ   1  s,    

ýÿú	z'DataFrameFormatter._get_formatted_indexzlist[Hashable]c                 C  sL   g }| j j}t|tƒr.| dd„ |jD ƒ¡ n| |jd u r@dn|j¡ |S )Nc                 s  s   | ]}|d u rdn|V  qd S )Nrt   rf   )rÙ   rS   rf   rf   rg   rø   ^  rÝ   z;DataFrameFormatter._get_column_name_list.<locals>.<genexpr>rt   )r²   r³   r{   r,   ÚextendÚnamesrý   rS   )re   r  r³   rf   rf   rg   r  Z  s    
z(DataFrameFormatter._get_column_name_list)NNTTrN   NNNNTNNNFr¯   FT)(r‘   rž   rŸ   r    rC   rL   rh   rÉ   ÚpropertyrË   rÊ   rÌ   rr   rÍ   rÎ   rÏ   rÑ   rÒ   rÓ   r¿   r½   r¾   r»   r¼   rÁ   rÃ   rå   rá   râ   rä   rã   rz   rê   rë   rÆ   rú   r  rþ   rÇ   r  rf   rf   rf   rg   r®   Ÿ  s~                    í4/
/))r®   c                   @  s„   e Zd ZdZdddœdd„Zd$d	d
dddd
dd
dœdd„Zd%d	d
dd
dœdd„Zd&dd
dddddddd
dd
dd
dd d
d!œd"d#„ZdS )'ÚDataFrameRendereraJ  Class for creating dataframe output in multiple formats.

    Called in pandas.core.generic.NDFrame:
        - to_csv
        - to_latex

    Called in pandas.core.frame.DataFrame:
        - to_html
        - to_string

    Parameters
    ----------
    fmt : DataFrameFormatter
        Formatter with the formatting options.
    r®   r]   )r  r_   c                 C  s
   || _ d S rº   )r  )re   r  rf   rf   rg   rh   u  s    zDataFrameRenderer.__init__NFú"FilePath | WriteBuffer[str] | Noner[   zstr | list | tuple | NonerY   zint | bool | None)ra   ÚencodingÚclassesÚnotebookÚborderÚtable_idÚrender_linksr_   c                 C  sF   ddl m}m}	 |r|	n|}
|
| j||||d�}| ¡ }t|||d�S )uJ  
        Render a DataFrame to a html table.

        Parameters
        ----------
        buf : str, path object, file-like object, or None, default None
            String, path object (implementing ``os.PathLike[str]``), or file-like
            object implementing a string ``write()`` function. If None, the result is
            returned as a string.
        encoding : str, default â€œutf-8â€�
            Set character encoding.
        classes : str or list-like
            classes to include in the `class` attribute of the opening
            ``<table>`` tag, in addition to the default "dataframe".
        notebook : {True, False}, optional, default False
            Whether the generated HTML is for IPython Notebook.
        border : int
            A ``border=border`` attribute is included in the opening
            ``<table>`` tag. Default ``pd.options.display.html.border``.
        table_id : str, optional
            A css id is included in the opening `<table>` tag if specified.
        render_links : bool, default False
            Convert URLs to HTML links.
        r   )ÚHTMLFormatterÚNotebookFormatter)r#  r%  r&  r'  ©ra   r"  )Zpandas.io.formats.htmlr(  r)  r  r�   Úsave_to_buffer)re   ra   r"  r#  r$  r%  r&  r'  r(  r)  ZKlassZhtml_formatterÚstringrf   rf   rg   Úto_htmlx  s    "ûzDataFrameRenderer.to_htmlr\   )ra   r"  r¨   r_   c                 C  s0   ddl m} || j|d�}| ¡ }t|||d�S )u%  
        Render a DataFrame to a console-friendly tabular output.

        Parameters
        ----------
        buf : str, path object, file-like object, or None, default None
            String, path object (implementing ``os.PathLike[str]``), or file-like
            object implementing a string ``write()`` function. If None, the result is
            returned as a string.
        encoding: str, default â€œutf-8â€�
            Set character encoding.
        line_width : int, optional
            Width to wrap a line in characters.
        r   )ÚStringFormatter)r¨   r*  )Zpandas.io.formats.stringr.  r  r�   r+  )re   ra   r"  r¨   r.  Zstring_formatterr,  rf   rf   rg   r�   «  s    zDataFrameRenderer.to_stringú,ÚwÚinferú"TÚstrictz7FilePath | WriteBuffer[bytes] | WriteBuffer[str] | NonerZ   zSequence[Hashable] | NonezIndexLabel | Noner9   zStorageOptions | None)Úpath_or_bufr"  Úsepr³   Úindex_labelr�   ÚcompressionÚquotingÚ	quotecharÚlineterminatorÚ	chunksizeÚdate_formatÚdoublequoteÚ
escapecharÚerrorsÚstorage_optionsr_   c                 C  s‚   ddl m} |du r d}tƒ }nd}|||
||||||||||	||||| jd�}| ¡  |r~t|tƒsjJ ‚| ¡ }| ¡  |S dS )z;
        Render dataframe as comma-separated file.
        r   )ÚCSVFormatterNTF)r4  r:  r5  r"  r?  r7  r8  rØ   r6  r�   r;  r9  r<  r=  r>  r@  r  )Zpandas.io.formats.csvsrA  r   r  Úsaver{   ÚgetvalueÚclose)re   r4  r"  r5  r³   r6  r�   r7  r8  r9  r:  r;  r<  r=  r>  r?  r@  rA  Zcreated_bufferZcsv_formatterÚcontentrf   rf   rg   Úto_csvÅ  s>    ïzDataFrameRenderer.to_csv)NNNFNNF)NNN)NNr/  NNr0  r1  Nr2  NNNTNr3  N)r‘   rž   rŸ   r    rh   r-  r�   rF  rf   rf   rf   rg   r   d  s>          ø5   ü                ïr   rZ   r!  r[   )r,  ra   r"  r_   c                 C  sZ   t ||d��:}| | ¡ |du r6| ¡ W  d  ƒ S W d  ƒ dS 1 sL0    Y  dS )zQ
    Perform serialization. Write to buf or return as string if buf is None.
    )r"  N)Ú_get_bufferÚwriterC  )r,  ra   r"  Úfdrf   rf   rg   r+    s
    
r+  zIGenerator[WriteBuffer[str], None, None] | Generator[StringIO, None, None])ra   r"  r_   c                 c  s¤   | durt | ƒ} ntƒ } |du r&d}nt| tƒs8tdƒ‚t| dƒrJ| V  nVt| tƒr˜tt| ƒƒ t| d|dd��}|V  W d  ƒ q 1 sŒ0    Y  ntdƒ‚dS )	z€
    Context manager to open, yield and close buffer for filenames or Path-like
    objects, otherwise yield buf unchanged.
    Nzutf-8z1buf is not a file name and encoding is specified.rH  r0  rt   )r"  Únewlinez1buf is not a file name and it has no write method)	r3   r   r{   rZ   r×   Úhasattrr2   ÚopenÚ	TypeError)ra   r"  Úfrf   rf   rg   rG    s    



&rG  rN   rE   r¯   Tr5   r  r°   r\   zstr | int | Noner±   r‚   )Úvaluesr  rT   rR   Údigitsr  rG   r·   rƒ   r8  Úfallback_formatterr_   c                 C  sè   t  | jd¡rt}tt| ƒ} nxt| jtƒr:t}tt| ƒ} n\t  | jd¡rXt	}tt
| ƒ} n>t| jtƒrjt}n,t  | jd¡r~t}nt  | jd¡r’t}nt}|du r¢d}|du r²tdƒ}|du rÂtdƒ}|| |||||||||	|
d	�}| ¡ S )
a™  
    Format an array for printing.

    Parameters
    ----------
    values : np.ndarray or ExtensionArray
    formatter
    float_format
    na_rep
    digits
    space
    justify
    decimal
    leading_space : bool, optional, default True
        Whether the array should be formatted with a leading space.
        When an array as a column of a Series or DataFrame, we do want
        the leading space to pad between columns.

        When formatting an Index subclass
        (e.g. IntervalIndex._get_values_for_csv), we don't want the
        leading space since it should be left-aligned.
    fallback_formatter

    Returns
    -------
    List[str]
    ÚMÚmÚfcÚiuNé   r`   údisplay.precision)
rP  rR   rT   r  r  rG   r·   rƒ   r8  rQ  )r   Zis_np_dtyperU   Ú_Datetime64Formatterr   r&   r{   r!   Ú_Datetime64TZFormatterÚ_Timedelta64Formatterr(   r"   Ú_ExtensionArrayFormatterÚFloatArrayFormatterÚ_IntArrayFormatterÚ_GenericArrayFormatterr   Ú
get_result)rO  r  rT   rR   rP  r  rG   r·   rƒ   r8  rQ  Z	fmt_klassZfmt_objrf   rf   rg   r„   7  sH    )õr„   c                   @  sP   e Zd Zddd	d
ddddddddd
ddœdd„Zddœdd„Zddœdd„ZdS )r^  é   NrN   rV  rE   r¯   Tr5   rm   r  rZ   r  r°   r\   rY   r±   r]   )rO  rP  r  rR   r  rT   rG   r·   r8  Úfixed_widthrƒ   rQ  r_   c                 C  sL   || _ || _|| _|| _|| _|| _|| _|| _|	| _|
| _	|| _
|| _d S rº   )rO  rP  rR   r  r  rT   rG   r·   r8  ra  rƒ   rQ  )re   rO  rP  r  rR   r  rT   rG   r·   r8  ra  rƒ   rQ  rf   rf   rg   rh   �  s    z_GenericArrayFormatter.__init__r‚   ri   c                 C  s   |   ¡ }t|| jƒS rº   )Ú_format_stringsrû   rG   )re   rš   rf   rf   rg   r_  ©  s    z!_GenericArrayFormatter.get_resultc                   s~  ˆj d u r0tdƒ}|d u r6tdƒ‰‡fdd„}nˆj }ˆjd urHˆj‰ n6ˆjd urZˆj‰ n$ˆjd uolˆjtk}ttjd|d�‰ ‡ ‡fdd„}ˆj	}t
|tjƒs¦td	ƒ‚t |t¡}|tjt|ƒttd
t|jƒƒƒd�@ }ˆj}|d u rî| ¡ }g }t|ƒD ]~\}	}
||	 �rˆjd u�r4|�r4| d||
ƒ› �¡ qú||	 �rN| ||
ƒ¡ qú|du �r^d}nd}| |j||
ƒd�¡ qú|S )Nr`   rW  c                   s   t | dˆ d›d�›ƒS )Nz .ÚdrN  )Ú_trim_zeros_single_floatr  )Ú	precisionrf   rg   Ú<lambda>²  s   ÿz8_GenericArrayFormatter._format_strings.<locals>.<lambda>ru   )ry   Úquote_stringsc                   s´   ˆj d urvt| ƒrvt| ƒrv| d u r&dS | tu r6ttƒS t | ¡rRt | ¡rRt| ƒS | t	u slt
| tjtjfƒrpdS ˆj S t
| tƒrˆt| ƒS t
| tƒr¤| jtu r¤t| ƒS tˆ | ƒƒS d S )Nr]   r   )rR   r   r#   r   rZ   r   r   rï   Úisinfr   r{   Z
datetime64Ztimedelta64r*   r)   Zna_valueÚreprr  )r  re   rf   rg   Ú_formatÄ  s    
z7_GenericArrayFormatter._format_strings.<locals>._formatz=ExtensionArray formatting should use _ExtensionArrayFormatterrj   rì   r  Fz{v}z {v}©r  )rT   r   r  rQ  r8  r   r
   r4   r}   rO  r{   rï   ZndarrayrM  r   Z	map_inferr   rÐ   r$   rî   Úrangerl   Úshaperƒ   r  rù   rý   Úformat)re   rT   rg  rj  ÚvalsÚinferredZis_float_typerƒ   rš   r   r  Ztplrf   )r  re  re   rg   rb  ­  sR    


ýÿ þÿ

z&_GenericArrayFormatter._format_strings)r`  NrN   rV  NrE   r¯   NTTN)r‘   rž   rŸ   rh   r_  rb  rf   rf   rf   rg   r^  Œ  s              ó(r^  c                      sR   e Zd Zddœ‡ fdd„Zddddd	œd
d„Zddœdd„Zddœdd„Z‡  ZS )r\  r]   ri   c                   sH   t ƒ j|i |¤Ž | jd urD| jd u rDd| _t| jƒrD| j| _d | _d S )NF)Úsuperrh   rT   r  ra  Úcallable)re   ÚargsÚkwargs©Ú	__class__rf   rg   rh   û  s    
zFloatArrayFormatter.__init__Nr°   zfloat | Noner   )rT   Ú	thresholdr_   c                   sl   ˆdu rˆj ‰ˆr"‡‡fdd„‰ n‡fdd„‰ ˆjdkrH‡ ‡fdd„‰nˆ ‰ˆdu rXˆS ‡‡‡fdd	„}|S )
z;Returns a function to be applied on each value to format itNc                   s$   ˆ d usJ ‚t | ƒrˆ | d�S ˆjS )N©Úvalue)r$   rR   rk  )rT   re   rf   rg   Úbase_formatter  s
    ÿýz<FloatArrayFormatter._value_formatter.<locals>.base_formatterc                   s   t | ƒrt| ƒS ˆ jS rº   )r$   rZ   rR   rk  r…   rf   rg   rz  &  s    r¯   c                   s   ˆ | ƒ  dˆjd¡S )Nr¯   rj   )Úreplacer·   rk  )rz  re   rf   rg   Údecimal_formatter+  s    z?FloatArrayFormatter._value_formatter.<locals>.decimal_formatterc                   s0   t | ƒr&t| ƒˆkrˆ | ƒS ˆ dƒS nˆjS d S )Ng        )r$   ÚabsrR   rx  )r|  re   rw  rf   rg   r  4  s
    
z7FloatArrayFormatter._value_formatter.<locals>.formatter)rT   r·   )re   rT   rw  r  rf   )rz  r|  rT   re   rw  rg   Ú_value_formatter  s    
	z$FloatArrayFormatter._value_formatterz
np.ndarrayc           
        sl  ddddœdd„‰ddddœdd„‰ ˆj d	ur@ˆˆjˆj ˆjƒS ˆjrPtd
ƒ‰nd	‰‡ ‡‡‡fdd„}ˆjd	u r¤ˆjrœˆjdu r†d}nd}t|jˆj	d�}q°ˆj}n‡fdd„}||ƒ}ˆjsÂ|S t
|ƒdkrðtdd„ |D ƒƒ}|ˆj	d k}nd}t ˆj¡}|dk ¡ }|dˆj	  k |dk@  ¡ }	|	�s:|�rh|�rhˆjdu �rLd}nd}t|jˆj	d�}||ƒ}|S )zˆ
        Returns the float values converted into strings using
        the parameters given at initialisation, as a numpy array
        r5   r   rZ   )rO  r  rR   c                   s<   t | ƒ}t ‡ ‡fdd„t|  ¡ | ¡ ƒD ƒ¡ | j¡}|S )Nc                   s    g | ]\}}|sˆ |ƒnˆ‘qS rf   rf   )rÙ   ÚvalrS  ©r  rR   rf   rg   rô   H  s   ÿzWFloatArrayFormatter.get_result_as_array.<locals>.format_with_na_rep.<locals>.<listcomp>)r#   rï   Úarrayrà   ÚravelÚreshaperm  )rO  r  rR   ÚmaskÚ	formattedrf   r€  rg   Úformat_with_na_repE  s    þÿûzCFloatArrayFormatter.get_result_as_array.<locals>.format_with_na_repc                 S  sþ   t  | ¡ ¡ }t  | ¡ ¡ }t|ƒt|ƒ }}g }t|  ¡ ||||ƒD ]¤\}}	}
}}|sl|sl| ||ƒ¡ qF|sŒ| ||	ƒ› d|› d�¡ qF|sÔ||
ƒ ¡ }| d¡r¼| |› |› d�¡ qê| |› d|› d�¡ qF| |› d|› d�¡ qFt  	|¡ 
| j¡S )Nú+Újú-)rï   Úrealr‚  Úimagr#   rà   rý   ÚstripÚ
startswithr�  rƒ  rm  )rO  r  rR   Zreal_valuesZimag_valuesZ	real_maskZ	imag_maskZformatted_lstr  Zreal_valZimag_valZre_isnaZim_isnaZimag_formattedrf   rf   rg   Úformat_complex_with_na_repO  s,    û
zKFloatArrayFormatter.get_result_as_array.<locals>.format_complex_with_na_repNzdisplay.chop_thresholdc                   sˆ   ˆ  | ˆ¡}ˆjdkr dˆj nˆj}ˆj}t|ƒ}|rFˆ |||ƒ}nˆ|||ƒ}ˆjr„|rjt|ˆjƒ}nt|ˆjƒ}t	j
|dd�S |S )NrD   r  Úobject©rU   )r~  rG   rR   rO  r   ra  Ú_trim_zeros_complexr·   Ú_trim_zeros_floatrï   Úasarray)rT   r  rR   rO  Z
is_complexrœ   ©rŽ  r†  re   rw  rf   rg   Úformat_values_withu  s    zCFloatArrayFormatter.get_result_as_array.<locals>.format_values_withTz{value: .{digits:d}f}z{value:.{digits:d}f})rP  c                   s
   ˆ j |  S rº   )rT   rx  r…   rf   rg   rf  �  rÝ   z9FloatArrayFormatter.get_result_as_array.<locals>.<lambda>r   c                 s  s   | ]}t |ƒV  qd S rº   ©rl   rö   rf   rf   rg   rø   ©  rÝ   z:FloatArrayFormatter.get_result_as_array.<locals>.<genexpr>é   Fg    €„.Aé
   z{value: .{digits:d}e}z{value:.{digits:d}e})r  rO  rR   ra  r   rT   rƒ   r
   rn  rP  rl   rÿ   rï   r}  r  )
re   r•  Zfmt_strrT   Zformatted_valuesÚmaxlenZtoo_longZabs_valsZhas_large_valuesZhas_small_valuesrf   r”  rg   Úget_result_as_array?  sB    




z'FloatArrayFormatter.get_result_as_arrayr‚   c                 C  s   t |  ¡ ƒS rº   )rí   rš  r…   rf   rf   rg   rb  ¿  s    z#FloatArrayFormatter._format_strings)NN)r‘   rž   rŸ   rh   r~  rš  rb  Ú__classcell__rf   rf   ru  rg   r\  ú  s     ý8 r\  c                   @  s   e Zd Zddœdd„ZdS )r]  r‚   ri   c                   s>   | j du rdd„ }ndd„ }| jp$|‰ ‡ fdd„| jD ƒ}|S )NFc                 S  s   | d›j | d�S )Nrc  r  ©rn  r  rf   rf   rg   rf  Æ  rÝ   z4_IntArrayFormatter._format_strings.<locals>.<lambda>c                 S  s   | d›j | d�S )Nz dr  rœ  r  rf   rf   rg   rf  È  rÝ   c                   s   g | ]}ˆ |ƒ‘qS rf   rf   rö   ©r  rf   rg   rô   Ê  rÝ   z6_IntArrayFormatter._format_strings.<locals>.<listcomp>)rƒ   r  rO  )re   Zformatter_strrš   rf   r�  rg   rb  Ä  s    


z"_IntArrayFormatter._format_stringsN)r‘   rž   rŸ   rb  rf   rf   rf   rg   r]  Ã  s   r]  c                      sB   e Zd ZU ded< ddddddœ‡ fdd	„Zd
dœdd„Z‡  ZS )rX  r&   rO  r   NrZ   r]   )rO  Únat_repr<  r_   c                   s$   t ƒ j|fi |¤Ž || _|| _d S rº   )rq  rh   rž  r<  )re   rO  rž  r<  rt  ru  rf   rg   rh   Ñ  s    z_Datetime64Formatter.__init__r‚   ri   c                   s<   ˆ j }ˆ jdur"‡ fdd„|D ƒS |jˆ jˆ jd�}| ¡ S )z&we by definition have DO NOT have a TZNc                   s   g | ]}ˆ   |¡‘qS rf   r�  rö   r…   rf   rg   rô   á  rÝ   z8_Datetime64Formatter._format_strings.<locals>.<listcomp>)rR   r<  )rO  r  Z_format_native_typesrž  r<  Útolist)re   rO  rš   rf   r…   rg   rb  Ü  s    
ÿz$_Datetime64Formatter._format_strings)r   N©r‘   rž   rŸ   Ú__annotations__rh   rb  r›  rf   rf   ru  rg   rX  Î  s
   
  ürX  c                   @  s$   e Zd ZU ded< ddœdd„ZdS )r[  r'   rO  r‚   ri   c                 C  sx   | j }| j}d }|d u r$|jdd�}t|tƒr8| ¡ }ntj|td�}t	||| j
| j| j| j| j| j| j| j|d�}|S )NT)Zboxedr�  )	rT   rR   rP  r  rG   r·   rƒ   r8  rQ  )rO  r  Ú
_formatterr{   r%   Z_internal_get_valuesrï   r“  r�  r„   rT   rR   rP  r  rG   r·   rƒ   r8  )re   rO  r  rQ  r�  rš   rf   rf   rg   rb  ì  s,    

õz(_ExtensionArrayFormatter._format_stringsN©r‘   rž   rŸ   r¡  rb  rf   rf   rf   rg   r[  é  s   
r[  znp.ndarray | Sequence[float])Úpercentilesr_   c                 C  sê   t  | ¡} t| ƒr.t  | dk¡r.t  | dk¡s6tdƒ‚d|  } t| ƒ}|  |¡ t¡}t  	|| ¡}t  |¡r„| t
¡}dd„ |D ƒS t  | ¡}t|ƒ}t j| td�}| |  ¡  t¡ t
¡||< | |   |¡ t
¡|| < dd„ |D ƒS )	a  
    Outputs rounded and formatted percentiles.

    Parameters
    ----------
    percentiles : list-like, containing floats from interval [0,1]

    Returns
    -------
    formatted : list of strings

    Notes
    -----
    Rounding precision is chosen so that: (1) if any two elements of
    ``percentiles`` differ, they remain different after rounding
    (2) no entry is *rounded* to 0% or 100%.
    Any non-integer is always rounded to at least 1 decimal place.

    Examples
    --------
    Keeps all entries different after rounding:

    >>> format_percentiles([0.01999, 0.02001, 0.5, 0.666666, 0.9999])
    ['1.999%', '2.001%', '50%', '66.667%', '99.99%']

    No element is rounded to 0% or 100% (unless already equal to it).
    Duplicates are allowed:

    >>> format_percentiles([0, 0.5, 0.02001, 0.5, 0.666666, 0.9999])
    ['0%', '50%', '2.0%', '50%', '66.67%', '99.99%']
    r   rj   z/percentiles should all be in the interval [0,1]éd   c                 S  s   g | ]}|d  ‘qS ©ú%rf   ©rÙ   r   rf   rf   rg   rô   >  rÝ   z&format_percentiles.<locals>.<listcomp>r�  c                 S  s   g | ]}|d  ‘qS r¦  rf   r¨  rf   rf   rg   rô   F  rÝ   )rï   r“  r   rÐ   r×   Úget_precisionÚroundÚastyperm   ÚiscloserZ   ÚuniqueZ
empty_liker�  )r¤  ÚprecZpercentiles_round_typeZint_idxÚoutZunique_pctsrf   rf   rg   Úformat_percentiles
  s*    "
ÿþý


r°  rm   )r�  r_   c                 C  sx   | d dkr| d nd }| d dk r0d| d  nd }t j| ||d�}t|ƒ}t  t  t  |¡¡¡ t¡ }td|ƒ}|S )Nr   éÿÿÿÿr¥  )Úto_beginÚto_endrj   )	rï   Zediff1dr}  ÚfloorÚlog10rn   r«  rm   rÿ   )r�  r²  r³  Údiffr®  rf   rf   rg   r©  I  s    
r©  r   zNaTType | Timestamp)r÷   rž  r_   c                 C  s   | t u r|S t| ƒS rº   )r   rZ   )r÷   rž  rf   rf   rg   Ú_format_datetime64S  s    r·  )r÷   rž  r<  r_   c                 C  s&   t | tƒr|S |r|  |¡S | jS d S rº   )r{   r   ÚstrftimeZ
_date_repr)r÷   rž  r<  rf   rf   rg   Ú_format_datetime64_dateonly\  s
    

r¹  rY   r   )Úis_dates_onlyrž  r<  r_   c                   s"   | r‡ ‡fdd„S ‡fdd„S dS )z]Return a formatter callable taking a datetime64 as input and providing
    a string as outputc                   s   t | ˆˆ d�S )N)rž  r<  )r¹  r  ©r<  rž  rf   rg   rf  r  s   ÿz'get_format_datetime64.<locals>.<lambda>c                   s   t | ˆ d�S )N©rž  )r·  r  r¼  rf   rg   rf  v  rÝ   Nrf   )rº  rž  r<  rf   r»  rg   Úget_format_datetime64k  s    r½  c                   @  s$   e Zd ZU ded< ddœdd„ZdS )rY  r&   rO  r‚   ri   c                   s>   | j j}| j  t¡}| jp&t|| jd�‰ ‡ fdd„|D ƒ}|S )zwe by definition have a TZ)r<  c                   s   g | ]}ˆ |ƒ‘qS rf   rf   rö   r�  rf   rg   rô   ƒ  rÝ   z:_Datetime64TZFormatter._format_strings.<locals>.<listcomp>)rO  Ú_is_dates_onlyr«  r�  r  r½  r<  )re   ZidorO  rš   rf   r�  rg   rb  |  s    ÿz&_Datetime64TZFormatter._format_stringsNr£  rf   rf   rf   rg   rY  y  s   
rY  c                      s@   e Zd ZU ded< dddddœ‡ fdd„Zd	d
œdd„Z‡  ZS )rZ  r(   rO  r   rZ   r]   )rO  rž  r_   c                   s   t ƒ j|fi |¤Ž || _d S rº   )rq  rh   rž  )re   rO  rž  rt  ru  rf   rg   rh   ‹  s    z_Timedelta64Formatter.__init__r‚   ri   c                   s,   | j pt| j| jdd�‰ ‡ fdd„| jD ƒS )NF)rž  Úboxc                   s   g | ]}ˆ |ƒ‘qS rf   rf   rö   r�  rf   rg   rô   ™  rÝ   z9_Timedelta64Formatter._format_strings.<locals>.<listcomp>)r  Úget_format_timedelta64rO  rž  r…   rf   r�  rg   rb  •  s    
ÿz%_Timedelta64Formatter._format_strings)r   r   rf   rf   ru  rg   rZ  ˆ  s   
 ý
rZ  Fr(   zstr | float)rO  rž  r¿  r_   c                   s(   | j }|rd‰nd‰‡ ‡‡fdd„}|S )z�
    Return a formatter function for a range of timedeltas.
    These will all have the same format argument

    If box, then show the return in quotes
    NÚlongc                   sN   | d u st | ƒrt| ƒrˆS t| tƒs.t| ƒ} | jˆd�}ˆ rJd|› d�}|S )Nrœ  ú')r   r#   r{   r   Z
_repr_base)r÷   rœ   ©r¿  rn  rž  rf   rg   r¢  ®  s    
z*get_format_timedelta64.<locals>._formatter)r¾  )rO  rž  r¿  Z	even_daysr¢  rf   rÃ  rg   rÀ  œ  s    rÀ  zprinting._TextAdjustment | None)rñ   rG   rò   rc   r_   c                   s°   t | ƒdks|dkr| S |d u r*t ¡ ‰ n|‰ t‡ fdd„| D ƒƒ‰|d urVt|ˆƒ‰tdƒ‰ˆd urrˆˆkrrˆ‰dddœ‡ ‡‡fdd	„‰‡fd
d„| D ƒ} ˆ j| ˆ|d�}|S )Nr   rÐ   c                 3  s   | ]}ˆ   |¡V  qd S rº   r–  rö   )Ú
adjustmentrf   rg   rø   Ì  rÝ   z$_make_fixed_width.<locals>.<genexpr>r¤   rZ   )r÷   r_   c                   s6   ˆd ur2ˆdkˆ   | ¡ˆk@ r2| d ˆd … d } | S )NrŒ   r�   r–  r  )rÄ  Úconf_maxr  rf   rg   ÚjustÕ  s    z_make_fixed_width.<locals>.justc                   s   g | ]}ˆ |ƒ‘qS rf   rf   rö   )rÆ  rf   rg   rô   Û  rÝ   z%_make_fixed_width.<locals>.<listcomp>rŽ   )rl   r4   rb   rÿ   r   rG   )rñ   rG   rò   rc   rœ   rf   )rÄ  rÅ  rÆ  r  rg   rû   ¾  s    

rû   )Ústr_complexesr·   r_   c           	        s¸   g g  }}| D ]@}t  d|¡}| d |dd… ¡¡ | d |dd… ¡¡ qt| ƒ}t|| |ƒ}t|ƒdkrvg S tdd„ |D ƒƒd	 ‰ ‡ fd
d„t|d|… ||d… ƒD ƒ}|S )z‰
    Separates the real and imaginary parts from the complex number, and
    executes the _trim_zeros_float method on each of those.
    z([j+-])rt   Néüÿÿÿéþÿÿÿr   c                 s  s   | ]}t |ƒV  qd S rº   r–  )rÙ   Úpartrf   rf   rg   rø   ö  rÝ   z&_trim_zeros_complex.<locals>.<genexpr>rj   c                   s6   g | ].\}}||d   |dd… dˆ › �› d ‘qS )r   rj   Nú>rˆ  rf   )rÙ   Zreal_ptZimag_pt©Zpadded_lengthrf   rg   rô   ÷  s   üÿþýz'_trim_zeros_complex.<locals>.<listcomp>)Úrer•   rý   r˜   rl   r’  rÿ   rà   )	rÇ  r·   Z	real_partZ	imag_partr÷   ÚtrimmedÚnZpadded_partsÚpaddedrf   rÌ  rg   r‘  à  s    

ûr‘  )Ú	str_floatr_   c                 C  s    |   d¡} |  d¡r| d7 } | S )zX
    Trims trailing zeros after a decimal point,
    leaving just one if necessary.
    Ú0r¯   )ÚrstripÚendswith)rÑ  rf   rf   rg   rd    s    

rd  úArrayLike | list[str])Ú
str_floatsr·   r_   c                   sp   | }t  dˆ › d�¡‰ddœ‡fdd„‰dddœ‡fd	d
„}||ƒrX‡fdd„|D ƒ}q<‡ ‡fdd„|D ƒ}|S )z‰
    Trims the maximum number of trailing zeros equally from
    all numbers containing decimals, leaving just one if
    necessary.
    z^\s*[\+-]?[0-9]+\z[0-9]*$rY   ri   c                   s   t  ˆ | ¡d uS rº   )rÍ  Úmatchr  )Únumber_regexrf   rg   Úis_number_with_decimal  s    z1_trim_zeros_float.<locals>.is_number_with_decimalrÕ  )rO  r_   c                   s0   ‡ fdd„| D ƒ}t |ƒdko.tdd„ |D ƒƒS )zñ
        Determine if an array of strings should be trimmed.

        Returns True if all numbers containing decimals (defined by the
        above regular expression) within the array end in a zero, otherwise
        returns False.
        c                   s   g | ]}ˆ |ƒr|‘qS rf   rf   rö   ©rÙ  rf   rg   rô   #  rÝ   z:_trim_zeros_float.<locals>.should_trim.<locals>.<listcomp>r   c                 s  s   | ]}|  d ¡V  qdS )rÒ  N©rÔ  rö   rf   rf   rg   rø   $  rÝ   z9_trim_zeros_float.<locals>.should_trim.<locals>.<genexpr>)rl   rÐ   )rO  ÚnumbersrÚ  rf   rg   Úshould_trim  s    z&_trim_zeros_float.<locals>.should_trimc                   s$   g | ]}ˆ |ƒr|d d… n|‘qS )Nr±  rf   rö   rÚ  rf   rg   rô   '  rÝ   z%_trim_zeros_float.<locals>.<listcomp>c                   s*   g | ]"}ˆ|ƒr"|  ˆ ¡r"|d  n|‘qS )rÒ  rÛ  rö   )r·   rÙ  rf   rg   rô   *  s   ÿ)rÍ  Úcompile)rÖ  r·   rÎ  rÝ  rœ   rf   )r·   rÙ  rØ  rg   r’    s    þr’  r+   )rQ   r_   c                 C  s$   t | tƒrtj| jŽ S | jd uS d S rº   )r{   r,   ÚcomZany_not_noner  rS   )rQ   rf   rf   rg   r’   1  s    
r’   c                   @  s\   e Zd ZdZdddddddd	d
dddddddddœZd!ddddœdd„Zdddœdd „ZdS )"ÚEngFormatterzl
    Formats float values according to engineering format.

    Based on matplotlib.ticker.EngFormatter
    r  ÚzÚarN  ÚprÏ  ÚurS  rt   r  rR  ÚGÚTÚPÚEÚZÚY)ièÿÿÿiëÿÿÿiîÿÿÿiñÿÿÿiôÿÿÿi÷ÿÿÿiúÿÿÿéýÿÿÿr   rŒ   r—  é	   rV  é   é   é   é   NFr\   rY   r]   ©ÚaccuracyÚuse_eng_prefixr_   c                 C  s   || _ || _d S rº   ©rò  ró  )re   rò  ró  rf   rf   rg   rh   T  s    zEngFormatter.__init__ÚfloatrZ   )Únumr_   c           
      C  s  t t|ƒƒ}t  |¡rdS t  |¡r(dS d}|dk r>d}| }|dkrft tt | ¡ d ¡d ƒƒ}nt dƒ}| t	| j
 ¡ ƒ¡}| 	t| j
 ¡ ƒ¡}t|ƒ}| jr°| j
| }n$|dk rÈd| d›�}nd	|d›�}|| d
|  }| jdu rôd}nd| jd›d�}|j||d�}	|	S )añ  
        Formats a number in engineering notation, appending a letter
        representing the power of 1000 of the original number. Some examples:
        >>> format_eng = EngFormatter(accuracy=0, use_eng_prefix=True)
        >>> format_eng(0)
        ' 0'
        >>> format_eng = EngFormatter(accuracy=1, use_eng_prefix=True)
        >>> format_eng(1_000_000)
        ' 1.0M'
        >>> format_eng = EngFormatter(accuracy=2, use_eng_prefix=False)
        >>> format_eng("-1e-6")
        '-1.00E-06'

        @param num: the value to represent
        @type num: either a numeric value or a string that can be converted to
                   a numeric value (as per decimal.Decimal constructor)

        @return: engineering formatted string
        rN   Úinfrj   r   r±  rŒ   zE-Ú02dzE+r˜  Nz{mant: g}{prefix}z{mant: .rc  z
f}{prefix})ÚmantÚprefix)r	   rZ   Úis_nanÚis_infiniterm   Úmathr´  rµ  rn   rÿ   ÚENG_PREFIXESrß   ró  rò  rn  )
re   rö  ZdnumÚsignZpow10Z	int_pow10rú  rù  Ú
format_strr…  rf   rf   rg   Ú__call__Z  s4    

 
zEngFormatter.__call__)NF)r‘   rž   rŸ   r    rþ  rh   r  rf   rf   rf   rg   rà  8  s,   ï ÿrà  rŒ   r]   rñ  c                 C  s   t dt| |ƒƒ dS )a  
    Format float representation in DataFrame with SI notation.

    Parameters
    ----------
    accuracy : int, default 3
        Number of decimal digits after the floating point.
    use_eng_prefix : bool, default False
        Whether to represent a value with SI prefixes.

    Returns
    -------
    None

    Examples
    --------
    >>> df = pd.DataFrame([1e-9, 1e-3, 1, 1e3, 1e6])
    >>> df
                  0
    0  1.000000e-09
    1  1.000000e-03
    2  1.000000e+00
    3  1.000000e+03
    4  1.000000e+06

    >>> pd.set_eng_float_format(accuracy=1)
    >>> df
             0
    0  1.0E-09
    1  1.0E-03
    2  1.0E+00
    3  1.0E+03
    4  1.0E+06

    >>> pd.set_eng_float_format(use_eng_prefix=True)
    >>> df
            0
    0  1.000n
    1  1.000m
    2   1.000
    3  1.000k
    4  1.000M

    >>> pd.set_eng_float_format(accuracy=1, use_eng_prefix=True)
    >>> df
          0
    0  1.0n
    1  1.0m
    2   1.0
    3  1.0k
    4  1.0M

    >>> pd.set_option("display.float_format", None)  # unset option
    r`   N)r   rà  rô  rf   rf   rg   Úset_eng_float_format˜  s    7r  rt   r   zbool | object | strzlist[dict[int, int]])r  Úsentinelr_   c           	      C  s’   t | ƒdkrg S dgt | d ƒ }g }| D ]b}d}i }t|ƒD ]2\}}|| rX||krXq>d||< || ||< |}q>t |ƒ| ||< | |¡ q*|S )a�  
    For each index in each level the function returns lengths of indexes.

    Parameters
    ----------
    levels : list of lists
        List of values on for level.
    sentinel : string, optional
        Value which states that no new index starts on there.

    Returns
    -------
    Returns list of maps. For each level returns map of indexes (key is index
    in row and value is length of index).
    r   TF)rl   rù   rý   )	r  r  Úcontrolrœ   r
  Z
last_indexÚlengthsr   Úkeyrf   rf   rg   Úget_level_lengthsÒ  s     r  zWriteBuffer[str])ra   Úlinesr_   c                 C  s4   t dd„ |D ƒƒr dd„ |D ƒ}|  d |¡¡ dS )z‘
    Appends lines to a buffer.

    Parameters
    ----------
    buf
        The buffer to write to
    lines
        The lines to append.
    c                 s  s   | ]}t |tƒV  qd S rº   )r{   rZ   rö   rf   rf   rg   rø     rÝ   z#buffer_put_lines.<locals>.<genexpr>c                 S  s   g | ]}t |ƒ‘qS rf   r  rö   rf   rf   rg   rô   	  rÝ   z$buffer_put_lines.<locals>.<listcomp>rx   N)r  rH  r˜   )ra   r  rf   rf   rg   Úbuffer_put_linesý  s    r	  )NN)N)	NrN   NNrE   r¯   TNN)r   )r   N)r   N)r   F)rE   NN)r¯   )r¯   )rŒ   F)rt   )ˆr    Ú
__future__r   Úcollections.abcr   r   r   r   Ú
contextlibr   Úcsvr   r·   r	   Ú	functoolsr
   Úior   rý  rÍ  Úshutilr   Útypingr   r   r   r   r   Únumpyrï   Zpandas._config.configr   r   Zpandas._libsr   Zpandas._libs.missingr   Zpandas._libs.tslibsr   r   r   Zpandas._libs.tslibs.nattyper   Zpandas.core.dtypes.commonr   r   r   r   r   r   Zpandas.core.dtypes.dtypesr    r!   r"   Zpandas.core.dtypes.missingr#   r$   Zpandas.core.arraysr%   r&   r'   r(   Zpandas.core.arrays.string_r)   Zpandas.core.baser*   Zpandas.core.commonÚcoreÚcommonrß  Zpandas.core.indexes.apir+   r,   r-   r.   Zpandas.core.indexes.datetimesr/   Zpandas.core.indexes.timedeltasr0   Zpandas.core.reshape.concatr1   Zpandas.io.commonr2   r3   r©   r4   Zpandas._typingr5   r6   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   ZpandasrA   rB   rC   r¡  ZVALID_JUSTIFY_PARAMETERSrL   rM   r«   r­   r®   r   r+  rG  r„   r^  r\  r]  rX  r[  r°  r©  r·  r¹  r½  rY  rZ  rÀ  rû   r‘  rd  r’  r’   rà  r  r  r	  rf   rf   rf   rg   Ú<module>   s¾    88	 #!   H    ý ÿ(         õ&Un J!?
  ý ÿ  ý$   ü"! ÿ$`; ÿ+