Made header, body, footer optional

Author: DenverCoder1

table2ascii/__init__.py

@@ -1,4 +1,4 @@
-from typing import List, Union
+from typing import List, Optional, Union
 from math import floor, ceil
 
 # constants
@@ -10,57 +10,74 @@
 class TableToAscii:
     """Class used to convert a 2D Python table to ASCII text"""
 
-    def __init__(self, header_row: List, body: List[List], footer_row: List):
+    def __init__(
+        self,
+        header_row: Optional[List],
+        body: Optional[List[List]],
+        footer_row: Optional[List],
+    ):
         """Validate arguments and initialize fields"""
-        # check that values are valid
-        if len(header_row) != len(footer_row):
-            raise ValueError("header row and footer row must have the same length")
-        if len(header_row) != len(body[0]):
-            raise ValueError("header row and body rows must have the same length")
-        for row in body[1:]:
-            if len(body[0]) != len(row):
-                raise ValueError("all rows in body must have the same length")
+        # check if columns in header are different from footer
+        if header_row and footer_row and len(header_row) != len(footer_row):
+            raise ValueError("Header row and footer row must have the same length")
+        # check if columns in header are different from body
+        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)):
+            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
 
         """
-        ╔═════╦═══════════════════════╗   0111112111113111113111113111114
-        ║  #  ║  G     H     R     S  ║   5     6     7     7     7     5
-        ╟─────╫───────────────────────╢   899999a99999b99999b99999b99999c
-        ║  1  ║  30    40    35    30 ║   5     6     7     7     7     5
-        ║  2  ║  30    40    35    30 ║   5     6     7     7     7     5
-        ╟─────╫───────────────────────╢   deeeeefeeeeegeeeeegeeeeegeeeeeh
-        ║ SUM ║ 130   140   135   130 ║   5     6     7     7     7     5
-        ╚═════╩═══════════════════════╝   i11111j11111k11111k11111k11111l
+        ╔═════╦═══════════════════════╗   ABBBBBCBBBBBDBBBBBDBBBBBDBBBBBE
+        ║  #  ║  G     H     R     S  ║   F     G     H     H     H     F
+        ╟─────╫───────────────────────╢   IJJJJJKJJJJJLJJJJJLJJJJJLJJJJJM
+        ║  1  ║  30    40    35    30 ║   F     G     H     H     H     F
+        ║  2  ║  30    40    35    30 ║   F     G     H     H     H     F
+        ╟─────╫───────────────────────╢   NOOOOOPOOOOOQOOOOOQOOOOOQOOOOOR
+        ║ SUM ║ 130   140   135   130 ║   F     G     H     H     H     F
+        ╚═════╩═══════════════════════╝   SBBBBBTBBBBBUBBBBBUBBBBBUBBBBBV
         """
-        self.parts = {
-            "top_left_corner": "╔",  # 0
-            "top_and_bottom_edge": "═",  # 1
-            "first_col_top_tee": "╦",  # 2
-            "top_tee": "═",  # 3
-            "top_right_corner": "╗",  # 4
-            "left_and_right_edge": "║",  # 5
-            "first_col_sep": "║",  # 6
-            "middle_edge": " ",  # 7
-            "header_left_tee": "╟",  # 8
-            "header_row_sep": "─",  # 9
-            "first_col_header_cross": "╫",  # a
-            "header_row_cross": "─",  # b
-            "right_tee": "╢",  # c
-            "footer_left_tee": "╟",  # d
-            "footer_row_sep": "─",  # e
-            "first_col_footer_cross": "╫",  # f
-            "footer_row_cross": "─",  # g
-            "bottom_left_corner": "╚",  # i
-            "first_col_bottom_tee": "╩",  # j
-            "bottom_tee": "═",  # k
-            "bottom_right_corner": "╝",  # l
+        self.__parts = {
+            "top_left_corner": "╔",  # A
+            "top_and_bottom_edge": "═",  # B
+            "first_col_top_tee": "╦",  # C
+            "top_tee": "═",  # D
+            "top_right_corner": "╗",  # E
+            "left_and_right_edge": "║",  # F
+            "first_col_sep": "║",  # G
+            "middle_edge": " ",  # H
+            "header_left_tee": "╟",  # I
+            "header_row_sep": "─",  # J
+            "first_col_header_cross": "╫",  # K
+            "header_row_cross": "─",  # L
+            "header_right_tee": "╢",  # M
+            "footer_left_tee": "╟",  # N
+            "footer_row_sep": "─",  # O
+            "first_col_footer_cross": "╫",  # P
+            "footer_row_cross": "─",  # Q
+            "footer_right_tee": "╢",  # R
+            "bottom_left_corner": "╚",  # S
+            "first_col_bottom_tee": "╩",  # T
+            "bottom_tee": "═",  # U
+            "bottom_right_corner": "╝",  # V
         }
 
+    def __count_columns(self):
+        if self.__header_row:
+            return len(self.__header_row)
+        if self.__footer_row:
+            return len(self.__footer_row)
+        if self.__body and len(self.__body) > 0:
+            return len(self.__body[0])
+        return 0
+
     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:
@@ -95,7 +112,7 @@ def __row_to_ascii(
         # separation of first column from the rest of the table
         output += first_col_sep
         # add remaining columns
-        for i in range(1, len(self.__header_row)):
+        for i in range(1, self.__columns):
             # content between separators
             output += (
                 # edge or row separator if filler is specified
@@ -113,90 +130,100 @@ def __row_to_ascii(
     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"],
-            first_col_sep=self.parts["first_col_top_tee"],
-            col_sep=self.parts["top_tee"],
-            right=self.parts["top_right_corner"],
-            filler=self.parts["top_and_bottom_edge"],
+            left=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"],
+            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"],
-            first_col_sep=self.parts["first_col_bottom_tee"],
-            col_sep=self.parts["bottom_tee"],
-            right=self.parts["bottom_right_corner"],
-            filler=self.parts["top_and_bottom_edge"],
+            left=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"],
+            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"],
-            first_col_sep=self.parts["first_col_sep"],
-            col_sep=self.parts["middle_edge"],
-            right=self.parts["left_and_right_edge"],
+            left=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"],
             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"],
-            first_col_sep=self.parts["first_col_sep"],
-            col_sep=self.parts["middle_edge"],
-            right=self.parts["left_and_right_edge"],
+            left=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"],
             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"],
-            first_col_sep=self.parts["first_col_header_cross"],
-            col_sep=self.parts["header_row_cross"],
-            right=self.parts["right_tee"],
-            filler=self.parts["header_row_sep"],
+            left=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"],
+            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"],
-            first_col_sep=self.parts["first_col_footer_cross"],
-            col_sep=self.parts["footer_row_cross"],
-            right=self.parts["right_tee"],
-            filler=self.parts["header_row_sep"],
+            left=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"],
+            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"],
-                first_col_sep=self.parts["first_col_sep"],
-                col_sep=self.parts["middle_edge"],
-                right=self.parts["left_and_right_edge"],
+                left=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"],
                 filler=row,
             )
         return output
 
     def to_ascii(self) -> str:
+        # top row of table
+        table = self.__top_edge_to_ascii()
         # add table header
-        table: str = self.__top_edge_to_ascii()
-        table += self.__header_row_to_ascii()
-        table += self.__header_sep_to_ascii()
+        if self.__header_row:
+            table += self.__header_row_to_ascii()
+            table += self.__header_sep_to_ascii()
         # add table body
-        table += self.__body_to_ascii()
+        if self.__body:
+            table += self.__body_to_ascii()
         # add table footer
-        table += self.__footer_sep_to_ascii()
-        table += self.__footer_row_to_ascii()
+        if self.__footer_row:
+            table += self.__footer_sep_to_ascii()
+            table += self.__footer_row_to_ascii()
+        # bottom row of table
         table += self.__bottom_edge_to_ascii()
+        # reurn ascii table
         return table
 
 
-def table2ascii(header_row: List, body: List[List], footer_row: List) -> str:
+def table2ascii(
+    header_row: Optional[List] = None,
+    body: Optional[List[List]] = None,
+    footer_row: Optional[List] = None,
+) -> str:
     """Convert a 2D Python table to ASCII text
     #TODO: add param documentation
     """

tests/test_convert.py

@@ -1,7 +1,7 @@
 from table2ascii import table2ascii as t2a
 
 
-def test_normal():
+def test_header_body_footer():
     text = t2a(
         header_row=["#", "G", "H", "R", "S"],
         body=[["1", "30", "40", "35", "30"], ["2", "30", "40", "35", "30"]],
@@ -18,3 +18,90 @@ def test_normal():
         "╚═════╩═══════════════════════╝\n"
     )
     assert text == expected
+
+
+def test_body_footer():
+    text = t2a(
+        body=[["1", "30", "40", "35", "30"], ["2", "30", "40", "35", "30"]],
+        footer_row=["SUM", "130", "140", "135", "130"],
+    )
+    expected = (
+        "╔═════╦═══════════════════════╗\n"
+        "║  1  ║  30    40    35    30 ║\n"
+        "║  2  ║  30    40    35    30 ║\n"
+        "╟─────╫───────────────────────╢\n"
+        "║ SUM ║ 130   140   135   130 ║\n"
+        "╚═════╩═══════════════════════╝\n"
+    )
+    assert text == expected
+
+
+def test_header_body():
+    text = t2a(
+        header_row=["#", "G", "H", "R", "S"],
+        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"
+    )
+    assert text == expected
+
+
+def test_header_footer():
+    text = t2a(
+        header_row=["#", "G", "H", "R", "S"],
+        footer_row=["SUM", "130", "140", "135", "130"],
+    )
+    expected = (
+        "╔═════╦═══════════════════════╗\n"
+        "║  #  ║  G     H     R     S  ║\n"
+        "╟─────╫───────────────────────╢\n"
+        "╟─────╫───────────────────────╢\n"
+        "║ SUM ║ 130   140   135   130 ║\n"
+        "╚═════╩═══════════════════════╝\n"
+    )
+    assert text == expected
+
+
+def test_header():
+    text = t2a(
+        header_row=["#", "G", "H", "R", "S"],
+    )
+    expected = (
+        "╔═════╦═══════════════════════╗\n"
+        "║  #  ║  G     H     R     S  ║\n"
+        "╟─────╫───────────────────────╢\n"
+        "╚═════╩═══════════════════════╝\n"
+    )
+    assert text == expected
+
+
+def test_body():
+    text = t2a(
+        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"
+    )
+    assert text == expected
+
+
+def test_footer():
+    text = t2a(
+        footer_row=["SUM", "130", "140", "135", "130"],
+    )
+    expected = (
+        "╔═════╦═══════════════════════╗\n"
+        "╟─────╫───────────────────────╢\n"
+        "║ SUM ║ 130   140   135   130 ║\n"
+        "╚═════╩═══════════════════════╝\n"
+    )
+    assert text == expected