Initial Fix for Issue 158 (#160)

Elements that are lists in a sequence will remain lists when grouped.
Additionally, cleaning up as per the suggestions of black.

Author: stephan-rayner

functional/pipeline.py

@@ -1266,7 +1266,7 @@ def grouped(self, size):
         :param size: size of the partitions
         :return: sequence partitioned into groups of length size
         """
-        return self._transform(transformations.grouped_t(_wrap, size))
+        return self._transform(transformations.grouped_t(size))
 
     def sliding(self, size, step=1):
         """

functional/test/test_functional.py

@@ -619,6 +619,38 @@ def test_grouped_returns_list(self):
         self.assertTrue(is_iterable(l.grouped(2)))
         self.assertTrue(is_iterable(l.grouped(3)))
 
+    def test_grouped_returns_list_of_lists(self):
+        test_inputs = [
+            [i for i in "abcdefghijklmnop"],
+            [None for i in range(10)],
+            [i for i in range(10)],
+            [[i] for i in range(10)],
+            [{i} for i in range(10)],
+            [{i, i + 1} for i in range(10)],
+            [[i, i + 1] for i in range(10)],
+        ]
+
+        def gen_test(collection, group_size):
+            expected_type = type(collection[0])
+
+            types_after_grouping = (
+                seq(collection)
+                .grouped(group_size)
+                .flatten()
+                .map(lambda item: type(item))
+            )
+
+            err_msg = f"Typing was not maintained after grouping. An input of {collection} yielded output types of {set(types_after_grouping)} and not {expected_type} as expected."
+
+            return types_after_grouping.for_all(lambda t: t == expected_type), err_msg
+
+        for test_input in test_inputs:
+            for group_size in [1, 2, 4, 7]:
+                all_sub_collections_are_lists, err_msg = gen_test(
+                    test_input, group_size
+                )
+                self.assertTrue(all_sub_collections_are_lists, msg=err_msg)
+
     def test_sliding(self):
         l = self.seq([1, 2, 3, 4, 5, 6, 7])
         expect = [[1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7]]

functional/transformations.py

@@ -564,10 +564,9 @@ def group_by_t(func):
     )
 
 
-def grouped_impl(wrap, size, sequence):
+def grouped_impl(size, sequence):
     """
     Implementation for grouped_t
-    :param wrap: wrap children values with this
     :param size: size of groups
     :param sequence: sequence to group
     :return: grouped sequence
@@ -576,20 +575,19 @@ def grouped_impl(wrap, size, sequence):
     try:
         while True:
             batch = islice(iterator, size)
-            yield list(chain((wrap(next(batch)),), batch))
+            yield list(chain((next(batch),), batch))
     except StopIteration:
         return
 
 
-def grouped_t(wrap, size):
+def grouped_t(size):
     """
     Transformation for Sequence.grouped
-    :param wrap: wrap children values with this
     :param size: size of groups
     :return: transformation
     """
     return Transformation(
-        "grouped({0})".format(size), partial(grouped_impl, wrap, size), None
+        "grouped({0})".format(size), partial(grouped_impl, size), None
     )