U
    ¾mœd< ã                   @  sà  U d Z ddlmZ ddlmZ ddlmZ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mZmZmZmZmZmZmZ ddl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-m.Z.m/Z/m0Z0 ddl1m2Z2 ddl3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z> ddl?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZK ddlLmMZM ddlNmOZOmPZP ddlQmRZRmSZSmTZT ddlUmVZV ddlWmXZX ddlYmZ  m[Z\ ddl]m^Z^ ddl_m`Z`maZambZbmcZc ddldmeZe ddlfmgZg ddlhmiZi ddljmkZkmlZl ddlmmnZn e�rNddlompZpmqZq d Zrd!esd"< d#Ztd$Zud!esd%< G d&d'„ d'ƒZvG d(d)„ d)ƒZwG d*d+„ d+ƒZxG d,d-„ d-exƒZyd+d.œd/d0„Zzd1d.œd2d3„Z{d1d.œd4d5„Z|G d6d7„ d7ƒZ}G d8d9„ d9ƒZ~d¤d:d;d<d<d=œd>d?„Zed¥d;d<d@dAœdBdC„ƒZ€d¦dHdIdJd:dKdLd:d:dMdKdIdNdOœdPdQ„Z�G dRdS„ dSƒZ‚G dTdU„ dUe‚ƒZƒG dVdW„ dWe‚ƒZ„G dXdY„ dYe‚ƒZ…G dZd[„ d[e‚ƒZ†d\dNd]œd^d_„Z‡d`dadbœdcdd„Zˆd§dfd:d:dgœdhdi„Z‰d¨dfd:d<d:djœdkdl„ZŠd©dad:d<dmdnœdodp„Z‹dqd<d<drœdsdt„ZŒG dudv„ dve…ƒZ�G dwdx„ dxe‚ƒZŽdªdzd{dadmd|œd}d~„Z�d«dNd:dKddNd€œd�d‚„Z�d¬dƒd:dNd„œd…d†„Z‘d:d:d‡œdˆd‰„Z’d­dŠd:dNd‹œdŒd�„Z“dŽdad�œd�d‘„Z”G d’d“„ d“ƒZ•d®d•dad–d—œd˜d™„Z–d¯dHd›dœd�œdždŸ„Z—d dNd–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)Úcontextmanager)Ú
QUOTE_NONEÚQUOTE_NONNUMERIC)ÚDecimal)Úpartial)ÚStringION)Úget_terminal_size)ÚIOÚTYPE_CHECKINGÚAnyÚCallableÚFinalÚ	GeneratorÚHashableÚIterableÚListÚMappingÚSequenceÚcast)Úeast_asian_width)Ú
get_optionÚ
set_option)Úlib)ÚNA)ÚNaTÚ	TimedeltaÚ	TimestampÚget_unit_from_dtypeÚiNaTÚperiods_per_day)ÚNaTType)Ú	ArrayLikeÚAxesÚColspaceArgTypeÚColspaceTypeÚCompressionOptionsÚFilePathÚFloatFormatTypeÚFormattersTypeÚ
IndexLabelÚStorageOptionsÚWriteBuffer)Úis_categorical_dtypeÚis_complex_dtypeÚis_datetime64_dtypeÚis_extension_array_dtypeÚis_floatÚis_float_dtypeÚ
is_integerÚis_integer_dtypeÚis_list_likeÚis_numeric_dtypeÚ	is_scalarÚis_timedelta64_dtype)ÚDatetimeTZDtype)ÚisnaÚnotna)ÚCategoricalÚDatetimeArrayÚTimedeltaArray)ÚStringDtype)ÚPandasObject)Úextract_array)ÚIndexÚ
MultiIndexÚPeriodIndexÚensure_index)ÚDatetimeIndex)ÚTimedeltaIndex)Úconcat)Úcheck_parent_directoryÚstringify_path)Úprinting)Ú	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 : sequence, 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``.

            .. versionchanged:: 1.2.0

        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ÚinitialÚunsetz™
        Returns
        -------
        str or None
            If buf is None, returns the result as a string. Otherwise returns
            None.
    Úreturn_docstringc                   @  sP   e Zd Z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S )ÚCategoricalFormatterNTÚNaNr<   úIO[str] | NoneÚboolÚstrÚNone)ÚcategoricalÚbufÚlengthÚna_repÚfooterÚreturnc                 C  s8   || _ |d k	r|ntdƒ| _|| _|| _|| _t| _d S ©NÚ )r_   r   r`   rb   ra   rc   r   Úquoting)Úselfr_   r`   ra   rb   rc   © ri   úQ/home/sam/Atlas/atlas_env/lib/python3.8/site-packages/pandas/io/formats/format.pyÚ__init__É   s    zCategoricalFormatter.__init__©rd   c                 C  sP   d}| j r*|r|d7 }|dt| jƒ› �7 }| j ¡ }|r@|d7 }||7 }t|ƒS )Nrf   ú, úLength: Ú
)ra   Úlenr_   Ú_repr_categories_infor]   )rh   rc   Ú
level_infori   ri   rj   Ú_get_footerØ   s    
z CategoricalFormatter._get_footerú	list[str]c                 C  s   t | j ¡ d d | j| jd�S )N)Úfloat_formatrb   rg   )Úformat_arrayr_   Ú_internal_get_valuesrb   rg   ©rh   ri   ri   rj   Ú_get_formatted_valuesé   s    ûz*CategoricalFormatter._get_formatted_valuesc                 C  s|   | j }t|ƒdkr$| jr |  ¡ S dS |  ¡ }dd„ |D ƒ}d |¡}d| d g}| jrn|  ¡ }|rn| |¡ td |¡ƒS )	Nr   rf   c                 S  s   g | ]}|  ¡ ‘qS ri   )Ústrip©Ú.0Úiri   ri   rj   Ú
<listcomp>ý   s     z2CategoricalFormatter.to_string.<locals>.<listcomp>rm   ú[ú]ro   )r_   rp   rc   rs   ry   ÚjoinÚappendr]   )rh   r_   Ú
fmt_valuesÚvaluesÚresultrc   ri   ri   rj   Ú	to_stringò   s    

zCategoricalFormatter.to_string)NTrZ   T)Ú__name__Ú
__module__Ú__qualname__rk   rs   ry   r†   ri   ri   ri   rj   rY   È   s       ú	rY   c                   @  sx   e Zd Z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	dœdd„ZdS )ÚSeriesFormatterNTrZ   FrM   r[   ú
bool | strr\   r]   ú
str | Noneú
int | Noner^   )Úseriesr`   ra   ÚheaderÚindexrb   Únameru   ÚdtypeÚmax_rowsÚmin_rowsrd   c                 C  st   || _ |d k	r|ntƒ | _|| _|| _|| _|| _|| _|
| _|| _	|d krTt
dƒ}|| _|	| _tƒ | _|  ¡  d S )Núdisplay.float_format)rŽ   r   r`   r‘   rb   r�   ra   r�   r“   r”   r   ru   r’   Úget_adjustmentÚadjÚ_chk_truncate)rh   rŽ   r`   ra   r�   r�   rb   r‘   ru   r’   r“   r”   ri   ri   rj   rk   	  s    zSeriesFormatter.__init__rl   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é   é   )r”   r“   rp   rŽ   r   ÚintÚminÚilocrH   Ú
tr_row_numÚ	tr_seriesÚis_truncated_vertically)rh   r”   r“   r    rŽ   Úrow_numri   ri   rj   r˜   )  s$    

"zSeriesFormatter._chk_truncatec                 C  sF  | j j}d}t| j jdd ƒd k	rLt| j jtttfƒs8t‚|d| j jj	› �7 }| jdk	r†|d k	r†|rj|d7 }t
j|dd�}|d|› �7 }| jd	ks | jd
krÀ| jrÀ|r¬|d7 }|dt| j ƒ› �7 }| jdk	�r| jd k	�rt| jjdd ƒ}|�r|rú|d7 }|dt
 |¡› �7 }t| jjƒ�r>| jj ¡ }|�r6|d7 }||7 }t|ƒS )Nrf   ÚfreqzFreq: Frm   ©ú	úro   )Úescape_charszName: TÚtruncatern   r‘   zdtype: ro   )rŽ   r‘   Úgetattrr�   Ú
isinstancerF   rD   rG   ÚAssertionErrorZfreqstrrK   Úpprint_thingra   r    rp   r’   rŸ   r-   Ú_valuesrq   r]   )rh   r‘   rc   Zseries_nameZ
dtype_namerr   ri   ri   rj   rs   D  sB     ÿ
ÿÿzSeriesFormatter._get_footerztuple[list[str], bool]c                 C  sR   | j j}t|tƒr4tdd„ |jD ƒƒ}|jdd�}n|jd k	}|jdd�}||fS )Nc                 s  s   | ]
}|V  qd S ©Nri   ©r|   r‘   ri   ri   rj   Ú	<genexpr>q  s     z7SeriesFormatter._get_formatted_index.<locals>.<genexpr>T)Únames)r‘   )rŸ   r�   r©   rC   Úanyr°   Úformatr‘   )rh   r�   Úhave_headerÚ	fmt_indexri   ri   rj   Ú_get_formatted_indexm  s    

z$SeriesFormatter._get_formatted_indexrt   c                 C  s   t | jjd | j| j| jd�S )N)ru   rb   Úleading_space)rv   rŸ   r¬   ru   rb   r�   rx   ri   ri   rj   ry   x  s    ûz%SeriesFormatter._get_formatted_valuesc                 C  s.  | j }|  ¡ }t|ƒdkr2t| jƒj› d|› d�S |  ¡ \}}|  ¡ }| jr¾d}| j	}t
t|ƒ}| j ||d  ¡}|dkr‚d}	nd}	| jj|	g|dd	�d }	| || |	¡ | |d d
¡ | jrâ| jjd|dd … |gžŽ }
n| j d|¡}
| j�r|�r|d d |
 }
|�r |
d| 7 }
td
 |
¡ƒS )Nr   z([], ú)r™   é   ú...z..rQ   ©Úmoderf   ro   )r¸   )rŸ   rs   rp   ÚtyperŽ   r‡   rµ   ry   r    rž   r   r›   r—   rR   Úinsertr�   Úadjoinr�   r]   r�   )rh   rŽ   rc   r´   r³   rƒ   Zn_header_rowsr¡   ÚwidthZdot_strr…   ri   ri   rj   r†   �  s2    
zSeriesFormatter.to_string)
NTTTrZ   FNTNN)	r‡   rˆ   r‰   rk   r˜   rs   rµ   ry   r†   ri   ri   ri   rj   rŠ     s              ô& )	rŠ   c                   @  sP   e Zd Zddœdd„Zdddœdd	„Zddddddœdd„Zdddœdd„ZdS )ÚTextAdjustmentr^   rl   c                 C  s   t dƒ| _d S )Nzdisplay.encoding)r   Úencodingrx   ri   ri   rj   rk   ©  s    zTextAdjustment.__init__r]   r›   ©Útextrd   c                 C  s   t |ƒS r­   ©rp   ©rh   rÃ   ri   ri   rj   rp   ¬  s    zTextAdjustment.lenrP   r   rt   ©ÚtextsÚmax_lenr»   rd   c                 C  s   t j|||d�S )Nrº   )rK   rR   ©rh   rÇ   rÈ   r»   ri   ri   rj   rR   ¯  s    zTextAdjustment.justify)Úspacerd   c                 O  s    t j|f|ž| j| jdœ|—ŽS )N)ZstrlenZjustfunc)rK   r¾   rp   rR   )rh   rÊ   ÚlistsÚkwargsri   ri   rj   r¾   ²  s    ÿÿ ÿÿzTextAdjustment.adjoinN)rP   )r‡   rˆ   r‰   rk   rp   rR   r¾   ri   ri   ri   rj   rÀ   ¨  s   rÀ   c                      sH   e Zd Zddœ‡ fdd„Zdddœdd	„Zddddddœdd„Z‡  ZS )ÚEastAsianTextAdjustmentr^   rl   c                   s6   t ƒ  ¡  tdƒrd| _nd| _ddddddœ| _d S )Nz!display.unicode.ambiguous_as_widerš   r™   )ZNaÚNÚWÚFÚH)Úsuperrk   r   Úambiguous_widthÚ_EAW_MAPrx   ©Ú	__class__ri   rj   rk   ¹  s
    
z EastAsianTextAdjustment.__init__r]   r›   rÂ   c                   s(   t |tƒst|ƒS t‡ fdd„|D ƒƒS )zN
        Calculate display width considering unicode East Asian Width
        c                 3  s"   | ]}ˆ j  t|ƒˆ j¡V  qd S r­   )rÔ   Úgetr   rÓ   )r|   Úcrx   ri   rj   r¯   Ì  s    z.EastAsianTextAdjustment.len.<locals>.<genexpr>)r©   r]   rp   ÚsumrÅ   ri   rx   rj   rp   Å  s
    
ÿzEastAsianTextAdjustment.lenrP   zIterable[str]rt   rÆ   c                   sX   ‡‡fdd„‰ |dkr(‡ fdd„|D ƒS |dkrB‡ fdd„|D ƒS ‡ fdd„|D ƒS d S )	Nc                   s   ˆ ˆ  | ¡ t | ƒ S r­   rÄ   )Út)rÈ   rh   ri   rj   Ú_get_padÔ  s    z1EastAsianTextAdjustment.justify.<locals>._get_padrO   c                   s   g | ]}|  ˆ |ƒ¡‘qS ri   )Úljust©r|   Úx©rÛ   ri   rj   r~   Ø  s     z3EastAsianTextAdjustment.justify.<locals>.<listcomp>rQ   c                   s   g | ]}|  ˆ |ƒ¡‘qS ri   )rQ   rÝ   rß   ri   rj   r~   Ú  s     c                   s   g | ]}|  ˆ |ƒ¡‘qS ri   )ÚrjustrÝ   rß   ri   rj   r~   Ü  s     ri   rÉ   ri   )rÛ   rÈ   rh   rj   rR   Ð  s    zEastAsianTextAdjustment.justify)rP   )r‡   rˆ   r‰   rk   rp   rR   Ú__classcell__ri   ri   rÕ   rj   rÍ   ¸  s    ÿrÍ   rl   c                  C  s   t dƒ} | rtƒ S tƒ S d S )Nz display.unicode.east_asian_width)r   rÍ   rÀ   )Zuse_east_asian_widthri   ri   rj   r–   ß  s    r–   zdict[str, Any]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)r“   r”   Úmax_colsZmax_colwidthÚshow_dimensionsÚ
line_width)Úpandas.io.formatsrâ   r   Zget_console_size)râ   ré   Ú_ri   ri   rj   Úget_dataframe_repr_paramsç  s    úrì   c                  C  sN   t ƒ \} }tdƒdkr|ntdƒ}tdƒdkr2|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æ   )r‘   r’   r”   r“   ra   )r	   r   )r¿   Úheightr“   r”   ri   ri   rj   Ú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.rf   NTrZ   FÚ.rL   úSequence[Hashable] | NonezColspaceArgType | Nonezbool | Sequence[str]r\   r]   zFormattersType | NonerŒ   úFloatFormatType | Noneúbool | Noner�   r‹   r^   )ÚframeÚcolumnsÚ	col_spacer�   r�   rb   Ú
formattersrR   ru   ÚsparsifyÚindex_namesr“   r”   rç   rè   ÚdecimalÚ	bold_rowsÚescaperd   c                 C  sº   || _ |  |¡| _|  |¡| _|| _|| _|| _|  |¡| _	|  
|¡| _|	| _|  |
¡| _|| _|| _|| _|| _|| _|| _|| _|| _|  ¡ | _|  ¡ | _| j | _|  ¡  tƒ | _d S r­   )rô   Ú_initialize_columnsrõ   Ú_initialize_colspacerö   r�   r�   rb   Ú_initialize_formattersr÷   Ú_initialize_justifyrR   ru   Ú_initialize_sparsifyrø   Úshow_index_namesrú   rû   rü   r“   r”   rç   rè   Ú_calc_max_cols_fittedÚmax_cols_fittedÚ_calc_max_rows_fittedÚmax_rows_fittedÚtr_framer§   r–   r—   )rh   rô   rõ   rö   r�   r�   rb   r÷   rR   ru   rø   rù   r“   r”   rç   rè   rú   rû   rü   ri   ri   rj   rk   4  s.    

zDataFrameFormatter.__init__zlist[list[str]]rl   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_indexr�   rµ   r  r½   )rh   ÚstrcolsZ	str_indexri   ri   rj   Úget_strcolsc  s
    zDataFrameFormatter.get_strcolsc                 C  s   | j dkp| j dko| jS )NTr§   )rè   Úis_truncatedrx   ri   ri   rj   Úshould_show_dimensionso  s    
ÿz)DataFrameFormatter.should_show_dimensionsc                 C  s   t | jp| jƒS r­   )r\   Úis_truncated_horizontallyr    rx   ri   ri   rj   r  u  s    zDataFrameFormatter.is_truncatedc                 C  s   t | jot| jƒ| jkƒS r­   )r\   r  rp   rõ   rx   ri   ri   rj   r  y  s    z,DataFrameFormatter.is_truncated_horizontallyc                 C  s   t | jot| jƒ| jkƒS r­   )r\   r  rp   rô   rx   ri   ri   rj   r    }  s    z*DataFrameFormatter.is_truncated_verticallyc                 C  s    dt | jƒ› dt | jjƒ› d�S )Nz

[z rows x z	 columns])rp   rô   rõ   rx   ri   ri   rj   Údimensions_info�  s    z"DataFrameFormatter.dimensions_infoc                 C  s   t | jjƒS r­   )Ú
_has_namesrô   r�   rx   ri   ri   rj   Úhas_index_names…  s    z"DataFrameFormatter.has_index_namesc                 C  s   t | jjƒS r­   )r  rô   rõ   rx   ri   ri   rj   Úhas_column_names‰  s    z#DataFrameFormatter.has_column_namesc                 C  s   t | j| j| jfƒS r­   )Úallr  r�   r  rx   ri   ri   rj   Úshow_row_idx_names�  s    z%DataFrameFormatter.show_row_idx_namesc                 C  s   t | j| j| jfƒS r­   )r  r  r  r�   rx   ri   ri   rj   Úshow_col_idx_names‘  s    z%DataFrameFormatter.show_col_idx_namesr›   c                 C  s   t | jpt| jƒt| jƒƒS r­   )rœ   r“   rp   rô   rx   ri   ri   rj   Úmax_rows_displayed•  s    z%DataFrameFormatter.max_rows_displayed)rø   rd   c                 C  s   |d krt dƒS |S )Nzdisplay.multi_sparse©r   )rh   rø   ri   ri   rj   r  ™  s    z'DataFrameFormatter._initialize_sparsifyr)   )r÷   rd   c                 C  sT   |d k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·   )rp   rô   rõ   r©   ÚdictÚ
ValueError)rh   r÷   ri   ri   rj   rÿ   ž  s    ÿz)DataFrameFormatter._initialize_formatters)rR   rd   c                 C  s   |d krt dƒS |S d S )Nzdisplay.colheader_justifyr  )rh   rR   ri   ri   rj   r   «  s    z&DataFrameFormatter._initialize_justifyrB   )rõ   rd   c                 C  s2   |d k	r&t tt|ƒƒ}| j| | _|S | jjS d S r­   )rE   r   r#   rô   rõ   )rh   rõ   Úcolsri   ri   rj   rý   ±  s
    z&DataFrameFormatter._initialize_columnsr%   )rö   rd   c                   sÎ   ˆ d kri }n¼t ˆ ttfƒrBdˆ i}| ‡ fdd„| jjD ƒ¡ nˆt ˆ tƒr‚ˆ  ¡ D ]&}|| jjk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 )Nrf   c                   s   i | ]
}|ˆ “qS ri   ri   )r|   Úcolumn©rö   ri   rj   Ú
<dictcomp>Â  s      z;DataFrameFormatter._initialize_colspace.<locals>.<dictcomp>z,Col_space is defined for an unknown column: zCol_space length(r  r·   )r©   r›   r]   Úupdaterô   rõ   r   Úkeysr  rp   r  Úzip)rh   rö   r…   r  ri   r  rj   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)rh   r¿   rë   ri   ri   rj   r  Ó  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	   r“   Ú_get_number_of_auxillary_rowsÚ_is_screen_shortÚ_adjust_max_rows)rh   rë   rí   r“   ri   ri   rj   r  Þ  s    


z(DataFrameFormatter._calc_max_rows_fitted)r“   rd   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
        )rp   rô   r”   rœ   )rh   r“   ri   ri   rj   r%  ñ  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   )r\   rç   r“   rx   ri   ri   rj   r!  ÿ  s    z"DataFrameFormatter._is_in_terminalc                 C  s   t | jdkot| jjƒ|kƒS ©Nr   )r\   rç   rp   rô   rõ   )rh   Ú	max_widthri   ri   rj   r"    s    z$DataFrameFormatter._is_screen_narrowc                 C  s   t | jdkot| jƒ|kƒS r&  )r\   r“   rp   rô   )rh   Ú
max_heightri   ri   rj   r$    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.r™   )rè   rp   r  Ú
splitlinesr�   )rh   Zdot_rowZ
prompt_rowZnum_rowsri   ri   rj   r#  	  s    z0DataFrameFormatter._get_number_of_auxillary_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_horizontallyr    Ú_truncate_verticallyrx   ri   ri   rj   r§     s    zDataFrameFormatter.truncatec                 C  sÆ   | j dk	st‚| 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¼| 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
        Nrš   r™   ©Zaxis)r  rª   r  r�   rH   r©   r÷   ÚlistÚtupler   r›   rç   Z
tr_col_num)rh   Zcol_numrO   rP   ri   ri   rj   r*  !  s    
þz)DataFrameFormatter._truncate_horizontallyc                 C  s’   | j dk	st‚| j d }|dkrb| jjd|…dd…f }| jj| d…dd…f }t||fƒ| _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
        Nrš   r™   )	r  rª   r  r�   rH   r   r›   r“   rž   )rh   r¡   ÚheadÚtailri   ri   rj   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¡ƒf‡ fd	d
„|D ƒžŽ }ˆ  |¡}t|ˆ j|ˆ j
d�}tt‡ fdd
„|D ƒƒ|ƒ}	ˆ j
j||	ˆ jd�}| || ¡ qö|S )Nr   )ÚstringsrR   Úminimumr—   zWriting z cols but got z aliasesc                 S  s   g | ]
}|g‘qS ri   ri   )r|   Úlabelri   ri   rj   r~   d  s     zADataFrameFormatter._get_strcols_without_index.<locals>.<listcomp>rf   c                 3  s   | ]}ˆ j  |¡V  qd S r­   ©r—   rp   rÝ   rx   ri   rj   r¯   o  s     z@DataFrameFormatter._get_strcols_without_index.<locals>.<genexpr>)r2  r—   c                 3  s   | ]}ˆ j  |¡V  qd S r­   r4  rÝ   rx   ri   rj   r¯   v  s     rº   )r5   r�   Ú	enumerater  Ú
format_colÚ_make_fixed_widthrR   r›   rö   r×   r—   r‚   r   r   r]   rp   rõ   r  Ú_get_formatted_column_labelsr  Úmax)
rh   r	  r}   rØ   rƒ   Ústr_columnsrÞ   ZcheaderZheader_colwidthrÈ   ri   rx   rj   r  M  sR    
ü
ÿÿÿ
   ÿz-DataFrameFormatter._get_strcols_without_indexrt   )r}   rd   c              	   C  sL   | j }|  |¡}t|jd d …|f j|| j| j| j |j	| ¡| j
| jd�S )N)ru   rb   rÊ   rú   r¶   )r  Ú_get_formatterrv   r�   r¬   ru   rb   rö   r×   rõ   rú   r�   )rh   r}   rô   Ú	formatterri   ri   rj   r6  |  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krN| j| }| j |d ¡S d S r­   )	r©   r÷   r-  r.  r3   r   r›   rõ   r×   )rh   r}   ri   ri   rj   r;  ‰  s    


z!DataFrameFormatter._get_formatter)rô   rd   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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|   Úlevelri   ri   rj   r¯      s     zBDataFrameFormatter._get_formatted_column_labels.<locals>.<genexpr>c                   s"   |ˆj krˆ |  rˆsd| S |S )Nú )r÷   )rÞ   Úy)Úneed_leadspÚrestrict_formattingrh   ri   rj   Ú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 ri   ri   )r|   rB  )rE  rÞ   ri   rj   r~   ­  s     zMDataFrameFormatter._get_formatted_column_labels.<locals>.<genexpr>.<listcomp>Nri   )r|   )rE  ©rÞ   rj   r¯   ­  s     c                 S  s   g | ]}t |ƒ‘qS ri   )r-  rÝ   ri   ri   rj   r~   ²  s     zCDataFrameFormatter._get_formatted_column_labels.<locals>.<listcomp>c                   s0   g | ](\}}ˆ  |¡s&ˆ | r&d | n|g‘qS )rA  )r;  )r|   r}   rÞ   )rC  rh   ri   rj   r~   ·  s   ÿ)Zpandas.core.indexes.multir?  rõ   r©   rC   r²   r-  r   rô   Údtypesr¬   r±   Úlevelsr  Úmapr6   rø   rp   r5  )rh   rô   r?  rõ   Zfmt_columnsrG  r:  ri   )rC  rD  rh   rE  rj   r8  •  s,    

	ÿþz/DataFrameFormatter._get_formatted_column_labelsc                   sÄ   dd„ ˆj  ¡ D ƒ‰ |j}|j}ˆ d¡}t|tƒrL|jˆjdˆj	|d�}n|jˆj	|d�g}‡ ‡fdd„|D ƒ}ˆj
jd|žŽ  d
¡}ˆjr¢dd„ ˆ ¡ D ƒ}ndg|j }ˆjr¼|| S |S d S )Nc                 S  s   i | ]\}}|t t|ƒ“qS ri   )r   r›   )r|   ÚkÚvri   ri   rj   r  Á  s      z;DataFrameFormatter._get_formatted_index.<locals>.<dictcomp>Ú	__index__F)rø   r¾   r°   r<  )r‘   r<  c              
     s.   g | ]&}t tt|ƒd ˆ  dd¡ˆjd�ƒ‘qS )rO   rf   r   )rR   r2  r—   )r.  r7  r-  r×   r—   rÝ   ©rö   rh   ri   rj   r~   Ð  s   û  
 ÿÿz;DataFrameFormatter._get_formatted_index.<locals>.<listcomp>r™   ro   c                 S  s   g | ]}t |ƒ‘qS ri   ©r]   rÝ   ri   ri   rj   r~   Ý  s     rf   )r™   )rö   Úitemsr�   rõ   r;  r©   rC   r²   rø   r  r—   r¾   Úsplitr  Ú_get_column_name_listZnlevelsr�   )rh   rô   r�   rõ   Úfmtr´   ZadjoinedZ
col_headerri   rM  rj   rµ   ¾  s,    

üú	z'DataFrameFormatter._get_formatted_indexzlist[Hashable]c                 C  sL   g }| j j}t|tƒr.| dd„ |jD ƒ¡ n| |jd kr@dn|j¡ |S )Nc                 s  s   | ]}|d krdn|V  qd S re   ri   r®   ri   ri   rj   r¯   ê  s     z;DataFrameFormatter._get_column_name_list.<locals>.<genexpr>rf   )rô   rõ   r©   rC   Úextendr°   r‚   r‘   )rh   r°   rõ   ri   ri   rj   rQ  æ  s    
z(DataFrameFormatter._get_column_name_list)NNTTrZ   NNNNTNNNFrð   FT)(r‡   rˆ   r‰   Ú__doc__rN   rX   rk   r
  Úpropertyr  r  r  r    r  r  r  r  r  r  r  rÿ   r   rý   rþ   r  r  r%  r!  r"  r$  r#  r§   r*  r+  r  r6  r;  r8  rµ   rQ  ri   ri   ri   rj   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
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^   )rR  rd   c                 C  s
   || _ d S r­   )rR  )rh   rR  ri   ri   rj   rk     s    zDataFrameRenderer.__init__NFú"FilePath | WriteBuffer[str] | NonerŒ   r\   zstr | tuple[str, str] | None)r`   Úcolumn_formatÚ	longtablerÁ   ÚmulticolumnÚmulticolumn_formatÚmultirowÚcaptionr3  Úpositionrd   c                 C  s>   ddl m} || j|||||||	|
d�	}| ¡ }t|||d�S )zU
        Render a DataFrame to a LaTeX tabular/longtable environment output.
        r   )ÚLatexFormatter)rY  rX  rZ  r[  r\  r]  r3  r^  ©r`   rÁ   )Zpandas.io.formats.latexr_  rR  r†   Úsave_to_buffer)rh   r`   rX  rY  rÁ   rZ  r[  r\  r]  r3  r^  r_  Zlatex_formatterÚstringri   ri   rj   Úto_latex  s    ÷zDataFrameRenderer.to_latexzstr | list | tuple | Nonezint | bool | None)r`   rÁ   ÚclassesÚnotebookÚborderÚtable_idÚrender_linksrd   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)rd  rf  rg  rh  r`  )Zpandas.io.formats.htmlri  rj  rR  r†   ra  )rh   r`   rÁ   rd  re  rf  rg  rh  ri  rj  ZKlassZhtml_formatterrb  ri   ri   rj   Úto_html$  s    "ûzDataFrameRenderer.to_htmlr�   )r`   rÁ   ré   rd   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.stringrl  rR  r†   ra  )rh   r`   rÁ   ré   rl  Zstring_formatterrb  ri   ri   rj   r†   W  s    zDataFrameRenderer.to_stringú,ÚwÚinferú"TÚstrictz7FilePath | WriteBuffer[bytes] | WriteBuffer[str] | Noner]   rñ   zIndexLabel | Noner&   r+   )Úpath_or_bufrÁ   Úseprõ   Úindex_labelr»   Úcompressionrg   Ú	quotecharÚlineterminatorÚ	chunksizeÚdate_formatÚdoublequoteÚ
escapecharÚerrorsÚstorage_optionsrd   c                 C  s‚   ddl m} |dkr d}tƒ }nd}|||
||||||||||	||||| jd�}| ¡  |r~t|tƒsjt‚| ¡ }| ¡  |S dS )z;
        Render dataframe as comma-separated file.
        r   )ÚCSVFormatterNTF)rr  rw  rs  rÁ   r|  ru  rg   r  rt  r»   rx  rv  ry  rz  r{  r}  r<  )	Zpandas.io.formats.csvsr~  r   rR  Úsaver©   rª   ÚgetvalueÚclose)rh   rr  rÁ   rs  rõ   rt  r»   ru  rg   rv  rw  rx  ry  rz  r{  r|  r}  r~  Zcreated_bufferZcsv_formatterÚcontentri   ri   rj   Úto_csvq  s>    ïzDataFrameRenderer.to_csv)
NNFNFNFNNN)NNNFNNF)NNN)NNrm  NNrn  ro  Nrp  NNNTNrq  N)	r‡   rˆ   r‰   rT  rk   rc  rk  r†   rƒ  ri   ri   ri   rj   rV  ð  sT             õ$"       ø5   ü                ïrV  r]   rW  rŒ   )rb  r`   rÁ   rd   c              
   C  sL   t ||d��6}| | ¡ |dkr4| ¡ W  5 Q R £ S W 5 Q R £ dS Q R X dS )zQ
    Perform serialization. Write to buf or return as string if buf is None.
    )rÁ   N)Ú
get_bufferÚwriter€  )rb  r`   rÁ   Úfri   ri   rj   ra  ­  s
    
ra  zIGenerator[WriteBuffer[str], None, None] | Generator[StringIO, None, None])r`   rÁ   rd   c              	   c  s�   | dk	rt | ƒ} ntƒ } |dkr&d}nt| tƒs8tdƒ‚t| dƒrJ| V  nBt| tƒr„tt| ƒƒ t| d|dd��}|V  W 5 Q R X 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.r…  rn  rf   )rÁ   Únewlinez1buf is not a file name and it has no write method)	rJ   r   r©   r]   r  ÚhasattrrI   ÚopenÚ	TypeError)r`   rÁ   r†  ri   ri   rj   r„  ½  s    



r„  rZ   rP   rð   Tr   r>  rò   r�   zstr | int | Noneró   rt   )r„   r<  ru   rb   ÚdigitsrÊ   rR   rú   r¶   rg   Úfallback_formatterrd   c                 C  sÂ   t | jƒrt}n`t| jtƒr"t}nNt| jƒr2t}n>t| jƒrBt	}n.t
| jƒsVt| jƒr\t}nt| jƒrlt}nt}|dkr|d}|dkrŒtdƒ}|dkrœtdƒ}|| |||||||||	|
d�}| ¡ S )a{  
    Format an array for printing.

    Parameters
    ----------
    values
    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._format_native_types), we don't want the
        leading space since it should be left-aligned.
    fallback_formatter

    Returns
    -------
    List[str]
    Né   r•   údisplay.precision)
r‹  rb   ru   r<  rÊ   rR   rú   r¶   rg   rŒ  )r/   r’   ÚDatetime64Formatterr©   r9   ÚDatetime64TZFormatterr8   ÚTimedelta64Formatterr0   ÚExtensionArrayFormatterr2   r.   ÚFloatArrayFormatterr4   ÚIntArrayFormatterÚGenericArrayFormatterr   Ú
get_result)r„   r<  ru   rb   r‹  rÊ   rR   rú   r¶   rg   rŒ  Z	fmt_klassZfmt_objri   ri   rj   rv   ã  sB    )



õrv   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•  é   NrZ   r�  rP   rð   Tr   r›   r>  r]   r=  rò   r�   r\   ró   r^   )r„   r‹  r<  rb   rÊ   ru   rR   rú   rg   Úfixed_widthr¶   rŒ  rd   c                 C  sL   || _ || _|| _|| _|| _|| _|| _|| _|	| _|
| _	|| _
|| _d S r­   )r„   r‹  rb   rÊ   r<  ru   rR   rú   rg   r˜  r¶   rŒ  )rh   r„   r‹  r<  rb   rÊ   ru   rR   rú   rg   r˜  r¶   rŒ  ri   ri   rj   rk   6  s    zGenericArrayFormatter.__init__rt   rl   c                 C  s   |   ¡ }t|| jƒS r­   )Ú_format_stringsr7  rR   )rh   rƒ   ri   ri   rj   r–  R  s    z GenericArrayFormatter.get_resultc                   sˆ  ˆj d kr0tdƒ}|d kr6tdƒ‰‡fdd„}nˆj }ˆjd k	rHˆj‰ n6ˆjd k	rZˆj‰ n$ˆjd k	olˆjtk}ttjd|d�‰ ‡ ‡fdd„}t	ˆj
d	d
�}t|tjƒs®tdƒ‚t |t¡}|tjt|ƒttdt|jƒƒƒd�@ }ˆj}|d krö| ¡ }g }t|ƒD ]€\}	}
||	 �s|�s&ˆjd k	�r<| d||
ƒ› �¡ nD||	 �rV| ||
ƒ¡ n*|dk�rfd}nd}| |j||
ƒd�¡ �q|S )Nr•   rŽ  c                   s   t | dˆ d›d�›ƒS )Nz .Údr†  )Ú_trim_zeros_single_floatrF  )Ú	precisionri   rj   Ú<lambda>[  s   ÿz7GenericArrayFormatter._format_strings.<locals>.<lambda>r£   )r¦   Úquote_stringsc              	     sª   ˆj d k	rvt| ƒrvt| ƒrvz<| d kr*W dS | tkr<ttƒW S | tksNt | ¡rTW dS W n tt	fk
rn   Y nX ˆj S t
| tƒrˆt| ƒS t
| tƒršt| ƒS tˆ | ƒƒS d S )Nr^   r   )rb   r7   r:   r   r]   r   ÚnpZisnatrŠ  r  r©   r@   r?   ÚreprrF  )r<  rh   ri   rj   Ú_formatm  s     



z6GenericArrayFormatter._format_strings.<locals>._formatT©Zextract_numpyz<ExtensionArray formatting should use ExtensionArrayFormatterr™   r,  rA  Fz{v}z {v}©rK  )ru   r   r<  rŒ  rg   r   r   rK   r«   rA   r„   r©   rŸ  ÚndarrayrŠ  r   Z	map_inferr1   r  r;   r.  Úrangerp   Úshaper¶   r±   r5  r‚   r²   )rh   ru   rž  r¡  ÚvalsÚinferredZis_float_typer¶   rƒ   r}   rK  Ztplri   )r<  rœ  rh   rj   r™  V  sR    


ýÿ þÿ

z%GenericArrayFormatter._format_strings)r—  NrZ   r�  NrP   rð   NTTN)r‡   rˆ   r‰   rk   r–  r™  ri   ri   ri   rj   r•  5  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^   rl   c                   sD   t ƒ j||Ž | jd k	r@| jd kr@d| _t| jƒr@| j| _d | _d S )NF)rÒ   rk   ru   r<  r˜  Úcallable)rh   ÚargsrÌ   rÕ   ri   rj   rk   ¦  s    
zFloatArrayFormatter.__init__Nrò   zfloat | Noner   )ru   Ú	thresholdrd   c                   sl   ˆdkrˆj ‰ˆr"‡‡fdd„‰ n‡fdd„‰ ˆjdkrH‡ ‡fdd„‰nˆ ‰ˆdkrXˆS ‡‡‡fdd	„}|S )
z;Returns a function to be applied on each value to format itNc                   s$   ˆ d k	st ‚t| ƒrˆ | d�S ˆjS )N©Úvalue)rª   r;   rb   r£  )ru   rh   ri   rj   Úbase_formatterÄ  s
    ÿýz<FloatArrayFormatter._value_formatter.<locals>.base_formatterc                   s   t | ƒrt| ƒS ˆ jS r­   )r;   r]   rb   r£  rx   ri   rj   r®  Ñ  s    rð   c                   s   ˆ | ƒ  dˆjd¡S )Nrð   r™   )Úreplacerú   r£  )r®  rh   ri   rj   Ú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;   Úabsrb   r¬  )r°  rh   r«  ri   rj   r<  ß  s
    
z7FloatArrayFormatter._value_formatter.<locals>.formatter)ru   rú   )rh   ru   r«  r<  ri   )r®  r°  ru   rh   r«  rj   Ú_value_formatter²  s    
	z$FloatArrayFormatter._value_formatterú
np.ndarrayc           
   	     sp  ddddœdd„‰ ˆj dk	r.ˆ ˆjˆj ˆjƒS ˆjr>tdƒ‰nd‰‡ ‡‡fd	d
„}ˆjdkr�ˆjrˆˆjdkrrd}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d��: t ˆj¡}|dk ¡ }|dˆj	  k |dk@  ¡ }	W 5 Q R X |	�s>|�rl|�rlˆjdk�rPd}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
        r"   r   r]   )r„   r<  rb   c                   s<   t | ƒ}t ‡ ‡fdd„t|  ¡ | ¡ ƒD ƒ¡ | j¡}|S )Nc                   s    g | ]\}}|sˆ |ƒnˆ‘qS ri   ri   )r|   ÚvalÚm©r<  rb   ri   rj   r~   ó  s   ÿzWFloatArrayFormatter.get_result_as_array.<locals>.format_with_na_rep.<locals>.<listcomp>)r:   rŸ  Úarrayr   ÚravelZreshaper¦  )r„   r<  rb   ÚmaskÚ	formattedri   r¶  rj   Úformat_with_na_repð  s    þÿûzCFloatArrayFormatter.get_result_as_array.<locals>.format_with_na_repNzdisplay.chop_thresholdc                   sx   ˆ  | ˆ¡}ˆjdkr"dˆj }nˆj}ˆj}t|ƒ}ˆ |||ƒ}ˆjrt|rZt|ˆjƒ}nt|ˆjƒ}t	j
|dd�S |S )NrO   rA  Úobject©r’   )r²  rR   rb   r„   r.   r˜  Ú_trim_zeros_complexrú   Ú_trim_zeros_floatrŸ  Úasarray)ru   r<  rb   r„   Z
is_complexr…   ©r»  rh   r«  ri   rj   Úformat_values_with  s    
zCFloatArrayFormatter.get_result_as_array.<locals>.format_values_withTz{value: .{digits:d}f}z{value:.{digits:d}f})r‹  c                   s
   ˆ j |  S r­   )ru   r¬  rx   ri   rj   r�  (  ó    z9FloatArrayFormatter.get_result_as_array.<locals>.<lambda>r   c                 s  s   | ]}t |ƒV  qd S r­   rÄ   rÝ   ri   ri   rj   r¯   4  s     z:FloatArrayFormatter.get_result_as_array.<locals>.<genexpr>é   FÚignore©Úinvalidg    €„.Aé
   z{value: .{digits:d}e}z{value:.{digits:d}e})r<  r„   rb   r˜  r   ru   r¶   r   r²   r‹  rp   r9  rŸ  Úerrstater±  r±   )
rh   rÂ  Zfmt_strru   Zformatted_valuesÚmaxlenZtoo_longZabs_valsZhas_large_valuesZhas_small_valuesri   rÁ  rj   Úget_result_as_arrayê  sD    




ÿz'FloatArrayFormatter.get_result_as_arrayrt   c                 C  s   t |  ¡ ƒS r­   )r-  rË  rx   ri   ri   rj   r™  M  s    z#FloatArrayFormatter._format_strings)NN)r‡   rˆ   r‰   rk   r²  rË  r™  rá   ri   ri   rÕ   rj   r“  ¥  s     ý8cr“  c                   @  s   e Zd Zddœdd„ZdS )r”  rt   rl   c                   s>   | j dkrdd„ }ndd„ }| jp$|‰ ‡ fdd„| jD ƒ}|S )NFc                 S  s   | d›j | d�S )Nrš  rF  ©r²   rF  ri   ri   rj   r�  T  rÃ  z3IntArrayFormatter._format_strings.<locals>.<lambda>c                 S  s   | d›j | d�S )Nz drF  rÌ  rF  ri   ri   rj   r�  V  rÃ  c                   s   g | ]}ˆ |ƒ‘qS ri   ri   rÝ   ©r<  ri   rj   r~   X  s     z5IntArrayFormatter._format_strings.<locals>.<listcomp>)r¶   r<  r„   )rh   Zformatter_strrƒ   ri   rÍ  rj   r™  R  s    


z!IntArrayFormatter._format_stringsN©r‡   rˆ   r‰   r™  ri   ri   ri   rj   r”  Q  s   r”  c                      s8   e Zd Zddddddœ‡ fdd„Zd	d
œdd„Z‡  ZS )r�  r   Nz3np.ndarray | Series | DatetimeIndex | DatetimeArrayr]   r^   )r„   Únat_repry  rd   c                   s    t ƒ j|f|Ž || _|| _d S r­   )rÒ   rk   rÏ  ry  )rh   r„   rÏ  ry  rÌ   rÕ   ri   rj   rk   ]  s    zDatetime64Formatter.__init__rt   rl   c                   sZ   ˆ j }t|tƒst|ƒ}ˆ jdk	r>tˆ jƒr>‡ fdd„|D ƒS |jjˆ jˆ jd�}| 	¡ S )z&we by definition have DO NOT have a TZNc                   s   g | ]}ˆ   |¡‘qS ri   rÍ  rÝ   rx   ri   rj   r~   p  s     z7Datetime64Formatter._format_strings.<locals>.<listcomp>)rb   ry  )
r„   r©   rF   r<  r©  Ú_dataZ_format_native_typesrÏ  ry  Útolist)rh   r„   rƒ   ri   rx   rj   r™  h  s    
 ÿz#Datetime64Formatter._format_strings)r   N©r‡   rˆ   r‰   rk   r™  rá   ri   ri   rÕ   rj   r�  \  s     ür�  c                   @  s   e Zd Zddœdd„ZdS )r’  rt   rl   c                 C  s|   t | jdd�}| j}d }|d kr,|jdd�}t|tƒr@| ¡ }n
t |¡}t	||| j
| j| j| j| j| j| j| j|d�}|S )NTr¢  )Zboxed)	ru   rb   r‹  rÊ   rR   rú   r¶   rg   rŒ  )rA   r„   r<  Ú
_formatterr©   r<   rw   rŸ  rÀ  rv   ru   rb   r‹  rÊ   rR   rú   r¶   rg   )rh   r„   r<  rŒ  r·  rƒ   ri   ri   rj   r™  y  s,    


õz'ExtensionArrayFormatter._format_stringsNrÎ  ri   ri   ri   rj   r’  x  s   r’  znp.ndarray | Sequence[float])Úpercentilesrd   c                 C  sX  t  | ¡} t jdd��2 t| ƒr<t  | dk¡r<t  | dk¡sDtdƒ‚W 5 Q R X d|  } |  ¡  t¡}t  	|| ¡}t  |¡r’| t
¡}dd„ |D ƒS t  | ¡}|d dkr°|d nd	}|d
 dk rÌd|d
  nd	}t  t  t  t j|||d�¡¡¡ t¡ }td|ƒ}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Å  rÆ  r   r™   z/percentiles should all be in the interval [0,1]éd   c                 S  s   g | ]}|d  ‘qS ©ú%ri   r{   ri   ri   rj   r~   Ë  s     z&format_percentiles.<locals>.<listcomp>Néÿÿÿÿ)Úto_beginÚto_endr½  c                 S  s   g | ]}|d  ‘qS rÖ  ri   r{   ri   ri   rj   r~   Ú  s     )rŸ  rÀ  rÉ  r6   r  r  ÚroundÚastyper›   Úiscloser]   ÚuniqueÚfloorÚlog10rœ   Zediff1dr9  Z
empty_liker¼  )rÔ  Zpercentiles_round_typeZint_idxÚoutZunique_pctsrÙ  rÚ  Úprecri   ri   rj   Úformat_percentiles—  s8    "
ÿþý


ÿþ
rã  z2np.ndarray | DatetimeArray | Index | DatetimeIndexr\   ©r„   rd   c                 C  s~   t | tƒs|  ¡ } t | ttfƒs(t| ƒ} | jd k	r6dS | j}|tk}t| j	ƒ}t
|ƒ}t ||| dk¡ ¡ dk}|rzdS dS )NFr   T)r©   rB   r¸  r=   rF   ÚtzZasi8r   r   r’   r    rŸ  Úlogical_andrÙ   )r„   Ú
values_intÚconsider_valuesZresoZppdÚ	even_daysri   ri   rj   Úis_dates_onlyÝ  s    


rê  r   zNaTType | Timestamp)rÞ   rÏ  rd   c                 C  s   | t kr|S t| ƒS r­   )r   r]   )rÞ   rÏ  ri   ri   rj   Ú_format_datetime64ö  s    rë  )rÞ   rÏ  ry  rd   c                 C  s&   t | tƒr|S |r|  |¡S | jS d S r­   )r©   r!   ÚstrftimeZ
_date_repr)rÞ   rÏ  ry  ri   ri   rj   Ú_format_datetime64_dateonlyÿ  s
    

rí  r   )Úis_dates_only_rÏ  ry  rd   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Ï  ry  )rí  rF  ©ry  rÏ  ri   rj   r�    s     ÿz'get_format_datetime64.<locals>.<lambda>c                   s   t | ˆ d�S )N©rÏ  )rë  rF  rð  ri   rj   r�    rÃ  Nri   )rî  rÏ  ry  ri   rï  rj   Úget_format_datetime64  s    rñ  z*np.ndarray | DatetimeArray | DatetimeIndex)r„   ry  rd   c                 C  s6   t | tjƒr| jdkr|  ¡ } t| ƒ}|r2|p0dS |S )z6given values and a date_format, return a string formatr™   z%Y-%m-%d)r©   rŸ  r¤  Úndimr¸  rê  )r„   ry  Úidori   ri   rj   Ú!get_format_datetime64_from_values  s    rô  c                   @  s   e Zd Zddœdd„ZdS )r�  rt   rl   c                   s>   | j  t¡}t|ƒ}| jp&t|| jd�‰ ‡ fdd„|D ƒ}|S )zwe by definition have a TZ)ry  c                   s   g | ]}ˆ |ƒ‘qS ri   ri   rÝ   rÍ  ri   rj   r~   4  s     z9Datetime64TZFormatter._format_strings.<locals>.<listcomp>)r„   rÜ  r¼  rê  r<  rñ  ry  )rh   r„   ró  rƒ   ri   rÍ  rj   r™  -  s     ÿz%Datetime64TZFormatter._format_stringsNrÎ  ri   ri   ri   rj   r�  ,  s   r�  c                      s8   e Zd Zddddddœ‡ fdd	„Zd
dœdd„Z‡  ZS )r‘  r   Fznp.ndarray | TimedeltaIndexr]   r\   r^   ©r„   rÏ  Úboxrd   c                   s    t ƒ j|f|Ž || _|| _d S r­   )rÒ   rk   rÏ  rö  )rh   r„   rÏ  rö  rÌ   rÕ   ri   rj   rk   :  s    zTimedelta64Formatter.__init__rt   rl   c                   s.   | j pt| j| j| jd�‰ ‡ fdd„| jD ƒS )N)rÏ  rö  c                   s   g | ]}ˆ |ƒ‘qS ri   ri   rÝ   rÍ  ri   rj   r~   I  s     z8Timedelta64Formatter._format_strings.<locals>.<listcomp>)r<  Úget_format_timedelta64r„   rÏ  rö  rx   ri   rÍ  rj   r™  E  s      ÿz$Timedelta64Formatter._format_strings)r   FrÒ  ri   ri   rÕ   rj   r‘  9  s     ür‘  Fz,np.ndarray | TimedeltaIndex | TimedeltaArrayzstr | floatrõ  c           
        s^   |   tj¡}|tk}d}|| dk}t ||¡}| ¡ dk}|rFd‰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
    l     ž"R: r   NÚlongc                   sN   | d kst | ƒrt| ƒrˆS t| tƒs.t| ƒ} | jˆd�}ˆ rJd|› d�}|S )NrÌ  ú')r7   r:   r©   r   Z
_repr_base)rÞ   r…   ©rö  r²   rÏ  ri   rj   rÓ  k  s    
z*get_format_timedelta64.<locals>._formatter)ÚviewrŸ  Zint64r   ræ  rÙ   )
r„   rÏ  rö  rç  rè  Zone_day_nanosZnot_midnightZbothré  rÓ  ri   rú  rj   r÷  L  s    r÷  zTextAdjustment | None)r1  rR   r2  r—   rd   c                   s®   t | ƒdks|dkr| S |d kr(tƒ ‰ n|‰ t‡ fdd„| D ƒƒ‰|d k	rTt|ˆƒ‰tdƒ‰ˆd k	rpˆˆkrpˆ‰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Ý   )Ú
adjustmentri   rj   r¯   ‰  s     z$_make_fixed_width.<locals>.<genexpr>rå   r]   )rÞ   rd   c                   s6   ˆd k	r2ˆdkˆ   | ¡ˆk@ r2| d ˆd … d } | S )Nr¸   r¹   rÄ   rF  )rü  Úconf_maxrÈ   ri   rj   Újust’  s    z_make_fixed_width.<locals>.justc                   s   g | ]}ˆ |ƒ‘qS ri   ri   rÝ   )rþ  ri   rj   r~   ˜  s     z%_make_fixed_width.<locals>.<listcomp>rº   )rp   r–   r9  r   rR   )r1  rR   r2  r—   r…   ri   )rü  rý  rþ  rÈ   rj   r7  {  s    
r7  r³  )Ústr_complexesrú   rd   c                   sD   ‡ fdd„| D ƒ}dd„ |D ƒ}t |ƒ‰‡fdd„t||ƒD ƒ}|S )z‰
    Separates the real and imaginary parts from the complex number, and
    executes the _trim_zeros_float method on each of those.
    c              	     s$   g | ]}d   tt d|¡ˆ ƒ¡‘qS )rf   z([j+-]))r�   r¿  ÚrerP  rÝ   )rú   ri   rj   r~   ¢  s   ÿz'_trim_zeros_complex.<locals>.<listcomp>c                 S  s   g | ]}t |ƒ‘qS ri   rÄ   )r|   Úsri   ri   rj   r~   ¨  s     c                   sŒ   g | ]„\}}|d |d d d  … ˆ | d d  ||d d d  |d d  …  ||d d  d…  ˆ | d d  |d  ‘qS )Nr™   rš   Ú0rØ  ri   )r|   r  rJ  )Ú
max_lengthri   rj   r~   ª  s   úÿ"þýüû)r9  r   )rÿ  rú   ÚtrimmedÚlengthsÚpaddedri   )rú   r  rj   r¾  �  s    
þ
ù	r¾  )Ú	str_floatrd   c                 C  s    |   d¡} |  d¡r| d7 } | S )zX
    Trims trailing zeros after a decimal point,
    leaving just one if necessary.
    r  rð   )ÚrstripÚendswith)r  ri   ri   rj   r›  ¶  s    

r›  únp.ndarray | list[str])Ú
str_floatsrú   rd   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]*$r\   rl   c                   s   t  ˆ | ¡d k	S r­   )r   ÚmatchrF  )Únumber_regexri   rj   Úis_number_with_decimalÍ  s    z1_trim_zeros_float.<locals>.is_number_with_decimalr
  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 ri   ri   rÝ   ©r  ri   rj   r~   Ø  s      z:_trim_zeros_float.<locals>.should_trim.<locals>.<listcomp>r   c                 s  s   | ]}|  d ¡V  qdS )r  N©r	  rÝ   ri   ri   rj   r¯   Ù  s     z9_trim_zeros_float.<locals>.should_trim.<locals>.<genexpr>)rp   r  )r„   Únumbersr  ri   rj   Úshould_trimÐ  s    z&_trim_zeros_float.<locals>.should_trimc                   s$   g | ]}ˆ |ƒr|d d… n|‘qS )NrØ  ri   rÝ   r  ri   rj   r~   Ü  s     z%_trim_zeros_float.<locals>.<listcomp>c                   s*   g | ]"}ˆ|ƒr"|  ˆ ¡r"|d  n|‘qS )r  r  rÝ   )rú   r  ri   rj   r~   ß  s   ÿ)r   Úcompile)r  rú   r  r  r…   ri   )rú   r  r  rj   r¿  Â  s    þr¿  rB   )r�   rd   c                 C  s$   t | tƒrtj| jŽ S | jd k	S d S r­   )r©   rC   ÚcomZany_not_noner°   r‘   )r�   ri   ri   rj   r  æ  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
    rB  ÚzÚar†  ÚpÚnÚurµ  rf   rJ  ÚMÚGÚTÚPÚEÚZÚY)ièÿÿÿiëÿÿÿiîÿÿÿiñÿÿÿiôÿÿÿi÷ÿÿÿiúÿÿÿéýÿÿÿr   r¸   rÄ  é	   r�  é   é   é   é   NFr�   r\   r^   ©ÚaccuracyÚuse_eng_prefixrd   c                 C  s   || _ || _d S r­   ©r)  r*  )rh   r)  r*  ri   ri   rj   rk   	  s    zEngFormatter.__init__Úfloatr]   )Únumrd   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k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
        rZ   Úinfr™   r   rØ  r¸   zE-Ú02dzE+rÈ  Nz{mant: g}{prefix}z{mant: .rš  z
f}{prefix})ÚmantÚprefix)r   r]   Úis_nanÚis_infiniter›   Úmathrß  rà  rœ   r9  ÚENG_PREFIXESr  r*  r)  r²   )
rh   r-  ZdnumÚsignZpow10Z	int_pow10r1  r0  Ú
format_strrº  ri   ri   rj   Ú__call__  s4    

 
zEngFormatter.__call__)NF)r‡   rˆ   r‰   rT  r5  rk   r8  ri   ri   ri   rj   r  í  s.   ï   ÿr  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+  ri   ri   rj   Úset_eng_float_formatN  s    7r9  rf   zbool | object | strzlist[dict[int, int]])rH  Úsentinelrd   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)rp   r5  r‚   )	rH  r:  Úcontrolr…   r@  Ú
last_indexr  r}   Úkeyri   ri   rj   Úget_level_lengthsˆ  s     r>  zWriteBuffer[str])r`   Úlinesrd   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©   r]   rÝ   ri   ri   rj   r¯   ¾  s     z#buffer_put_lines.<locals>.<genexpr>c                 S  s   g | ]}t |ƒ‘qS ri   rN  rÝ   ri   ri   rj   r~   ¿  s     z$buffer_put_lines.<locals>.<listcomp>ro   N)r±   r…  r�   )r`   r?  ri   ri   rj   Úbuffer_put_lines³  s    r@  )NN)N)	NrZ   NNrP   rð   TNN)r   )r   N)r   N)r   F)rP   NN)rð   )rð   )r¸   F)rf   )™rT  Ú
__future__r   Ú
contextlibr   Úcsvr   r   rú   r   Ú	functoolsr   Úior   r4  r   Úshutilr	   Útypingr
   r   r   r   r   r   r   r   r   r   r   r   Úunicodedatar   ÚnumpyrŸ  Zpandas._config.configr   r   Zpandas._libsr   Zpandas._libs.missingr   Zpandas._libs.tslibsr   r   r   r   r   r    Zpandas._libs.tslibs.nattyper!   Zpandas._typingr"   r#   r$   r%   r&   r'   r(   r)   r*   r+   r,   Zpandas.core.dtypes.commonr-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   Zpandas.core.dtypes.dtypesr9   Zpandas.core.dtypes.missingr:   r;   Zpandas.core.arraysr<   r=   r>   Zpandas.core.arrays.string_r?   Zpandas.core.baser@   Zpandas.core.commonÚcoreÚcommonr  Zpandas.core.constructionrA   Zpandas.core.indexes.apirB   rC   rD   rE   Zpandas.core.indexes.datetimesrF   Zpandas.core.indexes.timedeltasrG   Zpandas.core.reshape.concatrH   Zpandas.io.commonrI   rJ   rê   rK   ZpandasrL   rM   rN   Ú__annotations__Z_VALID_JUSTIFY_PARAMETERSrX   rY   rŠ   rÀ   rÍ   r–   rì   rî   rï   rV  ra  r„  rv   r•  r“  r”  r�  r’  rã  rê  rë  rí  rñ  rô  r�  r‘  r÷  r7  r¾  r›  r¿  r  r  r9  r>  r@  ri   ri   ri   rj   Ú<module>   sÌ   8 48;	@ !'!&   E @  ý ÿ(         õ&Rp -F  ý   ÿ  ý1   ü" ÿ$a; ÿ+