table2ascii 1.1.0__tar.gz → 1.1.2__tar.gz

{table2ascii-1.1.0/table2ascii.egg-info → table2ascii-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: table2ascii
-Version: 1.1.0
+Version: 1.1.2
 Summary: Convert 2D Python lists into Unicode/ASCII tables
 Author-email: Jonah Lawrence <jonah@freshidea.com>
 License: MIT License

{table2ascii-1.1.0 → table2ascii-1.1.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "table2ascii"
-version = "1.1.0"
+version = "1.1.2"
 authors = [{name = "Jonah Lawrence", email = "jonah@freshidea.com"}]
 description = "Convert 2D Python lists into Unicode/ASCII tables"
 readme = "README.md"
@@ -54,8 +54,8 @@ docs = [
     "sphinx-book-theme==0.3.3",
 ]
 dev = [
-    "mypy>=0.982,<1",
-    "pre-commit>=2.0.0,<3",
+    "mypy>=0.982,<2",
+    "pre-commit>=2.0.0,<4",
     "pyright>=1.0.0,<2",
     "pytest>=6.0.0,<8",
     "slotscheck>=0.1.0,<1",

table2ascii-1.1.2/setup.py

@@ -0,0 +1,51 @@
+# /usr/bin/env python
+import re
+
+from setuptools import setup
+
+
+def get_name():
+    name = ""
+    with open("pyproject.toml") as f:
+        name = re.search(r'^name = ["\']([^"\']*)["\']', f.read(), re.M)
+    if not name:
+        raise RuntimeError("name is not set")
+    return name.group(1)
+
+
+def get_version():
+    version = ""
+    with open("pyproject.toml") as f:
+        version = re.search(r'^version = ["\']([^"\']*)["\']', f.read(), re.M)
+    if not version:
+        raise RuntimeError("version is not set")
+    return version.group(1)
+
+
+def get_dependencies():
+    with open("pyproject.toml") as f:
+        dependency_match = re.search(r"^dependencies = \[([\s\S]*?)\]", f.read(), re.M)
+    if not dependency_match or not dependency_match.group(1):
+        return []
+    return [
+        dependency.strip().strip(",").strip('"')
+        for dependency in dependency_match.group(1).split("\n")
+        if dependency
+    ]
+
+
+try:
+    # check if pyproject.toml can be used to install dependencies and set the version
+    setup(
+        packages=[get_name()],
+        package_data={get_name(): ["py.typed"]},
+    )
+except Exception:
+    # fallback for old versions of pip/setuptools
+    setup(
+        name=get_name(),
+        packages=[get_name()],
+        package_data={get_name(): ["py.typed"]},
+        version=get_version(),
+        install_requires=get_dependencies(),
+    )

table2ascii-1.1.2/table2ascii/__init__.py

@@ -0,0 +1,56 @@
+"""
+table2ascii - Library for converting 2D Python lists to fancy ASCII/Unicode tables
+"""
+import sys
+from typing import TYPE_CHECKING
+
+from .alignment import Alignment
+from .annotations import SupportsStr
+from .exceptions import (
+    AlignmentCountMismatchError,
+    BodyColumnCountMismatchError,
+    ColumnCountMismatchError,
+    ColumnWidthsCountMismatchError,
+    ColumnWidthTooSmallError,
+    FooterColumnCountMismatchError,
+    InvalidAlignmentError,
+    InvalidCellPaddingError,
+    InvalidColumnWidthError,
+    Table2AsciiError,
+    TableOptionError,
+    TableStyleTooLongError,
+    TableStyleTooShortWarning,
+)
+from .merge import Merge
+from .preset_style import PresetStyle
+from .table_style import TableStyle
+from .table_to_ascii import table2ascii
+
+if TYPE_CHECKING or sys.version_info >= (3, 8):
+    from importlib import metadata
+else:
+    import importlib_metadata as metadata
+
+__version__ = metadata.version(__name__)
+
+__all__ = [
+    "Alignment",
+    "Merge",
+    "PresetStyle",
+    "TableStyle",
+    "table2ascii",
+    "AlignmentCountMismatchError",
+    "BodyColumnCountMismatchError",
+    "ColumnCountMismatchError",
+    "ColumnWidthsCountMismatchError",
+    "ColumnWidthTooSmallError",
+    "FooterColumnCountMismatchError",
+    "InvalidAlignmentError",
+    "InvalidCellPaddingError",
+    "InvalidColumnWidthError",
+    "Table2AsciiError",
+    "TableOptionError",
+    "TableStyleTooLongError",
+    "TableStyleTooShortWarning",
+    "SupportsStr",
+]

{table2ascii-1.1.0 → table2ascii-1.1.2}/table2ascii/annotations.py

@@ -10,8 +10,9 @@ else:
 
 @runtime_checkable
 class SupportsStr(Protocol):
-    """An ABC with one abstract method __str__."""
+    """An abstract base class (ABC) with one abstract method :meth:`__str__`"""
 
     @abstractmethod
     def __str__(self) -> str:
+        """Return a string representation of the object"""
         pass

{table2ascii-1.1.0 → table2ascii-1.1.2}/table2ascii/exceptions.py

@@ -40,8 +40,9 @@ class FooterColumnCountMismatchError(ColumnCountMismatchError):
     This class is a subclass of :class:`ColumnCountMismatchError`.
 
     Attributes:
-        footer (Sequence[SupportsStr]): The footer that caused the error
-        expected_columns (int): The number of columns that were expected
+        footer (:class:`Sequence <collections.abc.Sequence>`\ [:class:`SupportsStr`]):
+            The footer that caused the error
+        expected_columns (:class:`int`): The number of columns that were expected
     """
 
     def __init__(self, footer: Sequence[SupportsStr], expected_columns: int):
@@ -63,9 +64,11 @@ class BodyColumnCountMismatchError(ColumnCountMismatchError):
     This class is a subclass of :class:`ColumnCountMismatchError`.
 
     Attributes:
-        body (Sequence[Sequence[SupportsStr]]): The body that caused the error
-        expected_columns (int): The number of columns that were expected
-        first_invalid_row (Sequence[SupportsStr]): The first row with an invalid column count
+        body (:class:`Sequence <collections.abc.Sequence>`\ [\ :class:`Sequence <collections.abc.Sequence>`\ [:class:`SupportsStr`]]):
+            The body that caused the error
+        expected_columns (:class:`int`): The number of columns that were expected
+        first_invalid_row (:class:`Sequence <collections.abc.Sequence>`\ [:class:`SupportsStr`]):
+            The first row with an invalid column count
     """
 
     def __init__(self, body: Sequence[Sequence[SupportsStr]], expected_columns: int):
@@ -90,8 +93,9 @@ class AlignmentCountMismatchError(ColumnCountMismatchError):
     This class is a subclass of :class:`ColumnCountMismatchError`.
 
     Attributes:
-        alignments (Sequence[Alignment]): The alignments that caused the error
-        expected_columns (int): The number of columns that were expected
+        alignments (:class:`Sequence <collections.abc.Sequence>`\ [:class:`Alignment`]):
+            The alignments that caused the error
+        expected_columns (:class:`int`): The number of columns that were expected
     """
 
     def __init__(self, alignments: Sequence[Alignment], expected_columns: int):
@@ -113,8 +117,9 @@ class ColumnWidthsCountMismatchError(ColumnCountMismatchError):
     This class is a subclass of :class:`ColumnCountMismatchError`.
 
     Attributes:
-        column_widths (Sequence[Optional[int]]): The column widths that caused the error
-        expected_columns (int): The number of columns that were expected
+        column_widths (:class:`Sequence <collections.abc.Sequence>`\ [:data:`Optional <typing.Optional>`\ [:class:`int`]]):
+            The column widths that caused the error
+        expected_columns (:class:`int`): The number of columns that were expected
     """
 
     def __init__(self, column_widths: Sequence[int | None], expected_columns: int):
@@ -148,7 +153,7 @@ class InvalidCellPaddingError(TableOptionError):
     This class is a subclass of :class:`TableOptionError`.
 
     Attributes:
-        padding (int): The padding that caused the error
+        padding (:class:`int`): The padding that caused the error
     """
 
     def __init__(self, padding: int):
@@ -169,9 +174,9 @@ class ColumnWidthTooSmallError(TableOptionError):
     This class is a subclass of :class:`TableOptionError`.
 
     Attributes:
-        column_index (int): The index of the column that caused the error
-        column_width (int): The column width that caused the error
-        min_width (int): The minimum width that is allowed
+        column_index (:class:`int`): The index of the column that caused the error
+        column_width (:class:`int`): The column width that caused the error
+        min_width (:class:`int`): The minimum width that is allowed
     """
 
     def __init__(self, column_index: int, column_width: int, min_width: int | None = None):
@@ -208,7 +213,7 @@ class InvalidAlignmentError(TableOptionError):
     This class is a subclass of :class:`TableOptionError`.
 
     Attributes:
-        alignment (Any): The alignment value that caused the error
+        alignment (:data:`Any <typing.Any>`): The alignment value that caused the error
     """
 
     def __init__(self, alignment: Any):
@@ -230,8 +235,8 @@ class TableStyleTooLongError(Table2AsciiError, ValueError):
     This class is a subclass of :class:`Table2AsciiError` and :class:`ValueError`.
 
     Attributes:
-        string (str): The string that caused the error
-        max_characters (int): The maximum number of characters that are allowed
+        string (:class:`str`): The string that caused the error
+        max_characters (:class:`int`): The maximum number of characters that are allowed
     """
 
     def __init__(self, string: str, max_characters: int):
@@ -256,8 +261,8 @@ class TableStyleTooShortWarning(UserWarning):
     It can be silenced using :func:`warnings.filterwarnings`.
 
     Attributes:
-        string (str): The string that caused the warning
-        max_characters (int): The number of characters that :class:`TableStyle` accepts
+        string (:class:`str`): The string that caused the warning
+        max_characters (:class:`int`): The number of characters that :class:`TableStyle` accepts
     """
 
     def __init__(self, string: str, max_characters: int):

table2ascii-1.1.2/table2ascii/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561. The table2ascii package uses inline types.

{table2ascii-1.1.0 → table2ascii-1.1.2}/table2ascii/table_style.py

@@ -145,7 +145,7 @@ class TableStyle:
 
         Example::
 
-            TableStyle().set(top_left_corner="╔", top_and_bottom_edge="═")
+            TableStyle.from_string("~" * 30).set(left_and_right_edge="", col_sep="")
         """
         for key, value in kwargs.items():
             setattr(self, key, value)

{table2ascii-1.1.0 → table2ascii-1.1.2}/table2ascii/table_to_ascii.py

@@ -677,23 +677,27 @@ def table2ascii(
     """Convert a 2D Python table to ASCII text
 
     Args:
-        header: List of column values in the table's header row. All values should be :class:`str`
+        header (:data:`Optional <typing.Optional>`\ [:class:`Sequence <collections.abc.Sequence>`\ [:class:`SupportsStr`]]):
+            List of column values in the table's header row. All values should be :class:`str`
             or support :class:`str` conversion. If not specified, the table will not have a header row.
-        body: 2-dimensional list of values in the table's body. All values should be :class:`str`
+        body (:data:`Optional <typing.Optional>`\ [:class:`Sequence <collections.abc.Sequence>`\ [:class:`Sequence <collections.abc.Sequence>`\ [:class:`SupportsStr`]]]):
+            2-dimensional list of values in the table's body. All values should be :class:`str`
             or support :class:`str` conversion. If not specified, the table will not have a body.
-        footer: List of column values in the table's footer row. All values should be :class:`str`
+        footer (:data:`Optional <typing.Optional>`\ [:class:`Sequence <collections.abc.Sequence>`\ [:class:`SupportsStr`]]):
+            List of column values in the table's footer row. All values should be :class:`str`
             or support :class:`str` conversion. If not specified, the table will not have a footer row.
         first_col_heading: Whether to add a header column separator after the first column.
             Defaults to :py:obj:`False`.
         last_col_heading: Whether to add a header column separator before the last column.
             Defaults to :py:obj:`False`.
-        column_widths: List of widths in characters for each column. Any value of :py:obj:`None`
+        column_widths (:data:`Optional <typing.Optional>`\ [:class:`Sequence <collections.abc.Sequence>`\ [:data:`Optional <typing.Optional>`\ [:class:`int`]]]):
+            List of widths in characters for each column. Any value of :py:obj:`None`
             indicates that the column width should be determined automatically. If :py:obj:`None`
             is passed instead of a :class:`~collections.abc.Sequence`, all columns will be automatically
             sized. Defaults to :py:obj:`None`.
         alignments: List of alignments for each column
-            (ex. ``[Alignment.LEFT, Alignment.CENTER, Alignment.RIGHT, Alignment.DECIMAL]``)
-            or a single alignment to apply to all columns (ex. ``Alignment.LEFT``).
+            (ex. [:attr:`Alignment.LEFT`, :attr:`Alignment.CENTER`, :attr:`Alignment.RIGHT`, :attr:`Alignment.DECIMAL`])
+            or a single alignment to apply to all columns (ex. :attr:`Alignment.LEFT`).
             If not specified or set to :py:obj:`None`, all columns will be center-aligned.
             Defaults to :py:obj:`None`.
 

{table2ascii-1.1.0 → table2ascii-1.1.2/table2ascii.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: table2ascii
-Version: 1.1.0
+Version: 1.1.2
 Summary: Convert 2D Python lists into Unicode/ASCII tables
 Author-email: Jonah Lawrence <jonah@freshidea.com>
 License: MIT License

{table2ascii-1.1.0 → table2ascii-1.1.2}/table2ascii.egg-info/SOURCES.txt

@@ -9,10 +9,18 @@ table2ascii/exceptions.py
 table2ascii/merge.py
 table2ascii/options.py
 table2ascii/preset_style.py
+table2ascii/py.typed
 table2ascii/table_style.py
 table2ascii/table_to_ascii.py
 table2ascii.egg-info/PKG-INFO
 table2ascii.egg-info/SOURCES.txt
 table2ascii.egg-info/dependency_links.txt
 table2ascii.egg-info/requires.txt
-table2ascii.egg-info/top_level.txt
+table2ascii.egg-info/top_level.txt
+tests/test_alignments.py
+tests/test_cell_padding.py
+tests/test_column_widths.py
+tests/test_convert.py
+tests/test_heading_cols.py
+tests/test_merge.py
+tests/test_styles.py

{table2ascii-1.1.0 → table2ascii-1.1.2}/table2ascii.egg-info/requires.txt

@@ -5,8 +5,8 @@ typing-extensions>=3.7.4
 importlib-metadata<5,>=1
 
 [dev]
-mypy<1,>=0.982
-pre-commit<3,>=2.0.0
+mypy<2,>=0.982
+pre-commit<4,>=2.0.0
 pyright<2,>=1.0.0
 pytest<8,>=6.0.0
 slotscheck<1,>=0.1.0

table2ascii-1.1.2/tests/test_alignments.py

@@ -0,0 +1,192 @@
+import pytest
+
+from table2ascii import Alignment, PresetStyle, table2ascii as t2a
+from table2ascii.exceptions import AlignmentCountMismatchError, InvalidAlignmentError
+
+
+def test_first_left_four_right():
+    text = t2a(
+        header=["#", "G", "H", "R", "S"],
+        body=[["1", "30", "40", "35", "30"], ["2", "30", "40", "35", "30"]],
+        footer=["SUM", "130", "140", "135", "130"],
+        first_col_heading=True,
+        alignments=[Alignment.LEFT] + [Alignment.RIGHT] * 4,
+    )
+    expected = (
+        "╔═════╦═══════════════════════╗\n"
+        "║ #   ║   G     H     R     S ║\n"
+        "╟─────╫───────────────────────╢\n"
+        "║ 1   ║  30    40    35    30 ║\n"
+        "║ 2   ║  30    40    35    30 ║\n"
+        "╟─────╫───────────────────────╢\n"
+        "║ SUM ║ 130   140   135   130 ║\n"
+        "╚═════╩═══════════════════════╝"
+    )
+    assert text == expected
+
+
+def test_wrong_number_of_alignments():
+    with pytest.raises(AlignmentCountMismatchError):
+        t2a(
+            header=["#", "G", "H", "R", "S"],
+            body=[["1", "30", "40", "35", "30"], ["2", "30", "40", "35", "30"]],
+            footer=["SUM", "130", "140", "135", "130"],
+            first_col_heading=True,
+            alignments=[Alignment.LEFT, Alignment.CENTER, Alignment.RIGHT],
+        )
+
+
+def test_invalid_alignments():
+    with pytest.raises(InvalidAlignmentError):
+        t2a(
+            header=["#", "G", "H", "R", "S"],
+            body=[["1", "30", "40", "35", "30"], ["2", "30", "40", "35", "30"]],
+            footer=["SUM", "130", "140", "135", "130"],
+            first_col_heading=True,
+            alignments=[9999, -1, Alignment.RIGHT, Alignment.CENTER, Alignment.RIGHT],  # type: ignore
+        )
+
+
+def test_alignment_numeric_data():
+    text = t2a(
+        header=[1, "G", "H", "R", "S"],
+        body=[[1, 2, 3, 4, 5]],
+        footer=["A", "B", 1, 2, 3],
+        column_widths=[4, 5, 5, 4, 5],
+        alignments=[Alignment.RIGHT] + [Alignment.CENTER] * 4,
+        first_col_heading=True,
+    )
+    expected = (
+        "╔════╦══════════════════════╗\n"
+        "║  1 ║  G     H    R     S  ║\n"
+        "╟────╫──────────────────────╢\n"
+        "║  1 ║  2     3    4     5  ║\n"
+        "╟────╫──────────────────────╢\n"
+        "║  A ║  B     1    2     3  ║\n"
+        "╚════╩══════════════════════╝"
+    )
+    assert text == expected
+
+
+def test_alignments_multiline_data():
+    text = t2a(
+        header=["Multiline\nHeader\nCell", "G", "Two\nLines", "R", "S"],
+        body=[[1, "Alpha\nBeta\nGamma", 3, 4, "One\nTwo"]],
+        footer=["A", "Footer\nBreak", 1, "Second\nCell\nBroken", 3],
+        alignments=[
+            Alignment.LEFT,
+            Alignment.RIGHT,
+            Alignment.CENTER,
+            Alignment.LEFT,
+            Alignment.CENTER,
+        ],
+    )
+    expected = (
+        "╔═══════════════════════════════════════════╗\n"
+        "║ Multiline        G    Two    R         S  ║\n"
+        "║ Header               Lines                ║\n"
+        "║ Cell                                      ║\n"
+        "╟───────────────────────────────────────────╢\n"
+        "║ 1            Alpha     3     4        One ║\n"
+        "║               Beta                    Two ║\n"
+        "║              Gamma                        ║\n"
+        "╟───────────────────────────────────────────╢\n"
+        "║ A           Footer     1     Second    3  ║\n"
+        "║              Break           Cell         ║\n"
+        "║                              Broken       ║\n"
+        "╚═══════════════════════════════════════════╝"
+    )
+    assert text == expected
+
+
+def test_decimal_alignment():
+    text = t2a(
+        header=["1.1.1", "G", "Long Header", "H", "R", "３.８"],
+        body=[[100.00001, 2, 3.14, 33, "AB", "1.5"], [10.0001, 22.0, 2.718, 3, "CD", "３.０３"]],
+        footer=[10000.01, "123", 10.0, 0, "E", "A"],
+        alignments=[Alignment.DECIMAL] * 6,
+        first_col_heading=True,
+        style=PresetStyle.double_thin_box,
+    )
+    expected = (
+        "╔═════════════╦═══════╤═════════════╤════╤════╤═════════╗\n"
+        "║    1.1.1    ║   G   │ Long Header │ H  │ R  │ ３.８   ║\n"
+        "╠═════════════╬═══════╪═════════════╪════╪════╪═════════╣\n"
+        "║   100.00001 ║   2   │    3.14     │ 33 │ AB │  1.5    ║\n"
+        "╟─────────────╫───────┼─────────────┼────┼────┼─────────╢\n"
+        "║    10.0001  ║  22.0 │    2.718    │  3 │ CD │ ３.０３ ║\n"
+        "╠═════════════╬═══════╪═════════════╪════╪════╪═════════╣\n"
+        "║ 10000.01    ║ 123   │   10.0      │  0 │ E  │    A    ║\n"
+        "╚═════════════╩═══════╧═════════════╧════╧════╧═════════╝"
+    )
+    assert text == expected
+
+
+def test_single_decimal_alignment():
+    text = t2a(
+        header=["1.1.1", "G", "Long Header"],
+        body=[[100.00001, 2, 3.14], [10.0001, 22.0, 2.718]],
+        alignments=Alignment.DECIMAL,
+    )
+    expected = (
+        "╔════════════════════════════════╗\n"
+        "║   1.1.1      G     Long Header ║\n"
+        "╟────────────────────────────────╢\n"
+        "║ 100.00001    2        3.14     ║\n"
+        "║  10.0001    22.0      2.718    ║\n"
+        "╚════════════════════════════════╝"
+    )
+    assert text == expected
+
+
+def test_single_left_alignment():
+    text = t2a(
+        header=["1.1.1", "G", "Long Header"],
+        body=[[100.00001, 2, 3.14], [10.0001, 22.0, 2.718]],
+        alignments=Alignment.LEFT,
+    )
+    expected = (
+        "╔════════════════════════════════╗\n"
+        "║ 1.1.1       G      Long Header ║\n"
+        "╟────────────────────────────────╢\n"
+        "║ 100.00001   2      3.14        ║\n"
+        "║ 10.0001     22.0   2.718       ║\n"
+        "╚════════════════════════════════╝"
+    )
+    assert text == expected
+
+
+def test_number_alignments():
+    text = t2a(
+        header=["1.1.1", "G", "Long Header", "Another Long Header"],
+        body=[[100.00001, 2, 3.14, 6.28], [10.0001, 22.0, 2.718, 1.618]],
+        alignments=[Alignment.LEFT, Alignment.RIGHT, Alignment.CENTER, Alignment.RIGHT],
+        number_alignments=[Alignment.DECIMAL, Alignment.LEFT, Alignment.RIGHT, Alignment.DECIMAL],
+    )
+    expected = (
+        "╔══════════════════════════════════════════════════════╗\n"
+        "║ 1.1.1          G   Long Header   Another Long Header ║\n"
+        "╟──────────────────────────────────────────────────────╢\n"
+        "║ 100.00001   2             3.14                 6.28  ║\n"
+        "║  10.0001    22.0         2.718                 1.618 ║\n"
+        "╚══════════════════════════════════════════════════════╝"
+    )
+    assert text == expected
+
+
+def test_single_number_alignments():
+    text = t2a(
+        header=["1.1.1", "G", "Long Header", "S"],
+        body=[[100.00001, 2, 3.14, 6.28], [10.0001, 22.0, 2.718, 1.618]],
+        alignments=[Alignment.LEFT, Alignment.CENTER, Alignment.CENTER, Alignment.RIGHT],
+        number_alignments=Alignment.RIGHT,
+    )
+    expected = (
+        "╔════════════════════════════════════════╗\n"
+        "║ 1.1.1        G     Long Header       S ║\n"
+        "╟────────────────────────────────────────╢\n"
+        "║ 100.00001      2          3.14    6.28 ║\n"
+        "║   10.0001   22.0         2.718   1.618 ║\n"
+        "╚════════════════════════════════════════╝"
+    )
+    assert text == expected

table2ascii-1.1.2/tests/test_cell_padding.py

@@ -0,0 +1,83 @@
+import pytest
+
+from table2ascii import Alignment, table2ascii as t2a
+from table2ascii.exceptions import InvalidCellPaddingError
+
+
+def test_without_cell_padding():
+    text = t2a(
+        header=["#", "G", "H", "R", "S"],
+        body=[[1, 2, 3, 4, 5]],
+        footer=["A", "B", 1, 2, 3],
+        first_col_heading=True,
+        cell_padding=0,
+    )
+    expected = (
+        "╔═╦═══════╗\n"
+        "║#║G H R S║\n"
+        "╟─╫───────╢\n"
+        "║1║2 3 4 5║\n"
+        "╟─╫───────╢\n"
+        "║A║B 1 2 3║\n"
+        "╚═╩═══════╝"
+    )
+    assert text == expected
+
+
+def test_column_width_and_alignment_without_cell_padding():
+    text = t2a(
+        header=["#", "G", "H", "R", "S"],
+        body=[[1, 2, 3, 4, 5]],
+        footer=["A", "B", 1, 2, 3],
+        column_widths=[4, 8, 5, 4, 5],
+        alignments=[
+            Alignment.LEFT,
+            Alignment.CENTER,
+            Alignment.RIGHT,
+            Alignment.LEFT,
+            Alignment.RIGHT,
+        ],
+        first_col_heading=True,
+        cell_padding=0,
+    )
+    expected = (
+        "╔════╦═════════════════════════╗\n"
+        "║#   ║   G         H R        S║\n"
+        "╟────╫─────────────────────────╢\n"
+        "║1   ║   2         3 4        5║\n"
+        "╟────╫─────────────────────────╢\n"
+        "║A   ║   B         1 2        3║\n"
+        "╚════╩═════════════════════════╝"
+    )
+    assert text == expected
+
+
+def test_cell_padding_more_than_one():
+    text = t2a(
+        header=["#", "G", "H", "R", "S"],
+        body=[[1, 2, 3, 4, 5]],
+        footer=["A", "B", 1, 2, 3],
+        first_col_heading=True,
+        cell_padding=2,
+    )
+    expected = (
+        "╔═════╦═══════════════════════╗\n"
+        "║  #  ║  G     H     R     S  ║\n"
+        "╟─────╫───────────────────────╢\n"
+        "║  1  ║  2     3     4     5  ║\n"
+        "╟─────╫───────────────────────╢\n"
+        "║  A  ║  B     1     2     3  ║\n"
+        "╚═════╩═══════════════════════╝"
+    )
+    assert text == expected
+
+
+def test_negative_cell_padding():
+    with pytest.raises(InvalidCellPaddingError):
+        t2a(
+            header=["#", "G", "H", "R", "S"],
+            body=[[1, 2, 3, 4, 5]],
+            footer=["A", "B", 1, 2, 3],
+            first_col_heading=True,
+            cell_padding=-1,
+        )