Set literals

cool-RR · cool-RR · commit cf8f93b49c8a · 2013-10-05T00:49:43.000+03:00
diff --git a/source_py2/python_toolbox/arguments_profile.py b/source_py2/python_toolbox/arguments_profile.py
@@ -161,10 +161,10 @@ def __init__(self, function, *args, **kwargs):
         # `dict` that maps from argument name to default value:
         defaults = OrderedDict(zip(defaultful_args, s_defaults))
         
-        defaultful_args_differing_from_defaults = set((
+        defaultful_args_differing_from_defaults = {
             defaultful_arg for defaultful_arg in defaultful_args
             if defaults[defaultful_arg] != getcallargs_result[defaultful_arg]
-        ))
+        }
         
         if s_star_args and getcallargs_result[s_star_args]:
             # We have some arguments that go into `*args`! This means that we
diff --git a/source_py2/python_toolbox/dict_tools.py b/source_py2/python_toolbox/dict_tools.py
@@ -70,7 +70,7 @@ def reverse_with_set_values(d, sort=False):
     Example:
     
         reverse_with_set_values({1: 2, 3: 4, 'meow': 2}) == \
-            {2: set([1, 'meow']), 4: set([3])}
+                                                       {2: {1, 'meow'}, 4: {3}}
             
     Instead of a dict you may also input a tuple in which the first item is an
     iterable and the second item is either a key function or an attribute name.
diff --git a/source_py2/python_toolbox/emitting/emitter.py b/source_py2/python_toolbox/emitting/emitter.py
@@ -240,9 +240,7 @@ def _get_callable_outputs(self):
     
     def _get_emitter_outputs(self):
         '''Get the direct emitter outputs of this emitter.'''
-        return set((
-            output for output in self._outputs if isinstance(output, Emitter)
-        ))
+        return {output for output in self._outputs if isinstance(output, Emitter)}
         
     def get_total_callable_outputs(self):
         '''
diff --git a/source_py2/python_toolbox/misc_tools/name_mangling.py b/source_py2/python_toolbox/misc_tools/name_mangling.py
@@ -14,7 +14,7 @@ def mangle_attribute_name_if_needed(attribute_name, class_name):
     if ((not attribute_name.startswith('__')) or
         (len(attribute_name) + 2 >= MANGLE_LEN) or
         (attribute_name.endswith('__')) or
-        set(class_name) == set('_')):
+        set(class_name) == {'_'}):
         
         return attribute_name
     
diff --git a/source_py2/test_python_toolbox/test_arguments_profile.py b/source_py2/test_python_toolbox/test_arguments_profile.py
@@ -459,9 +459,9 @@ def func(a, b, c=3, d=4, **kwargs):
     assert not a1.kwargs
     hash(a1)
     
-    a2 = ArgumentsProfile(func, 7, ({'a': 'b'},), set([1, (3, 4)]),
+    a2 = ArgumentsProfile(func, 7, ({'a': 'b'},), {1, (3, 4)},
                           meow=[1, 2, {1: [1, 2]}])
-    assert a2.args == (7, ({'a': 'b'},), set([1, (3, 4)]))
+    assert a2.args == (7, ({'a': 'b'},), {1, (3, 4)})
     assert a2.kwargs == OrderedDict(
         (('meow', [1, 2, {1: [1, 2]}]),)
     )
@@ -477,17 +477,17 @@ def test_unhashable_star_empty():
     def func(a, b, c=3, d=4, **kwargs):
         pass
         
-    a2 = ArgumentsProfile(func, 7, ({'a': 'b'},), set([1, (3, 4)]),
+    a2 = ArgumentsProfile(func, 7, ({'a': 'b'},), {1, (3, 4)},
                           meow=[1, 2, {1: [1, 2]}])
-    assert a2.args == (7, ({'a': 'b'},), set([1, (3, 4)]))
+    assert a2.args == (7, ({'a': 'b'},), {1, (3, 4)})
     assert a2.kwargs == OrderedDict(
         (('meow', [1, 2, {1: [1, 2]}]),)
     )
     
     a3 = ArgumentsProfile(func, *(), b=({'a': 'b'},),
-                          c=set([1, (3, 4)]), a=7,
+                          c={1, (3, 4)}, a=7,
                           meow=[1, 2, {1: [1, 2]}])
-    assert a3.args == (7, ({'a': 'b'},), set([1, (3, 4)]))
+    assert a3.args == (7, ({'a': 'b'},), {1, (3, 4)})
     assert a3.kwargs == OrderedDict(
         (('meow', [1, 2, {1: [1, 2]}]),)
     )
diff --git a/source_py2/test_python_toolbox/test_caching/test_cache.py b/source_py2/test_python_toolbox/test_caching/test_cache.py
@@ -114,7 +114,7 @@ def test_unhashable_arguments():
     
     f = cache()(counting_func)
     
-    x = set((1, 2))
+    x = {1, 2}
     
     assert f(x) == f(x)
     
diff --git a/source_py2/test_python_toolbox/test_cheat_hashing.py b/source_py2/test_python_toolbox/test_cheat_hashing.py
@@ -18,7 +18,7 @@ def test_cheat_hash():
         [1, 2, 3.4],
         (1, 2, 3.4),
         {1: 2, 3: 4.5},
-        set((1, 2, 3.4)),
+        {1, 2, 3.4},
         [1, [1, 2], 3],
         [1, {frozenset((1, 2)): 'meow'}, 3],
         sum,
diff --git a/source_py2/test_python_toolbox/test_context_management/test_reentrant_context_manager.py b/source_py2/test_python_toolbox/test_context_management/test_reentrant_context_manager.py
@@ -109,7 +109,7 @@ def reentrant_exit(self, exc_type, exc_value, exc_traceback):
                 my_set.add(6)
             my_set.add(7)
         my_set.add(8)
-    assert my_set == set([0, 1, 2, 3, 4])
+    assert my_set == {0, 1, 2, 3, 4}
         
 
         
diff --git a/source_py2/test_python_toolbox/test_cute_profile/test_cute_profile.py b/source_py2/test_python_toolbox/test_cute_profile/test_cute_profile.py
@@ -18,7 +18,7 @@
 def func(x, y, z=3):
     '''Function that does some meaningless number-juggling.'''
     sum([1, 2, 3])
-    set([1, 2]) | set([2, 3])
+    {1, 2} | {2, 3}
     return x, y, z
 
 
diff --git a/source_py2/test_python_toolbox/test_dict_tools/test_devour_items.py b/source_py2/test_python_toolbox/test_dict_tools/test_devour_items.py
@@ -9,7 +9,6 @@
 def test():
     '''Test the basic workings of `devour_items`.'''
     my_dict = {1: 2, 3: 4, 5: 6,}
-    assert set(dict_tools.devour_items(my_dict)) == set(((1, 2), (3, 4),
-                                                         (5, 6)))
+    assert set(dict_tools.devour_items(my_dict)) == {(1, 2), (3, 4), (5, 6)}
     assert not my_dict
     
diff --git a/source_py2/test_python_toolbox/test_dict_tools/test_devour_keys.py b/source_py2/test_python_toolbox/test_dict_tools/test_devour_keys.py
@@ -9,6 +9,6 @@
 def test():
     '''Test the basic workings of `devour_keys`.'''
     my_dict = {1: 2, 3: 4, 5: 6,}
-    assert set(dict_tools.devour_keys(my_dict)) == set((1, 3, 5))
+    assert set(dict_tools.devour_keys(my_dict)) == {1, 3, 5}
     assert not my_dict
     
diff --git a/source_py2/test_python_toolbox/test_dict_tools/test_remove_keys.py b/source_py2/test_python_toolbox/test_dict_tools/test_remove_keys.py
@@ -23,8 +23,7 @@ class HoledNumbersContainer(object):
         def __contains__(self, number):
             if not isinstance(number, numbers.Integral):
                 return False
-            return bool(set(str(number)).intersection(set(('0', '4', '6', '8',
-                                                           '9'))))
+            return bool(set(str(number)).intersection({'0', '4', '6', '8', '9'}))
             
     
     non_holed_numbers_dict = dict(origin_dict)
diff --git a/source_py2/test_python_toolbox/test_dict_tools/test_reverse_with_set_values.py b/source_py2/test_python_toolbox/test_dict_tools/test_reverse_with_set_values.py
@@ -10,22 +10,22 @@
 def test():
     '''Test the basic workings of `reverse_with_set_values`.'''
     assert dict_tools.reverse_with_set_values({1: 2, 3: 4, 'meow': 2}) == \
-                                             {2: set([1, 'meow']), 4: set([3])}
+                                                       {2: {1, 'meow'}, 4: {3}}
     
 def test_iterable_input():
     assert dict_tools.reverse_with_set_values((range(1, 5), str)) == \
-        {'1': set([1]), '2': set([2]), '3': set([3]), '4': set([4]),}
+                                 {'1': {1}, '2': {2}, '3': {3}, '4': {4},}
     
     assert dict_tools.reverse_with_set_values(([1, 2+3j, 4, 5-6j], 'imag')) \
-                           == {0: set([1, 4]), 3: set([2+3j]), -6: set([5-6j])}
+                                          == {0: {1, 4}, 3: {2+3j}, -6: {5-6j}}
     
     
 def test_ordered_dict_output():
     assert dict_tools.reverse_with_set_values({1: 2, 3: 4, 'meow': 2},
                                               sort=True) == \
-    nifty_collections.OrderedDict([(2, set([1, 'meow'])), (4, set([3]))])
+    nifty_collections.OrderedDict([(2, {1, 'meow'}), (4, {3})])
     
     assert dict_tools.reverse_with_set_values({1: 2, 3: 4, 'meow': 2},
                                               sort=lambda x: -x) == \
-    nifty_collections.OrderedDict([(4, set([3])), (2, set([1, 'meow']))])
+    nifty_collections.OrderedDict([(4, {3}), (2, {1, 'meow'})])
     
diff --git a/source_py2/test_python_toolbox/test_logic_tools/test_all_equal.py b/source_py2/test_python_toolbox/test_logic_tools/test_all_equal.py
@@ -21,15 +21,15 @@ def _check(exhaustive):
     assert all_equal(((1 + 0j), 1, 1.0, 1), exhaustive)
     assert all_equal([], exhaustive)
     assert all_equal(iter([1, 1, 1.0, 1]), exhaustive)
-    assert all_equal(set(['meow']), exhaustive)
+    assert all_equal({'meow'}, exhaustive)
     assert all_equal(['frr', 'frr', 'frr', 'frr'], exhaustive)
     
     assert not all_equal([1, 1, 2, 1], exhaustive)
     assert not all_equal([1, 1, 1.001, 1], exhaustive)
     assert not all_equal(((1 + 0j), 3, 1.0, 1), exhaustive)
     assert not all_equal(range(7), exhaustive)
     assert not all_equal(iter([1, 17, 1.0, 1]), exhaustive)
-    assert not all_equal(set(['meow', 'grr']), exhaustive)
+    assert not all_equal({'meow', 'grr'}, exhaustive)
     assert not all_equal(['frr', 'frr', {}, 'frr', 'frr'], exhaustive)
     assert not all_equal(itertools.count()) # Not using given `exhaustive`
                                             # flag here because `count()` is
diff --git a/source_py2/test_python_toolbox/test_nifty_collections/test_weak_key_default_dict/test.py b/source_py2/test_python_toolbox/test_nifty_collections/test_weak_key_default_dict/test.py
@@ -42,10 +42,9 @@ def test():
     )
     
     assert set(wkd_dict.iterkeys()) == set(wkd_dict.keys()) == \
-           set((ref() for ref in wkd_dict.iterkeyrefs())) == \
-           set((ref() for ref in wkd_dict.keyrefs())) == \
-           set((weakreffable_object_0, weakreffable_object_1,
-                weakreffable_object_2))
+           {ref() for ref in wkd_dict.iterkeyrefs()} == \
+           {ref() for ref in wkd_dict.keyrefs()} == \
+           {weakreffable_object_0, weakreffable_object_1, weakreffable_object_2}
     
     weakreffable_object_3 = WeakreffableObject()
     wkd_dict[weakreffable_object_3] = 123
diff --git a/source_py2/test_python_toolbox/test_pickle_tools/test_compressing.py b/source_py2/test_python_toolbox/test_pickle_tools/test_compressing.py
@@ -16,7 +16,7 @@
 my_messy_object = (
     'Whatever',
     {1: 2,}, 
-    set([3, 4]), 
+    {3, 4}, 
     frozenset([3, 4]),
     ((((((((((((())))))))))))),
     u'unicode_too',
diff --git a/source_py2/test_python_toolbox/test_sleek_reffing/test_cute_sleek_value_dict/tests.py b/source_py2/test_python_toolbox/test_sleek_reffing/test_cute_sleek_value_dict/tests.py
@@ -19,7 +19,7 @@
 def test():
     '''Test the basic workings of `CuteSleekValueDict`.'''
     volatile_things = [A(), 1, 4.5, 'meow', u'woof', [1, 2], (1, 2), {1: 2},
-                       set([1, 2, 3])]
+                       {1, 2, 3}]
     unvolatile_things = [__builtins__, list, type, sum]
     
     # Using len(csvd) as our key; just to guarantee we're not running over an
@@ -56,7 +56,7 @@ def test():
         
 def test_one_by_one():
     volatile_things = [A(), 1, 4.5, 'meow', u'woof', [1, 2], (1, 2), {1: 2},
-                       set([1, 2, 3])]
+                       {1, 2, 3}]
     unvolatile_things = [__builtins__, list, type, sum]
     
     # Using len(csvd) as our key; just to guarantee we're not running over an
diff --git a/source_py2/test_python_toolbox/test_sleek_reffing/test_sleek_call_args.py b/source_py2/test_python_toolbox/test_sleek_reffing/test_sleek_call_args.py
@@ -39,7 +39,7 @@ def test_unhashable():
     '''Test `SleekCallArgs` on unhashable arguments.'''
     sca_dict = {}
     
-    args = ([1, 2], {1: [1, 2]}, set(['a', 1]))
+    args = ([1, 2], {1: [1, 2]}, {'a', 1})
     sca1 = SleekCallArgs(sca_dict, f, *args)
     hash(sca1)
     sca_dict[sca1] = 'meow'
@@ -52,11 +52,7 @@ def test_unhashable():
         'a': {1: 2},
         'b': [
             set(),
-            set(
-                (
-                    frozenset((3, 4)),
-                )
-            )
+            {frozenset((3, 4))}
         ]
     }
     sca2 = SleekCallArgs(sca_dict, f, **kwargs)
diff --git a/source_py2/test_python_toolbox/test_sleek_reffing/test_sleek_ref.py b/source_py2/test_python_toolbox/test_sleek_reffing/test_sleek_ref.py
@@ -21,7 +21,7 @@ def test_sleek_ref():
     '''Test the basic workings of `SleekRef`.'''
 
     volatile_things = [A(), 1, 4.5, 'meow', u'woof', [1, 2], (1, 2), {1: 2},
-                       set([1, 2, 3]), (None, 3, {None: 4})]
+                       {1, 2, 3}, (None, 3, {None: 4})]
     unvolatile_things = [__builtins__, type, sum, None]
     # (Used to have `list` here too but Pypy 2.0b choked on it.)
     
diff --git a/source_py2/test_python_toolbox/test_string_cataloging/test.py b/source_py2/test_python_toolbox/test_string_cataloging/test.py
@@ -13,5 +13,5 @@ def test():
     assert string_cataloging.integer_to_string(y) == 'zwei'
     assert string_cataloging.integer_to_string(z) == 'drei'
     
-    assert set([string_cataloging.string_to_integer('zwei') for
-                i in range(10)]) == set([y])
+    assert {string_cataloging.string_to_integer('zwei') for i in range(10)} \
+                                                                         == {y}
