Merge pull request #79 from python-effect/py3.7-support

Py3.7 support

Author: radix

.travis.yml

@@ -6,6 +6,11 @@ python:
     - "3.4"
     - "3.5"
     - "pypy"
+matrix:
+    include:
+        - python: 3.7
+          dist: xenial
+          sudo: true
 install:
     - pip install .
     - pip install -r dev-requirements.txt

Makefile

@@ -16,7 +16,7 @@ upload-dist:
 doc:
 	rm -rf docs/build
 	rm -rf docs/source/api
-	cd docs; sphinx-apidoc -e -o source/api ../effect ../setup.py ../examples ../effect/test_*.py
+	cd docs; sphinx-apidoc -e -o source/api ../effect ../setup.py ../examples ../effect/test_*.py ../effect/async.py
 	rm docs/source/api/modules.rst
 	rm docs/source/api/effect.rst
 	# can't use sed -i on both linux and mac, so...

dev-requirements.txt

@@ -1,3 +1,5 @@
 testtools
 flake8
 pytest
+sphinx
+sphinx-rtd-theme

docs/source/api/effect.async.rst

@@ -0,0 +1,7 @@
+effect.parallel\_async module
+=============================
+
+.. automodule:: effect.parallel_async
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/api/effect.parallel_async.rst

@@ -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/_base.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/_intents.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 perform_parallel_async
+__all__ = ['perform_parallel_async']

effect/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/parallel_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