Don't change the event loop policy

Author: smurfix

docs/source/usage.rst

@@ -122,9 +122,17 @@ Compatibility Mode
 ------------------
 
 You still can do things "the asyncio way": the to-be-replaced code from the
-:ref:`previosu section <native-loop>`
-still works – or at least it attempts to work.
+:ref:`previous section <native-loop>`
+still works – or at least it attempts to work::
 
+    import asyncio
+    import trio_asyncio
+    asyncio.set_event_loop_policy(trio_asyncio.TrioPolicy())
+
+    def main():
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(async_main())
+    
 .. warning::
 
    tl;dr: Don't use Compatibility Mode in production code.
@@ -150,6 +158,11 @@ just as with a regular asyncio loop.
 If you use a compatibility-mode loop in a separate thread, you *must* stop and close it
 before terminating that thread. Otherwise your thread will leak resources.
 
+In a multi-threaded program, globally setting the event loop policy may not
+be a good idea. If you want to run trio-asyncio in a separate thread, you
+might get away with using ``TrioPolicy().new_event_loop()`` to create a new
+event loop – but a far better idea is to use native mode.
+
 .. note::
 
    Compatibility mode has been added to verify that various test suites,

trio_asyncio/async_.py

@@ -106,11 +106,9 @@ def _main_loop_exit(self):
         self._thread = None
 
     async with trio.open_nursery() as nursery:
-        old_loop = asyncio.get_event_loop()
         loop = TrioEventLoop(queue_len=queue_len)
         try:
             loop._closed = False
-            asyncio.set_event_loop(loop)
             await loop._main_loop_init(nursery)
             await nursery.start(loop._main_loop)
             await yield_(loop)
@@ -120,5 +118,4 @@ def _main_loop_exit(self):
             finally:
                 await loop._main_loop_exit()
                 loop.close()
-                asyncio.set_event_loop(old_loop)
                 nursery.cancel_scope.cancel()

trio_asyncio/base.py

@@ -646,6 +646,7 @@ async def _main_loop_init(self, nursery):
         self._nursery = nursery
         self._task = trio.hazmat.current_task()
         self._token = trio.hazmat.current_trio_token()
+        asyncio.events._set_running_loop(self)
 
     async def _main_loop(self, task_status=trio.TASK_STATUS_IGNORED):
         """Run the loop by processing its event queue.
@@ -725,6 +726,7 @@ async def _main_loop_exit(self):
         # clean core fields
         self._nursery = None
         self._task = None
+        asyncio.events._set_running_loop(None)
 
     def is_running(self):
         if self._stopped is None:

trio_asyncio/loop.py

@@ -98,7 +98,7 @@ def set_event_loop(self, loop):
         # in a sub-task, which is exactly what we intend to be possible
         if self._trio_local._loop is not None and loop is not None and \
                 self._trio_local._task == task:
-            raise RuntimeError('You cannot replace an event loop.')
+            raise RuntimeError('You cannot replace an event loop.',self._trio_local._loop,loop)
         self._trio_local._loop = loop
         self._trio_local._task = task
 
@@ -231,5 +231,3 @@ async def _run_task(proc, args):
 
     trio.run(_run_task, proc, args)
 
-
-asyncio.set_event_loop_policy(TrioPolicy())