-

cool-RR · cool-RR · commit 482d24fba0bf · 2014-10-02T00:38:52.000+03:00
diff --git a/source_py3/python_toolbox/combi/perm_space.py b/source_py3/python_toolbox/combi/perm_space.py
@@ -193,8 +193,10 @@ def __init__(self, iterable_or_length, domain=None, n_elements=None,
         self.n_elements = self.sequence_length if (n_elements is None) \
                                                                 else n_elements
         if not 0 <= self.n_elements <= self.sequence_length:
-            raise Exception('`n_elements` must be between 0 and %s' %
-                                                          self.sequence_length)
+            raise Exception(
+                '`n_elements` must be between 0 and %s, you gave %s' %
+                                        (self.sequence_length, self.n_elements)
+            )
         self.is_partial = (self.n_elements < self.sequence_length)
         
         self.indices = sequence_tools.CuteRange(self.n_elements)
@@ -571,6 +573,7 @@ def __getitem__(self, i):
             reserved_values = list(self.fixed_map.values())
             wip_perm_sequence_dict = dict(self.fixed_map)
             wip_i = i
+            shit_set = set()
             for j in range(self.n_elements):
                 if j in self.fixed_map:
                     available_values.remove(self.fixed_map[j])
@@ -608,16 +611,23 @@ def __getitem__(self, i):
                             ]
                         else:
                             sequence_to_use.remove(item)
+                            
+                    sequence_to_use = [x for x in sequence_to_use if x not in
+                                       shit_set]
                         
                     fixed_map_to_use = {key - len(head): value for key, value
                                         in fixed_map_to_use.items()}
                     
-                    candidate_sub_perm_space = PermSpace(
-                        sequence_to_use,
-                        n_elements=n_elements_to_use,
-                        fixed_map=fixed_map_to_use, 
-                        is_combination=self.is_combination
-                    )
+                    if len(sequence_to_use) < n_elements_to_use:
+                        class O: length = 0
+                        candidate_sub_perm_space = O()
+                    else:
+                        candidate_sub_perm_space = PermSpace(
+                            sequence_to_use,
+                            n_elements=n_elements_to_use,
+                            fixed_map=fixed_map_to_use, 
+                            is_combination=self.is_combination
+                        )
                     #                                                         #
                     ###########################################################
                     
@@ -626,6 +636,7 @@ def __getitem__(self, i):
                         break
                     else:
                         wip_i -= candidate_sub_perm_space.length
+                        shit_set.add(wip_perm_sequence_dict[j])
                         del wip_perm_sequence_dict[j]
                 else:
                     raise RuntimeError
diff --git a/source_py3/test_python_toolbox/test_combi/test_exhaustive.py b/source_py3/test_python_toolbox/test_combi/test_exhaustive.py
@@ -29,6 +29,7 @@ def __init__(self, iterable_or_length, domain=None, n_elements=None,
         self.sequence_length = len(self.sequence)
         self._sequence_frozen_counter = \
                                  nifty_collections.FrozenCounter(self.sequence)
+        self.is_recurrent = len(set(self.sequence)) < len(self.sequence)
         self.domain = domain or sequence_tools.CuteRange(self.sequence_length)
         self.n_elements = n_elements if n_elements is not None else \
                                                              len(self.sequence)
@@ -42,10 +43,23 @@ def __init__(self, iterable_or_length, domain=None, n_elements=None,
                                 sequence_tools.CuteRange(self.sequence_length))
         
     def __iter__(self):
+        if (self.is_recurrent and self.is_combination):
+            def make_iterator():
+                crap = set()
+                for item in self._iter():
+                    fc = nifty_collections.FrozenCounter(item)
+                    if fc in crap:
+                        continue
+                    else:
+                        yield item
+                        crap.add(fc)
+            iterator = make_iterator()
+        else:
+            iterator = self._iter()
         if self.slice_:
-            return itertools.islice(self._iter(), *self.slice_)
+            return itertools.islice(iterator, *self.slice_)
         else:
-            return self._iter()
+            return iterator
         
     def _iter(self):
         yielded_candidates = set()
@@ -104,6 +118,12 @@ def _check_variation_selection(variation_selection):
         # Can't even test this illogical clash.
         return 
         
+    #blocktodo remove
+    if not (variation_selection.is_recurrent and variation_selection.is_combination):
+        return
+    #blocktodo remove
+    if variation_selection.number != 240:
+        return
     
     iterable_or_length = (
         'abracab' if variation_selection.is_recurrent else
@@ -175,6 +195,9 @@ def _check_variation_selection(variation_selection):
     
     assert perm_space.length == len(brute_perm_space_tuple)
     
+    #blocktodo remove
+    tuple(perm_space)
+    
     if perm_space.length >= 2:
         assert perm_space.index(perm_space[-1]) > \
                                                 perm_space.index(perm_space[0])
