Release 0.12.0

docs/source/history.rst

@@ -5,6 +5,50 @@ Release history
 
 .. towncrier release notes start
 
+trio-asyncio 0.12.0 (2021-01-04)
+--------------------------------
+
+Bugfixes
+~~~~~~~~
+
+- On Python versions with native contextvars support (3.7+), a Trio task
+  started from asyncio context (using :func:`trio_as_aio`,
+  :meth:`~BaseTrioEventLoop.trio_as_future`, etc) will now properly
+  inherit the contextvars of its caller.  Also, if the entire
+  trio-asyncio loop is cancelled, such tasks will no longer let
+  `trio.Cancelled` exceptions leak into their asyncio caller. (`#76 <https://github.com/python-trio/trio-asyncio/issues/76>`__)
+- Previously, cancelling the context surrounding an :func:`open_loop`
+  block might cause a deadlock in some cases. The ordering of operations
+  during loop teardown has been improved, so this shouldn't happen
+  anymore. (`#81 <https://github.com/python-trio/trio-asyncio/issues/81>`__)
+
+Deprecations and Removals
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+A number of functions deprecated since 0.10.0 are now removed:
+
+================================================= =============================================
+  Removed                                           Replacement
+================================================= =============================================
+``wrap_generator(proc, *args)``                   :func:`aio_as_trio(proc(*args))<aio_as_trio>`
+``run_iterator(aiter)``                           :func:`aio_as_trio(aiter)<aio_as_trio>`
+``trio2aio``                                      :func:`aio_as_trio`
+``aio2trio``                                      :func:`trio_as_aio`
+``run_future`` ``TrioEventLoop.run_future``       :func:`run_aio_future`
+``run_coroutine`` ``TrioEventLoop.run_coroutine`` :func:`run_aio_coroutine`
+``wrap_trio_context(ctx)``                        :func:`trio_as_aio(ctx)<trio_as_aio>`
+``TrioEventLoop.run_trio(proc, *args)``           :func:`trio_as_aio(proc)(*args)<trio_as_aio>`
+``run_asyncio(proc, *args)``                      :func:`aio_as_trio(proc)(*args)<aio_as_trio>`
+================================================= =============================================
+
+Miscellaneous
+~~~~~~~~~~~~~
+
+- ``trio-asyncio`` now requires Trio 0.15. Support for Python < 3.6 has been removed. (`#82 <https://github.com/python-trio/trio-asyncio/issues/82>`__)
+
+- No more ``TrioDeprecationWarning`` about ``trio.hazmat``. (`#82 <https://github.com/python-trio/trio-asyncio/issues/82>`__)
+
+
 trio-asyncio 0.11.0 (2020-03-09)
 --------------------------------
 

pyproject.toml

@@ -1,6 +1,32 @@
 [tool.towncrier]
 package = "trio_asyncio"
+title_format = "trio-asyncio {version} ({project_date})"
 filename = "docs/source/history.rst"
 directory = "newsfragments"
 underlines = ["-", "~", "^"]
 issue_format = "`#{issue} <https://github.com/python-trio/trio-asyncio/issues/{issue}>`__"
+
+[[tool.towncrier.type]]
+directory = "feature"
+name = "Features"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "bugfix"
+name = "Bugfixes"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "doc"
+name = "Improved documentation"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "removal"
+name = "Deprecations and removals"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "misc"
+name = "Miscellaneous"
+showcontent = true

tests/aiotest/test_callback.py

@@ -1,7 +1,6 @@
 from tests import aiotest
 import signal
 import pytest
-from .. import utils as test_utils
 
 
 class TestCallback(aiotest.TestCase):
@@ -51,10 +50,6 @@ async def test():
         func = lambda: False
         coro = test()
         try:
-            # no longer depends on the loop
-            # with pytest.raises(RuntimeError):
-            #    fut = config.asyncio.Future(loop=loop)
-            #    await loop.run_future(fut)
             with pytest.raises(RuntimeError, match='not a sync loop'):
                 loop.run_until_complete(None)
             with pytest.raises(RuntimeError):
@@ -71,9 +66,6 @@ async def test():
                 loop.run_in_executor(None, func)
             with pytest.raises(RuntimeError, match='Event loop is closed'):
                 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,13 +1,12 @@
 from tests import aiotest
 import trio_asyncio
 import pytest
-from .. import utils as test_utils
 
 
 async def hello_world(asyncio, result, delay, loop):
     result.append("Hello")
     # retrieve the event loop from the policy
-    await asyncio.sleep(delay, loop=loop)
+    await asyncio.sleep(delay)
     result.append('World')
     return "."
 
@@ -17,27 +16,13 @@ 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_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
-    async def run_hello_world(self, loop, config):
-        result = []
-        await loop.run_asyncio(hello_world, config.asyncio, result, 0.001, loop)
+        await loop.run_aio_coroutine(config.asyncio.ensure_future(coro))
         assert result == ['Hello', 'World']
 
     @pytest.mark.trio
     async def test_waiter(self, loop, config):
         async def waiter(asyncio, hello_world, result):
-            fut = asyncio.Future(loop=loop)
+            fut = asyncio.Future()
             loop.call_soon(fut.set_result, "Future")
 
             value = await fut
@@ -49,20 +34,3 @@ async def waiter(asyncio, hello_world, result):
         result = []
         await trio_asyncio.aio_as_trio(waiter)(config.asyncio, hello_world, result)
         assert result == ['Future', 'Hello', 'World', '.']
-
-    @pytest.mark.trio
-    async def test_waiter_depr(self, loop, config):
-        async def waiter(asyncio, hello_world, result):
-            fut = asyncio.Future(loop=loop)
-            loop.call_soon(fut.set_result, "Future")
-
-            value = await fut
-            result.append(value)
-
-            value = await hello_world(asyncio, result, 0.001, loop)
-            result.append(value)
-
-        result = []
-        with test_utils.deprecate(self):
-            await loop.run_asyncio(waiter, config.asyncio, hello_world, result)
-        assert result == ['Future', 'Hello', 'World', '.']

tests/aiotest/test_network.py

@@ -79,7 +79,7 @@ async def test_tcp_hello(self, loop, config):
 
         proto = TcpEchoClientProtocol(message, loop)
         coro = loop.create_connection(lambda: proto, host, port)
-        await loop.run_coroutine(coro)
+        await loop.run_aio_coroutine(coro)
         assert proto.state != 'new'
 
         await loop.stop().wait()()

tests/aiotest/test_thread.py

@@ -2,7 +2,6 @@
 import pytest
 import trio
 import trio_asyncio
-from .. import utils as test_utils
 
 
 class TestThread(aiotest.TestCase):
@@ -27,28 +26,6 @@ def work():
         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']
-        assert work_ident is not None
-        assert work_ident != get_ident()
-
     @pytest.mark.trio
     async def test_run_twice(self, loop):
         result = []
@@ -65,24 +42,6 @@ def 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)
-        with test_utils.deprecate(self):
-            await loop.run_future(fut)
-        assert result == ["run", "run"]
-
     @pytest.mark.trio
     async def test_policy(self, loop, config):
         asyncio = config.asyncio
@@ -99,23 +58,6 @@ def work():
         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
     async def test_run_in_thread(self, config):
         threading = config.threading