Bring trio-asyncio into the next decade (#66)

A collection of changes to make CI pass, including on 3.8.

Fix use of deprecated Trio features:
* Don't refer to trio.hazmat.Task._cancel_stack in interop tests
* Don't use deprecated trio.Event.clear
* Launch threads with trio.to_thread.run_sync

Collect Python stdlib asyncio tests from the installed stdlib, rather than trying to vendor them. This lets us run the tests on far more platforms.

Ignore some asyncio deprecation warnings on 3.8 for now.

Clean up the monkeypatching of asyncio event loop and event loop policy accessors. The primary functional changes are:
* Make TrioPolicy a singleton
* Patch new_event_loop and set_event_loop to go through TrioPolicy like get_event_loop does
* Improve SyncTrioEventLoop to not leak threads so much.

Author: oremanj

.travis.yml

@@ -1,40 +1,22 @@
 language: python
-python:
-  - 3.6
-  - 3.6-dev
-sudo: false
-dist: trusty
+dist: xenial
 
 matrix:
   include:
-    # As of 2018-07-05, Travis's 3.7 and 3.8 builds only work if you
-    # use dist: xenial AND sudo: required
-    # See: https://github.com/python-trio/trio/pull/556#issuecomment-402879391
+    - python: 3.5
+    - python: 3.6
     - python: 3.7
-      dist: xenial
-      sudo: required
     - python: 3.7-dev
-      dist: xenial
-      sudo: required
+    - python: 3.8
     - python: 3.8-dev
-      dist: xenial
-      sudo: required
-    # - os: linux
-    #   language: generic
-    #   env: USE_PYPY_RELEASE_VERSION=5.9-beta
-    # Uncomment if you want to test on pypy nightly
-    # - os: linux
-    #   language: generic
-    #   env: USE_PYPY_NIGHTLY=1
+    - python: nightly
     - os: osx
       language: generic
       env: MACPYTHON=3.6.3
     - python: 3.6
       env: CHECK_DOCS=1
     - python: 3.6
       env: CHECK_FORMATTING=1
-  allow_failures:
-    - python: 3.8-dev
 
 script:
   - ci/travis.sh

README.rst

@@ -26,18 +26,18 @@
 **Trio-Asyncio** is a re-implementation of the ``asyncio`` mainloop on top of
 Trio.
 
-Trio-Asyncio requires Python 3.6 or 3.7. It should work on Python 3.5.3, but
-that's not tested, as the test suite requires 3.6.
+Trio-Asyncio requires at least Python 3.5.3. It is tested on recent versions of
+3.5, 3.6, 3.7, 3.8, and nightly.
 
 +++++++++++
  Rationale
 +++++++++++
 
 Trio has native concepts of tasks and task cancellation. Asyncio is based
 on callbacks and chaining Futures, albeit with nicer syntax, which make
-handling of failures and timeouts fundamentally less reliable, esp. in
+handling of failures and timeouts fundamentally less reliable, especially in
 larger programs. Thus, you *really* want to base your async project on Trio.
- 
+
 On the other hand, there are quite a few asyncio-enhanced libraries. You
 *really* don't want to re-invent any wheels in your project.
 

ci/travis.sh

@@ -92,7 +92,7 @@ else
     mkdir empty
     cd empty
 
-    pytest -W error -ra -v --cov=trio_asyncio --cov-config=../.coveragerc --verbose ../tests
+    pytest -ra -v --cov=trio_asyncio --cov-config=../.coveragerc --verbose ../tests
 
     bash <(curl -s https://codecov.io/bash)
 fi

newsfragments/66.feature.rst

@@ -0,0 +1,3 @@
+Substantially reorganize monkeypatching for asyncio event loop and
+event loop policy accessors, fixing support for Python 3.8. Also, stop
+using features deprecated in Trio 0.12.

setup.py

@@ -53,7 +53,7 @@
 """
 
 install_requires = [
-    "trio >= 0.11.0",
+    "trio >= 0.12.0",
     "async_generator >= 1.6",
     "outcome",
 ]

tests/__init__.py

@@ -11,29 +11,3 @@
 aRepr.maxother = 9999
 aRepr.maxlong = 9999
 del aRepr
-
-# Find the test SSL keys.
-from . import utils as test_utils
-
-
-def finish_request(self, request, client_address):
-    import os
-    import ssl
-    here = os.path.join(os.path.dirname(__file__), 'python')
-    keyfile = os.path.join(here, 'ssl_key.pem')
-    certfile = os.path.join(here, 'ssl_cert.pem')
-    context = ssl.SSLContext()
-    context.load_cert_chain(certfile, keyfile)
-
-    ssock = context.wrap_socket(request, server_side=True)
-    try:
-        self.RequestHandlerClass(ssock, client_address, self)
-        ssock.close()
-    except OSError:
-        # maybe socket has been closed by peer
-        pass
-
-
-test_utils.SSLWSGIServerMixin.finish_request = finish_request
-del test_utils
-del finish_request

tests/interop/test_adapter.py

@@ -1,4 +1,5 @@
 import pytest
+from async_generator import async_generator, yield_
 from trio_asyncio import aio_as_trio, trio_as_aio, allow_asyncio
 from trio_asyncio import aio2trio, trio2aio
 import asyncio
@@ -72,39 +73,43 @@ async def dly_asyncio(self, do_test=True):
         self.flag |= 1
         return 4
 
+    @async_generator
     async def iter_asyncio(self, do_test=True):
         if do_test and sys.version_info >= (3, 7):
             assert sniffio.current_async_library() == "asyncio"
         await asyncio.sleep(0.01, loop=self.loop)
-        yield 1
+        await yield_(1)
         await asyncio.sleep(0.01, loop=self.loop)
-        yield 2
+        await yield_(2)
         await asyncio.sleep(0.01, loop=self.loop)
         self.flag |= 1
 
+    @async_generator
     async def iter_trio(self):
         if sys.version_info >= (3, 7):
             assert sniffio.current_async_library() == "trio"
         await trio.sleep(0.01)
-        yield 1
+        await yield_(1)
         await trio.sleep(0.01)
-        yield 2
+        await yield_(2)
         await trio.sleep(0.01)
         self.flag |= 1
 
     @asynccontextmanager
+    @async_generator
     async def ctx_asyncio(self):
         await asyncio.sleep(0.01, loop=self.loop)
         self.flag |= 1
-        yield self
+        await yield_(self)
         await asyncio.sleep(0.01, loop=self.loop)
         self.flag |= 2
 
     @asynccontextmanager
+    @async_generator
     async def ctx_trio(self):
         await trio.sleep(0.01)
         self.flag |= 1
-        yield self
+        await yield_(self)
         await trio.sleep(0.01)
         self.flag |= 2
 

tests/interop/test_calls.py

@@ -2,6 +2,7 @@
 import asyncio
 import trio
 import sniffio
+from async_generator import async_generator, yield_
 from trio_asyncio import aio_as_trio, trio_as_aio
 from tests import aiotest
 from functools import partial
@@ -302,7 +303,7 @@ async def test_asyncio_trio_cancel_out(self, loop):
         async def cancelled_trio(seen):
             seen.flag |= 1
             await trio.sleep(0.01)
-            scope = trio.hazmat.current_task()._cancel_stack[-1]
+            scope = trio.hazmat.current_task()._cancel_status._scope
             scope.cancel()
             seen.flag |= 2
             await trio.sleep(0.01)
@@ -525,21 +526,23 @@ def err_asyncio():
 
     @pytest.mark.trio
     async def test_trio_asyncio_generator(self, loop):
+        @async_generator
         async def dly_asyncio():
-            yield 1
+            await yield_(1)
             await asyncio.sleep(0.01, loop=loop)
-            yield 2
+            await yield_(2)
 
         with test_utils.deprecate(self):
             res = await async_gen_to_list(loop.wrap_generator(dly_asyncio))
         assert res == [1, 2]
 
     @pytest.mark.trio
     async def test_trio_asyncio_generator_with_error(self, loop):
+        @async_generator
         async def dly_asyncio():
-            yield 1
+            await yield_(1)
             raise RuntimeError("I has an owie")
-            yield 2
+            await yield_(2)
 
         with test_utils.deprecate(self):
             with pytest.raises(RuntimeError) as err:
@@ -548,8 +551,9 @@ async def dly_asyncio():
 
     @pytest.mark.trio
     async def test_trio_asyncio_generator_with_cancellation(self, loop):
+        @async_generator
         async def dly_asyncio(hold, seen):
-            yield 1
+            await yield_(1)
             seen.flag |= 1
             await hold.wait()
 
@@ -569,10 +573,11 @@ async def cancel_soon(nursery):
 
     @pytest.mark.trio
     async def test_trio_asyncio_iterator(self, loop):
+        @async_generator
         async def slow_nums():
             for n in range(1, 6):
-                asyncio.sleep(0.01, loop=loop)
-                yield n
+                await asyncio.sleep(0.01, loop=loop)
+                await yield_(n)
 
         sum = 0
         async for n in aio_as_trio(slow_nums()):
@@ -581,10 +586,11 @@ async def slow_nums():
 
     @pytest.mark.trio
     async def test_trio_asyncio_iterator_depr(self, loop):
+        @async_generator
         async def slow_nums():
             for n in range(1, 6):
-                asyncio.sleep(0.01, loop=loop)
-                yield n
+                await asyncio.sleep(0.01, loop=loop)
+                await yield_(n)
 
         sum = 0
         # with test_utils.deprecate(self): ## not yet

tests/pytest.ini

@@ -0,0 +1,6 @@
+[pytest]
+filterwarnings =
+    error
+    ignore:The loop argument is deprecated since Python 3.8:DeprecationWarning
+    ignore:"@coroutine" decorator is deprecated since Python 3.8:DeprecationWarning
+    default:Tried to add marker .* but that test doesn't exist.:RuntimeWarning

tests/python/__init__.py

@@ -1,16 +0,0 @@
-import os
-from test.support import load_package_tests, import_module
-
-# Skip tests if we don't have concurrent.futures.
-import_module('concurrent.futures')
-
-
-def load_tests(*args):
-    return load_package_tests(os.path.dirname(__file__), *args)
-
-
-# this code is from
-# git@github.com:python/cpython.git
-# Revision d48ecebad
-# Python 3.6.4
-#