-

cool-RR · cool-RR · commit c3b961b733b5 · 2014-10-04T22:45:59.000+03:00
diff --git a/source_py3/python_toolbox/combi/perming/perm_space.py b/source_py3/python_toolbox/combi/perming/perm_space.py
@@ -577,21 +577,20 @@ def __getitem__(self, i):
             assert not self.is_dapplied and not self.is_degreed and \
                                                              not self.is_sliced
             available_values = list(self.sequence)
-            reserved_values = list(self.fixed_map.values())
+            reserved_values = nifty_collections.Tally(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])
-                    reserved_values.remove(self.fixed_map[j])
+                    reserved_values[self.fixed_map[j]] -= 1
                     continue
-                unused_values = nifty_collections.OrderedSet((
-                    value for value in available_values if not
-                    ((value in reserved_values and available_values.count(value)
-                         == reserved_values.count(value)) or value in shit_set)
-                    
-                    ))
+                unused_values = [
+                    item for item in
+                    nifty_collections.OrderedTally(available_values) -
+                    reserved_values if item not in shit_set
+                ]
                 for unused_value in unused_values:
                     wip_perm_sequence_dict[j] = unused_value
                     
diff --git a/source_py3/python_toolbox/nifty_collections/tallying.py b/source_py3/python_toolbox/nifty_collections/tallying.py
@@ -295,8 +295,56 @@ def __repr__(self):
             '[%s]' % ', '.join('%s' % (item,) for item in self.items())
         )
     
+
+class _OrderedDictDelegator(collections.MutableMapping):
+
+    # Start by filling-out the abstract methods
+    def __init__(self, dict=None, **kwargs):
+        self.data = OrderedDict()
+        if dict is not None:
+            self.update(dict)
+        if len(kwargs):
+            self.update(kwargs)
+    def __len__(self): return len(self.data)
+    def __getitem__(self, key):
+        if key in self.data:
+            return self.data[key]
+        if hasattr(self.__class__, "__missing__"):
+            return self.__class__.__missing__(self, key)
+        raise KeyError(key)
+    def __setitem__(self, key, item): self.data[key] = item
+    def __delitem__(self, key): del self.data[key]
+    def __iter__(self):
+        return iter(self.data)
+
+    # Modify __contains__ to work correctly when __missing__ is present
+    def __contains__(self, key):
+        return key in self.data
+
+    # Now, add the methods in dicts but not in MutableMapping
+    def __repr__(self): return repr(self.data)
+    def copy(self):
+        if self.__class__ is _OrderedDictDelegator:
+            return _OrderedDictDelegator(self.data.copy())
+        import copy
+        data = self.data
+        try:
+            self.data = OrderedDict
+            c = copy.copy(self)
+        finally:
+            self.data = data
+        c.update(self)
+        return c
+    @classmethod
+    def fromkeys(cls, iterable, value=None):
+        d = cls()
+        for key in iterable:
+            d[key] = value
+        return d
+
+
                 
-class Tally(_TallyMixin, FrozenDict):
+class Tally(_TallyMixin, collections.UserDict):
     '''
     blocktododoc
     An immutable tally.
@@ -315,8 +363,10 @@ class that has an identity crisis and doesn't know whether it's a
        counter or a dict.
      
     '''                
+    _dict = property(lambda self: self.data)
+    
                 
-class OrderedTally(_TallyMixin, FrozenDict):
+class OrderedTally(_OrderedTallyMixin, _TallyMixin, _OrderedDictDelegator):
     '''
     blocktododoc
     An immutable, ordered tally.
@@ -336,7 +386,9 @@ class that has an identity crisis and doesn't know whether it's a
        
      - It has an order to its elements, like `collections.OrderedDict`.
      
-    '''                
+    '''
+    _dict = property(lambda self: self.data)
+    
                 
 class FrozenTally(_BaseTallyMixin, FrozenDict):
     '''
