rename effect.async to effect.parallel_async, replace async.py with 'from .parallel_async import *'

this should hopefully allow us to be backwards compatible so older versions of python can still use effect.async, but to switch to python 3.7 you will need to import effect.parallel_async.

Author: radix

effect/_base.py

@@ -116,8 +116,8 @@ def perform(dispatcher, effect):
 
     .. [#dispatcher] The dispatcher is passed because some performers need to
        make recursive calls to :func:`perform`, because they need to perform
-       other effects (see :func:`parallel` and :func:`.perform_parallel_async`
-       for an example of this).
+       other effects (see :func:`parallel` and
+       :func:`.parallel_async.perform_parallel_async` for an example of this).
 
     .. [#box] Without using one of those decorators, the performer is actually
        passed three arguments, not two: the dispatcher, the intent, and a

effect/_intents.py

@@ -26,7 +26,7 @@ class ParallelEffects(object):
     An effect intent that asks for a number of effects to be run in parallel,
     and for their results to be gathered up into a sequence.
 
-    :func:`effect.async.perform_parallel_async` can perform this Intent
+    :func:`effect.parallel_async.perform_parallel_async` can perform this Intent
     assuming all child effects have asynchronous performers.
     :func:`effect.threads.perform_parallel_with_pool` can perform blocking
     performers in a thread pool.

effect/async.py

@@ -1,40 +1,2 @@
-"""Generic asynchronous performers."""
-
-from functools import partial
-from itertools import count
-
-from ._base import perform
-from ._intents import FirstError
-
-
-def perform_parallel_async(dispatcher, intent, box):
-    """
-    A performer for :obj:`ParallelEffects` which works if all child Effects are
-    already asynchronous. Use this for things like Twisted, asyncio, etc.
-
-    WARNING: If this is used when child Effects have blocking performers, it
-    will run them in serial, not parallel.
-    """
-    effects = list(intent.effects)
-    if not effects:
-        box.succeed([])
-        return
-    num_results = count()
-    results = [None] * len(effects)
-
-    def succeed(index, result):
-        results[index] = result
-        if next(num_results) + 1 == len(effects):
-            box.succeed(results)
-
-    def fail(index, result):
-        box.fail((FirstError,
-                  FirstError(exc_info=result, index=index),
-                  result[2]))
-
-    for index, effect in enumerate(effects):
-        perform(
-            dispatcher,
-            effect.on(
-                success=partial(succeed, index),
-                error=partial(fail, index)))
+from .parallel_async import *
+__all__ = ['perform_parallel_async']

effect/parallel_async.py

@@ -0,0 +1,40 @@
+"""Generic asynchronous performers."""
+
+from functools import partial
+from itertools import count
+
+from ._base import perform
+from ._intents import FirstError
+
+
+def perform_parallel_async(dispatcher, intent, box):
+    """
+    A performer for :obj:`ParallelEffects` which works if all child Effects are
+    already asynchronous. Use this for things like Twisted, asyncio, etc.
+
+    WARNING: If this is used when child Effects have blocking performers, it
+    will run them in serial, not parallel.
+    """
+    effects = list(intent.effects)
+    if not effects:
+        box.succeed([])
+        return
+    num_results = count()
+    results = [None] * len(effects)
+
+    def succeed(index, result):
+        results[index] = result
+        if next(num_results) + 1 == len(effects):
+            box.succeed(results)
+
+    def fail(index, result):
+        box.fail((FirstError,
+                  FirstError(exc_info=result, index=index),
+                  result[2]))
+
+    for index, effect in enumerate(effects):
+        perform(
+            dispatcher,
+            effect.on(
+                success=partial(succeed, index),
+                error=partial(fail, index)))

effect/test_async.py

@@ -5,7 +5,7 @@
 from ._base import Effect, perform
 from ._dispatcher import ComposedDispatcher, TypeDispatcher
 from ._intents import ParallelEffects, base_dispatcher, parallel
-from .async import perform_parallel_async
+from .parallel_async import perform_parallel_async
 from .test_base import func_dispatcher
 from .test_parallel_performers import ParallelPerformerTestsMixin
 

effect/test_intents.py

@@ -21,7 +21,7 @@
     ParallelEffects, parallel_all_errors)
 from ._sync import sync_perform
 from ._test_utils import MatchesReraisedExcInfo, get_exc_info
-from .async import perform_parallel_async
+from .parallel_async import perform_parallel_async
 from .test_parallel_performers import EquitableException