Reverting changes to partitions

cool-RR · cool-RR · commit 4d1a80a5dd19 · 2015-07-18T18:57:10.000+03:00
diff --git a/source_py3/python_toolbox/sequence_tools/misc.py b/source_py3/python_toolbox/sequence_tools/misc.py
@@ -57,24 +57,20 @@ def partitions(sequence, partition_size=None, *, n_partitions=None,
                allow_remainder=True, larger_on_remainder=False,
                fill_value=NO_FILL_VALUE):
     '''
-    Break `sequence` into partitions.
-    
-    Partitions `sequence` into partitions of size `partition_size`, or
+    Partition `sequence` into equal partitions of size `partition_size`, or
     determine size automatically given the number of partitions as
     `n_partitions`.
 
-    This function attempts to break the sequence into partitions with an equal
-    number of items; if the sequence can't be divided into precisely equal
-    partitions, the first partitions will have more elements then the
-    partitions that come after them.
+    If the sequence can't be divided into precisely equal partitions, the last
+    partition will contain less members than all the other partitions.
 
     Example:
 
         >>> partitions([0, 1, 2, 3, 4], 2)
         [[0, 1], [2, 3], [4]]
 
-    You need to give *either* a `partition_size` *or* an `n_partitions`
-    argument, not both.
+    (You need to give *either* a `partition_size` *or* an `n_partitions`
+    argument, not both.)
 
     Specify `allow_remainder=False` to enforce that the all the partition sizes
     be equal; if there's a remainder while `allow_remainder=False`, an
@@ -99,14 +95,10 @@ def partitions(sequence, partition_size=None, *, n_partitions=None,
         [[0, 1, 2], [3, 4, 'meow']]
 
     '''
-    
-    from python_toolbox import cute_iter_tools
 
     sequence = ensure_iterable_is_sequence(sequence)
 
     sequence_length = len(sequence)
-    if 0 in (n_partitions, partition_size):
-        raise ValueError
 
     ### Validating input: #####################################################
     #                                                                         #
@@ -141,25 +133,23 @@ def partitions(sequence, partition_size=None, *, n_partitions=None,
 
     naive_length = partition_size * n_partitions
     
-    cutoff_indices = list(range(0, sequence_length, partition_size)) + [None]
+    blocks = [sequence[i : i + partition_size] for i in
+              range(0, naive_length, partition_size)]
 
     if naive_length != sequence_length:
-        assert cutoff_indices
+        assert blocks
         if larger_on_remainder:
-            if len(cutoff_indices) >= 3:
-                del blocks[-2]
-        elif fill_value is not NO_FILL_VALUE: # (We use elif because fill is 
-                                              # never done if
-                                              # `larger_on_remainder=True`.)
+            if len(blocks) >= 2:
+                small_block_to_append_back = blocks[-1]
+                del blocks[-1]
+                blocks[-1] += small_block_to_append_back
+        elif fill_value != NO_FILL_VALUE: # (We use elif because fill is never 
+                                          # done if `larger_on_remainder=True`.)
             filler = itertools.repeat(fill_value,
                                       naive_length - sequence_length)
             blocks[-1].extend(filler)
 
-    return [
-        sequence[cutoff_left:cutoff_right] for (cutoff_left, cutoff_right)
-        in cute_iter_tools.iterate_overlapping_subsequences(cutoff_indices)
-    ]
-
+    return blocks
 
 
 def is_immutable_sequence(thing):
diff --git a/source_py3/test_python_toolbox/test_sequence_tools/test_partitions.py b/source_py3/test_python_toolbox/test_sequence_tools/test_partitions.py
@@ -102,49 +102,3 @@ def test_fill_value():
     assert partitions(r, 3, fill_value=None) == [[0, 1, 2], [3, 4, None]]
     assert partitions([], 3, fill_value=None) == []
 
-
-def test_different_types():
-    sequences = (
-        list(range(5)),
-        tuple(range(5)),
-        range(5), #blocktodo on py2 ensure it's xrange
-    )
-    
-    for sequence in sequences:
-        assert partitions(sequence, partition_size=2) == [
-            sequence[:2], sequence[2:4], sequence[4:]
-        ]
-        assert partitions(sequence, partition_size=2,
-                          larger_on_remainder=True) == [
-            sequence[:2], sequence[2:]
-        ]
-        
-def test_n_partitions():
-    r = list(range(10))
-    with cute_testing.RaiseAssertor(ValueError):
-        partitions(r, n_partitions=0)
-    assert partitions(r, n_partitions=1) == [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]
-    assert partitions(r, n_partitions=2) == [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
-    assert partitions(r, n_partitions=3) == \
-                                           [[0, 1, 2, 3], [4, 5, 6,], [7, 8, 9]]
-    assert partitions(r, n_partitions=4) == \
-                                        [[0, 1, 2], [3, 4, 5], [6, 7], [8, 9]]
-    assert partitions(r, n_partitions=5) == \
-                                       [[0, 1], [2, 3], [4, 5], [6, 7], [8, 9]]
-    assert partitions(r, n_partitions=6) == \
-                                     [[0, 1], [2, 3], [4, 5], [6, 7], [8], [9]]
-    assert partitions(r, n_partitions=7) == \
-                                   [[0, 1], [2, 3], [4, 5], [6], [7], [8], [9]]
-    assert partitions(r, n_partitions=8) == \
-                                 [[0, 1], [2, 3], [4], [5], [6], [7], [8], [9]]
-    assert partitions(r, n_partitions=9) == \
-                               [[0, 1], [2], [3], [4], [5], [6], [7], [8], [9]]
-    assert partitions(r, n_partitions=10) == \
-                             [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9]]
-    assert partitions(r, n_partitions=11) == \
-                         [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9], []]
-    assert partitions(r, n_partitions=12) == \
-                     [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9], [], []]
-           
-    # blocktodo: add same batch of tests but with larger_on_remainder
-    
