HEX

File: //opt/alt/python37/lib/python3.7/site-packages/tabulate/__pycache__/__init__.cpython-37.pyc
B

�P�e:t�-@s>
dZddlmZddlmZmZddlmZddl	m
Z
mZddl
mZmZddlZddlZddlZddlZddlZyddlZWnek
r�dZYnXdd	�Zd
ddgZyd
dlmZWnek
r�YnXdZdZdZdZdZdZ edk	Z!dZ"edddddg�Z#eddddg�Z$edddddd d!d"d#g�Z%d$d%�Z&d&d'�Z'd(d)�Z(d*d+�Z)d,d-�Z*d.d/�Z+d0d1�Z,�d*d2d3�Z-�d+d4d5�Z.d6d7�Z/d8d9d:d;d<d=d>d?d@dAdBdCdD�Z0e0fdEdF�Z1dGdH�Z2e%e#ddIdJd�e#ddIdJd�de#ddIdJd�e$ddJd�e$ddJd�dddgdK�e%dddde$ddJd�e$ddJd�dddK�e%e#dLdIdLdL�e#dLdMdLdL�e#dLdIdLdL�e#dLdIdLdL�e$dNdNdN�e$dNdNdN�d
ddK�e%e#dOdPdQdR�e#dSdPdTdU�e#dSdPdTdU�e#dVdPdWdX�e$dYdYdY�e$dYdYdY�d
ddK�e%e#dZdPdQd[�e#dSdPdTdU�e#dSdPdTdU�e#d\dPdWd]�e$dYdYdY�e$dYdYdY�d
ddK�e%e#d^d_d`da�e#dbd_dcdd�e#dbd_dcdd�e#ded_dfdg�e$dhdhdh�e$dhdhdh�d
ddK�e%e#did_djdk�e#dld_dmdn�e#dSdPdTdU�e#dod_dpdq�e$dYdYdY�e$dYdYdY�d
ddK�e%e#drdsdtdu�e#dvdsdwdx�e#dvdsdwdx�e#dydsdzd{�e$d|d|d|�e$d|d|d|�d
ddK�e%e#d}dsd~d�e#d�dsd�d��e#dSdPdTdU�e#d�dsd�d��e$dYdYdY�e$dYdYdY�d
ddK�e%e#dLdIdLdL�e#dLdMdLdL�de#dLdIdLdL�e$dNdNdN�e$dNdNdN�d
ddK�e%e#dOdPdQdR�e#dSdPdTdU�de#dVdPdWdX�e$dYdYdY�e$dYdYdY�d
ddK�e%e#dZdPdQd[�e#dSdPdTdU�de#d\dPdWd]�e$dYdYdY�e$dYdYdY�d
ddK�e%e#d^d_d`da�e#dbd_dcdd�de#ded_dfdg�e$dhdhdh�e$dhdhdh�d
ddK�e%e#did_djdk�e#dld_dmdn�de#dod_dpdq�e$dYdYdY�e$dYdYdY�d
ddK�e%e#drdsdtdu�e#dvdsdwdx�de#dydsdzd{�e$d|d|d|�e$d|d|d|�d
ddK�e%e#d}dsd~d�e#d�dsd�d��de#d�dsd�d��e$dYdYdY�e$dYdYdY�d
ddK�e%e#dNdIdNdN�e#dNdIdNdN�dde$dNdNdN�e$dNdNdN�d
dgdK�e%e(e(dde$dNdNdN�e$dNdNdN�d
dgdK�e%de#dNdIdLdN�dde$dNdNdN�e$dNdNdN�d
ddK�e%dddde$d�d�d��e$dNdNdN�d
ddK�e%de#ddIdLd�dde$ddNd�e$ddNd�d
ddK�e%e#dLdIdLdL�e#dLdIdLdL�de#dLdIdLdL�e$dNdNdN�e$dNdNdN�d
ddK�e%e#dLdIdLdL�e#dNdIdLdN�de#dLdIdLdL�e$dNdNdN�e$dNdNdN�d
ddK�e%e#ddMdJd�e#ddMdJd�de#ddMdJd�e$ddJd�e$ddJd�dddK�e%e#d�ddd��e#d�ddd�e#d�ddd�e#d�ddd�ee)d��ee)dN�dddK�e%ddddee-d�d�d��ee-d��d
ddK�e%dddde$d�d�d��e$d�d�d��d
ddK�e%e+dde#d�ddd�ee,d�d�ee,d�d�ddgdK�e%e+dde#d�ddd�ee,d�d��ee,d�d��ddgdK�e%e.e#d�ddd�de#d�ddd�e1e1d
ddK�e%e.e#d�ddd�de#d�ddd�ee1id��ee1id��d
ddK�e%ee.d�d��e#d�ddd�de#d�ddd�e1e1d
ddK�e%ee.d�d��e#d�ddd�de#d�ddd�e1e1d
ddK�e%dddde$dd�d�e$dd�d�dddK�e%dddde$d�d�dN�e*d
ddK�e%ee/d�dde#d�ddd�ee/d��ee/d�d
dgdK�d��$Z3e4e5e3�6���Z7d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d��Z8e�9d��Z:e�9d��Z;d�Z<e<�d��Z=e<�d��Z>e<�d��Z?d�e=�d�e>�d�e<�d�e?�d�e<�d�e>�d�e?�dÝZ@e�9e@ejA�ZBe�9e@�CdġejA�ZDd�ZEe�9dơZFd�d�ZGd�dɄZHd�d˄ZId�d̈́ZJeKfd�dτZLd�dфZM�d,d�dӄZNd�dՄZOd�dׄZPd�dلZQd�dۄZRd�d݄ZSd�d߄ZTd�d�ZUd�d�ZVeWfd�d�ZXd�d�ZYd�d�ZZd�d�Z[eWfd�d�Z\d�d�Z]�d-d�d�Z^d�d�Z_�d.d�d��Z`�d/d�d��Za�d0d�d��Zbd�d��Zcd�d��Zdd�d��Ze�d�d�Zf�d1�d�d�Zg�d2�d�d�Zh�d3�d�d�Zi�d	d�eee e eddddddf
�d
d
�Zj�d�d�Zk�d
�d�Zl�d�d�Zm�d�d�Zn�d�d�Zo�d4�d�d�Zp�d�d�Zq�d5�d�d�Zr�d�d�Zs�d�d�ZtG�d�d ��d eu�Zv�d!�d"�ZwG�d#�d$��d$ejx�Zy�d%�d&�Zz�d'�d(�Z{e|�d)k�
r:ez�dS(6zPretty-print tabular data.�)�
namedtuple)�Iterable�Sized)�escape)�chain�zip_longest)�reduce�partialNcCst|tj�S)N)�
isinstance�io�IOBase)�f�r�B/opt/alt/python37/lib/python3.7/site-packages/tabulate/__init__.py�_is_filesr�tabulate�tabulate_formats�simple_separated_format�)�version�F�g��default��Line�beginZhline�sep�end�DataRow�TableFormat�	lineabove�linebelowheader�linebetweenrows�	linebelow�	headerrow�datarow�padding�with_header_hidecCsLt|�}|tks|tkoFt|�dkr0|dtkpFt|�dkoF|dtk}|S)Nrrr)�type�list�str�len�SEPARATING_LINE)�rowZrow_typeZis_slrrr�_is_separating_linehs
r/cCs\|}|dkrd|ddS|dkr8dd|ddS|dkrPdd|dSd|SdS)	z~Return a segment of a horizontal line with optional colons which
    indicate column's alignment (as in `pipe` output format).)�right�decimal�-r�:�centerr�leftNr)�align�colwidth�wrrr�_pipe_segment_with_colonsqsr9cCs8|sdgt|�}dd�t||�D�}dd�|�dS)znReturn a horizontal line with optional colons to indicate column's
    alignment (as in `pipe` output format).rcSsg|]\}}t||��qSr)r9)�.0�ar8rrr�
<listcomp>�sz*_pipe_line_with_colons.<locals>.<listcomp>�|)r,�zip�join)�	colwidths�	colaligns�segmentsrrr�_pipe_line_with_colonssrCcs@ddddd���fdd�t||�D�}|d}||�|���S)Nrzalign="right"| zalign="center"| )r5r0r4r1cs(g|] \}}d��|d�|d�qS)� r)�get)r:�cr;)�	alignmentrrr<�sz-_mediawiki_row_with_attrs.<locals>.<listcomp>r)r>r?�rstrip)�	separator�cell_valuesr@rA�values_with_attrsZcolsepr)rGr�_mediawiki_row_with_attrs�srLcsH|dd7<ddddd���fdd�t||�D�}d	d	�|�d	S)
NrrDz<.z>.z=.)r5r0r4r1c3s"|]\}}��|d�|VqdS)rN)rE)r:r;�v)rGrr�	<genexpr>�sz*_textile_row_with_attrs.<locals>.<genexpr>r=)r>r?)rJr@rA�valuesr)rGr�_textile_row_with_attrs�srPcCsdS)Nz<table>
<tbody>r)Zcolwidths_ignoreZcolaligns_ignorerrr� _html_begin_table_without_header�srQcstddddd��|r.��fdd�t||�D�}n��fdd�t||�D�}d�d�|����}�d	krpd
|�d�}|S)Nrz style="text-align: right;"z style="text-align: center;")r5r0r4r1c	s&g|]\}}d����|d�|��qS)z<{0}{1}>{2}</{0}>r)�formatrE)r:rFr;)rG�celltagrrr<�sz(_html_row_with_attrs.<locals>.<listcomp>c	s*g|]"\}}d����|d�t|���qS)z<{0}{1}>{2}</{0}>r)rRrE�
htmlescape)r:rFr;)rGrSrrr<�sz<tr>{}</tr>�thz<table>
<thead>
z
</thead>
<tbody>)r>rRr?rH)rS�unsaferJr@rArKZrowhtmlr)rGrSr�_html_row_with_attrs�srWcs8ddddd�����fdd�t||�D�}d�|�dS)Nrz<style="text-align: right;">z<style="text-align: center;">)r5r0r4r1c	s.g|]&\}}d����|d��|���qS)z{}{} {} r)rRrE)r:rFr;)rGrS�headerrrr<�sz(_moin_row_with_attrs.<locals>.<listcomp>z||)r>r?)rSrJr@rArXrKr)rGrSrXr�_moin_row_with_attrs�srYcsLddddd��d��fdd�|D��}d�|s2d	nd
|d|rDdnd
g�S)N�l�rrF)r5r0r4r1rcsg|]}��|d��qS)rZ)rE)r:r;)rGrrr<�sz-_latex_line_begin_tabular.<locals>.<listcomp>�
z\begin{tabular}{z\begin{longtable}{�}z\toprulez\hline)r?)r@rA�booktabs�	longtableZtabular_columns_fmtr)rGr�_latex_line_begin_tabular�s
r`cGsndd�}t|�dkr |d|��St|�dkrb|\}}}dd�|�}|r\|d||�d|S|Sntd	��d
S)z/handle header and data rows for asciidoc formatcs�ddddd��t|�fdd�|D��}dd�|D�}dd	�|�d
g}g}|rZ|�d�|rv|dd	�|�d
g7}d
�d	�|��S)N�<�>�^)r5r0r4r1csg|]}�|�qSrr)r:�colalign)rGrrr<�sz;_asciidoc_row.<locals>.make_header_line.<locals>.<listcomp>cSsg|]\}}d�||��qS)z{:d}{})rR)r:�widthr6rrrr<�szcols="�,�"rXz	options="z
[{}]
|====)r>r?�appendrR)�	is_headerr@rAZasciidoc_alignmentsZasciidoc_column_specifiersZheader_listZoptions_listr)rGr�make_header_line�s
z'_asciidoc_row.<locals>.make_header_linerF�r=Tr\zm _asciidoc_row() requires two (colwidths, colaligns) or three (cell_values, colwidths, colaligns) arguments) N)F)r,r?�
ValueError)ri�argsrjrJr@rAZ	data_linerrr�
_asciidoc_row�s
rnz\&z\%z\$z\#z\_z\^{}z\{z\}z\textasciitilde{}z\textbackslash{}z\ensuremath{<}z\ensuremath{>})�&�%�$�#�_rc�{r]�~�\rarbcs4�fdd���fdd�|D�}tddd�}t||�S)Ncs��||�S)N)rE)rF)�escrulesrr�escape_charsz_latex_row.<locals>.escape_charcsg|]}d�t�|���qS)r)r?�map)r:�cell)rxrrr<sz_latex_row.<locals>.<listcomp>rroz\\)r�_build_simple_row)rJr@rArwZescaped_values�rowfmtr)rxrwr�
_latex_rowsr}cCsddd�}t|�}g}|r(||d�|d<x2|D]*}t|�}|rN||d�|d<|�|�q.W||fS)NcSs"t|ttf�r|��sdS|SdS)Nz..)r
r+�bytes�strip)�valrrr�escape_empty%sz._rst_escape_first_column.<locals>.escape_emptyr)r*rh)�rows�headersr��new_headers�new_rowsr.�new_rowrrr�_rst_escape_first_column$s
r�r2z  )r!r"r#r$r%r&r'r(�+�=r=u┌u─u┬u┐u├u┼u┤u└u┴u┘u│u╭u╮u╰u╯u┏u━u┳u┓u┣u╋u┫u┗u┻u┛u┃u┍u┯u┑u┝u┿u┥u┕u┷u┙u╔u═u╦u╗u╠u╬u╣u╚u╩u╝u║u╒u╤u╕u╞u╪u╡u╘u╧u╛z||z.{| class="wikitable" style="text-align: left;"z
|+ <!-- caption -->
|-z|-z|}�!z''')rXz|| z || z| z | z |z</tbody>
</table>rU�tdTz\hlinez\hline
\end{tabular})rw)r^z\midrulez\bottomrule
\end{tabular})r_z\hline
\endheadz\hline
\end{longtable}�	z|_. z|_.z|====)$�simple�plain�grid�simple_grid�rounded_grid�
heavy_grid�
mixed_grid�double_grid�
fancy_grid�outlineZsimple_outlineZrounded_outlineZ
heavy_outlineZ
mixed_outlineZdouble_outlineZ
fancy_outlineZgithub�pipe�orgtbl�jira�presto�pretty�psql�rst�	mediawikiZmoinmoinZyoutrack�htmlZ
unsafehtml�latexZ	latex_rawZlatex_booktabsZlatex_longtableZtsvZtextileZasciidocr�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�r�r�r�r�r�r�z
\r|\n|\r\ns
|
|
z\x1bz\[z\]z\\z.
    (
        # terminal colors, etc
        z�        # CSI
        [\x30-\x3f]*  # parameter bytes
        [\x20-\x2f]*  # intermediate bytes
        [\x40-\x7e]   # final byte
    |
        # terminal hyperlinks
        z�8;        # OSC opening
        (\w+=\w+:?)*    # key=value params list (submatch 2)
        ;               # delimiter
        ([^z5]+)    # URI - anything but ESC (submatch 3)
        z           # ST
        ([^z;]+)    # link text - anything but ESC (submatch 4)
        z8;;z!  # "closing" OSC sequence
    )
�utf8z[0mz>^(([+-]?[0-9]{1,3})(?:,([0-9]{3}))*)?(?(1)\.[0-9]*|\.[0-9]+)?$c
Cs(tddddtd|d�td|d�ddd�S)z�Construct a simple TableFormat with columns separated by a separator.

    >>> tsv = simple_separated_format("\t") ;         tabulate([["foo", 1], ["spam", 23]], tablefmt=tsv) == 'foo \t 1\nspam\t23'
    True

    Nrr)r%r&r'r()r r)rIrrrrs

c	Cs6y|��}Wnttfk
r$YnXtt�t|��S)a�
    >>> _isnumber_with_thousands_separator(".")
    False
    >>> _isnumber_with_thousands_separator("1")
    True
    >>> _isnumber_with_thousands_separator("1.")
    True
    >>> _isnumber_with_thousands_separator(".1")
    True
    >>> _isnumber_with_thousands_separator("1000")
    False
    >>> _isnumber_with_thousands_separator("1,000")
    True
    >>> _isnumber_with_thousands_separator("1,0000")
    False
    >>> _isnumber_with_thousands_separator("1,000.1234")
    True
    >>> _isnumber_with_thousands_separator(b"1,000.1234")
    True
    >>> _isnumber_with_thousands_separator("+1,000.1234")
    True
    >>> _isnumber_with_thousands_separator("-1,000.1234")
    True
    )�decode�UnicodeDecodeError�AttributeError�bool�re�match� _float_with_thousands_separators)�stringrrr�"_isnumber_with_thousands_separators
r�c	Cs*y||�dSttfk
r$dSXdS)NTF)rl�	TypeError)�convr�rrr�_isconvertible9s
r�cCsHtt|�sdSt|ttf�rDt�t|��s8t�t|��rD|��dkSdS)z�
    >>> _isnumber("123.45")
    True
    >>> _isnumber("123")
    True
    >>> _isnumber("spam")
    False
    >>> _isnumber("123e45678")
    False
    >>> _isnumber("inf")
    True
    F)�infz-inf�nanT)	r��floatr
r+r~�math�isinf�isnan�lower)r�rrr�	_isnumberAs
r�cCs$t|�|kp"t|ttf�o"t||�S)zG
    >>> _isint("123")
    True
    >>> _isint("123.45")
    False
    )r)r
r~r+r�)r�Zinttyperrr�_isintWsr�cCs"t|�tkp t|ttf�o |dkS)zc
    >>> _isbool(True)
    True
    >>> _isbool("False")
    True
    >>> _isbool(1)
    False
    )�True�False)r)r�r
r~r+)r�rrr�_isbooles	r�cCsz|rt|ttf�rt|�}|dkr*td�St|d�r8tSt|�rDtSt|�rT|rTt	St
|�rd|rdtSt|t�rrtStSdS)a%The least generic type (type(None), int, float, str, unicode).

    >>> _type(None) is type(None)
    True
    >>> _type("foo") is type("")
    True
    >>> _type("1") is type(1)
    True
    >>> _type('[31m42[0m') is type(42)
    True
    >>> _type('[31m42[0m') is type(42)
    True

    N�	isoformat)r
r+r~�_strip_ansir)�hasattrr�r�r��intr�r�)r��
has_invisible�numparserrr�_typess

r�cCsft|�st|�r^t|�rdS|�d�}|dkr<|���d�n|}|dkrXt|�|dSdSndSdS)aSymbols after a decimal point, -1 if the string lacks the decimal point.

    >>> _afterpoint("123.45")
    2
    >>> _afterpoint("1001")
    -1
    >>> _afterpoint("eggs")
    -1
    >>> _afterpoint("123e45")
    2
    >>> _afterpoint("123,456.78")
    2

    ����.r�erN)r�r�r��rfindr�r,)r��posrrr�_afterpoint�s
r�cCsd|}|�|�S)uLFlush right.

    >>> _padleft(6, 'яйца') == '  яйца'
    True

    z{0:>%ds})rR)re�s�fmtrrr�_padleft�sr�cCsd|}|�|�S)uLFlush left.

    >>> _padright(6, 'яйца') == 'яйца  '
    True

    z{0:<%ds})rR)rer�r�rrr�	_padright�sr�cCsd|}|�|�S)uNCenter string.

    >>> _padboth(6, 'яйца') == ' яйца '
    True

    z{0:^%ds})rR)rer�r�rrr�_padboth�sr�cCs|S)Nr)Zignore_widthr�rrr�_padnone�sr�cCs&t|t�rt�d|�St�d|�SdS)a�Remove ANSI escape sequences, both CSI (color codes, etc) and OSC hyperlinks.

    CSI sequences are simply removed from the output, while OSC hyperlinks are replaced
    with the link text. Note: it may be desirable to show the URI instead but this is not
    supported.

    >>> repr(_strip_ansi('\x1B]8;;https://example.com\x1B\\This is a link\x1B]8;;\x1B\\'))
    "'This is a link'"

    >>> repr(_strip_ansi('\x1b[31mred\x1b[0m text'))
    "'red text'"

    z\4N)r
r+�_ansi_codes�sub�_ansi_codes_bytes)r�rrrr��s
r�cCsBtdk	rtrtj}nt}t|ttf�r2|t|��S|t|��SdS)z�Visible width of a printed string. ANSI color codes are removed.

    >>> _visible_width('[31mhello[0m'), _visible_width("world")
    (5, 5)

    N)�wcwidth�WIDE_CHARS_MODE�wcswidthr,r
r+r~r�)r�Zlen_fnrrr�_visible_width�sr�cCs.t|t�rtt�t|��Stt�t|��SdS)N)r
r+r�r��search�_multiline_codes�_multiline_codes_bytes)r�rrr�
_is_multiline�s
r�cCstt|t�d|���S)z1Visible width of a potentially multiline content.z[
])�maxryr��split)�multiline_s�
line_width_fnrrr�_multiline_widthsr�cs4|r
t�n|rtj�nt�|r,�fdd�}n�}|S)z2Return a function to calculate visible cell width.cs
t|��S)N)r�)r�)r�rr�<lambda>�z"_choose_width_fn.<locals>.<lambda>)r�r�r�r,)r��enable_widechars�is_multiline�width_fnr)r�r�_choose_width_fn
sr�cs�|dkr tsdd�|D�}t}n�|dkr@ts:dd�|D�}t}np|dkr�|r\dd�|D�}ndd�|D�}t|���fd	d�t||�D�}t}n |s�t}nts�d
d�|D�}t}||fS)Nr0cSsg|]}|���qSr)r)r:r�rrrr<sz._align_column_choose_padfn.<locals>.<listcomp>r4cSsg|]}|���qSr)r)r:r�rrrr< sr1cSsg|]}tt|���qSr)r�r�)r:r�rrrr<$scSsg|]}t|��qSr)r�)r:r�rrrr<&scs g|]\}}|�|d�qS)rDr)r:r�Zdecs)�maxdecimalsrrr<(scSsg|]}|���qSr)r)r:r�rrrr<.s)�PRESERVE_WHITESPACEr�r�r�r>r�r�)�stringsrGr��padfnZdecimalsr)r�r�_align_column_choose_padfns*r�cs4|r
t�n|rtj�nt�|r,�fdd�}n�}|S)Ncs
t|��S)N)�_align_column_multiline_width)r�)r�rrr�;r�z/_align_column_choose_width_fn.<locals>.<lambda>)r�r�r�r,)r�r�r�r�r)r�r�_align_column_choose_width_fn3sr�cCstt|t�d|���S)z1Visible width of a potentially multiline content.z[
])r*ryr�r�)r�r�rrrr�Asr�cCsDg}x:|D]2}t|t�r2x"|D]}|�|�qWq
|�|�q
W|S)N)r
r*rh)Znested_list�ret�item�subitemrrr�
_flat_listFs


r�cs�t|||�\}�t|||�}tt||��}ttt|��|��|r�|s^|s^��fdd�|D�}q�dd�|D�}	�fdd�t||	�D�}
�fdd�t||
�D�}n\|s�|s���fdd�|D�}n>ttt|��}	�fdd�t||	�D�}
�fdd�t||
�D�}|S)	z[string] -> [padded_string]cs*g|]"}d���fdd�|��D���qS)r\csg|]}��|��qSrr)r:r�)�maxwidthr�rrr<esz,_align_column.<locals>.<listcomp>.<listcomp>)r?�
splitlines)r:�ms)r�r�rrr<esz!_align_column.<locals>.<listcomp>cSs"g|]}dd�t�d|�D��qS)cSsg|]}t|��qSr)r,)r:r�rrrr<jsz,_align_column.<locals>.<listcomp>.<listcomp>z[
])r�r�)r:r�rrrr<jscs(g|] \}}�fdd�t||�D��qS)csg|]\}}�||�qSrr)r:r8rZ)r�rrr<lsz,_align_column.<locals>.<listcomp>.<listcomp>)r>)r:�mw�ml)r�rrr<lscs6g|].\}}d��fdd�t|��p&||�D���qS)r\csg|]\}}�||��qSrr)r:r�r8)r�rrr<rsz,_align_column.<locals>.<listcomp>.<listcomp>)r?r>r�)r:r�r�)r�rrr<rscsg|]}��|��qSrr)r:r�)r�r�rrr<wscsg|]\}}�||�qSrr)r:r8rZ)r�rrr<{scsg|]\}}�||��qSrr)r:r�r8)r�rrr<~s)r�r�r*ryr�r�r>r,)r�rGZminwidthr�r�r�r�Zs_widthsZpadded_stringsZs_lensZvisible_widthsr)r�r�r�
_align_columnQs(	



r�cCsXtd�dtdtdtdtdtdi}ttttttd�d�}t|�|d�|�|d��}||S)Nrrrrk��)r�r�rkrrr)r)r�r�r�r~r+r�rE)Ztype1Ztype2�typesZinvtypesZmoregenericrrr�
_more_generic�sr�cs ��fdd�|D�}tt|t�S)u)The least generic type all column values are convertible to.

    >>> _column_type([True, False]) is bool
    True
    >>> _column_type(["1", "2"]) is int
    True
    >>> _column_type(["1", "2.3"]) is float
    True
    >>> _column_type(["1", "2.3", "four"]) is str
    True
    >>> _column_type(["four", 'пять']) is str
    True
    >>> _column_type([None, "brux"]) is str
    True
    >>> _column_type([1, 2, None]) is int
    True
    >>> import datetime as dt
    >>> _column_type([dt.datetime(1991,2,19), dt.time(17,35)]) is str
    True

    csg|]}t|����qSr)r�)r:r�)r�r�rrr<�sz _column_type.<locals>.<listcomp>)rr�r�)r�r�r�r�r)r�r�r�_column_type�sr�c		Cs�|dkr|S|tkr|�S|tkr,t||�S|tkr^y
t|d�Sttfk
rZt|�SXnV|tkr�|ovt|ttf�}|r�t|�}tt|�|�}|�	||�Stt|�|�Sn|�SdS)u�Format a value according to its type.

    Unicode is supported:

    >>> hrow = ['буква', 'цифра'] ;         tbl = [['аз', 2], ['буки', 4]] ;         good_result = '\u0431\u0443\u043a\u0432\u0430      \u0446\u0438\u0444\u0440\u0430\n-------  -------\n\u0430\u0437             2\n\u0431\u0443\u043a\u0438           4' ;         tabulate(tbl, headers=hrow) == good_result
    True

    N�ascii)
r+r�rRr~r�r�r�r
r��replace)	r�Zvaltype�floatfmt�intfmt�
missingvalr�Zis_a_colored_numberZraw_valZ
formatted_valrrr�_format�s&

r�c	s�|r0t�t|�}���fdd�|D�}d�|�St|�|}�|7��dkrVt�|�S�dkrht�|�S�sr|�St�|�SdS)zIPad string header to width chars given known visible_width of the header.csg|]}t|���|���qSr)�
_align_header)r:�h)rGrer�rrr<�sz!_align_header.<locals>.<listcomp>r\r5r4N)r�r�r�r?r,r�r�r�)	rXrGreZ
visible_widthr�r�Zheader_linesZpadded_linesZ
ninvisibler)rGrer�rr��s


r�cCs\t|�tkrPg}g}x2t|�D]&\}}t|�r:|�|�q|�|�qW||fS|dfSdS)N)r)r*�	enumerater/rh)r��separating_lines�	sans_rows�indexr.rrr�_remove_separating_lines�srcCs"|rx|D]}|�|t�q
WdS)N)�insertr-)r�rrrrr�_reinsert_separating_lines�s
rcCs�|dks|dkr|St|t�rJt|�t|�krJtdd�t|�t|����t|�\}}g}t|�}x(|D] }t|�}|�|gt	|��qhW|}t
||�|S)zAdd a left-most index column.NFz2index must be as long as the number of data rows: zlen(index)={} len(rows)={})r
rr,rlrRr�iter�nextrhr*r)r�rrrr�Z
index_iterr.Zindex_vrrr�_prepend_row_indexs

r
cCs"yt|�Stk
rdSXdS)zDA wrapper around standard bool() which doesn't throw on NumPy arraysFN)r�rl)r�rrr�_boolsrc
s�yt��d}Wn tk
r0d}t���YnXd}t|d��rt|d��rt|jd�rt|���tt|����}n�t|d�r�t|��|dkr�|jjdk	r�t	|jjt�r�|jj�dd	�<n|jjg�dd	�<|j}t|j�}d
d�|D�}ntd���dk�r�tt
t�����n�t|�}�dk�r0|�s0g��n��dk�r`t|d
��r`t|j
d��r`|j
j��n��dk�r�t|�d	k�r�t	|d	t��r�t|d	d��r�tt
t|d	j����n6t|�d	k�rt|d	d��rt|d	d��rt�}g��dk�r0t|�d	k�r|d	ni�������|���|dd�}x@|D]8}x0|��D]$}	|	|k�rD��|	�|�|	��qDW�q6W�dk�r���n|t	�t��r��fdd��D��tt
t����nN�dk�r�t|�d	k�r�fdd��D��tt
t����ng�n��r�td���fdd�|D�}nԈdk�rRt|d��rRt|d��rRt|d��rRdd�|jD��n�tdk	�r�t|�d	k�r�t�|d	��r�dd�t�|d	�D���dk�r����fdd�|D�}n2�dk�r�t|�d	k�r�tt
ttt|d	������dk�rPt|�d	k�rP|dk	�r,|d	gt|d	��|dd�}n|d	�tt
t����|dd�}n�dk�r^g�tt
t����tt
dd�|��}t|�ttgk}
|dk�r�|dk	�r�t||�}n�t	|t ��r�|
�s�t|t|��}nxt	|t!��r�|
�s�t||�}nZ|dk�st"|��r.|
�s.|dk�r"ttt|���}t||�}n|d k�sHt"|��sH|
�sH��r�t|�d	k�r�t��}t|d	�}||k�r�d!g||��|�fS)"aTransform a supported data type to a list of lists, and a list of headers.

    Supported tabular data types:

    * list-of-lists or another iterable of iterables

    * list of named tuples (usually used with headers="keys")

    * list of dicts (usually used with headers="keys")

    * list of OrderedDicts (usually used with headers="keys")

    * list of dataclasses (Python 3.7+ only, usually used with headers="keys")

    * 2D NumPy arrays

    * NumPy record arrays (usually used with headers="keys")

    * dict of iterables (usually used with headers="keys")

    * pandas.DataFrame (usually used with headers="keys")

    The first row can be used as headers if headers="firstrow",
    column indices can be used as headers if headers="keys".

    If showindex="default", show row indices of the pandas.DataFrame.
    If showindex="always", show row indices for all types of data.
    If showindex="never", don't show row indices for all types of data.
    If showindex is an iterable, show its values as row indices.

    FTN�keysrO�__call__r)r�alwaysTrcSsg|]}t|��qSr)r*)r:r.rrrr<[sz+_normalize_tabular_data.<locals>.<listcomp>z7tabular data doesn't appear to be a dict or a DataFrame�dtype�names�_fields�firstrowrcsg|]}��||��qSr)rE)r:�k)r�rrr<�scsg|]}��||��qSr)rE)r:r)�	firstdictrrr<�sz6headers for a list of dicts is not a dict or a keywordcsg|]��fdd��D��qS)csg|]}��|��qSr)rE)r:r)r.rrr<�sz6_normalize_tabular_data.<locals>.<listcomp>.<listcomp>r)r:)r)r.rr<�s�descriptionZfetchoneZrowcountcSsg|]}|d�qS)rr)r:�columnrrrr<�scSsg|]
}|j�qSr)�name)r:�fieldrrrr<�scsg|]��fdd��D��qS)csg|]}t�|��qSr)�getattr)r:r
)r.rrr<�sz6_normalize_tabular_data.<locals>.<listcomp>.<listcomp>r)r:)�field_names)r.rr<�scSst|�r|St|�S)N)r/r*)r[rrrr��r�z)_normalize_tabular_data.<locals>.<lambda>rr�neverr)#r�rlr*r�rOr�izip_longestrrr
ryr+rrrr,�tupler�set�extend�updaterh�add�dictr�dataclasses�is_dataclass�fields�ranger)r~r
rrr)
�tabular_datar��	showindexZis_headers2bool_brokenrr��valsZ	uniq_keysr.rZshowindex_is_a_strZnhsZncolsr)rrr�rr�_normalize_tabular_datas�!




.













r*cCs�t|t|d�d�}g}x�|D]�}g}x�t|||�D]x\}}}t|�rV|rV|�|�q4|dk	r�t|d�}	t|�rxt|�nt||�|�}
|	�|
�}|�d�	|��q4|�|�q4W|�|�qW|S)NrT)rer\)
�_expand_iterabler,r>r�rh�_CustomTextWrapr+r��wrapr?)�
list_of_listsr@�	numparses�resultr.r�rzrer��wrapperZcasted_cell�wrappedrrr�_wrap_text_to_colwidths�s 



r3�ignorecCs t|t�r|j||d�St|�S)a)
    A type safe wrapper for converting a bytestring to str. This is essentially just
    a wrapper around .decode() intended for use with things like map(), but with some
    specific behavior:

    1. if the given parameter is not a bytestring, it is returned unmodified
    2. decode() is called for the given parameter and assumes utf8 encoding, but the
       default error behavior is changed from 'strict' to 'ignore'

    >>> repr(_to_str(b'foo'))
    "'foo'"

    >>> repr(_to_str('foo'))
    "'foo'"

    >>> repr(_to_str(42))
    "'42'"

    )�encoding�errors)r
r~r�r+)r�r5r6rrr�_to_str�s
r7rc!	s�|dkrg}t|||d�\}}t|�\}}|dk	rzt|d�}t|t�rVt|||�}nt||d�}t|	|�}t|||d�}|
dk	r�t|d�}t|
t�r�t|
||
�}
nt|
|d�}
t|	|�}t|g|
|d�d}|dkr�t||�\}}t	�|dk�r"d�d}	�t
k�r
dn���t
k�rdn��n$�t
k�r0d	n���t
k�rBd
n��d�tt
t|�t�dd
�|D����}t�|�dk	�tdk	�o�t�t|t��s�|tk�r�t|��r�t�||�}d�nd�t�����tt|��}t|	t|��}dd�t||�D�}t|t��rt|�|g}n6t|�}t|�t|�k�rJ|�t|�t|�tg�t|t��rft|�|g}n6t|�}t|�t|�k�r�|�t|�t|�tg�t|t��r�t|�|g}n6t|�}t|�t|�k�r�|�t|�t|�t g��fdd�t|||||�D�}��fdd�|D�}|
dk	�rZt|
t!��s:t"�xt#|
�D]\}}|||<�qDW|�rt��fdd�|D�ndgt|�}���fdd�t|||�D�}|�r|�p�dggt|�}|�pΈgt|�}�fdd�t||�D�}��fdd�t|||�D�}tt|��}n�fdd�|D�}tt|��}t|t��sLt$�|t$d�}t|t��r\|nd}t|t|�|�} t%||�t&|||||�| d�S)u�JFormat a fixed width table for pretty printing.

    >>> print(tabulate([[1, 2.34], [-56, "8.999"], ["2", "10001"]]))
    ---  ---------
      1      2.34
    -56      8.999
      2  10001
    ---  ---------

    The first required argument (`tabular_data`) can be a
    list-of-lists (or another iterable of iterables), a list of named
    tuples, a dictionary of iterables, an iterable of dictionaries,
    an iterable of dataclasses (Python 3.7+), a two-dimensional NumPy array,
    NumPy record array, or a Pandas' dataframe.


    Table headers
    -------------

    To print nice column headers, supply the second argument (`headers`):

      - `headers` can be an explicit list of column headers
      - if `headers="firstrow"`, then the first row of data is used
      - if `headers="keys"`, then dictionary keys or column indices are used

    Otherwise a headerless table is produced.

    If the number of headers is less than the number of columns, they
    are supposed to be names of the last columns. This is consistent
    with the plain-text format of R and Pandas' dataframes.

    >>> print(tabulate([["sex","age"],["Alice","F",24],["Bob","M",19]],
    ...       headers="firstrow"))
           sex      age
    -----  -----  -----
    Alice  F         24
    Bob    M         19

    By default, pandas.DataFrame data have an additional column called
    row index. To add a similar column to all other types of data,
    use `showindex="always"` or `showindex=True`. To suppress row indices
    for all types of data, pass `showindex="never" or `showindex=False`.
    To add a custom row index column, pass `showindex=some_iterable`.

    >>> print(tabulate([["F",24],["M",19]], showindex="always"))
    -  -  --
    0  F  24
    1  M  19
    -  -  --


    Column alignment
    ----------------

    `tabulate` tries to detect column types automatically, and aligns
    the values properly. By default it aligns decimal points of the
    numbers (or flushes integer numbers to the right), and flushes
    everything else to the left. Possible column alignments
    (`numalign`, `stralign`) are: "right", "center", "left", "decimal"
    (only for `numalign`), and None (to disable alignment).


    Table formats
    -------------

    `intfmt` is a format specification used for columns which
    contain numeric data without a decimal point. This can also be
    a list or tuple of format strings, one per column.

    `floatfmt` is a format specification used for columns which
    contain numeric data with a decimal point. This can also be
    a list or tuple of format strings, one per column.

    `None` values are replaced with a `missingval` string (like
    `floatfmt`, this can also be a list of values for different
    columns):

    >>> print(tabulate([["spam", 1, None],
    ...                 ["eggs", 42, 3.14],
    ...                 ["other", None, 2.7]], missingval="?"))
    -----  --  ----
    spam    1  ?
    eggs   42  3.14
    other   ?  2.7
    -----  --  ----

    Various plain-text table formats (`tablefmt`) are supported:
    'plain', 'simple', 'grid', 'pipe', 'orgtbl', 'rst', 'mediawiki',
    'latex', 'latex_raw', 'latex_booktabs', 'latex_longtable' and tsv.
    Variable `tabulate_formats`contains the list of currently supported formats.

    "plain" format doesn't use any pseudographics to draw tables,
    it separates columns with a double space:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                 ["strings", "numbers"], "plain"))
    strings      numbers
    spam         41.9999
    eggs        451

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="plain"))
    spam   41.9999
    eggs  451

    "simple" format is like Pandoc simple_tables:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                 ["strings", "numbers"], "simple"))
    strings      numbers
    ---------  ---------
    spam         41.9999
    eggs        451

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="simple"))
    ----  --------
    spam   41.9999
    eggs  451
    ----  --------

    "grid" is similar to tables produced by Emacs table.el package or
    Pandoc grid_tables:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                ["strings", "numbers"], "grid"))
    +-----------+-----------+
    | strings   |   numbers |
    +===========+===========+
    | spam      |   41.9999 |
    +-----------+-----------+
    | eggs      |  451      |
    +-----------+-----------+

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="grid"))
    +------+----------+
    | spam |  41.9999 |
    +------+----------+
    | eggs | 451      |
    +------+----------+

    "simple_grid" draws a grid using single-line box-drawing
    characters:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                ["strings", "numbers"], "simple_grid"))
    ┌───────────┬───────────┐
    │ strings   │   numbers │
    ├───────────┼───────────┤
    │ spam      │   41.9999 │
    ├───────────┼───────────┤
    │ eggs      │  451      │
    └───────────┴───────────┘

    "rounded_grid" draws a grid using single-line box-drawing
    characters with rounded corners:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                ["strings", "numbers"], "rounded_grid"))
    ╭───────────┬───────────╮
    │ strings   │   numbers │
    ├───────────┼───────────┤
    │ spam      │   41.9999 │
    ├───────────┼───────────┤
    │ eggs      │  451      │
    ╰───────────┴───────────╯

    "heavy_grid" draws a grid using bold (thick) single-line box-drawing
    characters:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                ["strings", "numbers"], "heavy_grid"))
    ┏━━━━━━━━━━━┳━━━━━━━━━━━┓
    ┃ strings   ┃   numbers ┃
    ┣━━━━━━━━━━━╋━━━━━━━━━━━┫
    ┃ spam      ┃   41.9999 ┃
    ┣━━━━━━━━━━━╋━━━━━━━━━━━┫
    ┃ eggs      ┃  451      ┃
    ┗━━━━━━━━━━━┻━━━━━━━━━━━┛

    "mixed_grid" draws a grid using a mix of light (thin) and heavy (thick) lines
    box-drawing characters:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                ["strings", "numbers"], "mixed_grid"))
    ┍━━━━━━━━━━━┯━━━━━━━━━━━┑
    │ strings   │   numbers │
    ┝━━━━━━━━━━━┿━━━━━━━━━━━┥
    │ spam      │   41.9999 │
    ├───────────┼───────────┤
    │ eggs      │  451      │
    ┕━━━━━━━━━━━┷━━━━━━━━━━━┙

    "double_grid" draws a grid using double-line box-drawing
    characters:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                ["strings", "numbers"], "double_grid"))
    ╔═══════════╦═══════════╗
    ║ strings   ║   numbers ║
    ╠═══════════╬═══════════╣
    ║ spam      ║   41.9999 ║
    ╠═══════════╬═══════════╣
    ║ eggs      ║  451      ║
    ╚═══════════╩═══════════╝

    "fancy_grid" draws a grid using a mix of single and
    double-line box-drawing characters:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                ["strings", "numbers"], "fancy_grid"))
    ╒═══════════╤═══════════╕
    │ strings   │   numbers │
    ╞═══════════╪═══════════╡
    │ spam      │   41.9999 │
    ├───────────┼───────────┤
    │ eggs      │  451      │
    ╘═══════════╧═══════════╛

    "outline" is the same as the "grid" format but doesn't draw lines between rows:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                ["strings", "numbers"], "outline"))
    +-----------+-----------+
    | strings   |   numbers |
    +===========+===========+
    | spam      |   41.9999 |
    | eggs      |  451      |
    +-----------+-----------+

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="outline"))
    +------+----------+
    | spam |  41.9999 |
    | eggs | 451      |
    +------+----------+

    "simple_outline" is the same as the "simple_grid" format but doesn't draw lines between rows:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                ["strings", "numbers"], "simple_outline"))
    ┌───────────┬───────────┐
    │ strings   │   numbers │
    ├───────────┼───────────┤
    │ spam      │   41.9999 │
    │ eggs      │  451      │
    └───────────┴───────────┘

    "rounded_outline" is the same as the "rounded_grid" format but doesn't draw lines between rows:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                ["strings", "numbers"], "rounded_outline"))
    ╭───────────┬───────────╮
    │ strings   │   numbers │
    ├───────────┼───────────┤
    │ spam      │   41.9999 │
    │ eggs      │  451      │
    ╰───────────┴───────────╯

    "heavy_outline" is the same as the "heavy_grid" format but doesn't draw lines between rows:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                ["strings", "numbers"], "heavy_outline"))
    ┏━━━━━━━━━━━┳━━━━━━━━━━━┓
    ┃ strings   ┃   numbers ┃
    ┣━━━━━━━━━━━╋━━━━━━━━━━━┫
    ┃ spam      ┃   41.9999 ┃
    ┃ eggs      ┃  451      ┃
    ┗━━━━━━━━━━━┻━━━━━━━━━━━┛

    "mixed_outline" is the same as the "mixed_grid" format but doesn't draw lines between rows:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                ["strings", "numbers"], "mixed_outline"))
    ┍━━━━━━━━━━━┯━━━━━━━━━━━┑
    │ strings   │   numbers │
    ┝━━━━━━━━━━━┿━━━━━━━━━━━┥
    │ spam      │   41.9999 │
    │ eggs      │  451      │
    ┕━━━━━━━━━━━┷━━━━━━━━━━━┙

    "double_outline" is the same as the "double_grid" format but doesn't draw lines between rows:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                ["strings", "numbers"], "double_outline"))
    ╔═══════════╦═══════════╗
    ║ strings   ║   numbers ║
    ╠═══════════╬═══════════╣
    ║ spam      ║   41.9999 ║
    ║ eggs      ║  451      ║
    ╚═══════════╩═══════════╝

    "fancy_outline" is the same as the "fancy_grid" format but doesn't draw lines between rows:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                ["strings", "numbers"], "fancy_outline"))
    ╒═══════════╤═══════════╕
    │ strings   │   numbers │
    ╞═══════════╪═══════════╡
    │ spam      │   41.9999 │
    │ eggs      │  451      │
    ╘═══════════╧═══════════╛

    "pipe" is like tables in PHP Markdown Extra extension or Pandoc
    pipe_tables:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                ["strings", "numbers"], "pipe"))
    | strings   |   numbers |
    |:----------|----------:|
    | spam      |   41.9999 |
    | eggs      |  451      |

    "presto" is like tables produce by the Presto CLI:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                ["strings", "numbers"], "presto"))
     strings   |   numbers
    -----------+-----------
     spam      |   41.9999
     eggs      |  451

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="pipe"))
    |:-----|---------:|
    | spam |  41.9999 |
    | eggs | 451      |

    "orgtbl" is like tables in Emacs org-mode and orgtbl-mode. They
    are slightly different from "pipe" format by not using colons to
    define column alignment, and using a "+" sign to indicate line
    intersections:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                ["strings", "numbers"], "orgtbl"))
    | strings   |   numbers |
    |-----------+-----------|
    | spam      |   41.9999 |
    | eggs      |  451      |


    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="orgtbl"))
    | spam |  41.9999 |
    | eggs | 451      |

    "rst" is like a simple table format from reStructuredText; please
    note that reStructuredText accepts also "grid" tables:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
    ...                ["strings", "numbers"], "rst"))
    =========  =========
    strings      numbers
    =========  =========
    spam         41.9999
    eggs        451
    =========  =========

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="rst"))
    ====  ========
    spam   41.9999
    eggs  451
    ====  ========

    "mediawiki" produces a table markup used in Wikipedia and on other
    MediaWiki-based sites:

    >>> print(tabulate([["strings", "numbers"], ["spam", 41.9999], ["eggs", "451.0"]],
    ...                headers="firstrow", tablefmt="mediawiki"))
    {| class="wikitable" style="text-align: left;"
    |+ <!-- caption -->
    |-
    ! strings   !! align="right"|   numbers
    |-
    | spam      || align="right"|   41.9999
    |-
    | eggs      || align="right"|  451
    |}

    "html" produces HTML markup as an html.escape'd str
    with a ._repr_html_ method so that Jupyter Lab and Notebook display the HTML
    and a .str property so that the raw HTML remains accessible
    the unsafehtml table format can be used if an unescaped HTML format is required:

    >>> print(tabulate([["strings", "numbers"], ["spam", 41.9999], ["eggs", "451.0"]],
    ...                headers="firstrow", tablefmt="html"))
    <table>
    <thead>
    <tr><th>strings  </th><th style="text-align: right;">  numbers</th></tr>
    </thead>
    <tbody>
    <tr><td>spam     </td><td style="text-align: right;">  41.9999</td></tr>
    <tr><td>eggs     </td><td style="text-align: right;"> 451     </td></tr>
    </tbody>
    </table>

    "latex" produces a tabular environment of LaTeX document markup:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="latex"))
    \begin{tabular}{lr}
    \hline
     spam &  41.9999 \\
     eggs & 451      \\
    \hline
    \end{tabular}

    "latex_raw" is similar to "latex", but doesn't escape special characters,
    such as backslash and underscore, so LaTeX commands may embedded into
    cells' values:

    >>> print(tabulate([["spam$_9$", 41.9999], ["\\emph{eggs}", "451.0"]], tablefmt="latex_raw"))
    \begin{tabular}{lr}
    \hline
     spam$_9$    &  41.9999 \\
     \emph{eggs} & 451      \\
    \hline
    \end{tabular}

    "latex_booktabs" produces a tabular environment of LaTeX document markup
    using the booktabs.sty package:

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="latex_booktabs"))
    \begin{tabular}{lr}
    \toprule
     spam &  41.9999 \\
     eggs & 451      \\
    \bottomrule
    \end{tabular}

    "latex_longtable" produces a tabular environment that can stretch along
    multiple pages, using the longtable package for LaTeX.

    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="latex_longtable"))
    \begin{longtable}{lr}
    \hline
     spam &  41.9999 \\
     eggs & 451      \\
    \hline
    \end{longtable}


    Number parsing
    --------------
    By default, anything which can be parsed as a number is a number.
    This ensures numbers represented as strings are aligned properly.
    This can lead to weird results for particular strings such as
    specific git SHAs e.g. "42992e1" will be parsed into the number
    429920 and aligned as such.

    To completely disable number parsing (and alignment), use
    `disable_numparse=True`. For more fine grained control, a list column
    indices is used to disable number parsing only on those columns
    e.g. `disable_numparse=[0, 2]` would disable number parsing only on the
    first and third columns.

    Column Widths and Auto Line Wrapping
    ------------------------------------
    Tabulate will, by default, set the width of each column to the length of the
    longest element in that column. However, in situations where fields are expected
    to reasonably be too long to look good as a single line, tabulate can help automate
    word wrapping long fields for you. Use the parameter `maxcolwidth` to provide a
    list of maximal column widths

    >>> print(tabulate(           [('1', 'John Smith',             'This is a rather long description that might look better if it is wrapped a bit')],           headers=("Issue Id", "Author", "Description"),           maxcolwidths=[None, None, 30],           tablefmt="grid"          ))
    +------------+------------+-------------------------------+
    |   Issue Id | Author     | Description                   |
    +============+============+===============================+
    |          1 | John Smith | This is a rather long         |
    |            |            | description that might look   |
    |            |            | better if it is wrapped a bit |
    +------------+------------+-------------------------------+

    Header column width can be specified in a similar way using `maxheadercolwidth`

    N)r(r)r/r�r�Tr4r1r5r�css|]}tt|�VqdS)N)ryr7)r:r.rrrrN=sztabulate.<locals>.<genexpr>FcSsg|]\}}t||d��qS))r�)r�)r:�col�nprrrr<Rsztabulate.<locals>.<listcomp>cs0g|](\}���������fdd�|D��qS)c	sg|]}t|�������qSr)r�)r:rM)�ct�fl_fmtr��int_fmt�miss_vrrr<jsz'tabulate.<locals>.<listcomp>.<listcomp>r)r:rF)r�)r:r;r<r=rr<jscs g|]}|ttgkr�n��qSr)r�r�)r:r:)�numalign�stralignrrr<qscsg|]}�|���qSrr)r:r)�min_paddingr�rrr<wsc	s$g|]\}}}t|||�����qSr)r�)r:rFr;�minw)r�r�r�rrr<zsrcs,g|]$\}}t|t�fdd�|D����qS)c3s|]}�|�VqdS)Nr)r:�cl)r�rrrN�sz&tabulate.<locals>.<listcomp>.<genexpr>)r�)r:rArF)r�rrr<�sc	s(g|] \}}}t|||�|�����qSr)r�)r:rr;rA)r�r�rrr<�scs"g|]}t�fdd�|D���qS)c3s|]}�|�VqdS)Nr)r:rB)r�rrrN�sz&tabulate.<locals>.<listcomp>.<genexpr>)r�)r:rF)r�rrr<�sr�)�	rowaligns)'r*rr,r
r�r+�_expand_numparser3r��MIN_PADDING�_DEFAULT_ALIGNr?rryr7�
from_iterabler�r�r�r�r �multiline_formatsr�rEr�r*rr>r+r�_DEFAULT_FLOATFMT�_DEFAULT_INTFMT�_DEFAULT_MISSINGVALr�AssertionErrorr�_table_formatsr�
_format_table)!r'r��tablefmtr�r�r>r?r�r(�disable_numparserdZmaxcolwidths�rowalignZmaxheadercolwidthsr.rZnum_colsr/�
plain_text�colsZcoltypesZ
float_formatsZint_formatsZmissing_valsZaligns�idxr6Z	minwidthsZt_colsZt_alignsr�Z
ra_defaultrCr)r�r�r�r@r>r?r�rrs�p










(

cCs>t|t�r.dg|}x|D]}d||<qW|S|g|SdS)aB
    Return a list of bools of length `column_count` which indicates whether
    number parsing should be used on each column.
    If `disable_numparse` is a list of indices, each of those indices are False,
    and everything else is True.
    If `disable_numparse` is a bool, then the returned list is all the same.
    TFN)r
r)rP�column_countr/rrrrrD�s


rDcCs8t|t�r*t|t�s*||g|t|�S|g|SdS)aY
    Expands the `original` argument to return a return a list of
    length `num_desired`. If `original` is shorter than `num_desired`, it will
    be padded with the value in `default`.
    If `original` is not a list to begin with (i.e. scalar value) a list of
    length `num_desired` completely populated with `default will be returned
    N)r
rr+r,)�originalZnum_desiredrrrrr+�sr+cs*|r"d|��fdd�|D�}|S|SdS)NrDcsg|]}�|��qSrr)r:rz)�padrrr<�sz_pad_row.<locals>.<listcomp>r)�cellsr'�padded_cellsr)rWr�_pad_row�s
rZcCs |\}}}||�|�|��S)z7Format row according to DataRow format without padding.)r?rH)rYr|rrrrrrr{�s
r{cCs,|sdSt|d�r||||�St||�SdS)z5Return a string which represents a row of data cells.Nr
)r�r{)rYr@rAr|rrr�
_build_row�s

r[cCs|�t||||��|S)N)rhr[)�linesrYr@rAr|rQrrr�_append_basic_row�sr]cCsf|t|�}d|g}|dkr*|||S|dkrV|d}||}|||||S|||SdS)NrD�bottomr4r)r,)Z
text_linesZ	num_lines�column_widthZ
row_alignmentZdelta_lines�blankZ	top_deltaZbottom_deltarrr�_align_cell_veritically�s
racs��fdd�|D�}dd�|D��ttt������fdd�t�|�D���fdd�t��D�}x&|D]}	t|	��}
t||
|||�qdW|S)Ncsg|]}|d��qS)rr)r:r8)rWrrr<�sz)_append_multiline_row.<locals>.<listcomp>cSsg|]}|���qSr)r�)r:rFrrrr<�scsg|]\}}t|�|���qSr)ra)r:rBr8)�nlinesrQrrr<�scsg|]��fdd��D��qS)csg|]}|��qSrr)r:rB)�irrr<�sz4_append_multiline_row.<locals>.<listcomp>.<listcomp>r)r:)�cells_lines)rcrr<�s)r�ryr,r>r&rZr])r\Zpadded_multiline_cells�
padded_widthsrAr|rWrQr@Zlines_cells�lnZ	padded_lnr)rdrbrWrQr�_append_multiline_row�s

rgcsN|sdSt|d�r|||�S|\}�}}�fdd�|D�}t||||f�SdS)z3Return a string which represents a horizontal line.Nr
csg|]}�|�qSrr)r:r8)�fillrrr<	sz_build_line.<locals>.<listcomp>)r�r{)r@rA�linefmtrrrrXr)rhr�_build_line�s

rjcCs|�t|||��|S)N)rhrj)r\r@rArirrr�_append_line	srkc@s$eZdZdZdd�Zedd��ZdS)�JupyterHTMLStrzUWrap the string with a _repr_html_ method so that Jupyter
    displays the HTML tablecCs|S)Nr)�selfrrr�_repr_html_	szJupyterHTMLStr._repr_html_cCs|S)z>add a .str property so that the raw string is still accessibler)rmrrrr+	szJupyterHTMLStr.strN)�__name__�
__module__�__qualname__�__doc__rn�propertyr+rrrrrl
	srlc	sg}|r|jr|jng}|j�|j}	�fdd�|D�}
|rPdd��tt�d�}nt�t}�|��}��fdd�|D�}
|jr�d|kr�t||
||j�|r�||||
||	�|j	r�d|kr�t||
||j	�|
�rD|j
�rDd	|k�rDxDt|
d
d�|�D].\}}||||
||j|d�t||
||j
�q�W|||
d|
||j|dd�nj|j
�pp|j	�pp|j
�pp|j�pptd
d
d
d
�}x:|
D]2}t|��r�t||
||�n||||
||j��qxW|j
�r�d|k�r�t||
||j
�|�s�|�rd�|�}|jtk�r�t|�S|Snd
Sd
S)z1Produce a plain-text representation of the table.csg|]}|d��qS)rr)r:r8)rWrrr<!	sz!_format_table.<locals>.<listcomp>cSs|S)Nr)r.rsrrrr�#	r�z_format_table.<locals>.<lambda>)rWcsg|]}�|���qSrr)r:r.)rW�pad_rowrrr<*	sr!r"r#Nr�)rQrr$r\)r(r'r%r	rgrZr]r!rkr"r#r>r&r$rr/r?rQrl)r�r�r�r@rAr�rCr\Zhiddenr%reZ
append_rowZpadded_headersZpadded_rowsr.ZralignZseparating_line�outputr)rWrtrrN	s^



rNc@s<eZdZdZdd�Zedd��Zdd�Zdd	�Zd
d�Z	dS)
r,a[A custom implementation of CPython's textwrap.TextWrapper. This supports
    both wide characters (Korea, Japanese, Chinese)  - including mixed string.
    For the most part, the `_handle_long_word` and `_wrap_chunks` functions were
    copy pasted out of the CPython baseline, and updated with our custom length
    and line appending logic.
    cOs$g|_d|_tjj|f|�|�dS)N)�
_active_codes�	max_lines�textwrap�TextWrapper�__init__)rmrm�kwargsrrrrzi	sz_CustomTextWrap.__init__cCs"t|�}trt�|�St|�SdS)zqCustom len that gets console column width for wide
        and non-wide characters as well as ignores color codesN)r�r�r�r,)r��strippedrrr�_lenn	s
z_CustomTextWrap._lencCs�dd�t�|�D�}dd�|D�}d�|j�|}x(|D] }|tkrR|j�|�q8g|_q8Wt|j�dkrr|t}|�|�dS)aAdds a new line to the list of lines the text is being wrapped into
        This function will also track any ANSI color codes in this string as well
        as add any colors from previous lines order to preserve the same formatting
        as a single unwrapped string.
        cSsg|]}|�qSrr)r:�xrrrr<~	sz1_CustomTextWrap._update_lines.<locals>.<listcomp>cSs*g|]"}|j|��d|��d��qS)rr)r��span)r:�coderrrr<�	srrN)r��finditerr?rv�_ansi_color_reset_coderhr,)rmr\�new_lineZcode_matchesZcolor_codesr�rrr�
_update_linesx	s

z_CustomTextWrap._update_linescCs�|dkrd}n||}|jrx|d}d}x"|�|d|��|krJ|d}q*W|�|d|d��||dd�|d<n|s�|�|���dS)a	_handle_long_word(chunks : [string],
                             cur_line : [string],
                             cur_len : int, width : int)
        Handle a chunk of text (most likely a word, not whitespace) that
        is too long to fit in any line.
        rr�N)�break_long_wordsr}rh�pop)rm�reversed_chunks�cur_line�cur_lenre�
space_left�chunkrcrrr�_handle_long_word�	s	z!_CustomTextWrap._handle_long_wordc	Cs�g}|jdkrtd|j��|jdk	rf|jdkr8|j}n|j}|�|�|�|j���|jkrftd��|���x:|�r�g}d}|r�|j}n|j}|j|�|�}|j	r�|d�
�dkr�|r�|d=x<|r�|�|d�}|||kr�|�|���||7}q�Pq�W|�r:|�|d�|k�r:|�
||||�tt|j|��}|j	�rr|�rr|d�
�dk�rr||�|d�8}|d=|rr|jdk�s�t|�d|jk�s�|�r�|j	�r�t|�dk�r�|d�
��s�||k�r�|�||d�|��qrx�|�rN|d�
��r2||�|j�|k�r2|�|j�|�||d�|��P||�|d�8}|d=�q�W|�r�|d��}|�|�|�|j�|jk�r�||j|d<P|�|||j���PqrW|S)a�_wrap_chunks(chunks : [string]) -> [string]
        Wrap a sequence of text chunks and return a list of lines of
        length 'self.width' or less.  (If 'break_long_words' is false,
        some lines may be longer than this.)  Chunks correspond roughly
        to words and the whitespace between them: each chunk is
        indivisible (modulo 'break_long_words'), but a line break can
        come between any two chunks.  Chunks should not have internal
        whitespace; ie. a chunk is either all whitespace or a "word".
        Whitespace chunks will be removed from the beginning and end of
        lines, but apart from that whitespace is preserved.
        rzinvalid width %r (must be > 0)Nrz#placeholder too large for max widthr�r)rerlrw�subsequent_indent�initial_indentr}�placeholder�lstrip�reverse�drop_whitespacerrhr�r��sumryr,r�r?rH)	rm�chunksr\�indentr�r�reZ	chunk_len�	prev_linerrr�_wrap_chunks�	sr


 

 

z_CustomTextWrap._wrap_chunksN)
rorprqrrrz�staticmethodr}r�r�r�rrrrr,a	s
&r,c
Csddl}ddl}ddl}|�tj�}y0|�|jdd�dddddd	d
ddg�\}}Wn>|jk
r�}zt|�t|�|�	d
�Wdd}~XYnXg}t
}t}	d}
d}d}d}
x�|D]�\}}|dkr�d}q�|dkr�|}
q�|dkr�|}q�|dkr�|}	q�|dk�r
|��}
q�|dk�rB|t
k�r<td|�t|�|�	d�|}q�|dk�rR|}q�|dkr�t|�|�	d�q�W|�s~|jgn|}|
dk�r�|jnt|
d��v}xn|D]f}|dk�r�|j}t|��r�t||||||	||
d�n,t|��}t||||||	||
d�WdQRX�q�WWdQRXdS)a    Usage: tabulate [options] [FILE ...]

    Pretty-print tabular data.
    See also https://github.com/astanin/python-tabulate

    FILE                      a filename of the file with tabular data;
                              if "-" or missing, read data from stdin.

    Options:

    -h, --help                show this message
    -1, --header              use the first row of data as a table header
    -o FILE, --output FILE    print table to FILE (default: stdout)
    -s REGEXP, --sep REGEXP   use a custom column separator (default: whitespace)
    -F FPFMT, --float FPFMT   floating point number format (default: g)
    -I INTFMT, --int INTFMT   integer point number format (default: "")
    -f FMT, --format FMT      set output table format; supported formats:
                              plain, simple, grid, fancy_grid, pipe, orgtbl,
                              rst, mediawiki, html, latex, latex_raw,
                              latex_booktabs, latex_longtable, tsv
                              (default: simple)
    rNrzh1o:s:F:A:f:�helprXruzsep=zfloat=zint=zalign=zformat=rr�z\s+r2)z-1z--headerr)z-oz--output)z-Fz--float)z-Iz--int)z-Cz
--colalign)z-fz--formatz"%s is not a supported table formatrk)z-sz--sep)z-hz--helpr8)r�rOrr�r��filerd)�getopt�sysrx�dedent�_mainrr�argv�GetoptError�print�exitrIrJr�r�stdin�stdout�openr�_pprint_file)r�r�rx�usage�optsrmr�r�r�r�rdrOr�outfile�opt�value�files�outr
�fobjrrrr�)
s�










r�c
	s:|��}�fdd�|D�}	tt|	|||||d�|d�dS)Ncs$g|]}|��rt��|����qSr)rr�r�rH)r:r[)rrrr<�
sz _pprint_file.<locals>.<listcomp>)r�r�rd)r�)�	readlinesr�r)
Zfobjectr�rOrr�r�r�rdr��tabler)rrr��
sr��__main__)r)FF)TT)rTFF)TT)rT)FN)r)T)r�r4)N)N)}rr�collectionsr�collections.abcrrr�rrT�	itertoolsrrr�	functoolsrr	rr�r�rxr#r��ImportErrorr�__all__r�__version__rEr�rIrJrKrFr�r-rrr r/r9rCrLrPrQrWrYr`rnZLATEX_ESCAPE_RULESr}r�rMr*�sortedrrrH�compiler�r�Z_escZ_csiZ_oscZ_stZ_ansi_escape_pat�VERBOSEr��encoder�r�r�rr�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�r�rrr
rr*r3r7rrDr+rZr{r[r]rargrjrkr+rlrNryr,r�r�rorrrr�<module>s�

"		
6	


































































0!#+%?	

GIb