pythonthings
diff --git a/‎source_py3/python_toolbox/combi/perm_space.py‎
Lines changed: 14 additions & 4 deletions b/‎source_py3/python_toolbox/combi/perm_space.py‎
Lines changed: 14 additions & 4 deletions
diff --git a/‎source_py3/python_toolbox/nifty_collections/__init__.py‎
Lines changed: 1 addition & 0 deletions b/‎source_py3/python_toolbox/nifty_collections/__init__.py‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎source_py3/python_toolbox/nifty_collections/default_sorted_dict.py‎
Lines changed: 24 additions & 0 deletions b/‎source_py3/python_toolbox/nifty_collections/default_sorted_dict.py‎
Lines changed: 24 additions & 0 deletions
diff --git a/‎source_py3/python_toolbox/third_party/sortedcontainers/__init__.py‎
Lines changed: 55 additions & 0 deletions b/‎source_py3/python_toolbox/third_party/sortedcontainers/__init__.py‎
Lines changed: 55 additions & 0 deletions
@@ -10,20 +10,19 @@
 import numbers
 
 from python_toolbox import misc_tools
-from python_toolbox import dict_tools
 from python_toolbox import nifty_collections
 from python_toolbox import sequence_tools
 from python_toolbox import caching
 import python_toolbox.arguments_profiling
-
 from python_toolbox import math_tools
 from python_toolbox import sequence_tools
 from python_toolbox import cute_iter_tools
 from python_toolbox import nifty_collections
 from python_toolbox import dict_tools
+from python_toolbox.third_party import sortedcontainers
+from python_toolbox import misc_tools
 
 from . import misc
-from python_toolbox import misc_tools
 
 infinity = float('inf')
 
@@ -165,7 +164,14 @@ def __init__(self, iterable_or_length, domain=None, n_elements=None,
                 self.sequence = sequence_tools.CuteRange(self.sequence_length)
 
 
-        if self.is_rapplied and (len(set(self.sequence)) < len(self.sequence)):
+        if self.is_rapplied:
+            self.repeating_elements = sortedcontainers.SortedDict()
+            sequence_set = set()
+            for item in self.sequence:
+                if item in sequence_set:
+                    
+                    self.repeating_elements.setdefault(item,)
+                sequence_set.add(item)
             # Can implement this later by calculating the actual length.
             raise NotImplementedError
 
@@ -502,6 +508,10 @@ def __getitem__(self, i):
                 return self.perm_type(i, self)
 
 
+    enumerated_sequence = caching.CachedProperty(
+        lambda self: tuple(enumerate(self.sequence))
+    )
+                
     n_unused_elements = caching.CachedProperty(
         lambda self: self.sequence_length - self.n_elements,
         '''In partial perm spaces, number of elements that aren't used.'''
 
@@ -10,6 +10,7 @@
 from .lazy_tuple import LazyTuple
 from .frozen_dict import FrozenDict
 from .frozen_counter import FrozenCounter
+from .default_sorted_dict import DefaultSortedDict
 
 from .emitting_ordered_set import EmittingOrderedSet
 from .emitting_weak_key_default_dict import EmittingWeakKeyDefaultDict
@@ -0,0 +1,24 @@
+# Copyright 2009-2014 Ram Rachum.
+# This program is distributed under the MIT license.
+
+import collections
+
+from python_toolbox.third_party import sortedcontainers
+
+
+class DefaultSortedDict(sortedcontainers.SortedDict):
+
+    def __init__(self, default_factory, *args, **kwargs):
+        assert isinstance(default_factory, collections.Callable)
+        self.default_factory = default_factory
+        sortedcontainers.SortedDict.__init__(self, *args, **kwargs)
+  
+    def copy(self):
+        """ D.copy() -> a shallow copy of D. """
+        return type(self)(self.default_factory, self.items())
+  
+    def __getitem__(self, key):
+        try:
+            return self._dict[key]
+        except KeyError:
+            return self.default_factory()
@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+
+"""
+sortedcontainers Sorted Container Types Library
+===============================================
+
+SortedContainers is an Apache2 licensed containers library, written in
+pure-Python, and fast as C-extensions.
+
+Python's standard library is great until you need a sorted container type. Many
+will attest that you can get really far without one, but the moment you
+**really need** a sorted list, dict, or set, you're faced with a dozen
+different implementations, most using C-extensions without great documentation
+and benchmarking.
+
+Things shouldn't be this way. Not in Python.
+
+::
+
+    >>> from sortedcontainers import SortedList, SortedDict, SortedSet
+    >>> sl = SortedList(xrange(10000000))
+    >>> 1234567 in sl
+    True
+    >>> sl[7654321]
+    7654321
+    >>> sl.add(1234567)
+    >>> sl.count(1234567)
+    2
+    >>> sl *= 3
+    >>> len(sl)
+    30000003
+
+SortedContainers takes all of the work out of Python sorted types - making your
+deployment and use of Python easy. There's no need to install a C compiler or
+pre-build and distribute custom extensions. Performance is a feature and
+testing has 100% coverage with unit tests and hours of stress.
+
+:copyright: (c) 2014 by Grant Jenks.
+:license: Apache 2.0, see LICENSE for more details.
+
+"""
+
+__title__ = 'sortedcontainers'
+__version__ = '0.9.1'
+__build__ = 0x000901
+__author__ = 'Grant Jenks'
+__license__ = 'Apache 2.0'
+__copyright__ = 'Copyright 2014 Grant Jenks'
+
+from .sortedlist import SortedList
+from .sortedset import SortedSet
+from .sorteddict import SortedDict
+from .sortedlistwithkey import SortedListWithKey
+
+__all__ = [SortedList, SortedSet, SortedDict, SortedListWithKey]