Automatically get column widths

Author: DenverCoder1

table2ascii/__init__.py

@@ -24,15 +24,15 @@ def __init__(
         if header_row and body and len(body) > 0 and len(header_row) != len(body[0]):
             raise ValueError("Header row and body rows must have the same length")
         # check if any rows in body have a different number of columns
-        if body and len(body) and list(filter(lambda x: len(x) != len(body[0]), body)):
+        if body and len(body) and tuple(filter(lambda r: len(r) != len(body[0]), body)):
             raise ValueError("All rows in body must have the same length")
 
         # initialize fields
         self.__header_row = header_row
         self.__body = body
         self.__footer_row = footer_row
-        self.__columns = self.__count_columns()
-        self.__cell_widths = [5, 5, 5, 5, 5]  # TODO: make this automatic
+        self.__columns = self.count_columns()
+        self.__cell_widths = self.get_column_widths()
 
         """
         ╔═════╦═══════════════════════╗   ABBBBBCBBBBBDBBBBBDBBBBBDBBBBBE
@@ -69,7 +69,10 @@ def __init__(
             "bottom_right_corner": "╝",  # V
         }
 
-    def __count_columns(self):
+    def count_columns(self) -> int:
+        """Get the number of columns in the table
+        based on the provided header, footer, and body lists.
+        """
         if self.__header_row:
             return len(self.__header_row)
         if self.__footer_row:
@@ -78,35 +81,54 @@ def __count_columns(self):
             return len(self.__body[0])
         return 0
 
+    def get_column_widths(self) -> List[int]:
+        """Get the minimum number of characters needed for the values
+        in each column in the table with 1 space of padding on each side.
+        """
+        col_counts = []
+        for i in range(self.__columns):
+            # number of characters in column of i of header, each body row, and footer
+            header_size = len(self.__header_row[i]) if self.__header_row else 0
+            body_size = (
+                map(lambda row, i=i: len(row[i]), self.__body) if self.__body else [0]
+            )
+            footer_size = len(self.__footer_row[i]) if self.__footer_row else 0
+            # get the max and add 2 for padding each side with a space
+            col_counts.append(max(header_size, *body_size, footer_size) + 2)
+        return col_counts
+
     def __pad(self, text: str, width: int, alignment: int = ALIGN_CENTER):
         """Pad a string of text to a given width with specified alignment"""
         if alignment == ALIGN_LEFT:
+            # pad with spaces on the end
             return f" {text} " + (" " * (width - len(text) - 2))
         if alignment == ALIGN_CENTER:
+            # pad with spaces, half on each side
             before = " " * ceil((width - len(text) - 2) / 2)
             after = " " * floor((width - len(text) - 2) / 2)
             return before + f" {text} " + after
         if alignment == ALIGN_RIGHT:
+            # pad with spaces at the beginning
             return (" " * (width - len(text) - 2)) + f" {text} "
         raise ValueError(f"The value '{alignment}' is not valid for alignment.")
 
     def __row_to_ascii(
         self,
-        left: str,
+        left_edge: str,
         first_col_sep: str,
-        col_sep: str,
-        right: str,
+        column_seperator: str,
+        right_edge: str,
         filler: Union[str, List],
     ) -> str:
         """Assembles a row of the ascii table"""
         # left edge of the row
-        output: str = left
+        output = left_edge
         # content across the first column
         output += (
-            # edge or row separator if filler is specified
+            # edge or row separator if filler is a specific character
             filler * self.__cell_widths[0]
             if isinstance(filler, str)
-            # otherwise, first column content
+            # otherwise, use the first column's content
             else self.__pad(str(filler[0]), self.__cell_widths[0])
         )
         # separation of first column from the rest of the table
@@ -115,86 +137,86 @@ def __row_to_ascii(
         for i in range(1, self.__columns):
             # content between separators
             output += (
-                # edge or row separator if filler is specified
+                # edge or row separator if filler is a specific character
                 filler * self.__cell_widths[i]
                 if isinstance(filler, str)
-                # otherwise, column content
+                # otherwise, use the column content
                 else self.__pad(str(filler[i]), self.__cell_widths[i])
             )
             # add a separator
-            output += col_sep
+            output += column_seperator
         # replace last seperator with symbol for edge of the row
-        output = output[0:-1] + right
+        output = output[0:-1] + right_edge
         return output + "\n"
 
     def __top_edge_to_ascii(self) -> str:
         """Assembles the top edge of the ascii table"""
         return self.__row_to_ascii(
-            left=self.__parts["top_left_corner"],
+            left_edge=self.__parts["top_left_corner"],
             first_col_sep=self.__parts["first_col_top_tee"],
-            col_sep=self.__parts["top_tee"],
-            right=self.__parts["top_right_corner"],
+            column_seperator=self.__parts["top_tee"],
+            right_edge=self.__parts["top_right_corner"],
             filler=self.__parts["top_and_bottom_edge"],
         )
 
     def __bottom_edge_to_ascii(self) -> str:
         """Assembles the top edge of the ascii table"""
         return self.__row_to_ascii(
-            left=self.__parts["bottom_left_corner"],
+            left_edge=self.__parts["bottom_left_corner"],
             first_col_sep=self.__parts["first_col_bottom_tee"],
-            col_sep=self.__parts["bottom_tee"],
-            right=self.__parts["bottom_right_corner"],
+            column_seperator=self.__parts["bottom_tee"],
+            right_edge=self.__parts["bottom_right_corner"],
             filler=self.__parts["top_and_bottom_edge"],
         )
 
     def __header_row_to_ascii(self) -> str:
         """Assembles the header row line of the ascii table"""
         return self.__row_to_ascii(
-            left=self.__parts["left_and_right_edge"],
+            left_edge=self.__parts["left_and_right_edge"],
             first_col_sep=self.__parts["first_col_sep"],
-            col_sep=self.__parts["middle_edge"],
-            right=self.__parts["left_and_right_edge"],
+            column_seperator=self.__parts["middle_edge"],
+            right_edge=self.__parts["left_and_right_edge"],
             filler=self.__header_row,
         )
 
     def __footer_row_to_ascii(self) -> str:
         """Assembles the header row line of the ascii table"""
         return self.__row_to_ascii(
-            left=self.__parts["left_and_right_edge"],
+            left_edge=self.__parts["left_and_right_edge"],
             first_col_sep=self.__parts["first_col_sep"],
-            col_sep=self.__parts["middle_edge"],
-            right=self.__parts["left_and_right_edge"],
+            column_seperator=self.__parts["middle_edge"],
+            right_edge=self.__parts["left_and_right_edge"],
             filler=self.__footer_row,
         )
 
     def __header_sep_to_ascii(self) -> str:
         """Assembles the seperator below the header of the ascii table"""
         return self.__row_to_ascii(
-            left=self.__parts["header_left_tee"],
+            left_edge=self.__parts["header_left_tee"],
             first_col_sep=self.__parts["first_col_header_cross"],
-            col_sep=self.__parts["header_row_cross"],
-            right=self.__parts["header_right_tee"],
+            column_seperator=self.__parts["header_row_cross"],
+            right_edge=self.__parts["header_right_tee"],
             filler=self.__parts["header_row_sep"],
         )
 
     def __footer_sep_to_ascii(self) -> str:
         """Assembles the seperator below the header of the ascii table"""
         return self.__row_to_ascii(
-            left=self.__parts["footer_left_tee"],
+            left_edge=self.__parts["footer_left_tee"],
             first_col_sep=self.__parts["first_col_footer_cross"],
-            col_sep=self.__parts["footer_row_cross"],
-            right=self.__parts["footer_right_tee"],
+            column_seperator=self.__parts["footer_row_cross"],
+            right_edge=self.__parts["footer_right_tee"],
             filler=self.__parts["footer_row_sep"],
         )
 
     def __body_to_ascii(self) -> str:
         output: str = ""
         for row in self.__body:
             output += self.__row_to_ascii(
-                left=self.__parts["left_and_right_edge"],
+                left_edge=self.__parts["left_and_right_edge"],
                 first_col_sep=self.__parts["first_col_sep"],
-                col_sep=self.__parts["middle_edge"],
-                right=self.__parts["left_and_right_edge"],
+                column_seperator=self.__parts["middle_edge"],
+                right_edge=self.__parts["left_and_right_edge"],
                 filler=row,
             )
         return output
@@ -225,6 +247,10 @@ def table2ascii(
     footer_row: Optional[List] = None,
 ) -> str:
     """Convert a 2D Python table to ASCII text
-    #TODO: add param documentation
+
+    ### Arguments
+    :param header_row: :class:`Optional[List]` List of column values in the table's header row
+    :param body: :class:`Optional[List[List]]` 2-dimensional list of values in the table's body
+    :param footer_row: :class:`Optional[List]` List of column values in the table's footer row
     """
     return TableToAscii(header_row, body, footer_row).to_ascii()

tests/test_convert.py

@@ -42,12 +42,12 @@ def test_header_body():
         body=[["1", "30", "40", "35", "30"], ["2", "30", "40", "35", "30"]],
     )
     expected = (
-        "╔═════╦═══════════════════════╗\n"
-        "║  #  ║  G     H     R     S  ║\n"
-        "╟─────╫───────────────────────╢\n"
-        "║  1  ║  30    40    35    30 ║\n"
-        "║  2  ║  30    40    35    30 ║\n"
-        "╚═════╩═══════════════════════╝\n"
+        "╔═══╦═══════════════════╗\n"
+        "║ # ║  G    H    R    S ║\n"
+        "╟───╫───────────────────╢\n"
+        "║ 1 ║ 30   40   35   30 ║\n"
+        "║ 2 ║ 30   40   35   30 ║\n"
+        "╚═══╩═══════════════════╝\n"
     )
     assert text == expected
 
@@ -73,10 +73,10 @@ def test_header():
         header_row=["#", "G", "H", "R", "S"],
     )
     expected = (
-        "╔═════╦═══════════════════════╗\n"
-        "║  #  ║  G     H     R     S  ║\n"
-        "╟─────╫───────────────────────╢\n"
-        "╚═════╩═══════════════════════╝\n"
+        "╔═══╦═══════════════╗\n"
+        "║ # ║ G   H   R   S ║\n"
+        "╟───╫───────────────╢\n"
+        "╚═══╩═══════════════╝\n"
     )
     assert text == expected
 
@@ -86,10 +86,10 @@ def test_body():
         body=[["1", "30", "40", "35", "30"], ["2", "30", "40", "35", "30"]],
     )
     expected = (
-        "╔═════╦═══════════════════════╗\n"
-        "║  1  ║  30    40    35    30 ║\n"
-        "║  2  ║  30    40    35    30 ║\n"
-        "╚═════╩═══════════════════════╝\n"
+        "╔═══╦═══════════════════╗\n"
+        "║ 1 ║ 30   40   35   30 ║\n"
+        "║ 2 ║ 30   40   35   30 ║\n"
+        "╚═══╩═══════════════════╝\n"
     )
     assert text == expected