-

cool-RR · cool-RR · commit 6ad406d22ea6 · 2015-06-09T18:59:12.000+03:00
diff --git a/source_py2/python_toolbox/logic_tools.py b/source_py2/python_toolbox/logic_tools.py
@@ -63,7 +63,7 @@ def all_equivalent(iterable, relation=operator.eq, assume_reflexive=True,
 
 
 misc_tools.limit_positional_arguments(3)
-def get_equivalence_classes(iterable, key=None, container=set,
+def get_equivalence_classes(iterable, key=None, container=set, 
                             use_ordered_dict=False, sort_ordered_dict=False):
     '''
     Divide items in `iterable` to equivalence classes, using the key function.
diff --git a/source_py2/test_python_toolbox/test_address_tools/test_describe.py b/source_py2/test_python_toolbox/test_address_tools/test_describe.py
@@ -246,7 +246,7 @@ def test_bad_module_name():
 def test_function_in_something():
     '''Test `describe` doesn't fail when describing `{1: sum}`.'''
     if python_toolbox.__version_info__ <= (0, 7, 0, 'release'):
-        raise nose.SkipTest("This test doesn't pass in `python_toolbox`"
+        raise nose.SkipTest("This test doesn't pass in `python_toolbox` "
                             "version 0.7.0 and below.")
     assert describe({1: sum}) == '{1: sum}'
     assert describe((sum, sum, list, chr)) == '(sum, sum, list, chr)'
diff --git a/source_py2/test_python_toolbox/test_address_tools/test_resolve.py b/source_py2/test_python_toolbox/test_address_tools/test_resolve.py
@@ -8,7 +8,7 @@
 from python_toolbox.address_tools import describe, resolve
 
 
-# Class tree we'll try to some resolvings on:
+# Class tree we'll try to do some resolvings on:
 class A(object):
     def method(self):
         pass
diff --git a/source_py2/test_python_toolbox/test_combi/test_perm_space.py b/source_py2/test_python_toolbox/test_combi/test_perm_space.py
@@ -76,9 +76,11 @@ def test_perm_spaces():
     # Testing hashing: 
     pure_perm_space_dict = {pure_0a: 'a', pure_0b: 'b',
                             pure_0c: 'c', pure_0d: 'd',}
+    (single_value,) = pure_perm_space_dict.values()
     assert len(pure_perm_space_dict) == 1 # They're all the same
     assert pure_perm_space_dict[pure_0a] == pure_perm_space_dict[pure_0b] == \
-          pure_perm_space_dict[pure_0c] == pure_perm_space_dict[pure_0d] == 'd'
+          pure_perm_space_dict[pure_0c] == pure_perm_space_dict[pure_0d] == \
+                                                                   single_value
     
     assert None not in pure_0a # Because, damn.
     assert PermSpace('meow')[0] not in pure_0a
@@ -106,7 +108,8 @@ def test_perm_spaces():
     assert not (first_perm != first_perm)
     assert first_perm == first_perm
     assert first_perm
-    assert {pure_0a[4]: 1, pure_0b[4]: 2, pure_0c[4]: 3,} == {pure_0d[4]: 3,}
+    assert tuple({pure_0a[4]: 1, pure_0b[4]: 2, pure_0c[4]: 3,}.keys()) == \
+                                                                 (pure_0d[4], )
     
     
     assert some_perm.inverse == ~ some_perm
diff --git a/source_py2/test_python_toolbox/test_cute_iter_tools/test_iterate_overlapping_subsequences.py b/source_py2/test_python_toolbox/test_cute_iter_tools/test_iterate_overlapping_subsequences.py
@@ -47,6 +47,8 @@ def test_various_lengths():
                        ((0, 1, 2, 3), (1, 2, 3, 4), (2, 3, 4, 5), (3, 4, 5, 6))
     assert tuple(iterate_overlapping_subsequences(xrange(7), length=5)) == \
                             ((0, 1, 2, 3, 4), (1, 2, 3, 4, 5), (2, 3, 4, 5, 6))
+    assert tuple(iterate_overlapping_subsequences(range(7), length=1)) == \
+                                                                tuple(range(7))
     
     assert tuple(iterate_overlapping_subsequences(xrange(7), length=4,
             wrap_around=True)) == ((0, 1, 2, 3), (1, 2, 3, 4), (2, 3, 4, 5),
@@ -145,7 +147,10 @@ def assert_garbage_collected(indexes):
     assert_garbage_collected((0, 1, 2, 3, 4, 5, 6))
         
     
-    
+def test_short_iterables():
+    assert tuple(iterate_overlapping_subsequences([1])) == ()
+    assert tuple(iterate_overlapping_subsequences([1], length=7)) == ()
+        
     
             
             
diff --git a/source_py2/test_python_toolbox/test_cute_profile/shared.py b/source_py2/test_python_toolbox/test_cute_profile/shared.py
@@ -22,7 +22,7 @@ def call_and_check_if_profiled(f):
         
     segments_found = [(segment in output) for segment in segments]
     
-    if not logic_tools.all_equal(segments_found):
+    if not logic_tools.all_equivalent(segments_found):
         raise Exception("Some segments were found, but some weren't; can't "
                         "know if this was a profiled call or not. Possibly "
                         "some of our segments are wrong.")
diff --git a/source_py2/test_python_toolbox/test_dict_tools/test_reverse.py b/source_py2/test_python_toolbox/test_dict_tools/test_reverse.py
@@ -0,0 +1,16 @@
+# Copyright 2009-2015 Ram Rachum.
+# This program is distributed under the MIT license.
+
+from python_toolbox import cute_testing
+
+from python_toolbox import dict_tools
+
+
+def test():
+    assert dict_tools.reverse({'one': 1, 'two': 2, 'three': 3}) == \
+                                               {1: 'one', 2: 'two', 3: 'three'}
+    assert dict_tools.reverse({}) == {}
+    with cute_testing.RaiseAssertor():
+        dict_tools.reverse({1: 0, 2: 0})
+    with cute_testing.RaiseAssertor():
+        dict_tools.reverse({1: []})
diff --git a/source_py2/test_python_toolbox/test_emitting/test_emitter.py b/source_py2/test_python_toolbox/test_emitting/test_emitter.py
@@ -4,9 +4,8 @@
 
 
 def test():
-    ''' '''
     emitter_1 = emitting.Emitter()
-    emitter_2 = emitting.Emitter(inputs=(emitter_1,))
+    emitter_2 = emitting.Emitter(inputs=emitter_1) # Single item without tuple
     emitter_0 = emitting.Emitter(outputs=(emitter_1,))
 
     @misc_tools.set_attributes(call_counter=0)
diff --git a/source_py2/test_python_toolbox/test_future_tools/__init__.py b/source_py2/test_python_toolbox/test_future_tools/__init__.py
diff --git a/source_py2/test_python_toolbox/test_future_tools/test_future_tools.py b/source_py2/test_python_toolbox/test_future_tools/test_future_tools.py
@@ -0,0 +1,40 @@
+# Copyright 2009-2015 Ram Rachum.
+# This program is distributed under the MIT license.
+
+import concurrent.futures
+import time
+
+from python_toolbox import future_tools
+
+
+def test():
+    
+    def sleep_and_return(seconds):
+        time.sleep(seconds)
+        return seconds
+        
+    
+    with future_tools.CuteThreadPoolExecutor(10) as executor:
+        assert isinstance(executor, future_tools.CuteThreadPoolExecutor)
+        assert tuple(executor.filter(lambda x: (x % 2 == 0), range(10))) == \
+                                                         tuple(range(0, 10, 2))
+        assert sorted(executor.filter(lambda x: (x % 2 == 0), range(10),
+                                     timeout=10**5, as_completed=True)) == \
+                                                          list(range(0, 10, 2))
+        assert tuple(executor.filter(
+            lambda x: (sleep_and_return(x) % 2 == 0), range(9, -1, -1),
+            as_completed=True)) == tuple(range(0, 10, 2))
+        
+        
+        assert tuple(executor.map(lambda x: x % 3, range(10))) == \
+                                                 (0, 1, 2, 0, 1, 2, 0, 1, 2, 0)
+        assert sorted(executor.map(lambda x: x % 3, range(10),
+                                     timeout=10**5, as_completed=True)) == \
+                                                 [0, 0, 0, 0, 1, 1, 1, 2, 2, 2]
+
+        assert tuple(executor.map(sleep_and_return, range(9, -1, -1),
+                                  as_completed=True)) == tuple(range(10))
+        
+        
+        
+        
diff --git a/source_py2/test_python_toolbox/test_logic_tools/test_all_equivalent.py b/source_py2/test_python_toolbox/test_logic_tools/test_all_equivalent.py
@@ -0,0 +1,145 @@
+# Copyright 2009-2015 Ram Rachum.
+# This program is distributed under the MIT license.
+
+import operator
+import itertools
+
+from python_toolbox.logic_tools import all_equivalent
+
+
+def test():
+    _check(False)
+    _check(True)
+
+
+def _check(assume_transitive):
+    assert all_equivalent([1, 1, 1, 1], assume_transitive=assume_transitive)
+    assert all_equivalent([1, 1, 1.0, 1], assume_transitive=assume_transitive)
+    assert all_equivalent(((1 + 0j), 1, 1.0, 1),
+                          assume_transitive=assume_transitive)
+    assert all_equivalent([], assume_transitive=assume_transitive)
+    assert all_equivalent(iter([1, 1, 1.0, 1]),
+                          assume_transitive=assume_transitive)
+    assert all_equivalent({'meow'}, assume_transitive=assume_transitive)
+    assert all_equivalent(['frr', 'frr', 'frr', 'frr'],
+                          assume_transitive=assume_transitive)
+    
+    assert not all_equivalent([1, 1, 2, 1],
+                              assume_transitive=assume_transitive)
+    assert not all_equivalent([1, 1, 1.001, 1],
+                              assume_transitive=assume_transitive)
+    assert not all_equivalent(((1 + 0j), 3, 1.0, 1),
+                              assume_transitive=assume_transitive)
+    assert not all_equivalent(range(7), assume_transitive=assume_transitive)
+    assert not all_equivalent(iter([1, 17, 1.0, 1]),
+                              assume_transitive=assume_transitive)
+    assert not all_equivalent({'meow', 'grr'},
+                              assume_transitive=assume_transitive)
+    assert not all_equivalent(['frr', 'frr', {}, 'frr', 'frr'],
+                              assume_transitive=assume_transitive)
+    assert not all_equivalent(itertools.count())
+    # Not using given `assume_transitive` flag here because `count()` is
+    # infinite.
+    
+    
+def test_assume_transitive_false():
+    '''
+    Test `all_equivalent` in cases where `assume_transitive=False` is relevant.
+    '''
+    
+    class FunkyFloat(float):
+        def __eq__(self, other):
+            return (abs(self - other) <= 2)
+        
+    funky_floats = [
+        FunkyFloat(1),
+        FunkyFloat(2),
+        FunkyFloat(3),
+        FunkyFloat(4)
+    ]
+    
+    assert all_equivalent(funky_floats)
+    assert not all_equivalent(funky_floats, assume_transitive=False)
+    
+    
+def test_all_assumptions():
+    class EquivalenceChecker:
+        pairs_checked = []
+        def __init__(self, tag):
+            self.tag = tag
+        def is_equivalent(self, other):
+            EquivalenceChecker.pairs_checked.append((self, other))
+            return True
+        def __eq__(self, other):
+            return (type(self), self.tag) == (type(other), other.tag)
+            
+    def get_pairs_for_options(**kwargs):
+        assert EquivalenceChecker.pairs_checked == []
+        # Testing with an iterator instead of the tuple to ensure it works and that
+        # the function doesn't try to exhaust it twice.
+        assert all_equivalent(iter(things), EquivalenceChecker.is_equivalent,
+                              **kwargs) is True
+        try:
+            return tuple((a.tag, b.tag) for (a, b) in
+                         EquivalenceChecker.pairs_checked)
+        finally:
+            EquivalenceChecker.pairs_checked = []
+        
+    x0 = EquivalenceChecker(0)
+    x1 = EquivalenceChecker(1)
+    x2 = EquivalenceChecker(2)
+    things = (x0, x1, x2)
+    
+    assert get_pairs_for_options(assume_reflexive=False, assume_symmetric=False,
+                                 assume_transitive=False) == (
+        (0, 1), (1, 0), (0, 2), (2, 0), (1, 2), (2, 1), (0, 0), (1, 1), (2, 2)
+    )
+    assert get_pairs_for_options(assume_reflexive=False, assume_symmetric=False,
+                                 assume_transitive=True) == (
+        (0, 1), (1, 0), (1, 2), (2, 1), (0, 0), (1, 1), (2, 2)
+    )
+    assert get_pairs_for_options(assume_reflexive=False, assume_symmetric=True,
+                                 assume_transitive=False) == (
+        (0, 1), (0, 2), (1, 2), (0, 0), (1, 1), (2, 2)
+    )
+    assert get_pairs_for_options(assume_reflexive=False, assume_symmetric=True,
+                                 assume_transitive=True) == (
+        (0, 1), (1, 2), (0, 0), (1, 1), (2, 2)
+    )
+    assert get_pairs_for_options(assume_reflexive=True, assume_symmetric=False,
+                                 assume_transitive=False) == (
+        (0, 1), (1, 0), (0, 2), (2, 0), (1, 2), (2, 1),
+    )
+    assert get_pairs_for_options(assume_reflexive=True, assume_symmetric=False,
+                                 assume_transitive=True) == (
+        (0, 1), (1, 0), (1, 2), (2, 1),
+    )
+    assert get_pairs_for_options(assume_reflexive=True, assume_symmetric=True,
+                                 assume_transitive=False) == (
+        (0, 1), (0, 2), (1, 2),
+    )
+    assert get_pairs_for_options(assume_reflexive=True, assume_symmetric=True,
+                                 assume_transitive=True) == ((0, 1), (1, 2))
+    
+                
+    
+    
+def test_custom_relations():
+    assert all_equivalent(range(4), relation=operator.ne) is True
+    assert all_equivalent(range(4), relation=operator.ge) is False
+    assert all_equivalent(range(4), relation=operator.le) is True
+    assert all_equivalent(range(4), relation=operator.le,
+                          assume_transitive=True) is True
+    # (Always comparing small to big, even on `assume_transitive=False`.)
+    
+    assert all_equivalent(range(4),
+                          relation=lambda x, y: (x // 10 == y // 10)) is True
+    assert all_equivalent(range(4),
+                          relation=lambda x, y: (x // 10 == y // 10),
+                          assume_transitive=True) is True
+    assert all_equivalent(range(8, 12), 
+                          relation=lambda x, y: (x // 10 == y // 10)) is False
+    assert all_equivalent(range(8, 12),
+                          relation=lambda x, y: (x // 10 == y // 10),
+                          assume_transitive=True) is False
+    
diff --git a/source_py2/test_python_toolbox/test_logic_tools/test_get_equivalence_classes.py b/source_py2/test_python_toolbox/test_logic_tools/test_get_equivalence_classes.py
@@ -3,6 +3,7 @@
 
 import itertools
 
+from python_toolbox import nifty_collections
 from python_toolbox.logic_tools import get_equivalence_classes
 
 
@@ -15,4 +16,56 @@ def test():
         abs(1 + 1j): {1 + 1j},
         abs(2 + 2j): {2 + 2j},
         abs(3 + 3j): {3 + 3j},
-    }
+    }
+
+    assert get_equivalence_classes({1: 2, 3: 4, 'meow': 2}) == \
+                                                       {2: {1, 'meow'}, 4: {3}}
+    
+def test_iterable_input():
+    assert get_equivalence_classes(range(1, 5), str) == \
+                                 {'1': {1}, '2': {2}, '3': {3}, '4': {4},}
+    
+    assert get_equivalence_classes([1, 2+3j, 4, 5-6j], 'imag') \
+                                          == {0: {1, 4}, 3: {2+3j}, -6: {5-6j}}
+    
+    
+def test_ordered_dict_output():
+    # Insertion order:
+    
+    assert get_equivalence_classes(
+        nifty_collections.OrderedDict(((1, 2), (3, 4), ('meow', 2))),
+        use_ordered_dict=True) == \
+    nifty_collections.OrderedDict([(2, {1, 'meow'}), (4, {3})])
+    
+    assert get_equivalence_classes(
+        nifty_collections.OrderedDict((('meow', 2), (1, 2), (3, 4))),
+        use_ordered_dict=True) == \
+    nifty_collections.OrderedDict([(2, {1, 'meow'}), (4, {3})])
+    
+    assert get_equivalence_classes(
+        nifty_collections.OrderedDict(((3, 4), (1, 2), ('meow', 2))),
+        use_ordered_dict=True) == \
+    nifty_collections.OrderedDict([(4, {3}), (2, {1, 'meow'})])
+    
+    assert get_equivalence_classes(
+        nifty_collections.OrderedDict(((1, 2), (3, 4), ('meow', 2))),
+        container=tuple, 
+        use_ordered_dict=True) == \
+    nifty_collections.OrderedDict([(2, (1, 'meow')), (4, (3,))])
+    
+    assert get_equivalence_classes(
+        nifty_collections.OrderedDict((('meow', 2), (1, 2), (3, 4))),
+        container=tuple, 
+        use_ordered_dict=True) == \
+    nifty_collections.OrderedDict([(2, ('meow', 1)), (4, (3,))])
+    
+    # Sorting:
+    
+    assert get_equivalence_classes({1: 2, 3: 4, 'meow': 2},
+                                                   sort_ordered_dict=True) == \
+    nifty_collections.OrderedDict([(2, {1, 'meow'}), (4, {3})])
+    
+    assert get_equivalence_classes({1: 2, 3: 4, 'meow': 2},
+                                           sort_ordered_dict=lambda x: -x) == \
+    nifty_collections.OrderedDict([(4, {3}), (2, {1, 'meow'})])
+    
diff --git a/source_py2/test_python_toolbox/test_math_tools/test_cute_floor_div_and_divmod.py b/source_py2/test_python_toolbox/test_math_tools/test_cute_floor_div_and_divmod.py
@@ -23,7 +23,7 @@ def cute_equal(*items):
     # For testing purposes, we need `nan == nan`, so we use `cute_equal`.
     if all(isinstance(item, numbers.Number) for item in items):
         if all(map(math.isnan, items)): return True
-        else: return logic_tools.all_equal(items)
+        else: return logic_tools.all_equivalent(items)
     else:
         assert all(isinstance(item, tuple) for item in items)
         return all(cute_equal(*sub_items) for sub_items in zip(*items))
@@ -54,13 +54,16 @@ def test_illegal_cases():
             divmod(*illegal_case)
         with cute_testing.RaiseAssertor() as raise_assertor_2:
             cute_floor_div(*illegal_case)
-        assert logic_tools.all_equal((
+        assert logic_tools.all_equivalent((
             type(raise_assertor_0.exception),
             type(raise_assertor_1.exception),
             type(raise_assertor_2.exception),
         ))
-        # (I once had asserts here for exception messages being equal, but it
-        # failed in Pypy so I removed them.)
+        assert logic_tools.all_equivalent((
+            raise_assertor_0.exception.args,
+            raise_assertor_1.exception.args,
+            raise_assertor_2.exception.args,
+        ))
     
         
 def test_meaningful_cases():
diff --git a/source_py2/test_python_toolbox/test_misc_tools/test_name_mangling/test_pocket.py b/source_py2/test_python_toolbox/test_misc_tools/test_name_mangling/test_pocket.py
diff --git a/source_py2/test_python_toolbox/test_misc_tools/test_non_instantiable.py b/source_py2/test_python_toolbox/test_misc_tools/test_non_instantiable.py
diff --git a/source_py2/test_python_toolbox/test_misc_tools/test_overridable_property.py b/source_py2/test_python_toolbox/test_misc_tools/test_overridable_property.py
diff --git a/source_py3/test_python_toolbox/test_dict_tools/test_devour_items.py b/source_py3/test_python_toolbox/test_dict_tools/test_devour_items.py
diff --git a/source_py3/test_python_toolbox/test_dict_tools/test_reverse.py b/source_py3/test_python_toolbox/test_dict_tools/test_reverse.py
