-

cool-RR · cool-RR · commit 2102d7d9d086 · 2014-10-24T21:28:57.000+03:00
diff --git a/source_py3/python_toolbox/nifty_collections/bagging.py b/source_py3/python_toolbox/nifty_collections/bagging.py
@@ -980,6 +980,10 @@ def popitem(self, last=True):
         doc='Sort the keys in this bag. (With optional `key` function.)'
     )
     
+    @property
+    def reversed(self):
+        '''Get a version of this `OrderedBag` with key order reversed.'''
+        return type(self)(self._dict_type(reversed(tuple(self.items()))))
     
                 
 class FrozenBag(_BaseBagMixin, _FrozenBagMixin, FrozenDict):
@@ -1044,6 +1048,14 @@ class FrozenOrderedBag(_OrderedBagMixin, _FrozenBagMixin, _BaseBagMixin,
     '''
     def __hash__(self):
         return hash((type(self), tuple(self.items())))
+    
+    @_BootstrappedCachedProperty
+    def reversed(self):
+        '''
+        Get a version of this `FrozenOrderedBag` with key order reversed.
+        '''        
+        return type(self)(self._dict_type(reversed(tuple(self.items()))))
+        
         
         
 Bag._frozen_type = FrozenBag
diff --git a/source_py3/python_toolbox/nifty_collections/frozen_dict_and_frozen_ordered_dict.py b/source_py3/python_toolbox/nifty_collections/frozen_dict_and_frozen_ordered_dict.py
@@ -79,3 +79,15 @@ def __eq__(self, other):
     # (Gotta manually carry `__hash__` over from the base class because setting
     # `__eq__` resets it. )
 
+    
+    # Poor man's caching because we can't import `CachedProperty` due to import
+    # loop:
+    _reversed = None
+    @property
+    def reversed(self):
+        '''
+        Get a version of this `FrozenOrderedDict` with key order reversed.
+        '''
+        if self._reversed is None:
+            self._reversed = type(self)(reversed(tuple(self.items())))
+        return self._reversed
diff --git a/source_py3/python_toolbox/nifty_collections/ordered_dict.py b/source_py3/python_toolbox/nifty_collections/ordered_dict.py
@@ -35,4 +35,9 @@ def index(self, key):
         for i, key_ in enumerate(self):
             if key_ == key:
                 return i
-        raise RuntimeError
+        raise RuntimeError
+    
+    @property
+    def reversed(self):
+        '''Get a version of this `OrderedDict` with key order reversed.'''
+        return type(self)(reversed(tuple(self.items())))
diff --git a/source_py3/test_python_toolbox/test_nifty_collections/test_bagging.py b/source_py3/test_python_toolbox/test_nifty_collections/test_bagging.py
@@ -682,6 +682,28 @@ def test_clear(self):
               
 class BaseOrderedBagTestCase(BaseBagTestCase):
     
+    def test_reversed(self):
+        bag = self.bag_type('mississippi')
+        
+        # Cached only for a frozen type:
+        assert (bag.reversed is bag.reversed) == \
+               (bag.reversed.reversed is bag.reversed.reversed) == \
+               isinstance(bag, collections.Hashable)
+        
+        assert bag.reversed == bag.reversed
+        assert bag.reversed.reversed == bag.reversed.reversed
+        
+        assert Bag(bag) == Bag(bag.reversed)
+        assert OrderedBag(bag) != OrderedBag(bag.reversed)
+        
+        assert Bag(bag.elements) == Bag(bag.reversed.elements)
+        assert OrderedBag(bag.elements) != OrderedBag(bag.reversed.elements)
+        assert OrderedBag(bag.elements) == \
+                             OrderedBag(reversed(tuple(bag.reversed.elements)))
+        
+        assert set(bag.keys()) == set(bag.reversed.keys())
+        assert tuple(bag.keys()) == tuple(reversed(tuple(bag.reversed.keys())))
+    
     def test_ordering(self):
         ordered_bag_0 = self.bag_type('ababb')
         ordered_bag_1 = self.bag_type('bbbaa')
@@ -694,10 +716,12 @@ def test_ordering(self):
         assert ordered_bag_0 != ordered_bag_1
         assert ordered_bag_0 <= ordered_bag_1
         assert ordered_bag_0 >= ordered_bag_1
+        
           
-    def test_reversed(self):
+    def test_builtin_reversed(self):
         bag = self.bag_type('abracadabra')
         assert tuple(reversed(bag)) == tuple(reversed(tuple(bag)))
+
         
     def test_index(self):
         bag = self.bag_type('aaabbc')
@@ -717,6 +741,12 @@ def test_index(self):
           
 class BaseUnorderedBagTestCase(BaseBagTestCase):
     
+    def test_reversed(self):
+        bag = self.bag_type('mississippi')
+        with cute_testing.RaiseAssertor(AttributeError):
+            bag.reversed
+        
+    
     def test_ordering(self):
         bag_0 = self.bag_type('ababb')
         bag_1 = self.bag_type('bbbaa')
@@ -725,7 +755,7 @@ def test_ordering(self):
             assert hash(bag_0) == hash(bag_1)
             
             
-    def test_reversed(self):
+    def test_builtin_reversed(self):
         bag = self.bag_type('abracadabra')
         with cute_testing.RaiseAssertor(TypeError):
             reversed(bag)
diff --git a/source_py3/test_python_toolbox/test_nifty_collections/test_frozen_ordered_dict.py b/source_py3/test_python_toolbox/test_nifty_collections/test_frozen_ordered_dict.py
@@ -39,4 +39,29 @@ def test():
     assert repr(frozen_ordered_dict).startswith('FrozenOrderedDict(')
     
     assert pickle.loads(pickle.dumps(frozen_ordered_dict)) == \
-                                                            frozen_ordered_dict
+                                                            frozen_ordered_dict
+    
+def test_reversed():
+
+    frozen_ordered_dict = \
+                        FrozenOrderedDict((('1', 'a'), ('2', 'b'), ('3', 'c')))
+    
+    assert frozen_ordered_dict.reversed == \
+                        FrozenOrderedDict((('3', 'c'), ('2', 'b'), ('1', 'a')))
+    
+    assert frozen_ordered_dict.reversed is frozen_ordered_dict.reversed
+    assert frozen_ordered_dict.reversed == frozen_ordered_dict.reversed
+    assert frozen_ordered_dict.reversed.reversed is \
+                                          frozen_ordered_dict.reversed.reversed
+    assert frozen_ordered_dict.reversed.reversed == \
+                                          frozen_ordered_dict.reversed.reversed
+    assert frozen_ordered_dict.reversed.reversed == frozen_ordered_dict
+    assert frozen_ordered_dict.reversed.reversed.reversed == \
+                                                   frozen_ordered_dict.reversed
+    
+    assert set(frozen_ordered_dict.items()) == \
+                                      set(frozen_ordered_dict.reversed.items())
+    assert tuple(frozen_ordered_dict.items()) == \
+                   tuple(reversed(tuple(frozen_ordered_dict.reversed.items())))
+    assert type(frozen_ordered_dict.reversed) is type(frozen_ordered_dict) \
+                                                           is FrozenOrderedDict
diff --git a/source_py3/test_python_toolbox/test_nifty_collections/test_ordered_dict/test.py b/source_py3/test_python_toolbox/test_nifty_collections/test_ordered_dict/test.py
@@ -67,8 +67,13 @@ def test_index():
         ordered_dict.index('Non-existing key')
         
         
-def test_reversed():
+def test_builtin_reversed():
     '''Test the `OrderedDict.__reversed__` method.'''
     
     ordered_dict = OrderedDict(((1, 'a'), (2, 'b'), (3, 'c')))
-    assert list(reversed(ordered_dict)) == [3, 2, 1]
+    assert list(reversed(ordered_dict)) == [3, 2, 1]
+    
+def test_reversed():
+    ordered_dict = OrderedDict(((1, 'a'), (2, 'b'), (3, 'c')))
+    assert ordered_dict.reversed == OrderedDict(((3, 'c'), (2, 'b'), (1, 'a')))
+    assert type(ordered_dict.reversed) is type(ordered_dict) is OrderedDict
