Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/tabulate/__init_

1309 good_result = '\\u0431\\u0443\\u043a\\u0432\\u0430 \\u0446\\u0438\\u0444\\u0440\\u0430\\n------- -------\\n\\u0430\\u0437 2\\n\\u0431\\u0443\\u043a\\u0438 4' ; \

1310 tabulate(tbl, headers=hrow) == good_result

1311 True

1312

1313 """

1314 if val is None:

1315 return missingval

1316 if isinstance(val, (bytes, str)) and not val:

1317 return ""

1318

1319 if valtype is str:

1320 return f"{val}"

1321 elif valtype is int:

1322 if isinstance(val, str):

1323 val_striped = val.encode("unicode_escape").decode("utf-8")

1324 colored = re.search(r"(\\[xX]+[0-9a-fA-F]+\[\d+[mM]+)([0-9.]+)(\\.*)$", val_striped)

1325 if colored:

1326 total_groups = len(colored.groups())

1327 if total_groups == 3:

1328 digits = colored.group(2)

1329 if digits.isdigit():

1330 val_new = colored.group(1) + format(int(digits), intfmt) + colored.group(3)

1331 val = val_new.encode("utf-8").decode("unicode_escape")

1332 intfmt = ""

1333 return format(val, intfmt)

1334 elif valtype is bytes:

1335 try:

1336 return str(val, "ascii")

1337 except (TypeError, UnicodeDecodeError):

1338 return str(val)

1339 elif valtype is float:

1340 is_a_colored_number = has_invisible and isinstance(val, (str, bytes))

1341 if is_a_colored_number:

1342 raw_val = _strip_ansi(val)

1343 try:

1344 formatted_val = format(float(raw_val), floatfmt)

1345 except (ValueError, TypeError):

1346 return f"{val}"

1347 return val.replace(raw_val, formatted_val)

1348 else:

1349 if isinstance(val, str) and "," in val:

1350 val = val.replace(",", "") # handle thousands-separators

1351 if isinstance(val, Decimal):

1352 return format(val, floatfmt)

1353 try:

1354 return format(float(val), floatfmt)

1355 except (ValueError, TypeError):

1356 return f"{val}"

1357 else:

1358 return f"{val}"

1359

1360

1361def _align_header(header, alignment, width, visible_width, is_multiline=False, width_fn=None):

1362 "Pad string header to width chars given known visible_width of the header."

1363 if is_multiline:

1364 header_lines = re.split(_multiline_codes, header)

1365 padded_lines = [_align_header(h, alignment, width, width_fn(h)) for h in header_lines]

1366 return "\n".join(padded_lines)

1367 # else: not multiline

1368 ninvisible = len(header) - visible_width

1369 width += ninvisible

1370 if alignment == "left":

1371 return _padright(width, header)

1372 elif alignment == "center":

1373 return _padboth(width, header)

1374 elif not alignment:

1375 return f"{header}"

1376 else:

1377 return _padleft(width, header)

1378

1379

1380def _remove_separating_lines(rows):

1381 if isinstance(rows, list):

1382 separating_lines = []

1383 sans_rows = []

1384 for index, row in enumerate(rows):

1385 if _is_separating_line(row):

1386 separating_lines.append(index)

1387 else:

1388 sans_rows.append(row)

1389 return sans_rows, separating_lines

1390 else:

1391 return rows, None

1392

1393

1394def _reinsert_separating_lines(rows, separating_lines):

1395 if separating_lines:

1396 for index in separating_lines:

1397 rows.insert(index, SEPARATING_LINE)

1398

1399

1400def _prepend_row_index(rows, index):

1401 """Add a left-most index column."""

1402 if index is None or index is False:

1403 return rows

1404 if isinstance(index, Sized) and len(index) != len(rows):

1405 raise ValueError(

1406 "index must be as long as the number of data rows: "

1407 f"len(index)={len(index)} len(rows)={len(rows)}"

1408 )

1409 sans_rows, separating_lines = _remove_separating_lines(rows)

1410 new_rows = []

1411 index_iter = iter(index)

1412 for row in sans_rows:

1413 index_v = next(index_iter)

1414 new_rows.append([index_v] + list(row))

1415 rows = new_rows

1416 _reinsert_separating_lines(rows, separating_lines)

1417 return rows

1418

1419

1420def _bool(val):

1421 "A wrapper around standard bool() which doesn't throw on NumPy arrays"

1422 try:

1423 return bool(val)

1424 except ValueError: # val is likely to be a numpy array with many elements

1425 return False

1426

1427

1428def _normalize_tabular_data(tabular_data, headers, showindex="default"):

1429 """Transform a supported data type to a list of lists, and a list of headers,

1430 with headers padding.

1431

1432 Supported tabular data types:

1433

1434 * list-of-lists or another iterable of iterables

1435

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

1437

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

1439

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

1441

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

1443

1444 * 2D NumPy arrays

1445

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

1447

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

1449

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

1451

1452 The first row can be used as headers if headers="firstrow",

1453 column indices can be used as headers if headers="keys".

1454

1455 If showindex="default", show row indices of the pandas.DataFrame.

1456 If showindex="always", show row indices for all types of data.

1457 If showindex="never", don't show row indices for all types of data.

1458 If showindex is an iterable, show its values as row indices.

1459

1460 """

1461

1462 try:

1463 bool(headers)

1464 except ValueError: # numpy.ndarray, pandas.core.index.Index, ...

1465 headers = list(headers)

1466

1467 err_msg = (

1468 "\n\nTo build a table python-tabulate requires two-dimensional data "

1469 "like a list of lists or similar."

1470 "\nDid you forget a pair of extra [] or ',' in ()?"

1471 )

1472 index = None

1473 if hasattr(tabular_data, "keys") and hasattr(tabular_data, "values"):

1474 # dict-like and pandas.DataFrame?

1475 if callable(tabular_data.values):

1476 # likely a conventional dict

1477 keys = tabular_data.keys()

1478 try:

1479 rows = list(izip_longest(*tabular_data.values())) # columns have to be transposed

1480 except TypeError as e: # not iterable

1481 raise TypeError(err_msg) from e

1482

1483 elif hasattr(tabular_data, "index"):

1484 # values is a property, has .index => it's likely a pandas.DataFrame (pandas 0.11.0)

1485 keys = list(tabular_data)

1486 if showindex in ["default", "always", True] and tabular_data.index.name is not None:

1487 if isinstance(tabular_data.index.name, list):

1488 keys[:0] = tabular_data.index.name

1489 else:

1490 keys[:0] = [tabular_data.index.name]

1491 vals = tabular_data.values # values matrix doesn't need to be transposed

1492 # for DataFrames add an index per default

1493 index = list(tabular_data.index)

1494 rows = [list(row) for row in vals]

1495 else:

1496 raise ValueError("tabular data doesn't appear to be a dict or a DataFrame")

1497

1498 if headers == "keys":

1499 headers = list(map(str, keys)) # headers should be strings

1500

1501 else: # it's a usual iterable of iterables, or a NumPy array, or an iterable of dataclasses

1502 try:

1503 rows = list(tabular_data)

1504 except TypeError as e: # not iterable

1505 raise TypeError(err_msg) from e

1506

1507 if headers == "keys" and not rows:

1508 # an empty table (issue #81)

1509 headers = []

1510 elif headers == "keys" and hasattr(tabular_data, "dtype") and tabular_data.dtype.names:

1511 # numpy record array

1512 headers = tabular_data.dtype.names

1513 elif (

1514 headers == "keys"

1515 and len(rows) > 0

1516 and isinstance(rows[0], tuple)

1517 and hasattr(rows[0], "_fields")

1518 ):

1519 # namedtuple

1520 headers = list(map(str, rows[0]._fields))

1521 elif len(rows) > 0 and hasattr(rows[0], "keys") and hasattr(rows[0], "values"):

1522 # dict-like object

1523 uniq_keys = set() # implements hashed lookup

1524 keys = [] # storage for set

1525 if headers == "firstrow":

1526 firstdict = rows[0] if len(rows) > 0 else {}

1527 keys.extend(firstdict.keys())

1528 uniq_keys.update(keys)

1529 rows = rows[1:]

1530 for row in rows:

1531 for k in row.keys():

1532 # Save unique items in input order

1533 if k not in uniq_keys:

1534 keys.append(k)

1535 uniq_keys.add(k)

1536 if headers == "keys":

1537 headers = keys

1538 elif isinstance(headers, dict):

1539 # a dict of headers for a list of dicts

1540 headers = [headers.get(k, k) for k in keys]

1541 headers = list(map(str, headers))

1542 elif headers == "firstrow":

1543 if len(rows) > 0:

1544 headers = [firstdict.get(k, k) for k in keys]

1545 headers = list(map(str, headers))

1546 else:

1547 headers = []

1548 elif headers:

1549 raise ValueError("headers for a list of dicts is not a dict or a keyword")

1550 rows = [[row.get(k) for k in keys] for row in rows]

1551

1552 elif (

1553 headers == "keys"

1554 and hasattr(tabular_data, "description")

1555 and hasattr(tabular_data, "fetchone")

1556 and hasattr(tabular_data, "rowcount")

1557 ):

1558 # Python Database API cursor object (PEP 0249)

1559 # print tabulate(cursor, headers='keys')

1560 headers = [column[0] for column in tabular_data.description]

1561

1562 elif dataclasses is not None and len(rows) > 0 and dataclasses.is_dataclass(rows[0]):

1563 # Python's dataclass

1564 field_names = [field.name for field in dataclasses.fields(rows[0])]

1565 if headers == "keys":

1566 headers = field_names

1567 rows = [

1568 ([getattr(row, f) for f in field_names] if not _is_separating_line(row) else row)

1569 for row in rows

1570 ]

1571

1572 elif headers == "keys" and len(rows) > 0:

1573 # keys are column indices

1574 headers = list(map(str, range(len(rows[0]))))

1575

1576 # take headers from the first row if necessary

1577 if headers == "firstrow" and len(rows) > 0:

1578 if index is not None:

1579 headers = [index[0]] + list(rows[0])

1580 index = index[1:]

1581 else:

1582 headers = rows[0]

1583 headers = list(map(str, headers)) # headers should be strings

1584 rows = rows[1:]

1585 elif headers == "firstrow":

1586 headers = []

1587

1588 headers = list(map(str, headers))

1589 # rows = list(map(list, rows))

1590 rows = [r if _is_separating_line(r) else list(r) for r in rows]

1591

1592 # add or remove an index column

1593 showindex_is_a_str = type(showindex) in [str, bytes]

1594 if showindex_is_a_str and showindex == "default" and index is not None:

1595 rows = _prepend_row_index(rows, index)

1596 elif isinstance(showindex, Sized) and not showindex_is_a_str:

1597 rows = _prepend_row_index(rows, list(showindex))

1598 elif isinstance(showindex, Iterable) and not showindex_is_a_str:

1599 rows = _prepend_row_index(rows, showindex)

1600 elif showindex == "always" or (_bool(showindex) and not showindex_is_a_str):

1601 if index is None:

1602 index = list(range(len(rows)))

1603 rows = _prepend_row_index(rows, index)

1604 elif showindex == "never" or (not _bool(showindex) and not showindex_is_a_str):

1605 pass

1606

1607 # pad with empty headers for initial columns if necessary

1608 headers_pad = 0

1609 if headers and len(rows) > 0:

1610 headers_pad = max(0, len(rows[0]) - len(headers))

1611 headers = [""] * headers_pad + headers

1612

1613 return rows, headers, headers_pad

1614

1615

1616def _wrap_text_to_colwidths(

1617 list_of_lists,

1618 colwidths,

1619 numparses=True,

1620 missingval=_DEFAULT_MISSINGVAL,

1621 break_long_words=_BREAK_LONG_WORDS,

1622 break_on_hyphens=_BREAK_ON_HYPHENS,

1623):

1624 if len(list_of_lists):

1625 num_cols = len(list_of_lists[0])

1626 else:

1627 num_cols = 0

1628 numparses = _expand_iterable(numparses, num_cols, True)

1629

1630 result = []

1631

1632 for row in list_of_lists:

1633 new_row = []

1634 for cell, width, numparse in zip(row, colwidths, numparses):

1635 if _isnumber(cell) and numparse:

1636 new_row.append(cell)

1637 continue

1638

1639 if width is not None:

1640 wrapper = _CustomTextWrap(

1641 width=width,

1642 break_long_words=break_long_words,

1643 break_on_hyphens=break_on_hyphens,

1644 )

1645 # Cast based on our internal type handling. Any future custom

1646 # formatting of types (such as datetimes) may need to be more

1647 # explicit than just `str` of the object. Also doesn't work for

1648 # custom floatfmt/intfmt, nor with any missing/blank cells.

1649 casted_cell = (

1650 missingval

1651 if cell is None

1652 else (

1653 str(cell)

1654 if cell == "" or _isnumber(cell)

1655 else str(_type(cell, numparse)(cell))

1656 )

1657 )

1658 wrapped = [

1659 "\n".join(wrapper.wrap(line))

1660 for line in casted_cell.splitlines()

1661 if line.strip() != ""

1662 ]

1663 new_row.append("\n".join(wrapped))

1664 else:

1665 new_row.append(cell)

1666 result.append(new_row)

1667

1668 return result

1669

1670

1671def _to_str(s, encoding="utf8", errors="ignore"):

1672 """

1673 A type safe wrapper for converting a bytestring to str. This is essentially just

1674 a wrapper around .decode() intended for use with things like map(), but with some

1675 specific behavior:

1676

1677 1. if the given parameter is not a bytestring, it is returned unmodified

1678 2. decode() is called for the given parameter and assumes utf8 encoding, but the

1679 default error behavior is changed from 'strict' to 'ignore'

1680

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

1682 "'foo'"

1683

1684 >>> repr(_to_str('foo'))

1685 "'foo'"

1686

1687 >>> repr(_to_str(42))

1688 "'42'"

1689

1690 """

1691 if isinstance(s, bytes):

1692 return s.decode(encoding=encoding, errors=errors)

1693 return str(s)

1694

1695

1696def tabulate(

1697 tabular_data,

1698 headers=(),

1699 tablefmt="simple",

1700 floatfmt=_DEFAULT_FLOATFMT,

1701 intfmt=_DEFAULT_INTFMT,

1702 numalign=_DEFAULT_ALIGN,

1703 stralign=_DEFAULT_ALIGN,

1704 missingval=_DEFAULT_MISSINGVAL,

1705 showindex="default",

1706 disable_numparse=False,

1707 colglobalalign=None,

1708 colalign=None,

1709 preserve_whitespace=False,

1710 maxcolwidths=None,

1711 headersglobalalign=None,

1712 headersalign=None,

1713 rowalign=None,

1714 maxheadercolwidths=None,

1715 break_long_words=_BREAK_LONG_WORDS,

1716 break_on_hyphens=_BREAK_ON_HYPHENS,

1717):

1718 """Format a fixed width table for pretty printing.

1719

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

1721 --- ---------

1722 1 2.34

1723 -56 8.999

1724 2 10001

1725 --- ---------

1726

1727 The first required argument (`tabular_data`) can be a

1728 list-of-lists (or another iterable of iterables), a list of named

1729 tuples, a dictionary of iterables, an iterable of dictionaries,

1730 an iterable of dataclasses, a two-dimensional NumPy array,

1731 NumPy record array, or a Pandas' dataframe.

1732

1733

1734 Table headers

1735 -------------

1736

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

1738

1739 - `headers` can be an explicit list of column headers

1740 - if `headers="firstrow"`, then the first row of data is used

1741 - if `headers="keys"`, then dictionary keys or column indices are used

1742

1743 Otherwise a headerless table is produced.

1744

1745 If the number of headers is less than the number of columns, they

1746 are supposed to be names of the last columns. This is consistent

1747 with the plain-text format of R and Pandas' dataframes.

1748

1749 >>> print(tabulate([["sex","age"],["Alice","F",24],["Bob","M",19]],

1750 ... headers="firstrow"))

1751 sex age

1752 ----- ----- -----

1753 Alice F 24

1754 Bob M 19

1755

1756 By default, pandas.DataFrame data have an additional column called

1757 row index. To add a similar column to all other types of data,

1758 use `showindex="always"` or `showindex=True`. To suppress row indices

1759 for all types of data, pass `showindex="never" or `showindex=False`.

1760 To add a custom row index column, pass `showindex=some_iterable`.

1761

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

1763 - - --

1764 0 F 24

1765 1 M 19

1766 - - --

1767

1768

1769 Column and Headers alignment

1770 ----------------------------

1771

1772 `tabulate` tries to detect column types automatically, and aligns

1773 the values properly. By default it aligns decimal points of the

1774 numbers (or flushes integer numbers to the right), and flushes

1775 everything else to the left. Possible column alignments

1776 (`numalign`, `stralign`) are: "right", "center", "left", "decimal"

1777 (only for `numalign`), and None (to disable alignment).

1778

1779 `colglobalalign` allows for global alignment of columns, before any

1780 specific override from `colalign`. Possible values are: None

1781 (defaults according to coltype), "right", "center", "decimal",

1782 "left".

1783 `colalign` allows for column-wise override starting from left-most

1784 column. Possible values are: "global" (no override), "right",

1785 "center", "decimal", "left".

1786 `headersglobalalign` allows for global headers alignment, before any

1787 specific override from `headersalign`. Possible values are: None

1788 (follow columns alignment), "right", "center", "left".

1789 `headersalign` allows for header-wise override starting from left-most

1790 given header. Possible values are: "global" (no override), "same"

1791 (follow column alignment), "right", "center", "left".

1792

1793 Note on intended behaviour: If there is no `tabular_data`, any column

1794 alignment argument is ignored. Hence, in this case, header

1795 alignment cannot be inferred from column alignment.

1796

1797 Table formats

1798 -------------

1799

1800 `intfmt` is a format specification used for columns which

1801 contain numeric data without a decimal point. This can also be

1802 a list or tuple of format strings, one per column.

1803

1804 `floatfmt` is a format specification used for columns which

1805 contain numeric data with a decimal point. This can also be

1806 a list or tuple of format strings, one per column.

1807

1808 `None` values are replaced with a `missingval` string (like

1809 `floatfmt`, this can also be a list of values for different

1810 columns):

1811

1812 >>> print(tabulate([["spam", 1, None],

1813 ... ["eggs", 42, 3.14],

1814 ... ["other", None, 2.7]], missingval="?"))

1815 ----- -- ----

1816 spam 1 ?

1817 eggs 42 3.14

1818 other ? 2.7

1819 ----- -- ----

1820

1821 Various plain-text table formats (`tablefmt`) are supported:

1822 'plain', 'simple', 'grid', 'pipe', 'orgtbl', 'rst', 'mediawiki',

1823 'latex', 'latex_raw', 'latex_booktabs', 'latex_longtable' and tsv.

1824 Variable `tabulate_formats`contains the list of currently supported formats.

1825

1826 "plain" format doesn't use any pseudographics to draw tables,

1827 it separates columns with a double space:

1828

1829 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

1830 ... ["strings", "numbers"], "plain"))

1831 strings numbers

1832 spam 41.9999

1833 eggs 451

1834

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

1836 spam 41.9999

1837 eggs 451

1838

1839 "simple" format is like Pandoc simple_tables:

1840

1841 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

1842 ... ["strings", "numbers"], "simple"))

1843 strings numbers

1844 --------- ---------

1845 spam 41.9999

1846 eggs 451

1847

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

1849 ---- --------

1850 spam 41.9999

1851 eggs 451

1852 ---- --------

1853

1854 "grid" is similar to tables produced by Emacs table.el package or

1855 Pandoc grid_tables:

1856

1857 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

1858 ... ["strings", "numbers"], "grid"))

1859 +-----------+-----------+

1860 | strings | numbers |

1861 +===========+===========+

1862 | spam | 41.9999 |

1863 +-----------+-----------+

1864 | eggs | 451 |

1865 +-----------+-----------+

1866

1867 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="grid"))

1868 +------+----------+

1869 | spam | 41.9999 |

1870 +------+----------+

1871 | eggs | 451 |

1872 +------+----------+

1873

1874 "simple_grid" draws a grid using single-line box-drawing

1875 characters:

1876

1877 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

1878 ... ["strings", "numbers"], "simple_grid"))

1879 ┌───────────┬───────────┐

1880 │ strings │ numbers │

1881 ├───────────┼───────────┤

1882 │ spam │ 41.9999 │

1883 ├───────────┼───────────┤

1884 │ eggs │ 451 │

1885 └───────────┴───────────┘

1886

1887 "rounded_grid" draws a grid using single-line box-drawing

1888 characters with rounded corners:

1889

1890 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

1891 ... ["strings", "numbers"], "rounded_grid"))

1892 ╭───────────┬───────────╮

1893 │ strings │ numbers │

1894 ├───────────┼───────────┤

1895 │ spam │ 41.9999 │

1896 ├───────────┼───────────┤

1897 │ eggs │ 451 │

1898 ╰───────────┴───────────╯

1899

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

1901 characters:

1902

1903 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

1904 ... ["strings", "numbers"], "heavy_grid"))

1905 ┏━━━━━━━━━━━┳━━━━━━━━━━━┓

1906 ┃ strings ┃ numbers ┃

1907 ┣━━━━━━━━━━━╋━━━━━━━━━━━┫

1908 ┃ spam ┃ 41.9999 ┃

1909 ┣━━━━━━━━━━━╋━━━━━━━━━━━┫

1910 ┃ eggs ┃ 451 ┃

1911 ┗━━━━━━━━━━━┻━━━━━━━━━━━┛

1912

1913 "mixed_grid" draws a grid using a mix of light (thin) and heavy (thick) lines

1914 box-drawing characters:

1915

1916 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

1917 ... ["strings", "numbers"], "mixed_grid"))

1918 ┍━━━━━━━━━━━┯━━━━━━━━━━━┑

1919 │ strings │ numbers │

1920 ┝━━━━━━━━━━━┿━━━━━━━━━━━┥

1921 │ spam │ 41.9999 │

1922 ├───────────┼───────────┤

1923 │ eggs │ 451 │

1924 ┕━━━━━━━━━━━┷━━━━━━━━━━━┙

1925

1926 "double_grid" draws a grid using double-line box-drawing

1927 characters:

1928

1929 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

1930 ... ["strings", "numbers"], "double_grid"))

1931 ╔═══════════╦═══════════╗

1932 ║ strings ║ numbers ║

1933 ╠═══════════╬═══════════╣

1934 ║ spam ║ 41.9999 ║

1935 ╠═══════════╬═══════════╣

1936 ║ eggs ║ 451 ║

1937 ╚═══════════╩═══════════╝

1938

1939 "fancy_grid" draws a grid using a mix of single and

1940 double-line box-drawing characters:

1941

1942 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

1943 ... ["strings", "numbers"], "fancy_grid"))

1944 ╒═══════════╤═══════════╕

1945 │ strings │ numbers │

1946 ╞═══════════╪═══════════╡

1947 │ spam │ 41.9999 │

1948 ├───────────┼───────────┤

1949 │ eggs │ 451 │

1950 ╘═══════════╧═══════════╛

1951

1952 "colon_grid" is similar to "grid" but uses colons only to define

1953 columnwise content alignment, without whitespace padding,

1954 similar to the alignment specification of Pandoc `grid_tables`:

1955

1956 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

1957 ... ["strings", "numbers"], "colon_grid"))

1958 +-----------+-----------+

1959 | strings | numbers |

1960 +:==========+:==========+

1961 | spam | 41.9999 |

1962 +-----------+-----------+

1963 | eggs | 451 |

1964 +-----------+-----------+

1965

1966 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

1967 ... ["strings", "numbers"], "colon_grid",

1968 ... colalign=["right", "left"]))

1969 +-----------+-----------+

1970 | strings | numbers |

1971 +==========:+:==========+

1972 | spam | 41.9999 |

1973 +-----------+-----------+

1974 | eggs | 451 |

1975 +-----------+-----------+

1976

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

1978

1979 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

1980 ... ["strings", "numbers"], "outline"))

1981 +-----------+-----------+

1982 | strings | numbers |

1983 +===========+===========+

1984 | spam | 41.9999 |

1985 | eggs | 451 |

1986 +-----------+-----------+

1987

1988 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="outline"))

1989 +------+----------+

1990 | spam | 41.9999 |

1991 | eggs | 451 |

1992 +------+----------+

1993

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

1995

1996 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

1997 ... ["strings", "numbers"], "simple_outline"))

1998 ┌───────────┬───────────┐

1999 │ strings │ numbers │

2000 ├───────────┼───────────┤

2001 │ spam │ 41.9999 │

2002 │ eggs │ 451 │

2003 └───────────┴───────────┘

2004

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

2006

2007 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

2008 ... ["strings", "numbers"], "rounded_outline"))

2009 ╭───────────┬───────────╮

2010 │ strings │ numbers │

2011 ├───────────┼───────────┤

2012 │ spam │ 41.9999 │

2013 │ eggs │ 451 │

2014 ╰───────────┴───────────╯

2015

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

2017

2018 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

2019 ... ["strings", "numbers"], "heavy_outline"))

2020 ┏━━━━━━━━━━━┳━━━━━━━━━━━┓

2021 ┃ strings ┃ numbers ┃

2022 ┣━━━━━━━━━━━╋━━━━━━━━━━━┫

2023 ┃ spam ┃ 41.9999 ┃

2024 ┃ eggs ┃ 451 ┃

2025 ┗━━━━━━━━━━━┻━━━━━━━━━━━┛

2026

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

2028

2029 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

2030 ... ["strings", "numbers"], "mixed_outline"))

2031 ┍━━━━━━━━━━━┯━━━━━━━━━━━┑

2032 │ strings │ numbers │

2033 ┝━━━━━━━━━━━┿━━━━━━━━━━━┥

2034 │ spam │ 41.9999 │

2035 │ eggs │ 451 │

2036 ┕━━━━━━━━━━━┷━━━━━━━━━━━┙

2037

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

2039

2040 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

2041 ... ["strings", "numbers"], "double_outline"))

2042 ╔═══════════╦═══════════╗

2043 ║ strings ║ numbers ║

2044 ╠═══════════╬═══════════╣

2045 ║ spam ║ 41.9999 ║

2046 ║ eggs ║ 451 ║

2047 ╚═══════════╩═══════════╝

2048

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

2050

2051 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

2052 ... ["strings", "numbers"], "fancy_outline"))

2053 ╒═══════════╤═══════════╕

2054 │ strings │ numbers │

2055 ╞═══════════╪═══════════╡

2056 │ spam │ 41.9999 │

2057 │ eggs │ 451 │

2058 ╘═══════════╧═══════════╛

2059

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

2061 pipe_tables:

2062

2063 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

2064 ... ["strings", "numbers"], "pipe"))

2065 | strings | numbers |

2066 |:----------|----------:|

2067 | spam | 41.9999 |

2068 | eggs | 451 |

2069

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

2071

2072 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

2073 ... ["strings", "numbers"], "presto"))

2074 strings | numbers

2075 -----------+-----------

2076 spam | 41.9999

2077 eggs | 451

2078

2079 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="pipe"))

2080 |:-----|---------:|

2081 | spam | 41.9999 |

2082 | eggs | 451 |

2083

2084 "orgtbl" is like tables in Emacs org-mode and orgtbl-mode. They

2085 are slightly different from "pipe" format by not using colons to

2086 define column alignment, and using a "+" sign to indicate line

2087 intersections:

2088

2089 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

2090 ... ["strings", "numbers"], "orgtbl"))

2091 | strings | numbers |

2092 |-----------+-----------|

2093 | spam | 41.9999 |

2094 | eggs | 451 |

2095

2096

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

2098 | spam | 41.9999 |

2099 | eggs | 451 |

2100

2101 "rst" is like a simple table format from reStructuredText; please

2102 note that reStructuredText accepts also "grid" tables:

2103

2104 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],

2105 ... ["strings", "numbers"], "rst"))

2106 ========= =========

2107 strings numbers

2108 ========= =========

2109 spam 41.9999

2110 eggs 451

2111 ========= =========

2112

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

2114 ==== ========

2115 spam 41.9999

2116 eggs 451

2117 ==== ========

2118

2119 "mediawiki" produces a table markup used in Wikipedia and on other

2120 MediaWiki-based sites:

2121

2122 >>> print(tabulate([["strings", "numbers"], ["spam", 41.9999], ["eggs", "451.0"]],

2123 ... headers="firstrow", tablefmt="mediawiki"))

2124 {| class="wikitable" style="text-align: left;"

2125 |+

2126 |-

2127 ! strings !! style="text-align: right;"| numbers

2128 |-

2129 | spam || style="text-align: right;"| 41.9999

2130 |-

2131 | eggs || style="text-align: right;"| 451

2132 |}

2133

2134 "html" produces HTML markup as an html.escape'd str

2135 with a ._repr_html_ method so that Jupyter Lab and Notebook display the HTML

2136 and a .str property so that the raw HTML remains accessible

2137 the unsafehtml table format can be used if an unescaped HTML format is required:

2138

2139 >>> print(tabulate([["strings", "numbers"], ["spam", 41.9999], ["eggs", "451.0"]],

2140 ... headers="firstrow", tablefmt="html"))

2141 <table>

2142 <thead>

2143 <tr><th style="text-align: left;">strings </th><th style="text-align: right;"> numbers</th></tr>

2144 </thead>

2145 <tbody>

2146 <tr><td style="text-align: left;">spam </td><td style="text-align: right;"> 41.9999</td></tr>

2147 <tr><td style="text-align: left;">eggs </td><td style="text-align: right;"> 451 </td></tr>

2148 </tbody>

2149 </table>

2150

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

2152

2153 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="latex"))

2154 \\begin{tabular}{lr}

2155 \\hline

2156 spam & 41.9999 \\\\

2157 eggs & 451 \\\\

2158 \\hline

2159 \\end{tabular}

2160

2161 "latex_raw" is similar to "latex", but doesn't escape special characters,

2162 such as backslash and underscore, so LaTeX commands may embedded into

2163 cells' values:

2164

2165 >>> print(tabulate([["spam$_9$", 41.9999], ["\\\\emph{eggs}", "451.0"]], tablefmt="latex_raw"))

2166 \\begin{tabular}{lr}

2167 \\hline

2168 spam$_9$ & 41.9999 \\\\

2169 \\emph{eggs} & 451 \\\\

2170 \\hline

2171 \\end{tabular}

2172

2173 "latex_booktabs" produces a tabular environment of LaTeX document markup

2174 using the booktabs.sty package:

2175

2176 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="latex_booktabs"))

2177 \\begin{tabular}{lr}

2178 \\toprule

2179 spam & 41.9999 \\\\

2180 eggs & 451 \\\\

2181 \\bottomrule

2182 \\end{tabular}

2183

2184 "latex_longtable" produces a tabular environment that can stretch along

2185 multiple pages, using the longtable package for LaTeX.

2186

2187 >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="latex_longtable"))

2188 \\begin{longtable}{lr}

2189 \\hline

2190 spam & 41.9999 \\\\

2191 eggs & 451 \\\\

2192 \\hline

2193 \\end{longtable}

2194

2195

2196 Number parsing

2197 --------------

2198 By default, anything which can be parsed as a number is a number.

2199 This ensures numbers represented as strings are aligned properly.

2200 This can lead to weird results for particular strings such as

2201 specific git SHAs e.g. "42992e1" will be parsed into the number

2202 429920 and aligned as such.

2203

2204 To completely disable number parsing (and alignment), use

2205 `disable_numparse=True`. For more fine grained control, a list column

2206 indices is used to disable number parsing only on those columns

2207 e.g. `disable_numparse=[0, 2]` would disable number parsing only on the

2208 first and third columns.

2209

2210 Column Widths and Auto Line Wrapping

2211 ------------------------------------

2212 Tabulate will, by default, set the width of each column to the length of the

2213 longest element in that column. However, in situations where fields are expected

2214 to reasonably be too long to look good as a single line, tabulate can help automate

2215 word wrapping long fields for you. Use the parameter `maxcolwidths` to provide a

2216 list of maximal column widths:

2217

2218 >>> print(tabulate( \

2219 [('1', 'John Smith', \

2220 'This is a rather long description that might look better if it is wrapped a bit')], \

2221 headers=("Issue Id", "Author", "Description"), \

2222 maxcolwidths=[None, None, 30], \

2223 tablefmt="grid" \

2224 ))

2225 +------------+------------+-------------------------------+

2226 | Issue Id | Author | Description |

2227 +============+============+===============================+

2228 | 1 | John Smith | This is a rather long |

2229 | | | description that might look |

2230 | | | better if it is wrapped a bit |

2231 +------------+------------+-------------------------------+

2232

2233 Header column width can be specified in a similar way using `maxheadercolwidths`.

2234

2235 """

2236

2237 if tabular_data is None:

2238 tabular_data = []

2239

2240 list_of_lists, headers, headers_pad = _normalize_tabular_data(

2241 tabular_data, headers, showindex=showindex

2242 )

2243 list_of_lists, separating_lines = _remove_separating_lines(list_of_lists)

2244

2245 if maxcolwidths is not None:

2246 if type(maxcolwidths) is tuple: # Check if tuple, convert to list if so

2247 maxcolwidths = list(maxcolwidths)

2248 if len(list_of_lists):

2249 num_cols = len(list_of_lists[0])

2250 else:

2251 num_cols = 0

2252 if isinstance(maxcolwidths, int): # Expand scalar for all columns

2253 maxcolwidths = _expand_iterable(maxcolwidths, num_cols, maxcolwidths)

2254 else: # Ignore col width for any 'trailing' columns

2255 maxcolwidths = _expand_iterable(maxcolwidths, num_cols, None)

2256

2257 numparses = _expand_numparse(disable_numparse, num_cols)

2258 list_of_lists = _wrap_text_to_colwidths(

2259 list_of_lists,

2260 maxcolwidths,

2261 numparses=numparses,

2262 missingval=missingval,

2263 break_long_words=break_long_words,

2264 break_on_hyphens=break_on_hyphens,

2265 )

2266

2267 if maxheadercolwidths is not None:

2268 num_cols = len(list_of_lists[0]) if list_of_lists else len(headers)

2269 if isinstance(maxheadercolwidths, int): # Expand scalar for all columns

2270 maxheadercolwidths = _expand_iterable(maxheadercolwidths, num_cols, maxheadercolwidths)

2271 else: # Ignore col width for any 'trailing' columns

2272 maxheadercolwidths = _expand_iterable(maxheadercolwidths, num_cols, None)

2273

2274 numparses = _expand_numparse(disable_numparse, num_cols)

2275 headers = _wrap_text_to_colwidths(

2276 [headers],

2277 maxheadercolwidths,

2278 numparses=numparses,

2279 missingval=missingval,

2280 break_long_words=break_long_words,

2281 break_on_hyphens=break_on_hyphens,

2282 )[0]

2283

2284 # empty values in the first column of RST tables should be escaped (issue #82)

2285 # "" should be escaped as "\\ " or ".."

2286 if tablefmt == "rst":

2287 list_of_lists, headers = _rst_escape_first_column(list_of_lists, headers)

2288

2289 # PrettyTable formatting does not use any extra padding.

2290 # Numbers are not parsed and are treated the same as strings for alignment.

2291 # Check if pretty is the format being used and override the defaults so it

2292 # does not impact other formats.

2293 min_padding = MIN_PADDING

2294 if tablefmt == "pretty":

2295 min_padding = 0

2296 disable_numparse = True

2297 numalign = "center" if numalign == _DEFAULT_ALIGN else numalign

2298 stralign = "center" if stralign == _DEFAULT_ALIGN else stralign

2299 else:

2300 numalign = "decimal" if numalign == _DEFAULT_ALIGN else numalign

2301 stralign = "left" if stralign == _DEFAULT_ALIGN else stralign

2302

2303 # 'colon_grid' uses colons in the line beneath the header to represent a column's

2304 # alignment instead of literally aligning the text differently. Hence,

2305 # left alignment of the data in the text output is enforced.

2306 if tablefmt == "colon_grid":

2307 colglobalalign = "left"

2308 headersglobalalign = "left"

2309

2310 # optimization: look for ANSI control codes once,

2311 # enable smart width functions only if a control code is found

2312 #

2313 # convert the headers and rows into a single, tab-delimited string ensuring

2314 # that any bytestrings are decoded safely (i.e. errors ignored)

2315 plain_text = "\t".join(

2316 chain(

2317 # headers

2318 map(_to_str, headers),

2319 # rows: chain the rows together into a single iterable after mapping

2320 # the bytestring conversino to each cell value

2321 chain.from_iterable(map(_to_str, row) for row in list_of_lists),

2322 )

2323 )

2324

2325 has_invisible = _ansi_codes.search(plain_text) is not None

2326

2327 enable_widechars = wcwidth is not None and WIDE_CHARS_MODE

2328 if (

2329 not isinstance(tablefmt, TableFormat)

2330 and tablefmt in multiline_formats

2331 and _is_multiline(plain_text)

2332 ):

2333 tablefmt = multiline_formats.get(tablefmt, tablefmt)

2334 is_multiline = True

2335 else:

2336 is_multiline = False

2337 width_fn = _choose_width_fn(has_invisible, enable_widechars, is_multiline)

2338

2339 # format rows and columns, convert numeric values to strings

2340 cols = list(izip_longest(*list_of_lists))

2341 numparses = _expand_numparse(disable_numparse, len(cols))

2342 coltypes = [_column_type(col, numparse=np) for col, np in zip(cols, numparses)]

2343 if isinstance(floatfmt, str): # old version

2344 float_formats = len(cols) * [floatfmt] # just duplicate the string to use in each column

2345 else: # if floatfmt is list, tuple etc we have one per column

2346 float_formats = list(floatfmt)

2347 if len(float_formats) < len(cols):

2348 float_formats.extend((len(cols) - len(float_formats)) * [_DEFAULT_FLOATFMT])

2349 if isinstance(intfmt, str): # old version

2350 int_formats = len(cols) * [intfmt] # just duplicate the string to use in each column

2351 else: # if intfmt is list, tuple etc we have one per column

2352 int_formats = list(intfmt)

2353 if len(int_formats) < len(cols):

2354 int_formats.extend((len(cols) - len(int_formats)) * [_DEFAULT_INTFMT])

2355 if isinstance(missingval, str):

2356 missing_vals = len(cols) * [missingval]

2357 else:

2358 missing_vals = list(missingval)

2359 if len(missing_vals) < len(cols):

2360 missing_vals.extend((len(cols) - len(missing_vals)) * [_DEFAULT_MISSINGVAL])

2361 cols = [

2362 [_format(v, ct, fl_fmt, int_fmt, miss_v, has_invisible) for v in c]

2363 for c, ct, fl_fmt, int_fmt, miss_v in zip(

2364 cols, coltypes, float_formats, int_formats, missing_vals

2365 )

2366 ]

2367

2368 # align columns

2369 # first set global alignment

2370 if colglobalalign is not None: # if global alignment provided

2371 aligns = [colglobalalign] * len(cols)

2372 else: # default

2373 aligns = [numalign if ct in [int, float] else stralign for ct in coltypes]

2374 # then specific alignments

2375 if colalign is not None:

2376 assert isinstance(colalign, Iterable)

2377 if isinstance(colalign, str):

2378 warnings.warn(

2379 f"As a string, `colalign` is interpreted as {list(colalign)}. "

2380 f'Did you mean `colglobalalign = "{colalign}"` or `colalign = ("{colalign}",)`?',

2381 stacklevel=2,

2382 )

2383 for idx, align in enumerate(colalign):

2384 if not idx < len(aligns):

2385 break

2386 elif align != "global":

2387 aligns[idx] = align

2388 minwidths = [width_fn(h) + min_padding for h in headers] if headers else [0] * len(cols)

2389 aligns_copy = aligns.copy()

2390 # Reset alignments in copy of alignments list to "left" for 'colon_grid' format,

2391 # which enforces left alignment in the text output of the data.

2392 if tablefmt == "colon_grid":

2393 aligns_copy = ["left"] * len(cols)

2394 cols = [

2395 _align_column(

2396 c,

2397 a,

2398 minw,

2399 has_invisible,

2400 enable_widechars,

2401 is_multiline,

2402 preserve_whitespace,

2403 )

2404 for c, a, minw in zip(cols, aligns_copy, minwidths)

2405 ]

2406

2407 aligns_headers = None

2408 if headers:

2409 # align headers and add headers

2410 t_cols = cols or [[""]] * len(headers)

2411 # first set global alignment

2412 if headersglobalalign is not None: # if global alignment provided

2413 aligns_headers = [headersglobalalign] * len(t_cols)

2414 else: # default

2415 aligns_headers = aligns or [stralign] * len(headers)

2416 # then specific header alignments

2417 if headersalign is not None:

2418 assert isinstance(headersalign, Iterable)

2419 if isinstance(headersalign, str):

2420 warnings.warn(

2421 f"As a string, `headersalign` is interpreted as {list(headersalign)}. "

2422 f'Did you mean `headersglobalalign = "{headersalign}"` '

2423 f'or `headersalign = ("{headersalign}",)`?',

2424 stacklevel=2,

2425 )

2426 for idx, align in enumerate(headersalign):

2427 hidx = headers_pad + idx

2428 if not hidx < len(aligns_headers):

2429 break

2430 elif align == "same" and hidx < len(aligns): # same as column align

2431 aligns_headers[hidx] = aligns[hidx]

2432 elif align != "global":

2433 aligns_headers[hidx] = align

2434 minwidths = [

2435 max(minw, max(width_fn(cl) for cl in c)) for minw, c in zip(minwidths, t_cols)

2436 ]

2437 headers = [

2438 _align_header(h, a, minw, width_fn(h), is_multiline, width_fn)

2439 for h, a, minw in zip(headers, aligns_headers, minwidths)

2440 ]

2441 rows = list(zip(*cols))

2442 else:

2443 minwidths = [max(width_fn(cl) for cl in c) for c in cols]

2444 rows = list(zip(*cols))

2445

2446 if not isinstance(tablefmt, TableFormat):

2447 tablefmt = _table_formats.get(tablefmt, _table_formats["simple"])

2448

2449 ra_default = rowalign if isinstance(rowalign, str) else None

2450 rowaligns = _expand_iterable(rowalign, len(rows), ra_default)

2451 _reinsert_separating_lines(rows, separating_lines)

2452

2453 return _format_table(

2454 tablefmt,

2455 headers,

2456 aligns_headers,

2457 rows,

2458 minwidths,

2459 aligns,

2460 is_multiline,

2461 rowaligns=rowaligns,

2462 )

2463

2464

2465def _expand_numparse(disable_numparse, column_count):

2466 """

2467 Return a list of bools of length `column_count` which indicates whether

2468 number parsing should be used on each column.

2469 If `disable_numparse` is a list of indices, each of those indices are False,

2470 and everything else is True.

2471 If `disable_numparse` is a bool, then the returned list is all the same.

2472 """

2473 if isinstance(disable_numparse, Iterable):

2474 numparses = [True] * column_count

2475 for index in disable_numparse:

2476 numparses[index] = False

2477 return numparses

2478 else:

2479 return [not disable_numparse] * column_count

2480

2481

2482def _expand_iterable(original, num_desired, default):

2483 """

2484 Expands the `original` argument to return a return a list of

2485 length `num_desired`. If `original` is shorter than `num_desired`, it will

2486 be padded with the value in `default`.

2487 If `original` is not a list to begin with (i.e. scalar value) a list of

2488 length `num_desired` completely populated with `default will be returned

2489 """

2490 if isinstance(original, Iterable) and not isinstance(original, str):

2491 return original + [default] * (num_desired - len(original))

2492 else:

2493 return [default] * num_desired

2494

2495

2496def _pad_row(cells, padding):

2497 if cells:

2498 if cells == SEPARATING_LINE:

2499 return SEPARATING_LINE

2500 pad = " " * padding

2501 padded_cells = [pad + cell + pad for cell in cells]

2502 return padded_cells

2503 else:

2504 return cells

2505

2506

2507def _build_simple_row(padded_cells: list[list], rowfmt: DataRow) -> str:

2508 "Format row according to DataRow format without padding."

2509 begin = rowfmt.begin

2510 sep = rowfmt.sep

2511 end = rowfmt.end

2512 escape_map: dict = rowfmt.escape_map

2513

2514 if escape_map:

2515

2516 def escape_char(c):

2517 return escape_map.get(c, c)

2518

2519 escaped_cells = ["".join(map(escape_char, cell)) for cell in padded_cells]

2520 else:

2521 escaped_cells = padded_cells

2522

2523 return (begin + sep.join(escaped_cells) + end).rstrip()

2524

2525

2526def _build_row(

2527 padded_cells: list[list],

2528 colwidths: list[int],

2529 colaligns: list[str],

2530 rowfmt: DataRow | Callable,

2531) -> str:

2532 "Return a string which represents a row of data cells."

2533 if not rowfmt:

2534 return None

2535 if callable(rowfmt):

2536 return rowfmt(padded_cells, colwidths, colaligns)

2537 else:

2538 return _build_simple_row(padded_cells, rowfmt)

2539

2540

2541def _append_basic_row(lines, padded_cells, colwidths, colaligns, rowfmt, rowalign=None):

2542 # NOTE: rowalign is ignored and exists for api compatibility with _append_multiline_row

2543 lines.append(_build_row(padded_cells, colwidths, colaligns, rowfmt))

2544 return lines

2545

2546

2547def _align_cell_veritically(text_lines, num_lines, column_width, row_alignment):

2548 delta_lines = num_lines - len(text_lines)

2549 blank = [" " * column_width]

2550 if row_alignment == "bottom":

2551 return blank * delta_lines + text_lines

2552 elif row_alignment == "center":

2553 top_delta = delta_lines // 2

2554 bottom_delta = delta_lines - top_delta

2555 return top_delta * blank + text_lines + bottom_delta * blank

2556 else:

2557 return text_lines + blank * delta_lines

2558

2559

2560def _append_multiline_row(

2561 lines, padded_multiline_cells, padded_widths, colaligns, rowfmt, pad, rowalign=None

2562):

2563 colwidths = [w - 2 * pad for w in padded_widths]

2564 cells_lines = [c.splitlines() for c in padded_multiline_cells]

2565 nlines = max(map(len, cells_lines)) # number of lines in the row

2566 # vertically pad cells where some lines are missing

2567 # cells_lines = [

2568 # (cl + [" " * w] * (nlines - len(cl))) for cl, w in zip(cells_lines, colwidths)

2569 # ]

2570

2571 cells_lines = [

2572 _align_cell_veritically(cl, nlines, w, rowalign) for cl, w in zip(cells_lines, colwidths)

2573 ]

2574 lines_cells = [[cl[i] for cl in cells_lines] for i in range(nlines)]

2575 for ln in lines_cells:

2576 padded_ln = _pad_row(ln, pad)

2577 _append_basic_row(lines, padded_ln, colwidths, colaligns, rowfmt)

2578 return lines

2579

2580

2581def _build_line(colwidths, colaligns, linefmt):

2582 "Return a string which represents a horizontal line."

2583 if not linefmt:

2584 return None

2585 if callable(linefmt):

2586 return linefmt(colwidths, colaligns)

2587 else:

2588 begin, fill, sep, end = linefmt

2589 cells = [fill * w for w in colwidths]

2590 rowfmt = DataRow(begin, sep, end)

2591 return _build_simple_row(cells, rowfmt)

2592

2593

2594def _append_line(lines, colwidths, colaligns, linefmt):

2595 lines.append(_build_line(colwidths, colaligns, linefmt))

2596 return lines

2597

2598

2599class JupyterHTMLStr(str):

2600 """Wrap the string with a _repr_html_ method so that Jupyter

2601 displays the HTML table"""

2602

2603 def _repr_html_(self):

2604 return self

2605

2606 @property

2607 def str(self):

2608 """add a .str property so that the raw string is still accessible"""

2609 return self

2610

2611

2612def _format_table(

2613 fmt, headers, headersaligns, rows, colwidths, colaligns, is_multiline, rowaligns

2614):

2615 """Produce a plain-text representation of the table."""

2616 lines = []

2617 hidden = fmt.with_header_hide if (headers and fmt.with_header_hide) else []

2618 pad = fmt.padding

2619 headerrow = fmt.headerrow

2620

2621 padded_widths = [(w + 2 * pad) for w in colwidths]

2622 if is_multiline:

2623 pad_row = lambda row, _: row # noqa: E731 # do it later, in _append_multiline_row

2624 append_row = partial(_append_multiline_row, pad=pad)

2625 else:

2626 pad_row = _pad_row

2627 append_row = _append_basic_row

2628

2629 padded_headers = pad_row(headers, pad)

2630

2631 if fmt.lineabove and "lineabove" not in hidden:

2632 _append_line(lines, padded_widths, colaligns, fmt.lineabove)

2633

2634 if padded_headers:

2635 append_row(lines, padded_headers, padded_widths, headersaligns, headerrow)

2636 if fmt.linebelowheader and "linebelowheader" not in hidden:

2637 _append_line(lines, padded_widths, colaligns, fmt.linebelowheader)

2638

2639 if rows and fmt.linebetweenrows and "linebetweenrows" not in hidden:

2640 # initial rows with a line below

2641 for row, ralign in zip(rows[:-1], rowaligns):

2642 if row != SEPARATING_LINE:

2643 append_row(

2644 lines,

2645 pad_row(row, pad),

2646 padded_widths,

2647 colaligns,

2648 fmt.datarow,

2649 rowalign=ralign,

2650 )

2651 _append_line(lines, padded_widths, colaligns, fmt.linebetweenrows)

2652 # the last row without a line below

2653 append_row(

2654 lines,

2655 pad_row(rows[-1], pad),

2656 padded_widths,

2657 colaligns,

2658 fmt.datarow,

2659 rowalign=rowaligns[-1],

2660 )

2661 else:

2662 separating_line = (

2663 fmt.linebetweenrows

2664 or fmt.linebelowheader

2665 or fmt.linebelow

2666 or fmt.lineabove

2667 or Line("", "", "", "")

2668 )

2669 for row in rows:

2670 # test to see if either the 1st column or the 2nd column (account for showindex) has

2671 # the SEPARATING_LINE flag

2672 if _is_separating_line(row):

2673 _append_line(lines, padded_widths, colaligns, separating_line)

2674 else:

2675 append_row(lines, pad_row(row, pad), padded_widths, colaligns, fmt.datarow)

2676

2677 if fmt.linebelow and "linebelow" not in hidden:

2678 _append_line(lines, padded_widths, colaligns, fmt.linebelow)

2679

2680 if headers or rows:

2681 output = "\n".join(lines)

2682 if fmt.lineabove == _html_begin_table_without_header:

2683 return JupyterHTMLStr(output)

2684 else:

2685 return output

2686 else: # a completely empty table

2687 return ""

2688

2689

2690class _CustomTextWrap(textwrap.TextWrapper):

2691 """A custom implementation of CPython's textwrap.TextWrapper. This supports

2692 both wide characters (Korea, Japanese, Chinese) - including mixed string.

2693 For the most part, the `_handle_long_word` and `_wrap_chunks` functions were

2694 copy pasted out of the CPython baseline, and updated with our custom length

2695 and line appending logic.

2696 """

2697

2698 def __init__(self, *args, **kwargs):

2699 self._active_codes = []

2700 self.max_lines = None # For python2 compatibility

2701 textwrap.TextWrapper.__init__(self, *args, **kwargs)

2702

2703 @staticmethod

2704 def _len(item):

2705 """Custom len that gets console column width for wide

2706 and non-wide characters as well as ignores color codes"""

2707 stripped = _strip_ansi(item)

2708 if wcwidth:

2709 return wcwidth.wcswidth(stripped)

2710 else:

2711 return len(stripped)

2712

2713 def _update_lines(self, lines, new_line):

2714 """Adds a new line to the list of lines the text is being wrapped into

2715 This function will also track any ANSI color codes in this string as well

2716 as add any colors from previous lines order to preserve the same formatting

2717 as a single unwrapped string.

2718 """

2719 code_matches = list(_ansi_codes.finditer(new_line))

2720 color_codes = [code.string[code.span()[0] : code.span()[1]] for code in code_matches]

2721

2722 # Add color codes from earlier in the unwrapped line, and then track any new ones we add.

2723 new_line = "".join(self._active_codes) + new_line

2724

2725 for code in color_codes:

2726 if code != _ansi_color_reset_code:

2727 self._active_codes.append(code)

2728 else: # A single reset code resets everything

2729 self._active_codes = []

2730

2731 # Always ensure each line is color terminated if any colors are

2732 # still active, otherwise colors will bleed into other cells on the console

2733 if len(self._active_codes) > 0:

2734 new_line = new_line + _ansi_color_reset_code

2735

2736 lines.append(new_line)

2737

2738 def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width):

2739 """_handle_long_word(chunks : [string],

2740 cur_line : [string],

2741 cur_len : int, width : int)

2742 Handle a chunk of text (most likely a word, not whitespace) that

2743 is too long to fit in any line.

2744 """

2745 # Figure out when indent is larger than the specified width, and make

2746 # sure at least one character is stripped off on every pass

2747 if width < 1:

2748 space_left = 1

2749 else:

2750 space_left = width - cur_len

2751

2752 # If we're allowed to break long words, then do so: put as much

2753 # of the next chunk onto the current line as will fit.

2754 if self.break_long_words and space_left > 0:

2755 # Tabulate Custom: Build the string up piece-by-piece in order to

2756 # take each charcter's width into account

2757 chunk = reversed_chunks[-1]

2758 i = 1

2759 # Only count printable characters, so strip_ansi first, index later.

2760 stripped_chunk = _strip_ansi(chunk)

2761 while i <= len(stripped_chunk) and self._len(stripped_chunk[:i]) <= space_left:

2762 i = i + 1

2763 # Always consume at least one character so _wrap_chunks makes

2764 # progress even when the first character is wider than space_left

2765 # (e.g. a 2-column CJK char in a 1-column-wide slot).

2766 i = max(i, 2)

2767 # Consider escape codes when breaking words up

2768 total_escape_len = 0

2769 last_group = 0

2770 if _ansi_codes.search(chunk) is not None:

2771 for group, _, _, _ in _ansi_codes.findall(chunk):

2772 escape_len = len(group)

2773 if group in chunk[last_group : i + total_escape_len + escape_len - 1]:

2774 total_escape_len += escape_len

2775 found = _ansi_codes.search(chunk[last_group:])

2776 last_group += found.end()

2777 cur_line.append(chunk[: i + total_escape_len - 1])

2778 reversed_chunks[-1] = chunk[i + total_escape_len - 1 :]

2779

2780 # Otherwise, we have to preserve the long word intact. Only add

2781 # it to the current line if there's nothing already there --

2782 # that minimizes how much we violate the width constraint.

2783 elif not cur_line:

2784 cur_line.append(reversed_chunks.pop())

2785

2786 # If we're not allowed to break long words, and there's already

2787 # text on the current line, do nothing. Next time through the

2788 # main loop of _wrap_chunks(), we'll wind up here again, but

2789 # cur_len will be zero, so the next line will be entirely

2790 # devoted to the long word that we can't handle right now.

2791

2792 def _wrap_chunks(self, chunks):

2793 """_wrap_chunks(chunks : [string]) -> [string]

2794 Wrap a sequence of text chunks and return a list of lines of

2795 length 'self.width' or less. (If 'break_long_words' is false,

2796 some lines may be longer than this.) Chunks correspond roughly

2797 to words and the whitespace between them: each chunk is

2798 indivisible (modulo 'break_long_words'), but a line break can

2799 come between any two chunks. Chunks should not have internal

2800 whitespace; ie. a chunk is either all whitespace or a "word".

2801 Whitespace chunks will be removed from the beginning and end of

2802 lines, but apart from that whitespace is preserved.

2803 """

2804 lines = []

2805 if self.width <= 0:

2806 raise ValueError(f"invalid width {self.width!r} (must be > 0)")

2807 if self.max_lines is not None:

2808 if self.max_lines > 1:

2809 indent = self.subsequent_indent

2810 else:

2811 indent = self.initial_indent

2812 if self._len(indent) + self._len(self.placeholder.lstrip()) > self.width:

2813 raise ValueError("placeholder too large for max width")

2814

2815 # Arrange in reverse order so items can be efficiently popped

2816 # from a stack of chucks.

2817 chunks.reverse()

2818

2819 while chunks:

2820 # Start the list of chunks that will make up the current line.

2821 # cur_len is just the length of all the chunks in cur_line.

2822 cur_line = []

2823 cur_len = 0

2824

2825 # Figure out which static string will prefix this line.

2826 if lines:

2827 indent = self.subsequent_indent

2828 else:

2829 indent = self.initial_indent

2830

2831 # Maximum width for this line.

2832 width = self.width - self._len(indent)

2833

2834 # First chunk on line is whitespace -- drop it, unless this

2835 # is the very beginning of the text (ie. no lines started yet).

2836 if self.drop_whitespace and chunks[-1].strip() == "" and lines:

2837 del chunks[-1]

2838

2839 while chunks:

2840 chunk_len = self._len(chunks[-1])

2841

2842 # Can at least squeeze this chunk onto the current line.

2843 if cur_len + chunk_len <= width:

2844 cur_line.append(chunks.pop())

2845 cur_len += chunk_len

2846

2847 # Nope, this line is full.

2848 else:

2849 break

2850

2851 # The current line is full, and the next chunk is too big to

2852 # fit on *any* line (not just this one).

2853 if chunks and self._len(chunks[-1]) > width:

2854 self._handle_long_word(chunks, cur_line, cur_len, width)

2855 cur_len = sum(map(self._len, cur_line))

2856

2857 # If the last chunk on this line is all whitespace, drop it.

2858 if self.drop_whitespace and cur_line and cur_line[-1].strip() == "":

2859 cur_len -= self._len(cur_line[-1])

2860 del cur_line[-1]

2861

2862 if cur_line:

2863 if (

2864 self.max_lines is None

2865 or len(lines) + 1 < self.max_lines

2866 or (

2867 not chunks

2868 or self.drop_whitespace

2869 and len(chunks) == 1

2870 and not chunks[0].strip()

2871 )

2872 and cur_len <= width

2873 ):

2874 # Convert current line back to a string and store it in

2875 # list of all lines (return value).

2876 self._update_lines(lines, indent + "".join(cur_line))

2877 else:

2878 while cur_line:

2879 if cur_line[-1].strip() and cur_len + self._len(self.placeholder) <= width:

2880 cur_line.append(self.placeholder)

2881 self._update_lines(lines, indent + "".join(cur_line))

2882 break

2883 cur_len -= self._len(cur_line[-1])

2884 del cur_line[-1]

2885 else:

2886 if lines:

2887 prev_line = lines[-1].rstrip()

2888 if self._len(prev_line) + self._len(self.placeholder) <= self.width:

2889 lines[-1] = prev_line + self.placeholder

2890 break

2891 self._update_lines(lines, indent + self.placeholder.lstrip())

2892 break

2893

2894 return lines

2895

2896

2897if __name__ == "__main__":

2898 from .cli import _main

2899

2900 _main()

Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/tabulate/init.py: 69%

856 statements