-

cool-RR · cool-RR · commit db7742b8ea1b · 2015-06-09T13:36:11.000+03:00
diff --git a/source_py3/python_toolbox/nifty_collections/various_ordered_sets.py b/source_py3/python_toolbox/nifty_collections/various_ordered_sets.py
@@ -2,6 +2,8 @@
 # This program is distributed under the MIT license.
 
 import collections
+import operator
+import itertools
 
 from python_toolbox import comparison_tools
 from python_toolbox import context_management
@@ -61,10 +63,9 @@ def __repr__(self):
 
     def __eq__(self, other):
         return (
-            isinstance(other, collections.Set) and
-            isinstance(other, collections.Sequence) and
-            len(self) == len(other) and
-            tuple(self) == tuple(other)
+            (type(self) is type(other)) and
+            (len(self) == len(other)) and 
+            all(itertools.starmap(operator.eq, zip(self, other)))
         )
     
     def __clear(self):
@@ -102,6 +103,10 @@ class FrozenOrderedSet(BaseOrderedSet):
     creation) except items have an order. (By default they're ordered by
     insertion order, but that order can be changed.)
     '''
+    
+    def __hash__(self):
+        return hash((type(self), tuple(self)))
+        
 
 
 class OrderedSet(BaseOrderedSet, collections.MutableSet):
@@ -218,4 +223,17 @@ def move_to_end(self, key, last=True):
             self.remove(key)
         self.add(key, last=last)
     
-    _emitter_freezer = freezing.FreezerProperty()
+    _emitter_freezer = freezing.FreezerProperty()
+    
+    def __eq__(self, other):
+        return (
+            (type(self) is type(other)) and
+            (len(self) == len(other)) and
+            (self.emitter is other.emitter) and 
+            all(itertools.starmap(operator.eq, zip(self, other)))
+        )
+      
+    def get_without_emitter(self):
+        '''Get a version of this ordered set without an emitter attached.'''
+        return OrderedSet(self)
+        
diff --git a/source_py3/test_python_toolbox/test_nifty_collections/test_various_ordered_sets.py b/source_py3/test_python_toolbox/test_nifty_collections/test_various_ordered_sets.py
@@ -19,6 +19,12 @@ def test_operations(self):
         assert type(ordered_set | ordered_set) == \
                type(ordered_set & ordered_set) == type(ordered_set)
         
+    def test_bool(self):
+        assert bool(self.ordered_set_type({})) is False
+        assert bool(self.ordered_set_type({0})) is True
+        assert bool(self.ordered_set_type(range(5))) is True
+        
+        
 class BaseMutableOrderedSetTestCase(BaseOrderedSetTestCase):
     __test__ = False
     def test_sort(self):
@@ -91,7 +97,16 @@ def test_frozen(self):
         assert list(frozen_ordered_set) == list(range(4))
           
     def test_hashable(self):
-        1 / 0blocktodo
+        d = {
+            FrozenOrderedSet(range(1)): 1,
+            FrozenOrderedSet(range(2)): 2,
+            FrozenOrderedSet(range(3)): 3,
+        }
+        assert len(d) == 3
+        assert set(d.values()) == {1, 2, 3}
+        assert d[FrozenOrderedSet(range(2))] == 2
+        d[FrozenOrderedSet(range(2))] = 20
+        assert set(d.values()) == {1, 20, 3}
         
 
 class EmittingOrderedSetTestCase(BaseMutableOrderedSetTestCase):
@@ -110,12 +125,14 @@ def increment_times_emitted():
         assert times_emitted == [1]
         emitting_ordered_set.discard(17)
         assert times_emitted == [1]
-        assert emitting_ordered_set == OrderedSet(range(8))
+        assert emitting_ordered_set.get_without_emitter() == \
+                                                           OrderedSet(range(8))
         emitting_ordered_set |= (8, 9, 10)
         assert times_emitted == [4]
         emitting_ordered_set |= (8, 9, 10)
         assert times_emitted == [4]
-        assert emitting_ordered_set == OrderedSet(range(11))
+        assert emitting_ordered_set.get_without_emitter() == \
+                                                          OrderedSet(range(11))
         emitting_ordered_set.move_to_end(4)
         assert times_emitted == [5]
         assert tuple(emitting_ordered_set) == \
