-

cool-RR · cool-RR · commit 23677eb24fd7 · 2015-06-06T18:55:30.000+03:00
diff --git a/source_py3/python_toolbox/future_tools.py b/source_py3/python_toolbox/future_tools.py
@@ -0,0 +1,55 @@
+# Copyright 2009-2015 Ram Rachum.
+# This program is distributed under the MIT license.
+
+import time
+import concurrent.futures
+
+from python_toolbox import sequence_tools
+
+
+class CuteExecutorMixin:
+    def filter(self, filter_function, iterable, timeout=None,
+               as_completed=False):
+        '''Get a parallelized version of filter(filter_function, iterable).'''
+        
+        sequence = sequence_tools.ensure_iterable_is_sequence(iterable)
+        return (
+            item for (item, keep) in zip(
+                sequence,
+                self.map(filter_function, sequence, timeout=timeout,
+                         as_completed=as_completed)
+            ) if keep
+        )
+
+    def map(self, function, *iterables, timeout=None, as_completed=False):
+        '''Get a parallelized version of map(function, iterable).'''
+        
+        if timeout is not None:
+            end_time = timeout + time.time()
+
+        futures = [self.submit(function, *args) for args in zip(*iterables)]
+        futures_iterator = concurrent.futures.as_completed(futures) if \
+                                                      as_completed else futures
+
+        # Yield must be hidden in closure so that the futures are submitted
+        # before the first iterator value is required.
+        def result_iterator():
+            try:
+                for future in futures:
+                    if timeout is None:
+                        yield future.result()
+                    else:
+                        yield future.result(end_time - time.time())
+            finally:
+                for future in futures:
+                    future.cancel()
+        return result_iterator()
+
+    
+class CuteThreadPoolExecutor(CuteExecutorMixin,
+                             concurrent.futures.ThreadPoolExecutor):
+    pass
+
+class CuteProcessPoolExecutor(CuteExecutorMixin,
+                             concurrent.futures.ProcessPoolExecutor):
+    pass
diff --git a/source_py3/test_python_toolbox/test_future_tools/__init__.py b/source_py3/test_python_toolbox/test_future_tools/__init__.py
diff --git a/source_py3/test_python_toolbox/test_future_tools/test_future_tools.py b/source_py3/test_python_toolbox/test_future_tools/test_future_tools.py
@@ -0,0 +1,30 @@
+# 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(5) 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)) == (range(0, 10, 2))
+        
+        
+        
+        
