a oEb" @sddlmZddlmZddlmZddlZddlmZm Z m Z m Z m Z m Z mZmZmZmZddlmZddlZddlmZddlmZdd lmZdd lmZdd lmZdd l m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&dd l'm(Z(ddl)m*m+Z,edddZ-ddl.m/Z0ee1e fZ2ee2e ee e2ffZ3ee1ee1e4e5ffZ6e e6Z7ee1e7fZ8GdddeZ9e e9Z:ee;ee"fZddddddddZ?did!d"d#d$Z@djd%dd&d'd(d)d*ZAdd"d+d,ZBd-d-d.d/d0ZCdkdd&ddd2d3d4ZDd5dd6d5d7d8d9ZEd:d;ZFd d?d@ZdKdz)StylerRenderer.__init__..cs ttdSrLrNr)rMr)r*rPrQcs ttdSrLrNr)rMr)r*rPrQ)( isinstancerZto_framer TypeErrorr9indexcolumnsr6rhexminr:lenr;r<r=r>r?csshide_index_nameshide_column_namesnlevels hide_index_ hide_columns_ hidden_rowshidden_columnsrlistctx ctx_index ctx_columnsr! cell_context_todotooltipsr_display_funcs_display_funcs_index_display_funcs_columns) selfr9r:r;r<r=r>r?r@r)rMr*__init__Ns\       zStylerRenderer.__init__r!) sparse_indexsparse_columnsmax_rowsmax_colsr,cKsB||||||}|||jjfi||j|jdS)z Renders the ``Styler`` including all applied styles to HTML. Generates a dict with necessary kwargs passed to jinja2 template. )Zhtml_table_tplZhtml_style_tpl)_compute _translateupdate template_htmlrendertemplate_html_tabletemplate_html_style)rkrmrnrorpkwargsdr)r)r* _render_htmls   zStylerRenderer._render_html)rmrnclinesr,cKsr||j||dd}|j||dt|jjd<t|jjd<t|jjd<t|jjd<| ||jj fi|S)z1 Render a Styler in latex format )rJ)r{Z parse_wrapZ parse_tableZ parse_cell parse_header) rqrr_translate_latex_parse_latex_table_wrappingtemplate_latexglobals_parse_latex_table_styles_parse_latex_cell_styles_parse_latex_header_spanrsru)rkrmrnr{rxryr)r)r* _render_latexs     zStylerRenderer._render_latexcCsJ|j|j|j|}|jD]\}}}|||i|}q(|S)a Execute the style functions built up in `self._todo`. Relies on the conventions that all style functions go through .apply or .applymap. The append styles to apply as tuples of (application method, *args, **kwargs) )rbclearrcrdrf)rkrfuncargsrxr)r)r*rqs   zStylerRenderer._compute )rm sparse_colsrorprJcCs||jd<|jt|jpg|jd}td}|r4|ntd}|rD|ntd}tt|jj t|jj |||\}}t t |_ |||}|d|it|j |||j} |d| it t |_t t |_|| ||} |d| id d d d } | D].\} } d dt|| D}|| |iq|j}tdsb|p@d}d|vrZ|dd}n|d7}|d|i|jr|j||}|S)a Process Styler data and settings into a dict for template rendering. Convert data and settings from ``Styler`` attributes such as ``self.data``, ``self.tooltips`` including applying any methods in ``self._todo``. Parameters ---------- sparse_index : bool Whether to sparsify the index or print all hierarchical index elements. Upstream defaults are typically to `pandas.options.styler.sparse.index`. sparse_cols : bool Whether to sparsify the columns or print all hierarchical column elements. Upstream defaults are typically to `pandas.options.styler.sparse.columns`. blank : str Entry to top-left blank cells. max_rows, max_cols : int, optional Specific max rows and cols. max_elements always take precedence in render. Returns ------- d : dict The following structure: {uuid, table_styles, caption, head, body, cellstyle, table_attributes} blank_value)r:r<r>zstyler.render.max_elementszstyler.render.max_rowszstyler.render.max_columnshead index_lengthsbody cellstyle_mapcellstyle_map_indexcellstyle_map_columns) cellstyleZcellstyle_indexZcellstyle_columnscSsg|]\}}t||dqS))r$ selectors)ra).0r$rr)r)r* sz-StylerRenderer._translate..zstyler.html.mathjaxr|zclass="zclass="tex2jax_ignore z class="tex2jax_ignore"r=)rYr:format_table_stylesr<r>r_get_trimming_maximumsrXr9rTrUrrar_translate_headerrs_get_level_lengthsr_rr_translate_bodyitemsgetattrr=replacergrr)rkrmrrorprJry max_elementsr idx_lengthsrZctx_mapskattrmapZ table_attrr)r)r*rrsb!           zStylerRenderer._translate) sparsify_colsrpc Cst|j|||j}|jj}|jjjdkr:dd|D}tt|}g}t|j D]0\}}|sT|shqTqT| ||f||}| |qT|jj j rtj|jj j rt|js|js||||} | | |S)aN Build each within table as a list Using the structure: +----------------------------+---------------+---------------------------+ | index_blanks ... | column_name_0 | column_headers (level_0) | 1) | .. | .. | .. | | index_blanks ... | column_name_n | column_headers (level_n) | +----------------------------+---------------+---------------------------+ 2) | index_names (level_0 to level_n) ... | column_blanks ... | +----------------------------+---------------+---------------------------+ Parameters ---------- sparsify_cols : bool Whether column_headers section will add colspan attributes (>1) to elements. max_cols : int Maximum number of columns to render. If exceeded will contain `...` filler. Returns ------- head : list The associated HTML elements needed for template rendering. cSsg|] }|gqSr)r)rxr)r)r*rOrQz4StylerRenderer._translate_header..)rrUr`r9tolistr\razip enumerater^_generate_col_header_rowappendrTnamescomZ any_not_noneallr]rZ_generate_index_names_row) rkrrp col_lengthsclabelsrrhide header_rowZindex_names_rowr)r)r*r/s8      z StylerRenderer._translate_headertupledict)iterrprc Cs|\}}td|jd|jddg|jjt|jd}|jjj|}td|durr|jdd|jd|n|jd d|jd||dur|j s|n|jdt |j g}gd } } t ||D]\} } t | ||} | r| | || fd 7} | |krJ| td|jd d|jd|d|jd d dddqtd|jd d|jd|d|jd| | | |j|| f| | || fd dkrd| || fd dndd}|jr|jd|d|jd| |d<| rz|| f|jvrz|j|| frz|jd|d|jd| |d<|jt|j|| f|jd|d|jd| | |q||| S)aC Generate the row containing column headers: +----------------------------+---------------+---------------------------+ | index_blanks ... | column_name_i | column_headers (level_i) | +----------------------------+---------------+---------------------------+ Parameters ---------- iter : tuple Looping variables from outer scope max_cols : int Permissible number of columns col_lenths : c Returns ------- list of elements thrJrTrN rIrDrrCrG...r| attributesrE colspan="" display_valuer_id)_elementrYrTr\sumr]r9rUrr[rr _is_visiblegetrrjr?rdrr)rkrrprrrZ index_blanksnameZ column_nameZcolumn_headersvisible_col_countcvalueheader_element_visibleheader_elementr)r)r*rks      &  &  z'StylerRenderer._generate_col_header_rowc s|}fddtjjjD}gd}}|rjjd}t||D]\} } t| ||} | rf|d7}||kr|tdj ddj d| dj d j d d d d q|tdj ddj d| j d | j vqF||S)a Generate the row containing index names +----------------------------+---------------+---------------------------+ | index_names (level_0 to level_n) ... | column_blanks ... | +----------------------------+---------------+---------------------------+ Parameters ---------- iter : tuple Looping variables from outer scope max_cols : int Permissible number of columns Returns ------- list of elements csRg|]J\}}tdjddjd||dur>jdn|j| qS)rrDrrINrrrYr])rrrrkr)r*rs z.rrrrJrrErGrTr|r) rr9rTrrUr\rrrrYr`) rkrrprrZ index_namesZ column_blanksrZ last_levelrrrr)rr*rsB       z(StylerRenderer._generate_index_names_row)rrorpc sjj}tjjts(dd|D}gd}}fddtjDD]N\}}|d7}||kr~|} || q |||f||} || qN|S)a Build each within table as a list Use the following structure: +--------------------------------------------+---------------------------+ | index_header_0 ... index_header_n | data_by_column ... | +--------------------------------------------+---------------------------+ Also add elements to the cellstyle_map for more efficient grouped elements in block Parameters ---------- sparsify_index : bool Whether index_headers section will add rowspan attributes (>1) to elements. Returns ------- body : list The associated HTML elements needed for template rendering. cSsg|] }|gqSr)r)rr)r)r*r&rQz2StylerRenderer._translate_body..rcsg|]}|djvr|qSrr_)rzrr)r*r)sr) r9rTrrRrrZ itertuples_generate_trimmed_rowr_generate_body_row) rkrrorprlabelsr row_countrrow_tupZ trimmed_rowZbody_rowr)rr*rs"        zStylerRenderer._translate_bodyra)rpr,c sfddtjjjD}gd}}tjD]\}}|jv}|rN|d7}||kr|tdj ddj ddj d d d d d q|tdj ddj d|dj dd |d d q0||S)z When a render has too many rows we generate a trimming row containing "..." Parameters ---------- max_cols : int Number of permissible columns Returns ------- list of elements c sLg|]D}tdjddjd|djddj| ddqS)rrBrrIrHrr|rr)rrrr)r*rDs  z8StylerRenderer._generate_trimmed_row..rrtdr9rrHrGrTr|rrE) ranger9rTr\rrUr`rrrY)rkrp index_headersr9rrrdata_element_visibler)rr*r7s>    ( z$StylerRenderer._generate_trimmed_row)rrprc CsL|\}}}g}t||D]V\}} t|||o:|j| } td|jdd|jd|d|jd|| | |j||f| |||fddkrd|||fdd nd d } |jr|jd|d |jd|| d <| rh||f|jvrh|j||frh|jd|d |jd|| d <|j t |j||f |jd|d |jd|| | qgd} } t|ddD]\}} ||j vo||j v}|r| d7} | |kr | td|jdd|jd|d|jdddd dqDd }||f|jvr0d|j||f}td|jdd|jd|d|jd||| |d |j||f| d}|jr|jd|d |jd||d <|r6||f|jvr6|j||fr6|jd|d |jd||d <|jt |j||f |jd|d |jd|| |q|| S)a Generate a regular row for the body section of appropriate format. +--------------------------------------------+---------------------------+ | index_header_0 ... index_header_n | data_by_column ... | +--------------------------------------------+---------------------------+ Parameters ---------- iter : tuple Iterable from outer scope: row number, row data tuple, row index labels. max_cols : int Number of permissible columns. idx_lengths : dict A map of the sparsification structure of the index Returns ------- list of elements rrBrrIrFrr rowspan="rr|rrrNrr9rGrTrrE)rr)rrr]rrYrirr?rcrrrr`r_rerhrbr)rkrrprrrrrrrrrr9rrclsZ data_elementr)r)r*rrs    &      &&& z!StylerRenderer._generate_body_rowNone)ryr{r,c sjj}|tjfddt|dD|d<g}tfddttjjD|dD]f\}t jrzg}n fddt|d|D}fddt||dD}| ||qb||d<|d vrt d |d n|durd |vrt|nd }t t |d<fddttjjD} fddt|D} t| D]\} t| D]t\} } | |dkrd|vrqd|d| fd}|durd|d| | d| ddt| |dqdqTdS)a Post-process the default render dict for the LaTeX template format. Processing items included are: - Remove hidden columns from the non-headers part of the body. - Place cellstyles directly in td cells rather than use cellstyle_map. - Remove hidden indexes or reinsert missing th elements if part of multiindex or multirow sparsification (so that \multirow and \multicol work correctly). cs*g|]"\}fddt|DqS)cs6g|].\}}|dri|dj|fiqS) is_visibler)rdrrrErrkvisible_index_level_nr)r*rsz>StylerRenderer._translate_latex...)r)rrF)rkr)rr*rsz3StylerRenderer._translate_latex..rcsg|]}|jvr|qSr)rrrrr)r*rrQrcsRg|]J\}}|ddkrj|si||dr8|dndj|fdqS)typerrrr|)rr)r]rcrrrkr)r*rs  Ncs>g|]6\}}|dr|ddkri|dj|fiqS)rrrr)rbrrr)r*rs)Nzall;dataz all;indexzskip-last;datazskip-last;indexz`clines` value of zj is invalid. Should either be None or one of 'all;data', 'all;index', 'skip-last;data', 'skip-last;index'.r9rr{csg|]}|jvr|qSr)rrrr)r*r-scsg|]}j|s|qSr))r]rirr)r*r0srz skip-lastrz\cline{-})rTr\rr]rrrrXr9rr ValueErrorrrar)rkryr{Z index_levelsrrFZrow_body_headersZrow_body_cellsdata_lenZvisible_row_indexesZvisible_index_levelsrnZlvlnlvlZidx_lenr)rr*r~sT             zStylerRenderer._translate_latex.zExtFormatter | Nonez Subset | None) formattersubsetna_repr@decimal thousandsr hyperlinksr,c  stdu|du|du|dk|du|du|du|dufrF|j|S|durVtdn|}t|}|jj|} ttsfdd| j D|j | j } |j | j } | D]>} t |j | ||||||d} | D]}| |j|| f<qq|S)u  Format the text display value of cells. Parameters ---------- formatter : str, callable, dict or None Object to define how values are displayed. See notes. subset : label, array-like, IndexSlice, optional A valid 2d input to `DataFrame.loc[]`, or, in the case of a 1d input or single key, to `DataFrame.loc[:, ]` where the columns are prioritised, to limit ``data`` to *before* applying the function. na_rep : str, optional Representation for missing values. If ``na_rep`` is None, no special formatting is applied. .. versionadded:: 1.0.0 precision : int, optional Floating point precision to use for display purposes, if not determined by the specified ``formatter``. .. versionadded:: 1.3.0 decimal : str, default "." Character used as decimal separator for floats, complex and integers. .. versionadded:: 1.3.0 thousands : str, optional, default None Character used as thousands separator for floats, complex and integers. .. versionadded:: 1.3.0 escape : str, optional Use 'html' to replace the characters ``&``, ``<``, ``>``, ``'``, and ``"`` in cell display string with HTML-safe sequences. Use 'latex' to replace the characters ``&``, ``%``, ``$``, ``#``, ``_``, ``{``, ``}``, ``~``, ``^``, and ``\`` in the cell display string with LaTeX-safe sequences. Escaping is done before ``formatter``. .. versionadded:: 1.3.0 hyperlinks : {"html", "latex"}, optional Convert string patterns containing https://, http://, ftp:// or www. to HTML tags as clickable URL hyperlinks if "html", or LaTeX \href commands if "latex". .. versionadded:: 1.4.0 Returns ------- self : Styler Notes ----- This method assigns a formatting function, ``formatter``, to each cell in the DataFrame. If ``formatter`` is ``None``, then the default formatter is used. If a callable then that function should take a data value as input and return a displayable representation, such as a string. If ``formatter`` is given as a string this is assumed to be a valid Python format specification and is wrapped to a callable as ``string.format(x)``. If a ``dict`` is given, keys should correspond to column names, and values should be string or callable, as above. The default formatter currently expresses floats and complex numbers with the pandas display precision unless using the ``precision`` argument here. The default formatter does not adjust the representation of missing values unless the ``na_rep`` argument is used. The ``subset`` argument defines which region to apply the formatting function to. If the ``formatter`` argument is given in dict form but does not include all columns within the subset then these columns will have the default formatter applied. Any columns in the formatter dict excluded from the subset will be ignored. When using a ``formatter`` string the dtypes must be compatible, otherwise a `ValueError` will be raised. When instantiating a Styler, default formatting can be applied be setting the ``pandas.options``: - ``styler.format.formatter``: default None. - ``styler.format.na_rep``: default None. - ``styler.format.precision``: default 6. - ``styler.format.decimal``: default ".". - ``styler.format.thousands``: default None. - ``styler.format.escape``: default None. Examples -------- Using ``na_rep`` and ``precision`` with the default ``formatter`` >>> df = pd.DataFrame([[np.nan, 1.0, 'A'], [2.0, np.nan, 3.0]]) >>> df.style.format(na_rep='MISS', precision=3) # doctest: +SKIP 0 1 2 0 MISS 1.000 A 1 2.000 MISS 3.000 Using a ``formatter`` specification on consistent column dtypes >>> df.style.format('{:.2f}', na_rep='MISS', subset=[0,1]) # doctest: +SKIP 0 1 2 0 MISS 1.00 A 1 2.00 MISS 3.000000 Using the default ``formatter`` for unspecified columns >>> df.style.format({0: '{:.2f}', 1: '£ {:.1f}'}, na_rep='MISS', precision=1) ... # doctest: +SKIP 0 1 2 0 MISS £ 1.0 A 1 2.00 MISS 3.0 Multiple ``na_rep`` or ``precision`` specifications under the default ``formatter``. >>> df.style.format(na_rep='MISS', precision=1, subset=[0]) ... .format(na_rep='PASS', precision=2, subset=[1, 2]) # doctest: +SKIP 0 1 2 0 MISS 1.00 A 1 2.0 PASS 3.00 Using a callable ``formatter`` function. >>> func = lambda s: 'STRING' if isinstance(s, str) else 'FLOAT' >>> df.style.format({0: '{:.1f}', 2: func}, precision=4, na_rep='MISS') ... # doctest: +SKIP 0 1 2 0 MISS 1.0000 STRING 1 2.0 MISS FLOAT Using a ``formatter`` with HTML ``escape`` and ``na_rep``. >>> df = pd.DataFrame([['
', '"A&B"', None]]) >>> s = df.style.format( ... '{0}', escape="html", na_rep="NA" ... ) >>> s.to_html() # doctest: +SKIP ... <div></div> "A&B" NA ... Using a ``formatter`` with LaTeX ``escape``. >>> df = pd.DataFrame([["123"], ["~ ^"], ["$%#"]]) >>> df.style.format("\\textbf{{{}}}", escape="latex").to_latex() ... # doctest: +SKIP \begin{tabular}{ll} {} & {0} \\ 0 & \textbf{123} \\ 1 & \textbf{\textasciitilde \space \textasciicircum } \\ 2 & \textbf{\$\%\#} \\ \end{tabular} Nrcsi|] }|qSr)r))rrErr)r* rQz)StylerRenderer.format..rr@rrrr)rrhrslicenon_reducing_slicer9locrRrrUZget_indexer_forrT_maybe_wrap_formatterr)rkrrrr@rrrrr9ZcisZrisci format_funcrir)rr*format=sD)    zStylerRenderer.formatrz int | strLevel | list[Level] | None) raxisrIrr@rrrrr,c  s|jdkr$|j|j} n|j|j} t|} tdu|du|du|dk|du|du|du| dufr| |St t sfdd| Dnfdd D| D]Jt  |||||| d} fdd ttDD] } | | | <qq|S) a Format the text display value of index labels or column headers. .. versionadded:: 1.4.0 Parameters ---------- formatter : str, callable, dict or None Object to define how values are displayed. See notes. axis : {0, "index", 1, "columns"} Whether to apply the formatter to the index or column headers. level : int, str, list The level(s) over which to apply the generic formatter. na_rep : str, optional Representation for missing values. If ``na_rep`` is None, no special formatting is applied. precision : int, optional Floating point precision to use for display purposes, if not determined by the specified ``formatter``. decimal : str, default "." Character used as decimal separator for floats, complex and integers. thousands : str, optional, default None Character used as thousands separator for floats, complex and integers. escape : str, optional Use 'html' to replace the characters ``&``, ``<``, ``>``, ``'``, and ``"`` in cell display string with HTML-safe sequences. Use 'latex' to replace the characters ``&``, ``%``, ``$``, ``#``, ``_``, ``{``, ``}``, ``~``, ``^``, and ``\`` in the cell display string with LaTeX-safe sequences. Escaping is done before ``formatter``. hyperlinks : {"html", "latex"}, optional Convert string patterns containing https://, http://, ftp:// or www. to HTML tags as clickable URL hyperlinks if "html", or LaTeX \href commands if "latex". Returns ------- self : Styler Notes ----- This method assigns a formatting function, ``formatter``, to each level label in the DataFrame's index or column headers. If ``formatter`` is ``None``, then the default formatter is used. If a callable then that function should take a label value as input and return a displayable representation, such as a string. If ``formatter`` is given as a string this is assumed to be a valid Python format specification and is wrapped to a callable as ``string.format(x)``. If a ``dict`` is given, keys should correspond to MultiIndex level numbers or names, and values should be string or callable, as above. The default formatter currently expresses floats and complex numbers with the pandas display precision unless using the ``precision`` argument here. The default formatter does not adjust the representation of missing values unless the ``na_rep`` argument is used. The ``level`` argument defines which levels of a MultiIndex to apply the method to. If the ``formatter`` argument is given in dict form but does not include all levels within the level argument then these unspecified levels will have the default formatter applied. Any levels in the formatter dict specifically excluded from the level argument will be ignored. When using a ``formatter`` string the dtypes must be compatible, otherwise a `ValueError` will be raised. Examples -------- Using ``na_rep`` and ``precision`` with the default ``formatter`` >>> df = pd.DataFrame([[1, 2, 3]], columns=[2.0, np.nan, 4.0]) >>> df.style.format_index(axis=1, na_rep='MISS', precision=3) # doctest: +SKIP 2.000 MISS 4.000 0 1 2 3 Using a ``formatter`` specification on consistent dtypes in a level >>> df.style.format_index('{:.2f}', axis=1, na_rep='MISS') # doctest: +SKIP 2.00 MISS 4.00 0 1 2 3 Using the default ``formatter`` for unspecified levels >>> df = pd.DataFrame([[1, 2, 3]], ... columns=pd.MultiIndex.from_arrays([["a", "a", "b"],[2, np.nan, 4]])) >>> df.style.format_index({0: lambda v: upper(v)}, axis=1, precision=1) ... # doctest: +SKIP A B 2.0 nan 4.0 0 1 2 3 Using a callable ``formatter`` function. >>> func = lambda s: 'STRING' if isinstance(s, str) else 'FLOAT' >>> df.style.format_index(func, axis=1, na_rep='MISS') ... # doctest: +SKIP STRING STRING FLOAT MISS FLOAT 0 1 2 3 Using a ``formatter`` with HTML ``escape`` and ``na_rep``. >>> df = pd.DataFrame([[1, 2, 3]], columns=['"A"', 'A&B', None]) >>> s = df.style.format_index('$ {0}', axis=1, escape="html", na_rep="NA") ... # doctest: +SKIP $ "A" $ A&B NA ... Using a ``formatter`` with LaTeX ``escape``. >>> df = pd.DataFrame([[1, 2, 3]], columns=["123", "~", "$%#"]) >>> df.style.format_index("\\textbf{{{}}}", escape="latex", axis=1).to_latex() ... # doctest: +SKIP \begin{tabular}{lrrr} {} & {\textbf{123}} & {\textbf{\textasciitilde }} & {\textbf{\$\%\#}} \\ 0 & 1 & 2 & 3 \\ \end{tabular} rNrcsi|] }|qSr)r))rrIrr)r*rrQz/StylerRenderer.format_index..csi|]\}}||qSr))_get_level_number)rrIZ formatter_r/r)r*rsrcs$g|]}dkr|fn|fqSrr)r)rrr)r*rrQz/StylerRenderer.format_index..)r9Z_get_axis_numberrirTrjrUrefactor_levelsrrrRrrrrrrX)rkrrrIrr@rrrrZdisplay_funcs_levels_ridxr))rrrr+r* format_index sJ       zStylerRenderer.format_index)Nr4NNNTN)NN)NNr)NNNNrNNN) NrNNNrNNN)r%r&r'r.r0rZ PackageLoaderr3 EnvironmentenvZ get_templatertrvrwrrlrzrrqrrrrrrrrr~rrr)r)r)r*r1BsfGd<bA);vW Rr1r!r7r) html_element html_classrrr,cKs"d|vr||d<||||d|S)z] Template to return container with information for a or element. r)rrclassrr))rr rrrxr)r)r*rs r皙?ztuple[int, int]r,csXfdd}|r ||kr|n|}|r4||kr0|n|}|||krP|||\}}q4||fS)a: Recursively reduce the number of rows and columns to satisfy max elements. Parameters ---------- rn, cn : int The number of input rows / columns max_elements : int The number of allowable elements max_rows, max_cols : int, optional Directly specify an initial maximum rows or columns before compression. scaling_factor : float Factor at which to reduce the number of rows / columns to fit. Returns ------- rn, cn : tuple New rn and cn values that satisfy the max_elements constraint cs,||kr|t|fSt||fSdSN)r6)rcnscaling_factorr)r* scale_downsz*_get_trimming_maximums..scale_downr))rrrrorprrr)rr*rs  rrr6zSequence[int] | None)rTsparsify max_indexhidden_elementscCstt|tr|jtjdd}n|}|dur0g}i}t|tsht|D]\}}||vrFd|d|f<qF|St|D]\}}d} t|D]\} } | |krqp|s| |vrd||| f<| d7} q| tjur| |vr| } d||| f<| d7} q| tjur| } d||| f<q| |vr| d7} | |kr"qp||| fdkrF| } d||| f<q||| fd7<qqpdd|D} | S)aZ Given an index, find the level length for each element. Parameters ---------- index : Index Index or columns to determine lengths of each element sparsify : bool Whether to hide or show each distinct element in a MultiIndex max_index : int The maximum number of elements to analyse along the index due to trimming hidden_elements : sequence of int Index positions of elements hidden from display in the index affecting length Returns ------- Dict : Result is a dictionary of (level, initial_position): span F)rZadjoinNrrcSsi|]\}}|dkr||qS)rr))relementlengthr)r)r*rJsz&_get_level_lengths..)rRrrrZ no_defaultrr)rTrrrZlevelslengthsrrrZvisible_row_countjrFZ last_labelZnon_zero_lengthsr)r)r*rsN        rcCs ||f|vS)z/ Index -> {(idx_row, idx_col): bool}). r))Zidx_rowZidx_colrr)r)r*rQsr CSSStyles)stylesr,cCsdd|DS)z looks for multiple CSS selectors and separates them: [{'selector': 'td, th', 'props': 'a:v;'}] ---> [{'selector': 'td', 'props': 'a:v;'}, {'selector': 'th', 'props': 'a:v;'}] cSs.g|]&}|ddD]}||ddqqS)r",r$r"r$)split)rZcss_dictr"r)r)r*r_sz'format_table_styles..r))rr)r)r*rXsrF)rr@rr,cCsTt|ttfr2|r"|d|dS|d|dSt|trP|rH|dS|dS|S)a Format the display of a value Parameters ---------- x : Any Input variable to be formatted precision : Int Floating point precision used if ``x`` is float or complex. thousands : bool, default False Whether to group digits with thousands separated with ",". Returns ------- value : Any Matches input type, or string if input is float or complex or int with sep. z,.frz,.0fz.0f)rRfloatcomplexr6)rr@rr)r)r*rOfs $ rOrr5)rrrr,csfdd}|S)z Takes a string formatting function and wraps logic to deal with thousands and decimal parameters, in the case that they are non-standard and that the input is a (float, complex, int). cst|tttfrdkrHdurHdkrH|ddddSdkrpdus`dkrp|dSdkrdurdkr|dS|S)Nrru§_§-)rRrr r6rrrrrr)r*wrappersz(_wrap_decimal_thousands..wrapperr))rrrr#r)r"r*_wrap_decimal_thousandss r$cCs<t|tr8|dkrt|S|dkr*t|Std||S)z/if escaping: only use on str, else return inputhtmllatexz2`escape` only permitted in {'html', 'latex'}, got )rRr! escape_html _escape_latexr)rrr)r)r* _str_escapes r)csLt|trH|dkrdn|dkr&dntdd}t|fdd|S|S) zMuses regex to detect a common URL pattern and converts to href tag in format.r%z%{0}r&z\href{{{0}}}{{{0}}}z3``hyperlinks`` format can only be 'html' or 'latex'z6(https?:\/\/|ftp:\/\/|www.)[\w/\-?=%.]+\.[\w/\-&?=%.]+cs|dS)Nr)rgroup)mhrefr)r*rPrQz_render_href..)rRr!rresub)rrpatr)r,r* _render_hrefs r1rzBaseFormatter | Noner8)rrr@rrrrr,csttrfddnPtr&nBdurV|dur>tdn|}tt||dudntdtdurfdd}n}|dks|dur|d krt|||d n|durȇfd dndur؈Sfd dSdS) z Allows formatters to be expressed as str, callable or None, where None returns a default formatting function. wraps with na_rep, and precision where they are available. cs |Sr rr!rr)r*rPrQz'_maybe_wrap_formatter..NrK)r@rz*'formatter' expected str or callable, got cst|dS)Nr)r)r!)rfunc_0r)r*rPrQrr)rrcst|dS)Nr2)r1r!)func_2rr)r*rPrQcst|r S|Sr )rr!)func_3rr)r*rPrQ) rRr!callablerrrOrSrr$)rrr@rrrrZfunc_1r))rrr3r4r5rrr*rs.  rSubset)slice_csvttjtttf}t||r*tdd|f}ddddt|s\t|t sT|gg}qn|g}nfdd|D}t |S)z Ensure that a slice doesn't reduce to a Series or Scalar. Any user-passed `subset` should have this called on it to make sure we're always working with DataFrames. Nr7r cSs2t|trtdd|DSt|tp,t|SdS)z Returns ------- bool True if slice does *not* reduce, False if `part` is a tuple. css |]}t|tpt|VqdSr )rRrr)rsr)r)r* rQz3non_reducing_slice..pred..N)rRranyrr)partr)r)r*preds z non_reducing_slice..predcsg|]}|r|n|gqSr)r))rpr=r)r*rrQz&non_reducing_slice..) rnpZndarrayrrar!rRrrrr)r8kindsr)r?r*rs    rr#CSSList)styler,cCsLt|trH|d}zdd|DWStyFtd|dYn0|S)z Convert css-string to sequence of tuples format if needed. 'color:red; border:1px solid black;' -> [('color', 'red'), ('border','1px solid red')] ;cSs<g|]4}|dkr|dd|ddfqS)r|:rr)striprrr)r)r*r s z/maybe_convert_css_to_tuples..zSStyles supplied as string must follow CSS rule formats, for example 'attr: val;'. 'z ' was given.)rRr!r IndexErrorr)rCr9r)r)r*maybe_convert_css_to_tupless    rHrz list[int])rIr+r,csl|durttj}nPt|tr*|g}n>t|trB|g}n&t|tr`fdd|D}ntd|S)aX Returns a consistent levels arg for use in ``hide_index`` or ``hide_columns``. Parameters ---------- level : int, str, list Original ``level`` arg supplied to above methods. obj: Either ``self.index`` or ``self.columns`` Returns ------- list : refactored arg with a list of levels to hide Ncs$g|]}t|ts|n|qSr))rRr6r)rZlevr/r)r*rFsz#refactor_levels..z4`level` must be of type `int`, `str` or list of such)rarr\rRr6r!rr)rIr+rr)r/r*r-s    rc@sbeZdZdZgddefdddddd Zed d Zddd d dd ddZdddddZ dS)Tooltipsa An extension to ``Styler`` that allows for and manipulates tooltips on hover of ```` cells in the HTML result. Parameters ---------- css_name: str, default "pd-t" Name of the CSS class that controls visualisation of tooltips. css_props: list-like, default; see Notes List of (attr, value) tuples defining properties of the CSS class. tooltips: DataFrame, default empty DataFrame of strings aligned with underlying Styler data for tooltip display. Notes ----- The default properties for the tooltip CSS class are: - visibility: hidden - position: absolute - z-index: 1 - background-color: black - color: white - transform: translate(-20px, -20px) Hidden visibility is a key prerequisite to the hover functionality, and should always be included in any manual properties specification. )) visibilityhidden)positionabsolute)zz-indexr)background-colorblack)colorwhite)Z transformztranslate(-20px, -20px)zpd-tr#r!r) css_propscss_namergcCs||_||_||_g|_dSr ) class_nameclass_propertiestt_datar<)rkrRrSrgr)r)r*rlms zTooltips.__init__cCsd|jt|jdgS)a Combine the ``_Tooltips`` CSS class name and CSS properties to the format required to extend the underlying ``Styler`` `table_styles` to allow tooltips to render in HTML. Returns ------- styles : List rr)rTrHrUrr)r)r* _class_styless zTooltips._class_stylesr6)r:rrFrEtextcCsZd|dt|dt|}|d|dgd|d|dd d |d fgdgS) a: For every table data-cell that has a valid tooltip (not None, NaN or empty string) must create two pseudo CSS entries for the specific element id which are added to overall table styles: an on hover visibility change and a content change dependent upon the user's chosen display string. For example: [{"selector": "T__row1_col1:hover .pd-t", "props": [("visibility", "visible")]}, {"selector": "T__row1_col1 .pd-t::after", "props": [("content", "Some Valid Text String")]}] Parameters ---------- uuid: str The uuid of the Styler instance name: str The css-name of the class used for styling tooltips row : int The row index of the specified tooltip string data col : int The col index of the specified tooltip string data text : str The textual content of the tooltip to be displayed in HTML. Returns ------- pseudo_css : List z#T_Z_rowZ_colz:hover .)rJvisiblerz .z::aftercontentr)r!)rkr:rrFrErXZ selector_idr)r)r* _pseudo_csss  zTooltips._pseudo_cssr1r)stylerrycsjj_jjr|SjjjdBddfddttjj DD_ j r|dD]8}|D].}|ddkr~t |dd jd |d<q~qv|d  j |d  j |S) a= Mutate the render dictionary to allow for tooltips: - Add ```` HTML element to each data cells ``display_value``. Ignores headers. - Add table level CSS styles to control pseudo classes. Parameters ---------- styler_data : DataFrame Underlying ``Styler`` DataFrame used for reindexing. uuid : str The underlying ``Styler`` uuid for CSS id. d : dict The dictionary prior to final render Returns ------- render_dict : Dict r|cSsg|]}|D]}|q qSr)r))rZsublistrCr)r)r*rs z'Tooltips._translate..c shg|]`}ttjjD]J}j||fs|jvs|jvsj||t jj||fqqSr)) rrXrVrUZilocr_r`r[r:r!)rrrmaskrrkr\r)r*rs   rrrrz r<)rVZ reindex_liker9emptyrTreqrrXrTr<r!extendrW)rkr\ryrFitemr)r]r*rrs*     zTooltips._translateN) r%r&r'r.rrlpropertyrWr[rrr)r)r)r*rIOs +rI)r<r>r,cs.gd|dur&tfdd|Dp,|duS)a8 Indicate whether LaTeX {tabular} should be wrapped with a {table} environment. Parses the `table_styles` and detects any selectors which must be included outside of {tabular}, i.e. indicating that wrapping must occur, and therefore return True, or if a caption exists and requires similar. )ZtopruleZmidruleZ bottomruleZ column_formatNc3s|]}|dvVqdS)r"Nr))rryZIGNORED_WRAPPERSr)r*r:rQz._parse_latex_table_wrapping..)r;)r<r>r)rdr*rs r)r<r"r,cCsD|dddD]0}|d|krt|dddddSqdS) uy Return the first 'props' 'value' from ``tables_styles`` identified by ``selector``. Examples -------- >>> table_styles = [{'selector': 'foo', 'props': [('attr','value')]}, ... {'selector': 'bar', 'props': [('attr', 'overwritten')]}, ... {'selector': 'bar', 'props': [('a1', 'baz'), ('a2', 'ignore')]}] >>> _parse_latex_table_styles(table_styles, selector='bar') 'baz' Notes ----- The replacement of "§" with ":" is to avoid the CSS problem where ":" has structural significance and cannot be used in LaTeX labels, but is often required by them. Nr"r$rr§rE)r!r)r<r"rCr)r)r*rs "r) latex_stylesr convert_cssr,c Cs|r t|}|dddD]\}}d|d|dd|d|d|d|d|d|dd|d |dd }d||d |}d D],}|t|vr||d t||d}qqq|S)a Mutate the ``display_value`` string including LaTeX commands from ``latex_styles``. This method builds a recursive latex chain of commands based on the CSSList input, nested around ``display_value``. If a CSS style is given as ('', '') this is translated to '\{display_value}', and this value is treated as the display value for the next iteration. The most recent style forms the inner component, for example for styles: `[('c1', 'o1'), ('c2', 'o2')]` this returns: `\c1o1{\c2o2{display_value}}` Sometimes latex commands have to be wrapped with curly braces in different ways: We create some parsing flags to identify the different behaviours: - `--rwrap` : `\{}` - `--wrap` : `{\ }` - `--nowrap` : `\ ` - `--lwrap` : `{\} ` - `--dwrap` : `{\}{}` For example for styles: `[('c1', 'o1--wrap'), ('c2', 'o2')]` this returns: `{\c1o1 \c2o2{display_value}} Nrez{\z --to_parse r\z --to_parse} z --to_parse{z --to_parse}{)--wrap--nowrap--lwrap--rwrap--dwrapr)rkrjrlrmrnz --to_parserarg)_parse_latex_css_conversionr!r_parse_latex_options_strip)rgrrhcommandoptionsrrpr)r)r*rs"  rzdict[str, Any])cellmultirow_alignmulticol_alignwraprhr,c Cs\t|d|d|}d|vrB|d}d|vr||ddd}t|d|d}d|kr|rrd |d n|}|rd nd } || |d Sd|kr|rd |d n|}|rdnd} | |d |Sd|d|d|d Sd|vrB|dkr|S||ddd} t| d| d} d|d| d|d S|rTd |d S|SdS)a Refactor the cell `display_value` if a 'colspan' or 'rowspan' attribute is present. 'rowspan' and 'colspan' do not occur simultaneouly. If they are detected then the `display_value` is altered to a LaTeX `multirow` or `multicol` command respectively, with the appropriate cell-span. ``wrap`` is used to enclose the `display_value` in braces which is needed for column headers using an siunitx package. Requires the package {multirow}, whereas multicol support is usually built in to the {tabular} environment. Examples -------- >>> cell = {'cellstyle': '', 'display_value':'text', 'attributes': 'colspan="3"'} >>> _parse_latex_header_span(cell, 't', 'c') '\\multicolumn{3}{c}{text}' rrrr Nrznaive-l{rz & {}z &rznaive-rz{} & z& z \multicolumn{z}{rZnaivez \multirow[z]{z}{*}{)rfindr6) rurvrwrxrhZ display_valattrsZcolspanoutZblanksZrowspanr)r)r*rLs4      rzstr | int | float)rrpr,cCs$t||dddddS)z Strip a css_value which may have latex wrapping arguments, css comment identifiers, and whitespaces, to a valid string for latex options parsing. For example: 'red /* --wrap */ ' --> 'red' r|z/*z*/)r!rrFror)r)r*rrsrrc Csdd}dd}dd}|t|ddd t|d d d |d }g}|D]\}}t|trrd |vrr|||d d f||vrBd }dD]$} | t|vr| t|| }}qq||||} | durB|| gqB|S)z Convert CSS (attribute,value) pairs to equivalent LaTeX (command,options) pairs. Ignore conversion if tagged with `--latex` option, skipped if no conversion found. cSs|dks|dkrd|fSdS)NboldZbolderZbfseriesr)ror)r)r* font_weights z0_parse_latex_css_conversion..font_weightcSs(|dkrd|fS|dkr$d|fSdS)NitalicZitshapeZobliqueZslshaper)ror)r)r* font_styles   z/_parse_latex_css_conversion..font_stylec Ss|dkr |n|}|ddkrHt|dkrH|d|ddd|fS|ddkrt|d kr|dd |d d |d d }|d|d|fS|dd d krtd |d}d|vrt|dddn t|d}td|d}d|vr(t|dddn t|d}|d dkrXtd|d}ntd|d}d|vrt|dddn t|d}|d|dd|dd|dd|fS|d|d|fSdS)a CSS colors have 5 formats to process: - 6 digit hex code: "#ff23ee" --> [HTML]{FF23EE} - 3 digit hex code: "#f0e" --> [HTML]{FF00EE} - rgba: rgba(128, 255, 0, 0.5) --> [rgb]{0.502, 1.000, 0.000} - rgb: rgb(128, 255, 0,) --> [rbg]{0.502, 1.000, 0.000} - string: red --> {red} Additionally rgb or rgba can be expressed in % which is also parsed. r|r#z[HTML]{rNrrgbz(?<=\()[0-9\s%]+(?=,)%redz(?<=,)[0-9\s%]+(?=,)az(?<=,)[0-9\s%]+(?=\))z[rgb]{z.3fz, rz)rXupperr.findallrFrr6) rZuser_argrscomm_argrpvalrgbr)r)r*rPs"  4(**&z*_parse_latex_css_conversion..colorZ cellcolorrl)rsrrPr|)z font-weightrNrPz font-stylez--latex)rjrkrlrnrmN)rrRr!rrkeysrrra) rrrrPZCONVERTED_ATTRIBUTESrg attributerrprZ latex_styler)r)r*rqs,"     rqcCst|ddddddddd d d d d dddddddddddddddS)al Replace the characters ``&``, ``%``, ``$``, ``#``, ``_``, ``{``, ``}``, ``~``, ``^``, and ``\`` in the string with LaTeX-safe sequences. Use this if you need to display text that might contain such characters in LaTeX. Parameters ---------- s : str Input to be escaped Return ------ str : Escaped string riu ab2§=§8yzu ab2§=§8yz uab2§=§8yz\space &z\&rz\%$z\$rz\#rz\_rzz\{rz\}z~ z~\space ~z\textasciitilde z^ z^\space ^z\textasciicircum z\textbackslash )r)r9r)r)r*r(s8      r()NNr )N)F)NNNrNNN)F)FF)T __future__r collectionsr functoolsrr.typingrrrrr r r r r rr:rnumpyr@Zpandas._configrZ pandas._libsrZpandas._typingrZpandas.compat._optionalrZpandas.core.dtypes.genericrr2rrrrrrZpandas.api.typesrZpandas.core.commoncorecommonrrZ markupsaferr'r! BaseFormatterZ ExtFormatterr6rZCSSPairrBr#r rrr7r0r1rrrrrrOr$r)r1rrrHrrIrrrrrrrqr(r)r)r)r*s   0            1Q6+"'47 L