taskflow 5.11.0__py3-none-any.whl → 6.0.0__py3-none-any.whl

taskflow/tests/unit/test_flow_dependencies.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 #    Copyright (C) 2012 Yahoo! Inc. All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -32,28 +30,28 @@ class FlowDependenciesTest(test.TestCase):
 
     def test_task_requires_default_values(self):
         flow = utils.TaskMultiArg()
-        self.assertEqual(set(['x', 'y', 'z']), flow.requires)
+        self.assertEqual({'x', 'y', 'z'}, flow.requires)
         self.assertEqual(set(), flow.provides, )
 
     def test_task_requires_rebinded_mapped(self):
         flow = utils.TaskMultiArg(rebind={'x': 'a', 'y': 'b', 'z': 'c'})
-        self.assertEqual(set(['a', 'b', 'c']), flow.requires)
+        self.assertEqual({'a', 'b', 'c'}, flow.requires)
         self.assertEqual(set(), flow.provides)
 
     def test_task_requires_additional_values(self):
         flow = utils.TaskMultiArg(requires=['a', 'b'])
-        self.assertEqual(set(['a', 'b', 'x', 'y', 'z']), flow.requires)
+        self.assertEqual({'a', 'b', 'x', 'y', 'z'}, flow.requires)
         self.assertEqual(set(), flow.provides)
 
     def test_task_provides_values(self):
         flow = utils.TaskMultiReturn(provides=['a', 'b', 'c'])
         self.assertEqual(set(), flow.requires)
-        self.assertEqual(set(['a', 'b', 'c']), flow.provides)
+        self.assertEqual({'a', 'b', 'c'}, flow.provides)
 
     def test_task_provides_and_requires_values(self):
         flow = utils.TaskMultiArgMultiReturn(provides=['a', 'b', 'c'])
-        self.assertEqual(set(['x', 'y', 'z']), flow.requires)
-        self.assertEqual(set(['a', 'b', 'c']), flow.provides)
+        self.assertEqual({'x', 'y', 'z'}, flow.requires)
+        self.assertEqual({'a', 'b', 'c'}, flow.provides)
 
     def test_linear_flow_without_dependencies(self):
         flow = lf.Flow('lf').add(
@@ -66,14 +64,14 @@ class FlowDependenciesTest(test.TestCase):
         flow = lf.Flow('lf').add(
             utils.TaskOneArg('task1'),
             utils.TaskMultiArg('task2'))
-        self.assertEqual(set(['x', 'y', 'z']), flow.requires)
+        self.assertEqual({'x', 'y', 'z'}, flow.requires)
         self.assertEqual(set(), flow.provides)
 
     def test_linear_flow_requires_rebind_values(self):
         flow = lf.Flow('lf').add(
             utils.TaskOneArg('task1', rebind=['q']),
             utils.TaskMultiArg('task2'))
-        self.assertEqual(set(['x', 'y', 'z', 'q']), flow.requires)
+        self.assertEqual({'x', 'y', 'z', 'q'}, flow.requires)
         self.assertEqual(set(), flow.provides)
 
     def test_linear_flow_provides_values(self):
@@ -81,14 +79,14 @@ class FlowDependenciesTest(test.TestCase):
             utils.TaskOneReturn('task1', provides='x'),
             utils.TaskMultiReturn('task2', provides=['a', 'b', 'c']))
         self.assertEqual(set(), flow.requires)
-        self.assertEqual(set(['x', 'a', 'b', 'c']), flow.provides)
+        self.assertEqual({'x', 'a', 'b', 'c'}, flow.provides)
 
     def test_linear_flow_provides_required_values(self):
         flow = lf.Flow('lf').add(
             utils.TaskOneReturn('task1', provides='x'),
             utils.TaskOneArg('task2'))
         self.assertEqual(set(), flow.requires)
-        self.assertEqual(set(['x']), flow.provides)
+        self.assertEqual({'x'}, flow.provides)
 
     def test_linear_flow_multi_provides_and_requires_values(self):
         flow = lf.Flow('lf').add(
@@ -97,8 +95,8 @@ class FlowDependenciesTest(test.TestCase):
                                           provides=['x', 'y', 'q']),
             utils.TaskMultiArgMultiReturn('task2',
                                           provides=['i', 'j', 'k']))
-        self.assertEqual(set(['a', 'b', 'c', 'z']), flow.requires)
-        self.assertEqual(set(['x', 'y', 'q', 'i', 'j', 'k']), flow.provides)
+        self.assertEqual({'a', 'b', 'c', 'z'}, flow.requires)
+        self.assertEqual({'x', 'y', 'q', 'i', 'j', 'k'}, flow.provides)
 
     def test_unordered_flow_without_dependencies(self):
         flow = uf.Flow('uf').add(
@@ -111,14 +109,14 @@ class FlowDependenciesTest(test.TestCase):
         flow = uf.Flow('uf').add(
             utils.TaskOneArg('task1'),
             utils.TaskMultiArg('task2'))
-        self.assertEqual(set(['x', 'y', 'z']), flow.requires)
+        self.assertEqual({'x', 'y', 'z'}, flow.requires)
         self.assertEqual(set(), flow.provides)
 
     def test_unordered_flow_requires_rebind_values(self):
         flow = uf.Flow('uf').add(
             utils.TaskOneArg('task1', rebind=['q']),
             utils.TaskMultiArg('task2'))
-        self.assertEqual(set(['x', 'y', 'z', 'q']), flow.requires)
+        self.assertEqual({'x', 'y', 'z', 'q'}, flow.requires)
         self.assertEqual(set(), flow.provides)
 
     def test_unordered_flow_provides_values(self):
@@ -126,7 +124,7 @@ class FlowDependenciesTest(test.TestCase):
             utils.TaskOneReturn('task1', provides='x'),
             utils.TaskMultiReturn('task2', provides=['a', 'b', 'c']))
         self.assertEqual(set(), flow.requires)
-        self.assertEqual(set(['x', 'a', 'b', 'c']), flow.provides)
+        self.assertEqual({'x', 'a', 'b', 'c'}, flow.provides)
 
     def test_unordered_flow_provides_required_values(self):
         flow = uf.Flow('uf')
@@ -134,23 +132,23 @@ class FlowDependenciesTest(test.TestCase):
                  utils.TaskOneArg('task2'))
         flow.add(utils.TaskOneReturn('task1', provides='x'),
                  utils.TaskOneArg('task2'))
-        self.assertEqual(set(['x']), flow.provides)
-        self.assertEqual(set(['x']), flow.requires)
+        self.assertEqual({'x'}, flow.provides)
+        self.assertEqual({'x'}, flow.requires)
 
     def test_unordered_flow_requires_provided_value_other_call(self):
         flow = uf.Flow('uf')
         flow.add(utils.TaskOneReturn('task1', provides='x'))
         flow.add(utils.TaskOneArg('task2'))
-        self.assertEqual(set(['x']), flow.provides)
-        self.assertEqual(set(['x']), flow.requires)
+        self.assertEqual({'x'}, flow.provides)
+        self.assertEqual({'x'}, flow.requires)
 
     def test_unordered_flow_provides_required_value_other_call(self):
         flow = uf.Flow('uf')
         flow.add(utils.TaskOneArg('task2'))
         flow.add(utils.TaskOneReturn('task1', provides='x'))
         self.assertEqual(2, len(flow))
-        self.assertEqual(set(['x']), flow.provides)
-        self.assertEqual(set(['x']), flow.requires)
+        self.assertEqual({'x'}, flow.provides)
+        self.assertEqual({'x'}, flow.requires)
 
     def test_unordered_flow_multi_provides_and_requires_values(self):
         flow = uf.Flow('uf').add(
@@ -159,19 +157,19 @@ class FlowDependenciesTest(test.TestCase):
                                           provides=['d', 'e', 'f']),
             utils.TaskMultiArgMultiReturn('task2',
                                           provides=['i', 'j', 'k']))
-        self.assertEqual(set(['a', 'b', 'c', 'x', 'y', 'z']), flow.requires)
-        self.assertEqual(set(['d', 'e', 'f', 'i', 'j', 'k']), flow.provides)
+        self.assertEqual({'a', 'b', 'c', 'x', 'y', 'z'}, flow.requires)
+        self.assertEqual({'d', 'e', 'f', 'i', 'j', 'k'}, flow.provides)
 
     def test_unordered_flow_provides_same_values(self):
         flow = uf.Flow('uf').add(utils.TaskOneReturn(provides='x'))
         flow.add(utils.TaskOneReturn(provides='x'))
-        self.assertEqual(set(['x']), flow.provides)
+        self.assertEqual({'x'}, flow.provides)
 
     def test_unordered_flow_provides_same_values_one_add(self):
         flow = uf.Flow('uf')
         flow.add(utils.TaskOneReturn(provides='x'),
                  utils.TaskOneReturn(provides='x'))
-        self.assertEqual(set(['x']), flow.provides)
+        self.assertEqual({'x'}, flow.provides)
 
     def test_nested_flows_requirements(self):
         flow = uf.Flow('uf').add(
@@ -184,21 +182,21 @@ class FlowDependenciesTest(test.TestCase):
                                           rebind=['b'], provides=['z']),
                 utils.TaskOneArgOneReturn('task4', rebind=['c'],
                                           provides=['q'])))
-        self.assertEqual(set(['a', 'b', 'c']), flow.requires)
-        self.assertEqual(set(['x', 'y', 'z', 'q']), flow.provides)
+        self.assertEqual({'a', 'b', 'c'}, flow.requires)
+        self.assertEqual({'x', 'y', 'z', 'q'}, flow.provides)
 
     def test_graph_flow_requires_values(self):
         flow = gf.Flow('gf').add(
             utils.TaskOneArg('task1'),
             utils.TaskMultiArg('task2'))
-        self.assertEqual(set(['x', 'y', 'z']), flow.requires)
+        self.assertEqual({'x', 'y', 'z'}, flow.requires)
         self.assertEqual(set(), flow.provides)
 
     def test_graph_flow_requires_rebind_values(self):
         flow = gf.Flow('gf').add(
             utils.TaskOneArg('task1', rebind=['q']),
             utils.TaskMultiArg('task2'))
-        self.assertEqual(set(['x', 'y', 'z', 'q']), flow.requires)
+        self.assertEqual({'x', 'y', 'z', 'q'}, flow.requires)
         self.assertEqual(set(), flow.provides)
 
     def test_graph_flow_provides_values(self):
@@ -206,20 +204,20 @@ class FlowDependenciesTest(test.TestCase):
             utils.TaskOneReturn('task1', provides='x'),
             utils.TaskMultiReturn('task2', provides=['a', 'b', 'c']))
         self.assertEqual(set(), flow.requires)
-        self.assertEqual(set(['x', 'a', 'b', 'c']), flow.provides)
+        self.assertEqual({'x', 'a', 'b', 'c'}, flow.provides)
 
     def test_graph_flow_provides_required_values(self):
         flow = gf.Flow('gf').add(
             utils.TaskOneReturn('task1', provides='x'),
             utils.TaskOneArg('task2'))
         self.assertEqual(set(), flow.requires)
-        self.assertEqual(set(['x']), flow.provides)
+        self.assertEqual({'x'}, flow.provides)
 
     def test_graph_flow_provides_provided_value_other_call(self):
         flow = gf.Flow('gf')
         flow.add(utils.TaskOneReturn('task1', provides='x'))
         flow.add(utils.TaskOneReturn('task2', provides='x'))
-        self.assertEqual(set(['x']), flow.provides)
+        self.assertEqual({'x'}, flow.provides)
 
     def test_graph_flow_multi_provides_and_requires_values(self):
         flow = gf.Flow('gf').add(
@@ -228,8 +226,8 @@ class FlowDependenciesTest(test.TestCase):
                                           provides=['d', 'e', 'f']),
             utils.TaskMultiArgMultiReturn('task2',
                                           provides=['i', 'j', 'k']))
-        self.assertEqual(set(['a', 'b', 'c', 'x', 'y', 'z']), flow.requires)
-        self.assertEqual(set(['d', 'e', 'f', 'i', 'j', 'k']), flow.provides)
+        self.assertEqual({'a', 'b', 'c', 'x', 'y', 'z'}, flow.requires)
+        self.assertEqual({'d', 'e', 'f', 'i', 'j', 'k'}, flow.provides)
 
     def test_graph_cyclic_dependency(self):
         flow = gf.Flow('g-3-cyclic')
@@ -255,27 +253,27 @@ class FlowDependenciesTest(test.TestCase):
 
     def test_retry_in_linear_flow_with_requirements(self):
         flow = lf.Flow('lf', retry.AlwaysRevert('rt', requires=['x', 'y']))
-        self.assertEqual(set(['x', 'y']), flow.requires)
+        self.assertEqual({'x', 'y'}, flow.requires)
         self.assertEqual(set(), flow.provides)
 
     def test_retry_in_linear_flow_with_provides(self):
         flow = lf.Flow('lf', retry.AlwaysRevert('rt', provides=['x', 'y']))
         self.assertEqual(set(), flow.requires)
-        self.assertEqual(set(['x', 'y']), flow.provides)
+        self.assertEqual({'x', 'y'}, flow.provides)
 
     def test_retry_in_linear_flow_requires_and_provides(self):
         flow = lf.Flow('lf', retry.AlwaysRevert('rt',
                                                 requires=['x', 'y'],
                                                 provides=['a', 'b']))
-        self.assertEqual(set(['x', 'y']), flow.requires)
-        self.assertEqual(set(['a', 'b']), flow.provides)
+        self.assertEqual({'x', 'y'}, flow.requires)
+        self.assertEqual({'a', 'b'}, flow.provides)
 
     def test_retry_requires_and_provides_same_value(self):
         flow = lf.Flow('lf', retry.AlwaysRevert('rt',
                                                 requires=['x', 'y'],
                                                 provides=['x', 'y']))
-        self.assertEqual(set(['x', 'y']), flow.requires)
-        self.assertEqual(set(['x', 'y']), flow.provides)
+        self.assertEqual({'x', 'y'}, flow.requires)
+        self.assertEqual({'x', 'y'}, flow.provides)
 
     def test_retry_in_unordered_flow_no_requirements_no_provides(self):
         flow = uf.Flow('uf', retry.AlwaysRevert('rt'))
@@ -284,20 +282,20 @@ class FlowDependenciesTest(test.TestCase):
 
     def test_retry_in_unordered_flow_with_requirements(self):
         flow = uf.Flow('uf', retry.AlwaysRevert('rt', requires=['x', 'y']))
-        self.assertEqual(set(['x', 'y']), flow.requires)
+        self.assertEqual({'x', 'y'}, flow.requires)
         self.assertEqual(set(), flow.provides)
 
     def test_retry_in_unordered_flow_with_provides(self):
         flow = uf.Flow('uf', retry.AlwaysRevert('rt', provides=['x', 'y']))
         self.assertEqual(set(), flow.requires)
-        self.assertEqual(set(['x', 'y']), flow.provides)
+        self.assertEqual({'x', 'y'}, flow.provides)
 
     def test_retry_in_unordered_flow_requires_and_provides(self):
         flow = uf.Flow('uf', retry.AlwaysRevert('rt',
                                                 requires=['x', 'y'],
                                                 provides=['a', 'b']))
-        self.assertEqual(set(['x', 'y']), flow.requires)
-        self.assertEqual(set(['a', 'b']), flow.provides)
+        self.assertEqual({'x', 'y'}, flow.requires)
+        self.assertEqual({'a', 'b'}, flow.provides)
 
     def test_retry_in_graph_flow_no_requirements_no_provides(self):
         flow = gf.Flow('gf', retry.AlwaysRevert('rt'))
@@ -306,20 +304,20 @@ class FlowDependenciesTest(test.TestCase):
 
     def test_retry_in_graph_flow_with_requirements(self):
         flow = gf.Flow('gf', retry.AlwaysRevert('rt', requires=['x', 'y']))
-        self.assertEqual(set(['x', 'y']), flow.requires)
+        self.assertEqual({'x', 'y'}, flow.requires)
         self.assertEqual(set(), flow.provides)
 
     def test_retry_in_graph_flow_with_provides(self):
         flow = gf.Flow('gf', retry.AlwaysRevert('rt', provides=['x', 'y']))
         self.assertEqual(set(), flow.requires)
-        self.assertEqual(set(['x', 'y']), flow.provides)
+        self.assertEqual({'x', 'y'}, flow.provides)
 
     def test_retry_in_graph_flow_requires_and_provides(self):
         flow = gf.Flow('gf', retry.AlwaysRevert('rt',
                                                 requires=['x', 'y'],
                                                 provides=['a', 'b']))
-        self.assertEqual(set(['x', 'y']), flow.requires)
-        self.assertEqual(set(['a', 'b']), flow.provides)
+        self.assertEqual({'x', 'y'}, flow.requires)
+        self.assertEqual({'a', 'b'}, flow.provides)
 
     def test_linear_flow_retry_and_task(self):
         flow = lf.Flow('lf', retry.AlwaysRevert('rt',
@@ -328,8 +326,8 @@ class FlowDependenciesTest(test.TestCase):
         flow.add(utils.TaskMultiArgOneReturn(rebind=['a', 'x', 'c'],
                                              provides=['z']))
 
-        self.assertEqual(set(['x', 'y', 'c']), flow.requires)
-        self.assertEqual(set(['a', 'b', 'z']), flow.provides)
+        self.assertEqual({'x', 'y', 'c'}, flow.requires)
+        self.assertEqual({'a', 'b', 'z'}, flow.provides)
 
     def test_unordered_flow_retry_and_task(self):
         flow = uf.Flow('uf', retry.AlwaysRevert('rt',
@@ -338,25 +336,25 @@ class FlowDependenciesTest(test.TestCase):
         flow.add(utils.TaskMultiArgOneReturn(rebind=['a', 'x', 'c'],
                                              provides=['z']))
 
-        self.assertEqual(set(['x', 'y', 'c']), flow.requires)
-        self.assertEqual(set(['a', 'b', 'z']), flow.provides)
+        self.assertEqual({'x', 'y', 'c'}, flow.requires)
+        self.assertEqual({'a', 'b', 'z'}, flow.provides)
 
     def test_unordered_flow_retry_and_task_same_requires_provides(self):
         flow = uf.Flow('uf', retry.AlwaysRevert('rt', requires=['x']))
         flow.add(utils.TaskOneReturn(provides=['x']))
-        self.assertEqual(set(['x']), flow.requires)
-        self.assertEqual(set(['x']), flow.provides)
+        self.assertEqual({'x'}, flow.requires)
+        self.assertEqual({'x'}, flow.provides)
 
     def test_unordered_flow_retry_and_task_provide_same_value(self):
         flow = uf.Flow('uf', retry.AlwaysRevert('rt', provides=['x']))
         flow.add(utils.TaskOneReturn('t1', provides=['x']))
-        self.assertEqual(set(['x']), flow.provides)
+        self.assertEqual({'x'}, flow.provides)
 
     def test_unordered_flow_retry_two_tasks_provide_same_value(self):
         flow = uf.Flow('uf', retry.AlwaysRevert('rt', provides=['y']))
         flow.add(utils.TaskOneReturn('t1', provides=['x']),
                  utils.TaskOneReturn('t2', provides=['x']))
-        self.assertEqual(set(['x', 'y']), flow.provides)
+        self.assertEqual({'x', 'y'}, flow.provides)
 
     def test_graph_flow_retry_and_task(self):
         flow = gf.Flow('gf', retry.AlwaysRevert('rt',
@@ -365,19 +363,19 @@ class FlowDependenciesTest(test.TestCase):
         flow.add(utils.TaskMultiArgOneReturn(rebind=['a', 'x', 'c'],
                                              provides=['z']))
 
-        self.assertEqual(set(['x', 'y', 'c']), flow.requires)
-        self.assertEqual(set(['a', 'b', 'z']), flow.provides)
+        self.assertEqual({'x', 'y', 'c'}, flow.requires)
+        self.assertEqual({'a', 'b', 'z'}, flow.provides)
 
     def test_graph_flow_retry_and_task_dependency_provide_require(self):
         flow = gf.Flow('gf', retry.AlwaysRevert('rt', requires=['x']))
         flow.add(utils.TaskOneReturn(provides=['x']))
-        self.assertEqual(set(['x']), flow.provides)
-        self.assertEqual(set(['x']), flow.requires)
+        self.assertEqual({'x'}, flow.provides)
+        self.assertEqual({'x'}, flow.requires)
 
     def test_graph_flow_retry_and_task_provide_same_value(self):
         flow = gf.Flow('gf', retry.AlwaysRevert('rt', provides=['x']))
         flow.add(utils.TaskOneReturn('t1', provides=['x']))
-        self.assertEqual(set(['x']), flow.provides)
+        self.assertEqual({'x'}, flow.provides)
 
     def test_builtin_retry_args(self):
 
@@ -389,4 +387,4 @@ class FlowDependenciesTest(test.TestCase):
                 pass
 
         flow = lf.Flow('lf', retry=FullArgsRetry(requires='a'))
-        self.assertEqual(set(['a']), flow.requires)
+        self.assertEqual({'a'}, flow.requires)

taskflow/tests/unit/test_formatters.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 #    Copyright (C) 2015 Yahoo! Inc. All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may

taskflow/tests/unit/test_functor_task.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 #    Copyright (C) 2012-2013 Yahoo! Inc. All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -24,7 +22,7 @@ def add(a, b):
     return a + b
 
 
-class BunchOfFunctions(object):
+class BunchOfFunctions:
 
     def __init__(self, values):
         self.values = values

taskflow/tests/unit/test_listeners.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 #    Copyright (C) 2014 Yahoo! Inc. All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -52,7 +50,7 @@ _LOG_LEVELS = frozenset([
 
 class SleepyTask(task.Task):
     def __init__(self, name, sleep_for=0.0):
-        super(SleepyTask, self).__init__(name=name)
+        super().__init__(name=name)
         self._sleep_for = float(sleep_for)
 
     def execute(self):
@@ -62,7 +60,7 @@ class SleepyTask(task.Task):
             time.sleep(self._sleep_for)
 
 
-class EngineMakerMixin(object):
+class EngineMakerMixin:
     def _make_engine(self, flow, flow_detail=None, backend=None):
         e = taskflow.engines.load(flow,
                                   flow_detail=flow_detail,
@@ -80,7 +78,7 @@ class TestClaimListener(test.TestCase, EngineMakerMixin):
         return f
 
     def setUp(self):
-        super(TestClaimListener, self).setUp()
+        super().setUp()
         self.client = fake_client.FakeClient()
         self.addCleanup(self.client.stop)
         self.board = jobs.fetch('test', 'zookeeper', client=self.client)
@@ -315,7 +313,7 @@ class TestLoggingListeners(test.TestCase, EngineMakerMixin):
         with logging_listeners.LoggingListener(e, log=log):
             e.run()
         self.assertGreater(0, handler.counts[logging.DEBUG])
-        for levelno in _LOG_LEVELS - set([logging.DEBUG]):
+        for levelno in _LOG_LEVELS - {logging.DEBUG}:
             self.assertEqual(0, handler.counts[levelno])
         self.assertEqual([], handler.exc_infos)
 
@@ -329,7 +327,7 @@ class TestLoggingListeners(test.TestCase, EngineMakerMixin):
         with listener:
             e.run()
         self.assertGreater(0, handler.counts[logging.INFO])
-        for levelno in _LOG_LEVELS - set([logging.INFO]):
+        for levelno in _LOG_LEVELS - {logging.INFO}:
             self.assertEqual(0, handler.counts[levelno])
         self.assertEqual([], handler.exc_infos)
 
@@ -341,7 +339,7 @@ class TestLoggingListeners(test.TestCase, EngineMakerMixin):
         with logging_listeners.LoggingListener(e, log=log):
             self.assertRaises(RuntimeError, e.run)
         self.assertGreater(0, handler.counts[logging.DEBUG])
-        for levelno in _LOG_LEVELS - set([logging.DEBUG]):
+        for levelno in _LOG_LEVELS - {logging.DEBUG}:
             self.assertEqual(0, handler.counts[levelno])
         self.assertEqual(1, len(handler.exc_infos))
 
@@ -353,7 +351,7 @@ class TestLoggingListeners(test.TestCase, EngineMakerMixin):
         with logging_listeners.DynamicLoggingListener(e, log=log):
             e.run()
         self.assertGreater(0, handler.counts[logging.DEBUG])
-        for levelno in _LOG_LEVELS - set([logging.DEBUG]):
+        for levelno in _LOG_LEVELS - {logging.DEBUG}:
             self.assertEqual(0, handler.counts[levelno])
         self.assertEqual([], handler.exc_infos)
 
@@ -367,7 +365,7 @@ class TestLoggingListeners(test.TestCase, EngineMakerMixin):
         self.assertGreater(0, handler.counts[logging.WARNING])
         self.assertGreater(0, handler.counts[logging.DEBUG])
         self.assertEqual(1, len(handler.exc_infos))
-        for levelno in _LOG_LEVELS - set([logging.DEBUG, logging.WARNING]):
+        for levelno in _LOG_LEVELS - {logging.DEBUG, logging.WARNING}:
             self.assertEqual(0, handler.counts[levelno])
 
     def test_dynamic_failure_customized_level(self):
@@ -382,5 +380,5 @@ class TestLoggingListeners(test.TestCase, EngineMakerMixin):
         self.assertGreater(0, handler.counts[logging.ERROR])
         self.assertGreater(0, handler.counts[logging.DEBUG])
         self.assertEqual(1, len(handler.exc_infos))
-        for levelno in _LOG_LEVELS - set([logging.DEBUG, logging.ERROR]):
+        for levelno in _LOG_LEVELS - {logging.DEBUG, logging.ERROR}:
             self.assertEqual(0, handler.counts[levelno])

taskflow/tests/unit/test_mapfunctor_task.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 #    Copyright 2015 Hewlett-Packard Development Company, L.P.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -29,7 +27,7 @@ square = lambda x: x * x
 class MapFunctorTaskTest(test.TestCase):
 
     def setUp(self):
-        super(MapFunctorTaskTest, self).setUp()
+        super().setUp()
 
         self.flow_store = {
             'a': 1,

taskflow/tests/unit/test_notifier.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 #    Copyright (C) 2013 Yahoo! Inc. All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -57,7 +55,7 @@ class NotifierTest(test.TestCase):
         def call_me(state, details):
             pass
 
-        class A(object):
+        class A:
             def call_me_too(self, state, details):
                 pass
 

taskflow/tests/unit/test_progress.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 #    Copyright (C) 2012 Yahoo! Inc. All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -26,7 +24,7 @@ from taskflow.utils import persistence_utils as p_utils
 
 class ProgressTask(task.Task):
     def __init__(self, name, segments):
-        super(ProgressTask, self).__init__(name=name)
+        super().__init__(name=name)
         self._segments = segments
 
     def execute(self):
@@ -57,7 +55,7 @@ class TestProgress(test.TestCase):
         return e
 
     def tearDown(self):
-        super(TestProgress, self).tearDown()
+        super().tearDown()
         with contextlib.closing(impl_memory.MemoryBackend({})) as be:
             with contextlib.closing(be.get_connection()) as conn:
                 conn.clear_all()

taskflow/tests/unit/test_reducefunctor_task.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 #    Copyright 2015 Hewlett-Packard Development Company, L.P.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -29,7 +27,7 @@ multiply = lambda x, y: x * y
 class ReduceFunctorTaskTest(test.TestCase):
 
     def setUp(self):
-        super(ReduceFunctorTaskTest, self).setUp()
+        super().setUp()
 
         self.flow_store = {
             'a': 1,

taskflow/tests/unit/test_retries.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 #    Copyright (C) 2012 Yahoo! Inc. All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -30,11 +28,6 @@ from taskflow.tests import utils
 from taskflow.types import failure
 from taskflow.utils import eventlet_utils as eu
 
-try:
-    from taskflow.engines.action_engine import process_executor as pe
-except ImportError:
-    pe = None
-
 
 class FailingRetry(retry.Retry):
 
@@ -740,7 +733,7 @@ class RetryTest(utils.EngineTestBase):
         self.assertEqual(expected, capturer.values)
 
     def test_for_each_with_set(self):
-        collection = set([3, 2, 5])
+        collection = {3, 2, 5}
         retry1 = retry.ForEach(collection, 'r1', provides='x')
         flow = lf.Flow('flow-1', retry1).add(utils.FailingTaskWithOneArg('t1'))
         engine = self._make_engine(flow)
@@ -1368,20 +1361,3 @@ class ParallelEngineWithEventletTest(RetryTest, test.TestCase):
                                      engine='parallel',
                                      executor=executor,
                                      defer_reverts=defer_reverts)
-
-
-@testtools.skipIf(pe is None, 'process_executor is not available')
-class ParallelEngineWithProcessTest(RetryTest, test.TestCase):
-    _EXECUTOR_WORKERS = 2
-
-    def _make_engine(self, flow, defer_reverts=None, flow_detail=None,
-                     executor=None):
-        if executor is None:
-            executor = 'processes'
-        return taskflow.engines.load(flow,
-                                     flow_detail=flow_detail,
-                                     engine='parallel',
-                                     backend=self.backend,
-                                     executor=executor,
-                                     max_workers=self._EXECUTOR_WORKERS,
-                                     defer_reverts=defer_reverts)

taskflow/tests/unit/test_states.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 #    Copyright (C) 2015 Yahoo! Inc. All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may