Enhance list_columns() function to accept different input types

Author: chrimaho

src/tests/test_output.py

@@ -12,16 +12,17 @@
 
 # ## Python StdLib Imports ----
 import logging
-from typing import Union
+from typing import Generator, Literal, Union
 from unittest import TestCase
 
 # ## Python Third Party Imports ----
 import pytest
 import requests
+from parameterized import parameterized
 from typeguard import TypeCheckError
 
 # ## Local First Party Imports ----
-from toolbox_python.collection_types import str_list
+from toolbox_python.collection_types import str_list, str_set, str_tuple
 from toolbox_python.output import list_columns, print_or_log_output
 
 
@@ -188,12 +189,11 @@ def get_list_of_words(num_words: int = 100) -> str_list:
         words: str_list = response.content.decode().splitlines()
         return words[:num_words]
 
-    def test_1(self) -> None:
+    def test_1_defaults(self) -> None:
         output: Union[str, None] = list_columns(
             self.get_list_of_words(4 * 5),
             print_output=False,
         )
-
         expected: str = "\n".join(
             [
                 "a             abandoned     able          abraham       ",
@@ -205,15 +205,15 @@ def test_1(self) -> None:
         )
         assert output == expected
 
-    def test_2(self) -> None:
+    def test_2_no_printing(self) -> None:
         output: Union[str, None] = list_columns(
             self.get_list_of_words(3),
             print_output=False,
         )
         expected = """a      aa     aaa    """
         assert output == expected
 
-    def test_3(self) -> None:
+    def test_3_columnwise(self) -> None:
         output: Union[str, None] = list_columns(
             self.get_list_of_words(5),
             cols_wide=2,
@@ -229,18 +229,60 @@ def test_3(self) -> None:
         )
         assert output == expected
 
-    def test_4(self) -> None:
+    def test_4_print_output(self) -> None:
         list_columns(
-            self.get_list_of_words(4 * 3),
-            columnwise=False,
-            cols_wide=4,
+            self.get_list_of_words(4 * 5),
             print_output=True,
         )
         output: str_list = self.capsys.readouterr().out.split("\n")
         expected: str_list = [
-            "a             aa            aaa           aaron         ",
-            "ab            abandoned     abc           aberdeen      ",
-            "abilities     ability       able          aboriginal    ",
+            "a             abandoned     able          abraham       ",
+            "aa            abc           aboriginal    abroad        ",
+            "aaa           aberdeen      abortion      abs           ",
+            "aaron         abilities     about         absence       ",
+            "ab            ability       above         absent        ",
             "",
         ]
         assert output == expected
+
+    def test_5_rowwise(self) -> None:
+        output = list_columns(
+            self.get_list_of_words(4 * 3),
+            columnwise=False,
+            cols_wide=4,
+            print_output=False,
+        )
+        expected: str = "\n".join(
+            [
+                "a             aa            aaa           aaron         ",
+                "ab            abandoned     abc           aberdeen      ",
+                "abilities     ability       able          aboriginal    ",
+            ]
+        )
+        assert output == expected
+
+    @parameterized.expand([("list"), ("tuple"), ("set"), ("generator")])
+    def test_6_types(self, input_type: Literal["list", "tuple", "set", "generator"]) -> None:
+        words: str_list = self.get_list_of_words(4 * 3)
+        expected: str = "\n".join(
+            [
+                "a             aaron         abc           ability       ",
+                "aa            ab            aberdeen      able          ",
+                "aaa           abandoned     abilities     aboriginal    ",
+            ]
+        )
+        if input_type == "list":
+            input_data: str_list = list(words)
+        elif input_type == "tuple":
+            input_data: str_tuple = tuple(words)
+        elif input_type == "set":
+            input_data: str_set = set(words)
+            expected = "\n".join(set(expected.splitlines()))
+        elif input_type == "generator":
+            input_data: Generator = (word for word in words)
+        output: Union[str, None] = list_columns(input_data)
+        if input_type != "set":
+            assert output == expected
+        else:
+            for word in words:
+                assert word in output

src/toolbox_python/output.py

@@ -41,14 +41,20 @@
 # ## Python StdLib Imports ----
 from logging import Logger, _nameToLevel
 from math import ceil
-from typing import Any, Literal, Optional, Union
+from typing import Any, Generator, Literal, Optional, Union
 
 # ## Python Third Party Imports ----
 from typeguard import typechecked
 
 # ## Local First Party Imports ----
 from toolbox_python.checkers import is_type
-from toolbox_python.collection_types import log_levels, str_list
+from toolbox_python.collection_types import (
+    any_list,
+    any_set,
+    any_tuple,
+    log_levels,
+    str_list,
+)
 
 
 # ---------------------------------------------------------------------------- #
@@ -230,11 +236,11 @@ def print_or_log_output(
 
 @typechecked
 def list_columns(
-    obj: list,
+    obj: Union[any_list, any_set, any_tuple, Generator],
     cols_wide: int = 4,
     columnwise: bool = True,
     gap: int = 4,
-    print_output: bool = True,
+    print_output: bool = False,
 ) -> Optional[str]:
     """
     !!! note Summary
@@ -376,9 +382,7 @@ def list_columns(
     ]
     if columnwise:
         if len(segmented_list[-1]) != cols_wide:
-            segmented_list[-1].extend(
-                [""] * (len(string_list) - len(segmented_list[-1]))
-            )
+            segmented_list[-1].extend([""] * (len(string_list) - len(segmented_list[-1])))
         combined_list: Union[list[str_list], Any] = zip(*segmented_list)
     else:
         combined_list = segmented_list