YAPF'd

Author: smurfix

tests/conftest.py

@@ -52,11 +52,11 @@ def pytest_pyfunc_call(pyfuncitem):
 _new_policy = trio_asyncio.TrioPolicy()
 asyncio.set_event_loop_policy(_new_policy)
 
+
 @pytest.fixture
 def old_policy():
     asyncio.set_event_loop_policy(_old_policy)
     try:
         yield _old_policy
     finally:
         asyncio.set_event_loop_policy(_new_policy)
-

tests/test_concurrent.py

@@ -5,62 +5,70 @@
 
 # Tests for concurrent or nested loops
 
+
 @pytest.mark.trio
 async def test_parallel():
-	loops = [None, None]
-	async with trio.open_nursery() as n:
-		async def gen_loop(i, task_status=trio.TASK_STATUS_IGNORED):
-			task_status.started()
-			async with trio_asyncio.open_loop() as loop:
-				loops[i] = loop
+    loops = [None, None]
+    async with trio.open_nursery() as n:
+
+        async def gen_loop(i, task_status=trio.TASK_STATUS_IGNORED):
+            task_status.started()
+            async with trio_asyncio.open_loop() as loop:
+                loops[i] = loop
+
+        assert not isinstance(asyncio._get_running_loop(), trio_asyncio.TrioEventLoop)
+        await n.start(gen_loop, 0)
+        await n.start(gen_loop, 1)
 
-		assert not isinstance(asyncio._get_running_loop(), trio_asyncio.TrioEventLoop)
-		await n.start(gen_loop, 0)
-		await n.start(gen_loop, 1)
+    assert isinstance(loops[0], trio_asyncio.TrioEventLoop)
+    assert isinstance(loops[1], trio_asyncio.TrioEventLoop)
+    assert loops[0] is not loops[1]
 
-	assert isinstance(loops[0], trio_asyncio.TrioEventLoop)
-	assert isinstance(loops[1], trio_asyncio.TrioEventLoop)
-	assert loops[0] is not loops[1]
 
 @pytest.mark.trio
 async def test_nested():
-	loops = [None, None]
-	async with trio.open_nursery() as n:
-		async def gen_loop(i, task_status=trio.TASK_STATUS_IGNORED):
-			task_status.started()
-			async with trio_asyncio.open_loop() as loop:
-				loops[i] = loop
-				if i > 0:
-					await n.start(gen_loop, i-1)
-
-		assert not isinstance(asyncio._get_running_loop(), trio_asyncio.TrioEventLoop)
-		await n.start(gen_loop, 1)
-	assert not isinstance(asyncio._get_running_loop(), trio_asyncio.TrioEventLoop)
-	assert isinstance(loops[0], trio_asyncio.TrioEventLoop)
-	assert isinstance(loops[1], trio_asyncio.TrioEventLoop)
-	assert loops[0] is not loops[1]
+    loops = [None, None]
+    async with trio.open_nursery() as n:
+
+        async def gen_loop(i, task_status=trio.TASK_STATUS_IGNORED):
+            task_status.started()
+            async with trio_asyncio.open_loop() as loop:
+                loops[i] = loop
+                if i > 0:
+                    await n.start(gen_loop, i - 1)
+
+        assert not isinstance(asyncio._get_running_loop(), trio_asyncio.TrioEventLoop)
+        await n.start(gen_loop, 1)
+    assert not isinstance(asyncio._get_running_loop(), trio_asyncio.TrioEventLoop)
+    assert isinstance(loops[0], trio_asyncio.TrioEventLoop)
+    assert isinstance(loops[1], trio_asyncio.TrioEventLoop)
+    assert loops[0] is not loops[1]
+
 
 async def _test_same_task():
-	loops = [None, None]
-	assert isinstance(asyncio.get_event_loop_policy(), trio_asyncio.TrioPolicy)
-	def get_loop(i):
-		loops[i] = (asyncio.get_event_loop(), asyncio.get_event_loop_policy())
-	async with trio.open_nursery() as n:
-		async with trio_asyncio.open_loop() as loop1:
-			async with trio_asyncio.open_loop() as loop2:
-				loop1.call_later(0.1, get_loop, 0)
-				loop2.call_later(0.1, get_loop, 1)
-				await trio.sleep(0.2)
-
-	assert isinstance(asyncio.get_event_loop_policy(), trio_asyncio.TrioPolicy)
-	assert not isinstance(asyncio._get_running_loop(), trio_asyncio.TrioEventLoop)
-	assert isinstance(loops[0][0], trio_asyncio.TrioEventLoop)
-	assert isinstance(loops[1][0], trio_asyncio.TrioEventLoop)
-	assert isinstance(loops[1][1], trio_asyncio.TrioPolicy)
-	assert loops[0][0] is not loops[1][0]
-	assert loops[0][1] is loops[1][1]
-	assert loops[0][1] is asyncio.get_event_loop_policy()
+    loops = [None, None]
+    assert isinstance(asyncio.get_event_loop_policy(), trio_asyncio.TrioPolicy)
+
+    def get_loop(i):
+        loops[i] = (asyncio.get_event_loop(), asyncio.get_event_loop_policy())
+
+    async with trio.open_nursery() as n:
+        async with trio_asyncio.open_loop() as loop1:
+            async with trio_asyncio.open_loop() as loop2:
+                loop1.call_later(0.1, get_loop, 0)
+                loop2.call_later(0.1, get_loop, 1)
+                await trio.sleep(0.2)
+
+    assert isinstance(asyncio.get_event_loop_policy(), trio_asyncio.TrioPolicy)
+    assert not isinstance(asyncio._get_running_loop(), trio_asyncio.TrioEventLoop)
+    assert isinstance(loops[0][0], trio_asyncio.TrioEventLoop)
+    assert isinstance(loops[1][0], trio_asyncio.TrioEventLoop)
+    assert isinstance(loops[1][1], trio_asyncio.TrioPolicy)
+    assert loops[0][0] is not loops[1][0]
+    assert loops[0][1] is loops[1][1]
+    assert loops[0][1] is asyncio.get_event_loop_policy()
+
 
 def test_same_task(old_policy):
-	assert not isinstance(asyncio.get_event_loop_policy(), trio_asyncio.TrioPolicy)
-	trio.run(_test_same_task)
+    assert not isinstance(asyncio.get_event_loop_policy(), trio_asyncio.TrioPolicy)
+    trio.run(_test_same_task)

trio_asyncio/async_.py

@@ -124,4 +124,3 @@ def _main_loop_exit(self):
                 loop.close()
                 nursery.cancel_scope.cancel()
                 _current_loop.loop = outer_loop
-

trio_asyncio/loop.py

@@ -32,6 +32,7 @@
 
 _current_loop = trio.TaskLocal(loop=None, policy=None)
 
+
 class _TrioPolicy(asyncio.events.BaseDefaultEventLoopPolicy):
     _loop_factory = TrioEventLoop
 
@@ -96,13 +97,14 @@ def set_event_loop(self, loop):
             return super().set_event_loop(loop)
 
 
-
 # We need to monkey-patch asyncio's policy+loop getters to return our
 # TrioPolicy+loop whenever we are within Trio.
 
 from asyncio import events as _aio_event
 
 _orig_policy_get = _aio_event.get_event_loop_policy
+
+
 def _new_policy_get():
     try:
         policy = _current_loop.policy
@@ -113,23 +115,33 @@ def _new_policy_get():
         policy = TrioPolicy()
         _current_loop.policy = policy
     return policy
+
+
 _aio_event.get_event_loop_policy = _new_policy_get
 asyncio.get_event_loop_policy = _new_policy_get
 
 _orig_run_get = _aio_event._get_running_loop
+
+
 def _new_loop_get():
     try:
         return _current_loop.loop
     except RuntimeError:
         return _orig_run_get()
+
+
 _aio_event._get_running_loop = _new_run_get
 
 _orig_loop_get = _aio_event.get_event_loop
+
+
 def _new_loop_get():
     try:
         return _current_loop.loop
     except RuntimeError:
         return _orig_loop_get()
+
+
 _aio_event.get_event_loop = _new_loop_get
 asyncio.get_event_loop = _new_loop_get