Move all parameters to Options and simplified code

Author: DenverCoder1

table2ascii/__init__.py

@@ -4,14 +4,6 @@
 from typing import List, Optional, Union
 
 
-@dataclass
-class Options:
-    """Class for storing options that the user sets"""
-
-    first_col_heading: bool = False
-    last_col_heading: bool = False
-
-
 class Alignment(enum.Enum):
     """Enum for alignment types"""
 
@@ -20,57 +12,63 @@ class Alignment(enum.Enum):
     RIGHT = 2
 
 
+@dataclass
+class Options:
+    """Class for storing options that the user sets"""
+
+    header: Optional[List] = None
+    body: Optional[List[List]] = None
+    footer: Optional[List] = None
+    first_col_heading: bool = False
+    last_col_heading: bool = False
+    column_widths: Optional[List[int]] = None
+    alignments: Optional[List[Alignment]] = None
+
+
 class TableToAscii:
     """Class used to convert a 2D Python table to ASCII text"""
 
-    def __init__(
-        self,
-        header: Optional[List],
-        body: Optional[List[List]],
-        footer: Optional[List],
-        column_widths: Optional[List[int]],
-        alignments: Optional[List[Alignment]],
-        options: Options,
-    ):
+    def __init__(self, options: Options):
         """Validate arguments and initialize fields"""
         # initialize fields
-        self.__header = header
-        self.__body = body
-        self.__footer = footer
-        self.__options = options
+        self.__header = options.header
+        self.__body = options.body
+        self.__footer = options.footer
+        self.__first_col_heading = options.first_col_heading
+        self.__last_col_heading = options.last_col_heading
 
         # calculate number of columns
         self.__columns = self.__count_columns()
 
         # check if footer has a different number of columns
-        if footer and len(footer) != self.__columns:
+        if options.footer and len(options.footer) != self.__columns:
             raise ValueError(
                 "Footer must have the same number of columns as the other rows"
             )
         # check if any rows in body have a different number of columns
-        if body and tuple(filter(lambda r: len(r) != self.__columns, body)):
+        if options.body and any(len(row) != self.__columns for row in options.body):
             raise ValueError(
                 "All rows in body must have the same number of columns as the other rows"
             )
 
         # calculate or use given column widths
-        self.__column_widths = column_widths or self.__auto_column_widths()
+        self.__column_widths = options.column_widths or self.__auto_column_widths()
 
         # check if column widths specified have a different number of columns
-        if column_widths and len(column_widths) != self.__columns:
+        if options.column_widths and len(options.column_widths) != self.__columns:
             raise ValueError(
                 "Length of `column_widths` list must equal the number of columns"
             )
         # check if column widths are not all at least 2
-        if column_widths and min(column_widths) < 2:
+        if options.column_widths and min(options.column_widths) < 2:
             raise ValueError(
                 "All values in `column_widths` must be greater than or equal to 2"
             )
 
-        self.__alignments = alignments or [Alignment.CENTER] * self.__columns
+        self.__alignments = options.alignments or [Alignment.CENTER] * self.__columns
 
         # check if alignments specified have a different number of columns
-        if alignments and len(alignments) != self.__columns:
+        if options.alignments and len(options.alignments) != self.__columns:
             raise ValueError(
                 "Length of `alignments` list must equal the number of columns"
             )
@@ -162,8 +160,6 @@ def __row_to_ascii(
         filler: Union[str, List],
     ) -> str:
         """Assembles a row of the ascii table"""
-        first_heading = self.__options.first_col_heading
-        last_heading = self.__options.last_col_heading
         # left edge of the row
         output = left_edge
         # add columns
@@ -180,8 +176,11 @@ def __row_to_ascii(
             )
             # column seperator
             sep = column_seperator
-            if (i == 0 and first_heading) or (i == self.__columns - 2 and last_heading):
-                # use column heading if option is specified
+            if i == 0 and self.__first_col_heading:
+                # use column heading if first column option is specified
+                sep = heading_col_sep
+            elif i == self.__columns - 2 and self.__last_col_heading:
+                # use column heading if last column option is specified
                 sep = heading_col_sep
             elif i == self.__columns - 1:
                 # replace last seperator with symbol for edge of the row
@@ -250,16 +249,16 @@ def __footer_sep_to_ascii(self) -> str:
         )
 
     def __body_to_ascii(self) -> str:
-        output: str = ""
-        for row in self.__body:
-            output += self.__row_to_ascii(
+        return "".join(
+            self.__row_to_ascii(
                 left_edge=self.__parts["left_and_right_edge"],
                 heading_col_sep=self.__parts["heading_col_sep"],
                 column_seperator=self.__parts["middle_edge"],
                 right_edge=self.__parts["left_and_right_edge"],
                 filler=row,
             )
-        return output
+            for row in self.__body
+        )
 
     def to_ascii(self) -> str:
         # top row of table
@@ -281,14 +280,7 @@ def to_ascii(self) -> str:
         return table
 
 
-def table2ascii(
-    header: Optional[List] = None,
-    body: Optional[List[List]] = None,
-    footer: Optional[List] = None,
-    column_widths: Optional[List[int]] = None,
-    alignments: Optional[List[Alignment]] = None,
-    **options,
-) -> str:
+def table2ascii(**options) -> str:
     """Convert a 2D Python table to ASCII text
 
     ### Arguments
@@ -297,11 +289,7 @@ def table2ascii(
     :param footer: :class:`Optional[List]` List of column values in the table's footer row
     :param column_widths: :class:`Optional[List[int]]` List of widths in characters for each column (defaults to auto-sizing)
     :param alignments: :class:`Optional[List[Alignment]]` List of alignments (ex. `[Alignment.LEFT, Alignment.CENTER, Alignment.RIGHT]`)
-
-    ### Additional options
     :param first_col_heading: :class:`Optional[bool]` Whether to add a header column separator after the first column
     :param last_col_heading: :class:`Optional[bool]` Whether to add a header column separator before the last column
     """
-    return TableToAscii(
-        header, body, footer, column_widths, alignments, Options(**options)
-    ).to_ascii()
+    return TableToAscii(Options(**options)).to_ascii()

tests/test_alignments.py

@@ -42,5 +42,5 @@ def test_invalid_alignments():
             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],
+            alignments=[9999, -1, Alignment.RIGHT, Alignment.CENTER, Alignment.RIGHT],
         )