Merge pull request #43 from micheles/coro-signaturerelease-4.1.24.1.2

Now the coroutine signature is determined by the caller

2 files changed, 28 insertions, 4 deletions

diff --git a/src/tests/documentation.py b/src/tests/documentation.py
index 3e1568a..e8fcc55 100644
--- a/src/tests/documentation.py
+++ b/src/tests/documentation.py
@@ -752,8 +752,23 @@ with a particularly complex chain of coroutines. With a single line you
 can decorate the troubling coroutine function, understand what happens, fix the
 issue and then remove the decorator (or keep it if continuous monitoring
 of the coroutines makes sense). Notice that
-`inspect.iscoroutinefunction(make_task)`
-will return then right answer (i.e. `True`).
+``inspect.iscoroutinefunction(make_task)``
+will return the right answer (i.e. ``True``).
+
+It is also possible to define decorators converting coroutine functions
+into regular functions, such as the following:
+
+.. code-block:: python
+
+ @decorator
+ def coro_to_func(coro, *args, **kw):
+     "Convert a coroutine into a function"
+     return get_event_loop().run_until_complete(coro(*args, **kw))
+
+Notice the diffence: the caller in ``log_start_stop`` was a coroutine
+function and the associate decorator was converting coroutines->coroutines;
+the caller in ``coro_to_func`` is a regular function and converts
+coroutines -> functions.
 
 Multiple dispatch
 -------------------------------------------
diff --git a/src/tests/test.py b/src/tests/test.py
index d882418..7eb8391 100644
--- a/src/tests/test.py
+++ b/src/tests/test.py
@@ -30,15 +30,25 @@ if sys.version >= '3.5':
 async def before_after(coro, *args, **kwargs):
     return "<before>" + (await coro(*args, **kwargs)) + "<after>"
 
+@decorator
+def coro_to_func(coro, *args, **kw):
+    return get_event_loop().run_until_complete(coro(*args, **kw))
 
 class CoroutineTestCase(unittest.TestCase):
-    def test(self):
+    def test_before_after(self):
         @before_after
         async def coro(x):
            return x
         self.assertTrue(inspect.iscoroutinefunction(coro))
         out = get_event_loop().run_until_complete(coro('x'))
         self.assertEqual(out, '<before>x<after>')
+
+    def test_coro_to_func(self):
+        @coro_to_func
+        async def coro(x):
+            return x
+        self.assertFalse(inspect.iscoroutinefunction(coro))
+        self.assertEqual(coro('x'), 'x')
 ''')
 
 
@@ -92,7 +102,6 @@ class ExtraTestCase(unittest.TestCase):
         @d1
         def f1(x, y, z):
             pass
-
         self.assertNotEqual(d1.__code__.co_filename, d2.__code__.co_filename)
         self.assertNotEqual(f1.__code__.co_filename, f2.__code__.co_filename)
         self.assertNotEqual(f1_orig.__code__.co_filename,