Re-write trio-to-asyncio case to use aio_as_trio.

Author: smurfix

tests/aiotest/test_callback.py

@@ -1,6 +1,7 @@
 from tests import aiotest
 import signal
 import pytest
+from .. import utils as test_utils
 
 
 class TestCallback(aiotest.TestCase):
@@ -70,7 +71,10 @@ def test():
             with pytest.raises(RuntimeError, match='Event loop is closed'):
                 loop.run_in_executor(None, func)
             with pytest.raises(RuntimeError, match='Event loop is closed'):
-                await loop.run_coroutine(coro)
+                await loop.run_aio_coroutine(coro)
+            with test_utils.deprecate(self):
+                with pytest.raises(RuntimeError, match='Event loop is closed'):
+                    await loop.run_coroutine(coro)
             with pytest.raises(RuntimeError, match='Event loop is closed'):
                 loop.add_signal_handler(signal.SIGTERM, func)
         finally:

tests/aiotest/test_coroutine.py

@@ -1,5 +1,6 @@
 from tests import aiotest
 import pytest
+from .. import utils as test_utils
 
 
 async def hello_world(asyncio, result, delay, loop):
@@ -15,7 +16,15 @@ class TestCoroutine(aiotest.TestCase):
     async def test_hello_world(self, loop, config):
         result = []
         coro = hello_world(config.asyncio, result, 0.001, loop)
-        await loop.run_coroutine(config.asyncio.ensure_future(coro, loop=loop))
+        await loop.run_aio_coroutine(config.asyncio.ensure_future(coro, loop=loop))
+        assert result == ['Hello', 'World']
+
+    @pytest.mark.trio
+    async def test_hello_world_depr(self, loop, config):
+        result = []
+        coro = hello_world(config.asyncio, result, 0.001, loop)
+        with test_utils.deprecate(self):
+            await loop.run_coroutine(config.asyncio.ensure_future(coro, loop=loop))
         assert result == ['Hello', 'World']
 
     @pytest.mark.trio

tests/aiotest/test_thread.py

@@ -2,6 +2,7 @@
 import pytest
 import trio
 import trio_asyncio
+from .. import utils as test_utils
 
 
 class TestThread(aiotest.TestCase):
@@ -19,7 +20,29 @@ def work():
             result['ident'] = get_ident()
 
         fut = loop.run_in_executor(None, work)
-        await loop.run_coroutine(fut)
+        await loop.run_aio_coroutine(fut)
+
+        # ensure that work() was executed in a different thread
+        work_ident = result['ident']
+        assert work_ident is not None
+        assert work_ident != get_ident()
+
+    @pytest.mark.trio
+    async def test_ident_depr(self, loop, config):
+        threading = config.threading
+        try:
+            get_ident = threading.get_ident  # Python 3
+        except AttributeError:
+            get_ident = threading._get_ident  # Python 2
+
+        result = {'ident': None}
+
+        def work():
+            result['ident'] = get_ident()
+
+        fut = loop.run_in_executor(None, work)
+        with test_utils.deprecate(self):
+            await loop.run_coroutine(fut)
 
         # ensure that work() was executed in a different thread
         work_ident = result['ident']
@@ -34,12 +57,30 @@ def work():
             result.append("run")
 
         fut = loop.run_in_executor(None, work)
-        await loop.run_future(fut)
+        await loop.run_aio_future(fut)
+        assert result == ["run"]
+
+        # ensure that run_in_executor() can be called twice
+        fut = loop.run_in_executor(None, work)
+        await loop.run_aio_future(fut)
+        assert result == ["run", "run"]
+
+    @pytest.mark.trio
+    async def test_run_twice_depr(self, loop):
+        result = []
+
+        def work():
+            result.append("run")
+
+        fut = loop.run_in_executor(None, work)
+        with test_utils.deprecate(self):
+            await loop.run_future(fut)
         assert result == ["run"]
 
         # ensure that run_in_executor() can be called twice
         fut = loop.run_in_executor(None, work)
-        await loop.run_future(fut)
+        with test_utils.deprecate(self):
+            await loop.run_future(fut)
         assert result == ["run", "run"]
 
     @pytest.mark.trio
@@ -55,7 +96,24 @@ def work():
 
         # get_event_loop() must return None in a different thread
         fut = loop.run_in_executor(None, work)
-        await loop.run_future(fut)
+        await loop.run_aio_future(fut)
+        assert isinstance(result['loop'], (AssertionError, RuntimeError))
+
+    @pytest.mark.trio
+    async def test_policy_depr(self, loop, config):
+        asyncio = config.asyncio
+        result = {'loop': 'not set'}  # sentinel, different than None
+
+        def work():
+            try:
+                result['loop'] = asyncio.get_event_loop()
+            except Exception as exc:
+                result['loop'] = exc
+
+        # get_event_loop() must return None in a different thread
+        fut = loop.run_in_executor(None, work)
+        with test_utils.deprecate(self):
+            await loop.run_future(fut)
         assert isinstance(result['loop'], (AssertionError, RuntimeError))
 
     @pytest.mark.trio

tests/interop/test_adapter.py

@@ -1,4 +1,5 @@
 import pytest
+from trio_asyncio import aio_as_trio
 from trio_asyncio import aio2trio, trio2aio
 import asyncio
 import trio
@@ -22,6 +23,14 @@ async def dly_trio(self):
         return 8
 
     @trio2aio
+    async def dly_asyncio_depr(self):
+        if sys.version_info >= (3, 7):
+            assert sniffio.current_async_library() == "asyncio"
+        await asyncio.sleep(0.01, loop=self.loop)
+        self.flag |= 1
+        return 4
+
+    @aio_as_trio
     async def dly_asyncio(self):
         if sys.version_info >= (3, 7):
             assert sniffio.current_async_library() == "asyncio"
@@ -46,3 +55,11 @@ async def test_trio_asyncio(self, loop):
         res = await sth.dly_asyncio()
         assert res == 4
         assert sth.flag == 1
+
+    @pytest.mark.trio
+    async def test_trio_asyncio_depr(self, loop):
+        sth = SomeThing(loop)
+        res = await sth.dly_asyncio_depr()
+        assert res == 4
+        assert sth.flag == 1
+

tests/interop/test_calls.py

@@ -2,10 +2,11 @@
 import asyncio
 import trio
 import sniffio
+from trio_asyncio import aio_as_trio
 from tests import aiotest
 from functools import partial
 import sys
-from .. import utils
+from .. import utils as test_utils
 
 
 class Seen:
@@ -307,7 +308,7 @@ async def dly_asyncio():
             await asyncio.sleep(0.01, loop=loop)
             yield 2
 
-        with utils.deprecate(self):
+        with test_utils.deprecate(self):
             res = await async_gen_to_list(loop.wrap_generator(dly_asyncio))
         assert res == [1, 2]
 
@@ -318,7 +319,7 @@ async def dly_asyncio():
             raise RuntimeError("I has an owie")
             yield 2
 
-        with utils.deprecate(self):
+        with test_utils.deprecate(self):
             with pytest.raises(RuntimeError) as err:
                 await async_gen_to_list(loop.wrap_generator(dly_asyncio))
         assert err.value.args[0] == "I has an owie"
@@ -337,7 +338,7 @@ async def cancel_soon(nursery):
         hold = asyncio.Event(loop=loop)
         seen = Seen()
 
-        with utils.deprecate(self):
+        with test_utils.deprecate(self):
             async with trio.open_nursery() as nursery:
                 nursery.start_soon(async_gen_to_list, loop.wrap_generator(dly_asyncio, hold, seen))
                 nursery.start_soon(cancel_soon, nursery)
@@ -352,6 +353,19 @@ async def slow_nums():
                 yield n
 
         sum = 0
+        async for n in aio_as_trio(slow_nums()):
+            sum += n
+        assert sum == 15
+
+    @pytest.mark.trio
+    async def test_trio_asyncio_iterator_depr(self, loop):
+        async def slow_nums():
+            for n in range(1, 6):
+                asyncio.sleep(0.01, loop=loop)
+                yield n
+
+        sum = 0
+        # with test_utils.deprecate(self): ## not yet
         async for n in loop.run_asyncio(slow_nums()):
             sum += n
         assert sum == 15

trio_asyncio/adapter.py

@@ -2,39 +2,104 @@
 # Trio.
 
 import types
+import warnings
+
 from async_generator import isasyncgenfunction
 import asyncio
 import trio_asyncio
-from contextvars import copy_context
+from contextvars import ContextVar
+
+from .util import run_aio_generator, run_aio_future
+
+current_loop = ContextVar('trio_aio_loop', default=None)
+current_policy = ContextVar('trio_aio_policy', default=None)
 
 # import logging
 # logger = logging.getLogger(__name__)
 
 from functools import wraps, partial
 
-__all__ = ['trio2aio', 'aio2trio', 'allow_asyncio']
+__all__ = ['trio2aio', 'aio2trio', 'aio_as_trio', 'allow_asyncio',
+           'current_loop', 'current_policy']
 
 
 def trio2aio(proc):
-    if isasyncgenfunction(proc):
+        """Call asyncio code from Trio.
 
-        @wraps(proc)
-        def call(*args, **kwargs):
-            proc_ = proc
-            if kwargs:
-                proc_ = partial(proc_, **kwargs)
-            return trio_asyncio.wrap_generator(proc_, *args)
+        Deprecated: Use aio_as_trio() instead.
 
-    else:
+            await loop.run_iterator(iter)
 
-        @wraps(proc)
-        async def call(*args, **kwargs):
-            proc_ = proc
-            if kwargs:
-                proc_ = partial(proc_, **kwargs)
-            return await trio_asyncio.run_asyncio(proc_, *args)
+        simply call
 
-    return call
+            await loop.run_asyncio(iter)
+        """
+        warnings.warn("Use 'aio_as_trio(proc)' instead'", DeprecationWarning)
+
+        return aio_as_trio(proc)
+
+class Asyncio_Trio_Wrapper:
+    """
+    This wrapper object encapsulates an asyncio-style coroutine,
+    generator, or iterator, to be called seamlessly from Trio.
+    """
+    def __init__(self, proc, args=[], loop=None):
+        self.proc = proc
+        self.args = args
+        self._loop = loop
+
+    @property
+    def loop(self):
+        """The loop argument needs to be lazily evaluated."""
+        loop = self._loop
+        if loop is None:
+            loop = current_loop.get()
+        return loop
+
+    def __get__(self, obj, cls):
+        """If this is used to decorate an instance,
+        we need to forward the original ``self`` to the wrapped method.
+        """
+        if obj is None:
+            return self.__call__
+        return partial(self.__call__, obj)
+
+    async def __call__(self, *args, **kwargs):
+        if self.args:
+            "Call 'aio_as_trio(oroc)(*args)', not 'aio_as_trio(proc, *args)'"
+
+        f = self.proc(*args, **kwargs)
+        return await self.loop.run_aio_coroutine(f)
+
+    def __await__(self):
+        """Compatbility code for loop.run_asyncio"""
+        f = self.proc(*self.args)
+        return self.loop.run_aio_coroutine(f).__await__()
+
+    def __aenter__(self):
+        proc_enter = getattr(self.proc, "__aenter__", None)
+        if proc_enter is None or self.args:
+            raise RuntimeError(
+                "Call 'aio_as_trio(ctxfactory(*args))', not 'aio_as_trio(ctxfactory, *args)'"
+            )
+        f = proc_enter()
+        return self.loop.run_aio_coroutine(f)
+
+    def __aexit__(self, *tb):
+        f = self.proc.__aexit__(*tb)
+        return self.loop.run_aio_coroutine(f)
+
+    def __aiter__(self):
+        proc_iter = getattr(self.proc, "__anext__", None)
+        if proc_iter is None or self.args:
+            raise RuntimeError(
+                "Call 'run_asyncio(gen(*args))', not 'run_asyncio(gen, *args)'"
+            )
+        return run_aio_generator(self.loop, self.proc)
+
+
+def aio_as_trio(proc, loop=None):
+    return Asyncio_Trio_Wrapper(proc, loop=loop)
 
 
 def aio2trio(proc):