YAPF'd

Author: smurfix

tests/conftest.py

@@ -56,7 +56,7 @@ def create_task(coro):
 async def loop():
     async with trio_asyncio.open_loop() as loop:
         try:
-            await yield_( loop)
+            await yield_(loop)
         finally:
             await loop.stop().wait()
 

tests/interop/test_adapter.py

@@ -9,6 +9,7 @@
 from async_generator import asynccontextmanager
 from .. import utils as test_utils
 
+
 class SomeThing:
     flag = 0
 
@@ -97,6 +98,7 @@ async def ctx_trio(self):
         await trio.sleep(0.01)
         self.flag |= 2
 
+
 class TestAdapt(aiotest.TestCase):
     @pytest.mark.trio
     async def test_asyncio_trio_depr(self, loop):
@@ -207,6 +209,7 @@ async def run_asyncio_trio_ctx(self, loop):
     async def test_asyncio_trio_ctx(self, loop):
         await aio_as_trio(self.run_asyncio_trio_ctx)(loop)
 
+
 class TestAllow(aiotest.TestCase):
     async def run_asyncio_trio(self, loop):
         """Call asyncio from trio"""
@@ -287,4 +290,3 @@ async def run_trio_asyncio_ctx(self, loop):
     @pytest.mark.trio
     async def test_trio_asyncio_ctx(self, loop):
         await allow_asyncio(self.run_trio_asyncio_ctx, loop)
-

tests/interop/test_calls.py

@@ -441,7 +441,9 @@ async def in_asyncio(started, seen):
         async def cancel_trio(seen):
             started = trio.Event()
             async with trio.open_nursery() as nursery:
-                nursery.start_soon(partial(self.call_t_a_depr, loop=loop), in_asyncio, started, seen)
+                nursery.start_soon(
+                    partial(self.call_t_a_depr, loop=loop), in_asyncio, started, seen
+                )
                 await started.wait()
                 nursery.cancel_scope.cancel()
             seen.flag |= 8
@@ -583,6 +585,8 @@ async def slow_nums():
 
         sum = 0
         # with test_utils.deprecate(self): ## not yet
-        async for n in aio_as_trio(slow_nums(), loop=loop):
+        async for n in aio_as_trio(
+            slow_nums(), loop=loop
+        ):
             sum += n
         assert sum == 15

tests/python/test_events.py

@@ -1836,8 +1836,7 @@ async def main():
 
     if False and hasattr(selectors, 'KqueueSelector'):
 
-        class KqueueEventLoopTests(UnixEventLoopTestsMixin, 
-                                   test_utils.TestCase):
+        class KqueueEventLoopTests(UnixEventLoopTestsMixin, test_utils.TestCase):
             def create_event_loop(self):
                 return asyncio.SelectorEventLoop(selectors.KqueueSelector())
 
@@ -1858,15 +1857,13 @@ def test_write_pty(self):
 
     if False and hasattr(selectors, 'EpollSelector'):
 
-        class EPollEventLoopTests(UnixEventLoopTestsMixin, 
-                                  test_utils.TestCase):
+        class EPollEventLoopTests(UnixEventLoopTestsMixin, test_utils.TestCase):
             def create_event_loop(self):
                 return asyncio.SelectorEventLoop(selectors.EpollSelector())
 
     if False and hasattr(selectors, 'PollSelector'):
 
-        class PollEventLoopTests(UnixEventLoopTestsMixin, 
-                                 test_utils.TestCase):
+        class PollEventLoopTests(UnixEventLoopTestsMixin, test_utils.TestCase):
             def create_event_loop(self):
                 return asyncio.SelectorEventLoop(selectors.PollSelector())
 

tests/python/test_locks.py

@@ -16,6 +16,7 @@
 )
 RGX_REPR = re.compile(STR_RGX_REPR)
 
+
 class LockTests(test_utils.TestCase):
     def setUp(self):
         super().setUp()

tests/test_aio_subprocess.py

@@ -15,6 +15,7 @@
 
 from . import utils as test_utils
 
+
 class MySubprocessProtocol(asyncio.SubprocessProtocol):
     def __init__(self, loop):
         self.state = 'INITIAL'
@@ -61,16 +62,20 @@ def check_terminated(returncode):
     else:
         assert -signal.SIGTERM == returncode
 
+
 def check_killed(returncode):
     if sys.platform == 'win32':
         assert isinstance(returncode, int)
         # expect 1 but sometimes get 0
     else:
         assert -signal.SIGKILL == returncode
 
+
 @pytest.mark.trio
 async def test_subprocess_exec(loop):
     await run_subprocess_exec(loop)
+
+
 @aio_as_trio
 async def run_subprocess_exec(loop):
     prog = os.path.join(os.path.dirname(__file__), 'scripts', 'echo.py')
@@ -92,9 +97,12 @@ async def run_subprocess_exec(loop):
     check_killed(proto.returncode)
     assert b'Python The Winner' == proto.data[1]
 
+
 @pytest.mark.trio
 async def test_subprocess_interactive(loop):
     await run_subprocess_interactive(loop)
+
+
 @aio_as_trio
 async def run_subprocess_interactive(loop):
     prog = os.path.join(os.path.dirname(__file__), 'scripts', 'echo.py')
@@ -122,14 +130,15 @@ async def run_subprocess_interactive(loop):
     await proto.completed
     check_killed(proto.returncode)
 
+
 @pytest.mark.trio
 async def test_subprocess_shell(loop):
     await run_subprocess_shell(loop)
+
+
 @aio_as_trio
 async def run_subprocess_shell(loop):
-    connect = loop.subprocess_shell(
-        functools.partial(MySubprocessProtocol, loop), 'echo Python'
-    )
+    connect = loop.subprocess_shell(functools.partial(MySubprocessProtocol, loop), 'echo Python')
     transp, proto = await connect
     assert isinstance(proto, MySubprocessProtocol)
     await proto.connected
@@ -142,9 +151,12 @@ async def run_subprocess_shell(loop):
     assert proto.data[2] == b''
     transp.close()
 
+
 @pytest.mark.trio
 async def test_subprocess_exitcode(loop):
     await run_subprocess_exitcode(loop)
+
+
 @aio_as_trio
 async def run_subprocess_exitcode(loop):
     connect = loop.subprocess_shell(
@@ -160,9 +172,12 @@ async def run_subprocess_exitcode(loop):
     assert 7 == proto.returncode
     transp.close()
 
+
 @pytest.mark.trio
 async def test_subprocess_close_after_finish(loop):
     await run_subprocess_close_after_finish(loop)
+
+
 @aio_as_trio
 async def run_subprocess_close_after_finish(loop):
     connect = loop.subprocess_shell(
@@ -181,9 +196,12 @@ async def run_subprocess_close_after_finish(loop):
     assert 7 == proto.returncode
     assert transp.close() is None
 
+
 @pytest.mark.trio
 async def test_subprocess_kill(loop):
     await run_subprocess_kill(loop)
+
+
 @aio_as_trio
 async def run_subprocess_kill(loop):
     prog = os.path.join(os.path.dirname(__file__), 'scripts', 'echo.py')
@@ -200,9 +218,12 @@ async def run_subprocess_kill(loop):
     check_killed(proto.returncode)
     transp.close()
 
+
 @pytest.mark.trio
 async def test_subprocess_terminate(loop):
     await run_subprocess_terminate(loop)
+
+
 @aio_as_trio
 async def run_subprocess_terminate(loop):
     prog = os.path.join(os.path.dirname(__file__), 'scripts', 'echo.py')
@@ -219,10 +240,13 @@ async def run_subprocess_terminate(loop):
     check_terminated(proto.returncode)
     transp.close()
 
+
 @unittest.skipIf(sys.platform == 'win32', "Don't have SIGHUP")
 @pytest.mark.trio
 async def test_subprocess_send_signal(loop):
     await run_subprocess_send_signal(loop)
+
+
 @aio_as_trio
 async def run_subprocess_send_signal(loop):
     # bpo-31034: Make sure that we get the default signal handler (killing
@@ -246,9 +270,12 @@ async def run_subprocess_send_signal(loop):
     finally:
         signal.signal(signal.SIGHUP, old_handler)
 
+
 @pytest.mark.trio
 async def test_subprocess_stderr(loop):
     await run_subprocess_stderr(loop)
+
+
 @aio_as_trio
 async def run_subprocess_stderr(loop):
     prog = os.path.join(os.path.dirname(__file__), 'scripts', 'echo2.py')
@@ -270,9 +297,12 @@ async def run_subprocess_stderr(loop):
     assert proto.data[2].startswith(b'ERR:test'), proto.data[2]
     assert 0 == proto.returncode
 
+
 @pytest.mark.trio
 async def test_subprocess_stderr_redirect_to_stdout(loop):
     await run_subprocess_stderr_redirect_to_stdout(loop)
+
+
 @aio_as_trio
 async def run_subprocess_stderr_redirect_to_stdout(loop):
     prog = os.path.join(os.path.dirname(__file__), 'scripts', 'echo2.py')
@@ -299,9 +329,12 @@ async def run_subprocess_stderr_redirect_to_stdout(loop):
     transp.close()
     assert 0 == proto.returncode
 
+
 @pytest.mark.trio
 async def test_subprocess_close_client_stream(loop):
     await run_subprocess_close_client_stream(loop)
+
+
 @aio_as_trio
 async def run_subprocess_close_client_stream(loop):
     prog = os.path.join(os.path.dirname(__file__), 'scripts', 'echo3.py')
@@ -336,9 +369,12 @@ async def run_subprocess_close_client_stream(loop):
     await proto.completed
     check_killed(proto.returncode)
 
+
 @pytest.mark.trio
 async def test_subprocess_wait_no_same_group(loop):
     await run_subprocess_wait_no_same_group(loop)
+
+
 @aio_as_trio
 async def run_subprocess_wait_no_same_group(loop):
     # start the new process in a new session
@@ -355,6 +391,7 @@ async def run_subprocess_wait_no_same_group(loop):
     await proto.completed
     assert 7 == proto.returncode
 
+
 @pytest.mark.trio
 async def test_subprocess_exec_invalid_args(loop):
     @aio_as_trio
@@ -368,6 +405,7 @@ async def connect(**kwds):
     with pytest.raises(ValueError):
         await connect(shell=True)
 
+
 @pytest.mark.trio
 async def test_subprocess_shell_invalid_args(loop):
     @aio_as_trio
@@ -384,5 +422,3 @@ async def connect(cmd=None, **kwds):
         await connect(bufsize=4096)
     with pytest.raises(ValueError):
         await connect(shell=False)
-
-

tests/utils.py

@@ -583,7 +583,6 @@ def get_function_source(func):
     return source
 
 
-
 def deprecate(tc, vers=None):
     if vers is None or sys.version_info >= vers:
         return pytest.deprecated_call()
@@ -599,5 +598,3 @@ def __exit__(self, *tb):
             pass
 
     return _deprecate(tc)
-
-